Strategie dużych baz kodu: Wskazówki 76-90

Praca z bazami kodu zawierającymi setki tysięcy lub miliony linii wymaga specjalistycznych strategii. Te 15 wskazówek pomoże ci utrzymać produktywność i dokładność podczas pracy z projektami w skali korporacyjnej.

Zrozumienie bazy kodu

Wskazówka 76: Włącz zaawansowane indeksowanie struktury projektu

Skonfiguruj Cursor dla optymalnego zrozumienia dużej bazy kodu:

{
  "cursor.indexing.strategy": "smart",
  "cursor.indexing.includeProjectStructure": true,
  "cursor.indexing.priorityPatterns": [
    "**/src/core/**",
    "**/src/api/**",
    "**/src/services/**"
  ],
  "cursor.indexing.merkleTree": {
    "enabled": true,
    "updateInterval": "3m",
    "maxDepth": 10
  }
}

Wskazówka 77: Używaj semantycznego wyszukiwania bazy kodu

Opanuj symbol @codebase do inteligentnych wyszukiwań:

// Znajdź według funkcjonalności, nie tekstu
"@codebase jak jest zaimplementowane uwierzytelnianie użytkowników"
"@codebase przepływ przetwarzania płatności"
"@codebase wzorce obsługi błędów"

// Zrozum design systemu
"@codebase pooling połączeń bazy danych"
"@codebase strategie cachowania"
"@codebase implementacja ograniczania szybkości API"

// Śledź zależności
"@codebase co zależy od UserService"
"@codebase użycie Redis w całej bazie kodu"
"@codebase integracje API zewnętrznych"

Wskazówka 78: Twórz mapy bazy kodu z AI

Używaj czatu do budowania modeli mentalnych:

// Przegląd architektury
"Utwórz diagram architektury wysokiego poziomu naszego systemu na podstawie
@src analizując główne komponenty i ich interakcje"

// Graf zależności
"Zmapuj relacje zależności między naszymi głównymi usługami
w @src/services"

// Analiza przepływu danych
"Śledź przepływ danych dla żądania rejestracji użytkownika przez
cały nasz system"

Optymalizacja wydajności

Wskazówka 79: Skonfiguruj inteligentne wykluczenia plików

Optymalizuj indeksowanie z inteligentnymi wykluczeniami:

{
  "cursor.indexing.exclude": {
    "patterns": [
      "**/node_modules/**",
      "**/dist/**",
      "**/build/**",
      "**/.next/**",
      "**/coverage/**",
      "**/*.min.js",
      "**/*.bundle.js"
    ],
    "sizeThreshold": "10MB",
    "generatedFilePatterns": [
      "**/*.generated.ts",
      "**/schema.graphql",
      "**/migrations/*.sql"
    ]
  }
}

Wskazówka 80: Implementuj wzorce plików priorytetowych

Kieruj skupienie AI z konfiguracjami priorytetów:

{
  "cursor.codebase.priorityFiles": [
    {
      "pattern": "**/index.{ts,js}",
      "weight": 1.5,
      "reason": "Punkty wejścia"
    },
    {
      "pattern": "**/routes/**",
      "weight": 1.3,
      "reason": "Definicje API"
    },
    {
      "pattern": "**/*.service.{ts,js}",
      "weight": 1.4,
      "reason": "Logika biznesowa"
    }
  ]
}

Wskazówka 81: Używaj strategii indeksowania przyrostowego

Utrzymuj wydajność z inteligentnym indeksowaniem:

Indeks początkowy: Pełne skanowanie przy otwarciu projektu
Obserwacja plików: Aktualizacje w czasie rzeczywistym przy zmianach
Okresowe odświeżanie: Indeksowanie w tle co 5 minut
Ręczne wyzwalanie: Wymuś re-indeksowanie gdy potrzeba

Polecenia do zarządzania indeksem:

Ctrl+Shift+P → "Cursor: Rebuild Index"
Ctrl+Shift+P → "Cursor: Clear Index Cache"
Ctrl+Shift+P → "Cursor: Show Indexing Status"

Strategie nawigacji

Wskazówka 82: Opanuj nawigację między repozytoriami

Pracuj efektywnie w wielu powiązanych repozytoriach:

Konfiguracja Multi-Root

workspace/
├── frontend/
├── backend/
├── shared/
└── infrastructure/

Współdzielony kontekst

Odwołuj się między repo:

@frontend/src/api/client.ts
@backend/src/routes/user.ts

Wskazówka 83: Używaj śledzenia zależności napędzanego AI

Nawiguj po złożonych łańcuchach zależności:

// Śledź użycie
"Pokaż mi wszystkie miejsca, gdzie wywoływane jest UserRepository.findById,
włączając pośrednie użycie przez inne usługi"

// Analiza wpływu
"Jeśli zmienię sygnaturę AuthService.validateToken,
które pliki będą dotknięte?"

// Wykrywanie zależności cyklicznych
"Sprawdź zależności cykliczne w @src/services"

Wskazówka 84: Twórz inteligentne skróty nawigacyjne

Skonfiguruj efektywne wzorce nawigacji:

{
  "cursor.navigation.bookmarks": [
    {
      "name": "Trasy API",
      "pattern": "**/routes/**/*.ts"
    },
    {
      "name": "Modele bazy danych",
      "pattern": "**/models/**/*.ts"
    },
    {
      "name": "Pliki testowe",
      "pattern": "**/*.{test,spec}.{ts,js}"
    }
  ]
}

Wyszukiwanie i analiza

Wskazówka 85: Łącz wiele strategii wyszukiwania

Warstwowo stosuj różne podejścia wyszukiwania dla kompleksowych wyników:

Wyszukiwanie wzorców
Wyszukiwanie architektoniczne

// 1. Semantyczne wyszukiwanie koncepcji
"@codebase middleware uwierzytelniania"

// 2. Grep dla konkretnych wzorców
"Wyszukaj: req.user we wszystkich trasach"

// 3. Wyszukiwanie symboli
"@definitions AuthMiddleware"

// 1. Znajdź wszystkie usługi
"@codebase wylistuj wszystkie klasy usług"

// 2. Śledź interakcje
"Pokaż komunikację usługa-usługa"

// 3. Zidentyfikuj wzorce
"Wspólne wzorce w implementacjach usług"

Wskazówka 86: Używaj wyszukiwań z zakresem dla wydajności

Inteligentnie ograniczaj zakres wyszukiwania:

// Zakres według katalogu
"@folder:src/api wyszukaj ograniczanie szybkości"

// Zakres według typu pliku
"W wszystkich plikach TypeScript: znajdź funkcje async bez try-catch"

// Zakres według ostatnich zmian
"@recent-changes przejrzyj obsługę błędów w zmodyfikowanych plikach"

// Łącz zakresy
"@folder:src/services @git:last-week znajdź nowe zapytania bazy danych"

Wskazówka 87: Implementuj skanowanie jakości kodu

Używaj Agent do sprawdzania jakości w całej bazie kodu:

// Skan bezpieczeństwa
"Przeskanuj bazę kodu pod kątem potencjalnych luk bezpieczeństwa:
- Ryzyko SQL injection
- Luki XSS
- Odsłonięte sekrety lub klucze API
- Brakujące sprawdzenia uwierzytelniania"

// Audyt wydajności
"Zidentyfikuj wąskie gardła wydajności:
- Problemy N+1 zapytań
- Brakujące odniesienia do indeksów bazy danych
- Operacje synchroniczne, które powinny być async
- Duże importy bundli"

// Ocena długu technicznego
"Znajdź obszary długu technicznego:
- Komentarze TODO/FIXME
- Użycie przestarzałych API
- Duplikacja kodu
- Złożone funkcje (złożoność cyklomatyczna > 10)"

Zarządzanie architekturą

Wskazówka 88: Utrzymuj spójność architektoniczną

Używaj AI do egzekwowania wzorców architektonicznych:

Walidacja warstw

Zapewnij właściwe rozdzielenie:

"Sprawdź, że kontrolery wywołują tylko usługi,
nigdy bezpośrednio repozytoria"

Egzekwowanie wzorców

Sprawdź wzorce implementacji:

"Upewnij się, że wszystkie usługi podążają za naszym
standardowym wzorcem obsługi błędów"

Zasady zależności

Waliduj zależności:

"Sprawdź, że warstwa domeny nie
zależy od warstwy infrastruktury"

Wskazówka 89: Generuj dokumentację architektury

Utrzymuj dokumentację zsynchronizowaną z kodem:

// Dokumentacja komponentów
"Wygeneruj README dla @src/services wyjaśniające:
- Cel każdej usługi
- Kluczowe metody i ich użycie
- Zależności i interakcje
- Wymagania konfiguracyjne"

// Dokumentacja API
"Utwórz dokumentację OpenAPI dla wszystkich tras w @src/api
na podstawie rzeczywistej implementacji"

// Wizualizacja zależności
"Utwórz diagram Mermaid pokazujący relacje
między wszystkimi głównymi komponentami w naszym systemie"

Przykładowy output:

graph TD A[API Gateway] --> B[Usługa Auth] A --> C[Usługa User] C --> D[Baza danych] B --> E[Cache Redis] C --> E

Wskazówka 90: Implementuj modularną refaktoryzację

Systematycznie refaktoryzuj duże bazy kodu:

Zidentyfikuj granice: “Przeanalizuj @src/monolith i zasugeruj granice modułów”
Utwórz interfejsy: “Zdefiniuj interfejsy między proponowanymi modułami”
Wyodrębnij stopniowo: “Wyodrębnij UserModule utrzymując wszystkie testy przechodzące”
Sprawdź izolację: “Upewnij się, że UserModule nie ma zależności cyklicznych”
Aktualizuj importy: “Zaktualizuj wszystkie importy, aby używały nowej struktury modułów”

Najlepsze praktyki dla skali

Zarządzanie pamięcią

Skonfiguruj Cursor dla dużych projektów:

{
  "cursor.performance.largeFiles": {
    "threshold": "1MB",
    "strategy": "stream",
    "maxInMemory": 50
  },
  "cursor.performance.maxOpenTabs": 20,
  "cursor.performance.gcInterval": "5m"
}

Optymalizacja okna kontekstu

Ważne Duże bazy kodu mogą szybko przekroczyć limity kontekstu

Strategie:

Skupiony kontekst: Odwołuj się do konkretnych plików, nie całych folderów
Progresywne ujawnianie: Zacznij szeroko, następnie zawęź
Regularnie czyść: Resetuj kontekst między niepowiązanymi zadaniami
Używaj podsumowań: Twórz skompresowane pliki dokumentacji

Współpraca zespołowa

Współdzielone indeksowanie Zespoły mogą dzielić się indeksami bazy kodu, aby zmniejszyć czas indeksowania indywidualnego

Konfiguracja współdzielonego indeksu:

# Wygeneruj indeks do udostępnienia
cursor index --export ./shared-index

# Importuj na maszynie członka zespołu
cursor index --import ./shared-index

Typowe wyzwania dużych baz kodu

Wyzwanie: Wolne początkowe indeksowanie

Rozwiązania:

Wstępnie skonfiguruj wykluczenia przed otwarciem
Używaj wzorców priorytetowych dla krytycznych ścieżek
Włącz indeksowanie przyrostowe
Dziel się indeksami zespołowymi

Wyzwanie: Przepełnienie kontekstu

Rozwiązania:

Pracuj z podzbiorami plików
Twórz dokumenty podsumowujące
Używaj wyszukiwań z zakresem
Dziel zadania na mniejsze fragmenty

Wyzwanie: Znajdowanie odpowiedniego kodu

Rozwiązania:

Łącz semantyczne i grep wyszukiwanie
Utrzymuj dobrą dokumentację
Używaj konsekwentnych konwencji nazewnictwa
Twórz mapy bazy kodu

Następne kroki

Z opanowanymi strategiami dużych baz kodu, eksploruj Zaawansowane techniki, aby wykorzystać funkcje na poziomie eksperckim jak niestandardowe serwery MCP, zaawansowane zasady i przepływy pracy automatyzacji.