Przepływy pracy multi-repo: zarządzanie systemami rozproszonymi

Nowoczesne architektury oprogramowania często obejmują wiele repozytoriów. Czy pracujesz z mikroserwisami, modułowymi monolitami czy systemami wielojęzycznymi, Cursor zapewnia potężne funkcje do efektywnego zarządzania przepływami pracy multi-repo.

Wyzwanie multi-repo

Fragmentacja kontekstu

Powiązany kod żyje w różnych repozytoriach

Śledzenie zależności

Zmiany w jednym repo wpływają na inne

Spójne standardy

Utrzymanie standardów kodowania w repozytoriach

Refaktoryzacja między repo

Wprowadzanie skoordynowanych zmian w serwisach

Konfiguracja workspace wielokorzeniowego

Podstawowa konfiguracja multi-root

Stwórz plik workspace, który zawiera wszystkie powiązane repozytoria:

// company.code-workspace
{
  "folders": [
    {
      "name": "🌐 Brama API",
      "path": "../api-gateway"
    },
    {
      "name": "👤 Serwis użytkowników",
      "path": "../user-service"
    },
    {
      "name": "💳 Serwis płatności",
      "path": "../payment-service"
    },
    {
      "name": "📧 Serwis powiadomień",
      "path": "../notification-service"
    },
    {
      "name": "📚 Biblioteki współdzielone",
      "path": "../shared-libs"
    }
  ],
  "settings": {
    "cursor.workspaceIndexing": {
      "strategy": "selective",
      "priority": ["Brama API", "Biblioteki współdzielone"]
    }
  }
}

Zaawansowana organizacja workspace

{
  "folders": [
    // Domena użytkowników
    {"name": "API użytkowników", "path": "../services/user-api"},
    {"name": "Baza użytkowników", "path": "../services/user-db"},
    {"name": "UI użytkowników", "path": "../frontends/user-dashboard"},

    // Domena płatności
    {"name": "API płatności", "path": "../services/payment-api"},
    {"name": "Procesor płatności", "path": "../services/payment-processor"},
    {"name": "UI płatności", "path": "../frontends/payment-portal"},

    // Współdzielone
    {"name": "Wspólne typy", "path": "../libraries/types"},
    {"name": "Narzędzia", "path": "../libraries/utils"}
  ]
}

{
  "folders": [
    // Serwisy backendowe
    {"name": "Serwisy Node", "path": "../backend/node"},
    {"name": "Serwisy Go", "path": "../backend/go"},
    {"name": "Serwisy Python", "path": "../backend/python"},

    // Aplikacje frontendowe
    {"name": "Aplikacje React", "path": "../frontend/react"},
    {"name": "Aplikacje Vue", "path": "../frontend/vue"},

    // Infrastruktura
    {"name": "Terraform", "path": "../infra/terraform"},
    {"name": "Konfiguracje K8s", "path": "../infra/kubernetes"}
  ]
}

{
  "folders": [
    // Zespół platformy
    {"name": "Serwis uwierzytelniania", "path": "../platform/auth"},
    {"name": "Brama API", "path": "../platform/gateway"},

    // Zespół produktowy A
    {"name": "API funkcji X", "path": "../team-a/feature-x-api"},
    {"name": "UI funkcji X", "path": "../team-a/feature-x-ui"},

    // Zespół produktowy B
    {"name": "API funkcji Y", "path": "../team-b/feature-y-api"},
    {"name": "UI funkcji Y", "path": "../team-b/feature-y-ui"}
  ]
}

Nawigacja między repozytoriami

Skuteczne strategie wyszukiwania

// Szukaj we wszystkich repozytoriach
"@all Znajdź wszystkie implementacje interfejsu UserService"

// Szukaj w konkretnych repo
"@workspace:'Serwis użytkowników' @workspace:'Serwis płatności'
Znajdź wszystkie wywołania API między tymi serwisami"

// Szukaj według technologii
"@ext:go Znajdź wszystkie definicje serwisów gRPC"
"@ext:ts @ext:tsx Znajdź wszystkie komponenty React używające UserContext"

// Szukaj według wzorca w repozytoriach
"@search('import.*@company/shared') Znajdź wszystkie użycia biblioteki współdzielonej"

Wzorce szybkiej nawigacji

Wskazówka: Stwórz aliasy nawigacyjne w ustawieniach Cursor dla często odwiedzanych ścieżek między repo:

{
  "cursor.navigation.aliases": {
    "@user-api": "user-service/src/api",
    "@payment-api": "payment-service/src/api",
    "@shared-types": "shared-libs/types/src"
  }
}

Zarządzanie zależnościami

Śledzenie zależności między serwisami

Stwórz mapę zależności, którą może wykorzystać Cursor:

services:
  user-service:
    depends_on:
      - shared-libs/auth
      - shared-libs/database
    consumers:
      - api-gateway
      - notification-service

  payment-service:
    depends_on:
      - shared-libs/auth
      - user-service/api
    consumers:
      - api-gateway
      - order-service

  api-gateway:
    depends_on:
      - user-service/api
      - payment-service/api
      - order-service/api

Automatyczna analiza zależności

// Niestandardowy serwer MCP do śledzenia zależności
class DependencyTracker {
  async analyzeDependencies(service: string) {
    const deps = await this.scanImports(service);
    const consumers = await this.findConsumers(service);

    return {
      directDependencies: deps.direct,
      transitiveDependencies: deps.transitive,
      consumers: consumers,
      circularDependencies: this.detectCircular(deps),
      outdated: await this.checkVersions(deps),
    };
  }

  async impactAnalysis(changedFile: string) {
    // Znajdź wszystkie serwisy dotknięte zmianą
    const affected = new Set<string>();

    const service = this.getServiceFromPath(changedFile);
    const consumers = await this.getConsumerChain(service);

    for (const consumer of consumers) {
      affected.add(consumer);
      // Rekurencyjnie znajdź dotknięte serwisy
      const downstream = await this.getConsumerChain(consumer);
      downstream.forEach((s) => affected.add(s));
    }

    return Array.from(affected);
  }
}

Zarządzanie współdzieloną konfiguracją

Scentralizowane reguły Cursor

Utrzymuj spójne zachowanie AI w repozytoriach:

Foldercursor-config/ - rules/ - base-rules.md - frontend-rules.md - backend-rules.md - security-rules.md - templates/ - service-template.md - component-template.md - scripts/ - sync-rules.sh - validate-config.js
- …

#!/bin/bash
# sync-rules.sh - synchronizuj reguły Cursor we wszystkich repo

REPOS=(
  "user-service"
  "payment-service"
  "notification-service"
  "api-gateway"
)

for repo in "${REPOS[@]}"; do
  echo "Synchronizuję reguły do $repo..."

  # Stwórz katalog .cursor, jeśli nie istnieje
  mkdir -p "../$repo/.cursor/rules"

  # Kopiuj podstawowe reguły
  cp ./rules/base-rules.md "../$repo/.cursor/rules/"

  # Kopiuj reguły specyficzne dla technologii
  if [[ -f "../$repo/package.json" ]]; then
    cp ./rules/frontend-rules.md "../$repo/.cursor/rules/"
  fi

  if [[ -f "../$repo/go.mod" ]]; then
    cp ./rules/backend-rules.md "../$repo/.cursor/rules/"
  fi

  # Zawsze uwzględnij reguły bezpieczeństwa
  cp ./rules/security-rules.md "../$repo/.cursor/rules/"
done

Współdzielona konfiguracja MCP

// shared-mcp.json - wspólne serwery MCP dla wszystkich repo
{
  "mcpServers": {
    "company-docs": {
      "command": "npx",
      "args": ["@company/docs-mcp"],
      "env": {
        "DOCS_URL": "https://docs.company.internal"
      }
    },
    "service-registry": {
      "command": "npx",
      "args": ["@company/service-registry-mcp"],
      "env": {
        "REGISTRY_URL": "https://registry.company.internal"
      }
    },
    "shared-db": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${SHARED_DB_URL}"
      }
    }
  }
}

Refaktoryzacja między repozytoriami

Wzorzec skoordynowanych zmian

Zaplanuj refaktoryzację

"Przeanalizuj wpływ zmiany nazwy UserProfile na UserAccount
we wszystkich serwisach. Stwórz plan refaktoryzacji."

Stwórz punkty kontrolne

"Stwórz punkt kontrolny w każdym dotkniętym repozytorium"

Wykonaj w kolejności

"1. Zaktualizuj shared-libs/types najpierw
2. Zaktualizuj API user-service
3. Zaktualizuj konsumujące serwisy
4. Zaktualizuj aplikacje frontendowe"

Waliduj zmiany

"Uruchom testy integracyjne we wszystkich serwisach"

Skoordynuj commity

"Stwórz powiązane commity ze spójną wiadomością:
'refactor: Zmień nazwę UserProfile na UserAccount [TICKET-123]'"

Przepływ pracy agenta multi-repo

// Przykład: aktualizacja API w serwisach
"@workspace:'Serwis użytkowników' @workspace:'Serwis płatności' @workspace:'Brama API'

Zadanie: Dodaj ograniczenie liczby żądań do wszystkich publicznych punktów końcowych
1. Dodaj middleware ograniczenia do shared-libs
2. Zaktualizuj każdy serwis, aby używał middleware
3. Skonfiguruj limity w bramie API
4. Zaktualizuj dokumentację
5. Dodaj testy integracyjne

Zachowaj kompatybilność wsteczną przez cały czas."

Scenariusze multi-repo z prawdziwego świata

Scenariusz 1: migracja mikroserwisów

Zespół migrujący z monolitu do mikroserwisów:

// Przed: monolit
legacy-app/
├── src/
│   ├── users/
│   ├── payments/
│   ├── orders/
│   └── notifications/

// Po: mikroserwisy
services/
├── user-service/
├── payment-service/
├── order-service/
├── notification-service/
└── legacy-app/ (w trakcie dekompozycji)

{
  "folders": [
    {"name": "Legacy (referencja)", "path": "./legacy-app"},
    {"name": "Serwis użytkowników", "path": "./services/user-service"},
    {"name": "Serwis płatności", "path": "./services/payment-service"},
    {"name": "Skrypty migracji", "path": "./migration"}
  ],
  "settings": {
    "cursor.rules": [
      "Odwołuj się do legacy kodu dla logiki biznesowej",
      "Zachowaj kompatybilność API",
      "Wyodrębnij stopniowo, testuj dokładnie"
    ]
  }
}

// Użyj Cursor do zarządzania migracją
# Przepływ pracy migracji używając Cursor
extractService() {
  local DOMAIN=$1

  # 1. Analizuj legacy kod
  echo "Analizuję legacy kod dla $DOMAIN..."
  cursor legacy-app/
  # Użyj trybu Agent (Ctrl+I):
  # "Znajdź cały kod związany z funkcjonalnością $DOMAIN"
  # "Wylistuj wszystkie pliki, funkcje i zależności dla $DOMAIN"
  # "Zidentyfikuj tabele bazy danych i zapytania używane przez $DOMAIN"

  # 2. Wygeneruj szkielet serwisu
  mkdir -p "services/$DOMAIN-service"
  cd "services/$DOMAIN-service"
  cursor .
  # Prompt agenta:
  # "Stwórz nową strukturę mikroserwisu dla $DOMAIN"
  # "Użyj naszego standardowego szablonu mikroserwisu z @Docs"
  # "Uwzględnij punkty końcowe API, modele i strukturę testów"

  # 3. Migruj logikę biznesową
  cursor legacy-app/ "services/$DOMAIN-service/"
  # Prompty agenta:
  # "Przenieś logikę biznesową $DOMAIN z legacy-app do nowego serwisu"
  # "Zachowaj dokładne zachowanie i wszystkie przypadki brzegowe"
  # "Stwórz kompleksowe testy, aby zweryfikować zgodność zachowania"

  # 4. Stwórz warstwę adaptera
  cursor legacy-app/adapters/
  # Prompt agenta:
  # "Stwórz adapter do przekierowania wywołań $DOMAIN do nowego serwisu"
  # "Zaimplementuj circuit breaker i fallback do legacy kodu"
  # "Dodaj flagę funkcji do przełączania między legacy a nowym serwisem"
}

Scenariusz 2: microfrontendy

Zarządzanie wieloma aplikacjami frontendowymi:

// Workspace dla architektury microfrontend
{
  "folders": [
    // Aplikacja shell
    {"name": "Aplikacja shell", "path": "./apps/shell"},

    // Aplikacje funkcji
    {"name": "Dashboard użytkownika", "path": "./apps/user-dashboard"},
    {"name": "Portal administratora", "path": "./apps/admin-portal"},
    {"name": "Analityka", "path": "./apps/analytics"},

    // Współdzielone
    {"name": "Biblioteka komponentów", "path": "./packages/ui-components"},
    {"name": "Zarządzanie stanem", "path": "./packages/state"},
    {"name": "Klient API", "path": "./packages/api-client"}
  ],
  "cursor": {
    "crossRepoImports": {
      "@company/ui": "./packages/ui-components/src",
      "@company/state": "./packages/state/src",
      "@company/api": "./packages/api-client/src"
    }
  }
}

Integracja przepływu pracy Git

Koordynacja gałęzi

#!/bin/bash
# Koordynuj gałęzie w repozytoriach

FEATURE_BRANCH="feature/add-oauth2"
REPOS=("user-service" "api-gateway" "shared-libs")

# Stwórz gałęzie funkcji we wszystkich repo
for repo in "${REPOS[@]}"; do
  cd "../$repo"
  git checkout -b "$FEATURE_BRANCH"
  cd -
done

# Użyj Cursor do wprowadzenia skoordynowanych zmian
cursor --workspace company.code-workspace

Automatyczne tworzenie PR

// Stwórz powiązane PR w repozytoriach
async function createLinkedPRs(feature: string, repos: string[]) {
  const prUrls = [];

  for (const repo of repos) {
    const pr = await github.createPR({
      repo,
      title: `${feature} [Multi-Repo]`,
      body: `
        Część zmiany multi-repo dla ${feature}

        Powiązane PR:
        ${prUrls.map((url) => `- ${url}`).join('\n')}
      `,
      branch: `feature/${feature}`,
    });

    prUrls.push(pr.url);
  }

  // Zaktualizuj wszystkie PR z kompletną listą
  for (let i = 0; i < prUrls.length; i++) {
    await github.updatePR(prUrls[i], {
      body: generatePRBody(feature, prUrls),
    });
  }
}

Optymalizacja wydajności dla multi-repo

Selektywne ładowanie

#!/bin/bash
# Optymalizuj workspace pod konkretne zadania
optimizeForTask() {
  local TASK=$1

  # Zdefiniuj zależności zadania
  case $TASK in
    "frontend")
      REQUIRED_REPOS="web-app design-system shared-components"
      ;;
    "backend")
      REQUIRED_REPOS="api-gateway auth-service data-service shared-libs"
      ;;
    "fullstack")
      REQUIRED_REPOS="web-app api-gateway auth-service shared-libs"
      ;;
  esac

  # Stwórz zoptymalizowany plik workspace
  cat > .cursor/workspace-$TASK.code-workspace << EOF
{
  "folders": [
EOF

  # Dodaj wymagane repo do workspace
  for repo in $REQUIRED_REPOS; do
    cat >> .cursor/workspace-$TASK.code-workspace << EOF
    {
      "path": "../$repo",
      "name": "$repo"
    },
EOF
  done

  # Zamknij plik workspace
  cat >> .cursor/workspace-$TASK.code-workspace << EOF
  ],
  "settings": {
    "cursor.ai.model": "claude-3.5-sonnet",
    "search.exclude": {
      "**/node_modules": true,
      "**/dist": true,
      "**/build": true
    }
  }
}
EOF

  # Otwórz zoptymalizowany workspace
  cursor .cursor/workspace-$TASK.code-workspace

  echo "Workspace zoptymalizowany dla rozwoju $TASK"
  echo "Załadowane repo: $REQUIRED_REPOS"
}

# Przykład użycia:
# optimizeForTask "frontend"
# optimizeForTask "backend"
# optimizeForTask "fullstack"

Strategie buforowania

// Konfiguracja cache multi-repo
{
  "cursor.cache": {
    "sharedCache": true,
    "cacheLocation": "~/.cursor/multi-repo-cache",
    "perRepoLimit": "500MB",
    "totalLimit": "5GB",
    "ttl": "7d"
  }
}

Współpraca zespołowa

Wspólne zrozumienie

Stwórz centrum dokumentacji multi-repo:

# Przegląd architektury serwisów

## Mapa serwisów

```mermaid
graph TB
    Gateway[Brama API]
    UserSvc[Serwis użytkowników]
    PaymentSvc[Serwis płatności]
    NotifSvc[Serwis powiadomień]

    Gateway --> UserSvc
    Gateway --> PaymentSvc
    UserSvc --> NotifSvc
    PaymentSvc --> NotifSvc
```

Struktura repozytoriów

user-service: Node.js, Express, PostgreSQL
payment-service: Go, gRPC, PostgreSQL
notification-service: Python, Celery, Redis
api-gateway: Node.js, Express, Redis

Przepływ pracy rozwoju

Zawsze pracuj z workspace multi-repo
Uruchamiaj testy integracyjne przed commitowaniem
Koordynuj wdrożenia przez pociąg wydań

## Najlepsze praktyki

<CardGrid>
  <Card title="Zacznij od małego" icon="seedling">
    Rozpocznij od 2-3 powiązanych repo, rozwijaj stopniowo
  </Card>
  <Card title="Spójna struktura" icon="building">
    Utrzymuj podobne struktury katalogów w repozytoriach
  </Card>
  <Card title="Współdzielone narzędzia" icon="wrench">
    Używaj wspólnych linterów, formatterów i narzędzi budowy
  </Card>
  <Card title="Dokumentuj zależności" icon="book">
    Utrzymuj aktualne grafy zależności
  </Card>
</CardGrid>

<Aside type="caution">
  **Ostrzeżenie wydajnościowe**: Otwieranie zbyt wielu repozytoriów jednocześnie może degradować wydajność Cursor. Zacznij od podstawowych repo i dodawaj inne w miarę potrzeb.
</Aside>

## Następne kroki

Opanuj przepływy pracy multi-repo:

1. **Ustaw swój pierwszy workspace multi-root** - zacznij od 2-3 repo
2. **Zaimplementuj współdzieloną konfigurację** - standaryzuj w repozytoriach
3. **Ćwicz refaktoryzację między repo** - wypróbuj prostą zmianę nazwy
4. **Eksploruj niestandardowe reguły** - kontynuuj do następnej sekcji

Pamiętaj: przepływy pracy multi-repo dotyczą utrzymania spójności w systemach rozproszonych. Opanuj to, a będziesz obsługiwać złożone architektury z łatwością.