codebase-intel 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

codebase_intel/cli/main.py

@@ -428,6 +428,114 @@ async def _detect_patterns_async(project_root: Path, save: bool) -> None:
         console.print("\nRun with `--save` to generate a draft contract from these patterns.")
 
 
+# -------------------------------------------------------------------
+# crossrepo
+# -------------------------------------------------------------------
+
+
+@app.command(name="crossrepo")
+def crossrepo(
+    paths: Annotated[
+        Optional[list[Path]],
+        typer.Argument(help="Paths to service repos (space-separated). Omit with --all."),
+    ] = None,
+    all_registered: bool = typer.Option(False, "--all", "-A", help="Scan all globally registered projects"),
+    impact: str = typer.Option("", "--impact", "-i", help="Service ID to check impact for"),
+    verbose: bool = typer.Option(False, "--verbose", "-v"),
+) -> None:
+    """Scan multiple repos and map cross-service dependencies.
+
+    Provide paths explicitly or use --all to scan all registered projects:
+        codebase-intel crossrepo /svc1 /svc2 /svc3
+        codebase-intel crossrepo --all
+    """
+    _setup_logging(verbose)
+
+    from codebase_intel.crossrepo.registry import CrossRepoRegistry
+
+    # Resolve paths: explicit args or global registry
+    if all_registered:
+        from codebase_intel.workspace.registry import GlobalRegistry
+
+        global_registry = GlobalRegistry()
+        resolved_paths = global_registry.get_all_paths()
+        if not resolved_paths:
+            console.print("[red]No projects registered.[/red] Use `codebase-intel register` first.")
+            raise typer.Exit(1)
+        console.print(f"[cyan]Scanning {len(resolved_paths)} registered project(s)...[/cyan]")
+    elif paths:
+        resolved_paths = [p.resolve() for p in paths]
+    else:
+        console.print("[red]Provide repo paths or use --all to scan registered projects.[/red]")
+        raise typer.Exit(1)
+
+    registry_dir = resolved_paths[0].parent / ".codebase-intel-crossrepo"
+    registry = CrossRepoRegistry(registry_dir)
+
+    # Scan all services
+    for resolved in resolved_paths:
+        if not resolved.is_dir():
+            console.print(f"[red]Not a directory: {resolved}[/red]")
+            continue
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task(f"Scanning {resolved.name}...", total=None)
+            result = registry.register_service(resolved)
+            progress.update(task, description=f"Done: {result.to_dict()['endpoints']} endpoints", completed=True)
+
+    # Resolve dependencies
+    console.print()
+    deps = registry.resolve_dependencies()
+    console.print(f"[green]Resolved {len(deps)} cross-service dependencies[/green]")
+
+    # Show service map
+    service_map = registry.get_service_map()
+    table = Table(title="Service Dependency Map")
+    table.add_column("Service", style="bold")
+    table.add_column("Endpoints", justify="right")
+    table.add_column("Outbound Calls", justify="right")
+    table.add_column("Depends On", style="cyan")
+    table.add_column("Depended On By", style="yellow")
+
+    for sid, info in service_map.items():
+        table.add_row(
+            sid,
+            str(info["endpoints_exposed"]),
+            str(info["outbound_calls"]),
+            ", ".join(info["depends_on"]) or "—",
+            ", ".join(info["depended_on_by"]) or "—",
+        )
+    console.print(table)
+
+    # Impact analysis if requested
+    if impact:
+        impacts = registry.impact_analysis(impact)
+        if impacts:
+            console.print()
+            for imp in impacts:
+                risk_color = {"critical": "bold red", "high": "red", "medium": "yellow", "low": "green"}.get(imp.risk_level, "white")
+                console.print(Panel(
+                    f"Endpoint: [bold]{imp.changed_endpoint}[/bold]\n"
+                    f"Risk: [{risk_color}]{imp.risk_level.upper()}[/{risk_color}] — "
+                    f"{imp.affected_count} services affected\n\n"
+                    f"{imp.recommendation}",
+                    title=f"Impact: {impact}",
+                ))
+                for dep in imp.affected_services:
+                    critical = " [red][CRITICAL][/red]" if dep.is_critical else ""
+                    console.print(f"  → {dep.consumer_service}{critical} at {dep.file_path}:{dep.line_number or '?'}")
+        else:
+            console.print(f"[green]No cross-service impact found for {impact}[/green]")
+
+    # Save registry
+    saved = registry.save()
+    console.print(f"\n[dim]Registry saved to {saved}[/dim]")
+
+
 # -------------------------------------------------------------------
 # serve
 # -------------------------------------------------------------------
@@ -435,15 +543,234 @@ async def _detect_patterns_async(project_root: Path, save: bool) -> None:
 
 @app.command()
 def serve(
-    path: Annotated[Path, typer.Argument(help="Project root")] = Path("."),
+    path: Annotated[Optional[Path], typer.Argument(help="Project root (omit for --auto mode)")] = None,
+    auto: bool = typer.Option(False, "--auto", "-a", help="Workspace-aware mode: serve all registered projects"),
     verbose: bool = typer.Option(False, "--verbose", "-v"),
 ) -> None:
-    """Start the MCP server (stdio transport)."""
+    """Start the MCP server (stdio transport).
+
+    Single-project mode (default):
+        codebase-intel serve /path/to/project
+
+    Multi-project mode (global):
+        codebase-intel serve --auto
+
+    In --auto mode, the server routes each request to the correct project
+    based on file paths. Register projects first with `codebase-intel register`.
+    """
     _setup_logging(verbose)
-    console.print("[dim]Starting MCP server over stdio...[/dim]", err=True)
 
     from codebase_intel.mcp.server import run_server
-    asyncio.run(run_server(path.resolve()))
+
+    if auto:
+        console.print("[dim]Starting MCP server in workspace-aware mode...[/dim]", err=True)
+        asyncio.run(run_server(auto_mode=True))
+    else:
+        project_root = (path or Path(".")).resolve()
+        console.print(f"[dim]Starting MCP server for {project_root.name}...[/dim]", err=True)
+        asyncio.run(run_server(project_root))
+
+
+# -------------------------------------------------------------------
+# register / unregister / projects (global workspace)
+# -------------------------------------------------------------------
+
+
+@app.command()
+def register(
+    path: Annotated[Path, typer.Argument(help="Project root to register")] = Path("."),
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Display name for the project"),
+    project_id: Optional[str] = typer.Option(None, "--id", help="Custom project ID (default: directory name)"),
+) -> None:
+    """Register a project in the global registry.
+
+    Once registered, the project is available to `codebase-intel serve --auto`
+    and `codebase-intel crossrepo scan --all`.
+
+    Examples:
+        codebase-intel register /path/to/user-service
+        codebase-intel register . --name "Payment API" --id payment-api
+    """
+    from codebase_intel.workspace.registry import GlobalRegistry
+
+    registry = GlobalRegistry()
+    resolved = path.resolve()
+
+    if not resolved.is_dir():
+        console.print(f"[red]Not a directory: {resolved}[/red]")
+        raise typer.Exit(1)
+
+    entry = registry.register(resolved, project_id=project_id, name=name)
+
+    init_status = "[green]initialized[/green]" if entry.initialized else "[yellow]not initialized[/yellow]"
+    console.print(
+        f"[green]Registered[/green] [bold]{entry.project_id}[/bold] "
+        f"→ {entry.root_path} ({init_status})"
+    )
+
+    if not entry.initialized:
+        console.print(
+            f"[dim]Run `codebase-intel init {resolved}` to build the code graph.[/dim]"
+        )
+
+
+@app.command()
+def unregister(
+    project_id: Annotated[str, typer.Argument(help="Project ID to remove")],
+) -> None:
+    """Remove a project from the global registry."""
+    from codebase_intel.workspace.registry import GlobalRegistry
+
+    registry = GlobalRegistry()
+
+    if registry.unregister(project_id):
+        console.print(f"[green]Unregistered[/green] [bold]{project_id}[/bold]")
+    else:
+        console.print(f"[red]Project '{project_id}' not found in registry[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def projects() -> None:
+    """List all globally registered projects."""
+    from codebase_intel.workspace.registry import GlobalRegistry
+
+    registry = GlobalRegistry()
+    all_projects = registry.get_all()
+
+    if not all_projects:
+        console.print("[yellow]No projects registered.[/yellow]")
+        console.print("Register with: `codebase-intel register /path/to/project`")
+        return
+
+    table = Table(title="Registered Projects")
+    table.add_column("ID", style="bold")
+    table.add_column("Name")
+    table.add_column("Path")
+    table.add_column("Status")
+    table.add_column("Initialized")
+    table.add_column("Last Accessed", style="dim")
+
+    for entry in all_projects:
+        exists = entry.is_valid
+        status = "[green]OK[/green]" if exists else "[red]MISSING[/red]"
+        init_status = "[green]Yes[/green]" if entry.initialized else "[yellow]No[/yellow]"
+        last_accessed = (
+            entry.last_accessed.strftime("%Y-%m-%d %H:%M")
+            if entry.last_accessed
+            else "—"
+        )
+
+        table.add_row(
+            entry.project_id,
+            entry.name,
+            entry.root_path,
+            status,
+            init_status,
+            last_accessed,
+        )
+
+    console.print(table)
+    console.print(f"\n[dim]{len(all_projects)} project(s) registered. "
+                  f"Use `codebase-intel serve --auto` to serve all.[/dim]")
+
+
+# -------------------------------------------------------------------
+# intent
+# -------------------------------------------------------------------
+
+
+@app.command()
+def intent(
+    path: Annotated[Path, typer.Argument(help="Project root")] = Path("."),
+    verify: bool = typer.Option(False, "--verify", "-v", help="Run verification on all active intents"),
+) -> None:
+    """Show and verify tracked intents — what was requested vs what's delivered."""
+    asyncio.run(_intent_async(path.resolve(), verify))
+
+
+async def _intent_async(project_root: Path, verify: bool) -> None:
+    from codebase_intel.intent.store import IntentStore
+    from codebase_intel.intent.verifier import IntentVerifier
+
+    intents_dir = project_root / ".codebase-intel" / "intents"
+    store = IntentStore(intents_dir)
+    all_intents = store.load_all()
+
+    if not all_intents:
+        console.print("[yellow]No intents tracked yet.[/yellow]")
+        console.print("Use the MCP tool `set_intent` to capture goals with acceptance criteria.")
+        return
+
+    if verify:
+        verifier = IntentVerifier(project_root)
+        console.print()
+
+        for intent_obj in all_intents:
+            if intent_obj.status.value not in ("active", "partial"):
+                continue
+
+            report = await verifier.verify(intent_obj)
+
+            # Update stored state
+            updated_criteria = []
+            for r in report.results:
+                updated_criteria.append(r.criterion.model_copy(update={
+                    "verified": r.passed,
+                    "failure_reason": r.failure_reason,
+                }))
+            store.update_criteria(intent_obj.id, updated_criteria)
+            store.update_status(intent_obj.id, report.status)
+
+            # Display
+            status_color = {
+                "verified": "green",
+                "partial": "yellow",
+                "failed": "red",
+                "active": "cyan",
+            }.get(report.status.value, "white")
+
+            console.print(Panel(
+                f"[bold]{intent_obj.title}[/bold]\n"
+                f"Status: [{status_color}]{report.status.value.upper()}[/{status_color}] — "
+                f"{report.passed_count}/{report.total} criteria met",
+                title=f"Intent {intent_obj.id}",
+            ))
+
+            for r in report.results:
+                icon = "[green]PASS[/green]" if r.passed else "[red]FAIL[/red]"
+                console.print(f"  {icon} {r.criterion.description}")
+                if r.failure_reason:
+                    console.print(f"       [dim]{r.failure_reason}[/dim]")
+            console.print()
+
+    else:
+        # Just show status
+        table = Table(title="Tracked Intents")
+        table.add_column("ID", style="dim")
+        table.add_column("Title", style="bold")
+        table.add_column("Status")
+        table.add_column("Progress", justify="right")
+        table.add_column("Gaps", justify="right", style="red")
+
+        for i in all_intents:
+            status_color = {
+                "verified": "green",
+                "partial": "yellow",
+                "failed": "red",
+                "active": "cyan",
+                "abandoned": "dim",
+            }.get(i.status.value, "white")
+
+            table.add_row(
+                i.id,
+                i.title[:50],
+                f"[{status_color}]{i.status.value}[/{status_color}]",
+                f"{i.criteria_met}/{i.criteria_total} ({i.completion_pct:.0f}%)",
+                str(len(i.gaps)),
+            )
+        console.print(table)
+        console.print("\nRun with `--verify` to check all criteria against the actual codebase.")
 
 
 # -------------------------------------------------------------------

codebase_intel/crossrepo/__init__.py

@@ -0,0 +1 @@
+"""Cross-repo awareness — tracks API contracts and dependencies between services."""

codebase_intel/crossrepo/models.py

@@ -0,0 +1,199 @@
+"""Cross-repo models — schemas for service dependencies and API contracts.
+
+In a microservice architecture, the most dangerous changes are ones that
+break OTHER services. Changing an endpoint in service A silently breaks
+service B, C, and D that call it. Nobody knows until production.
+
+This module tracks:
+1. Service Registry — what services exist and where they live
+2. API Contracts — what endpoints each service exposes
+3. Service Dependencies — which services call which endpoints
+4. Impact Propagation — "if this endpoint changes, which services break?"
+
+Edge cases:
+- Service not yet indexed: discovered incrementally as repos are scanned
+- Endpoint renamed: old contract marked deprecated, consumers flagged
+- Service removed: all dependents get critical warnings
+- Shared types diverge: contract A says field is string, contract B says int
+- Async communication (queues): tracked as event contracts, not HTTP
+- Multiple versions of same API: tracked with version tags
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class ServiceStatus(str, Enum):
+    ACTIVE = "active"
+    DEPRECATED = "deprecated"
+    REMOVED = "removed"
+
+
+class ProtocolType(str, Enum):
+    HTTP = "http"
+    GRPC = "grpc"
+    GRAPHQL = "graphql"
+    EVENT = "event"  # Message queue / pub-sub
+    INTERNAL = "internal"  # Direct function call (monorepo)
+
+
+class HttpMethod(str, Enum):
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    PATCH = "PATCH"
+    DELETE = "DELETE"
+    ANY = "ANY"
+
+
+class ContractStatus(str, Enum):
+    ACTIVE = "active"
+    DEPRECATED = "deprecated"
+    BREAKING_CHANGE = "breaking_change"
+    REMOVED = "removed"
+
+
+class ServiceInfo(BaseModel):
+    """A microservice in the ecosystem."""
+
+    model_config = ConfigDict(frozen=True)
+
+    service_id: str = Field(description="Unique ID: e.g., 'user-module'")
+    name: str = Field(description="Human name: 'User Management Service'")
+    repo_path: str = Field(description="Absolute path to the repo root")
+    status: ServiceStatus = ServiceStatus.ACTIVE
+    base_url_env: str = Field(
+        default="",
+        description="Env var that holds this service's base URL (e.g., USER_SERVICE_URL)",
+    )
+    tech_stack: str = Field(default="", description="e.g., 'FastAPI + Tortoise ORM'")
+    description: str = ""
+    indexed_at: datetime | None = None
+
+    @field_validator("indexed_at")
+    @classmethod
+    def ensure_utc(cls, v: datetime | None) -> datetime | None:
+        if v is None:
+            return None
+        if v.tzinfo is None:
+            return v.replace(tzinfo=UTC)
+        return v.astimezone(UTC)
+
+
+class APIEndpoint(BaseModel):
+    """An API endpoint exposed by a service."""
+
+    model_config = ConfigDict(frozen=True)
+
+    path: str = Field(description="Route path: '/api/v1/users/{user_id}'")
+    method: HttpMethod = HttpMethod.ANY
+    service_id: str = Field(description="Which service exposes this")
+    protocol: ProtocolType = ProtocolType.HTTP
+
+    # Schema info (what the endpoint expects/returns)
+    request_schema: str = Field(default="", description="Pydantic model name or JSON schema ref")
+    response_schema: str = Field(default="", description="Pydantic model name or JSON schema ref")
+    description: str = ""
+
+    # Source code location
+    file_path: str = ""
+    line_number: int | None = None
+    function_name: str = ""
+
+    # Contract status
+    status: ContractStatus = ContractStatus.ACTIVE
+    version: str = Field(default="v1", description="API version")
+    deprecated_at: datetime | None = None
+    breaking_changes: list[str] = Field(default_factory=list)
+
+
+class EventContract(BaseModel):
+    """An event/message published or consumed by a service."""
+
+    model_config = ConfigDict(frozen=True)
+
+    event_name: str = Field(description="Event type: 'user.created', 'order.completed'")
+    service_id: str
+    direction: str = Field(description="'publishes' or 'consumes'")
+    protocol: ProtocolType = ProtocolType.EVENT
+    payload_schema: str = ""
+    queue_name: str = ""
+    description: str = ""
+    file_path: str = ""
+
+
+class ServiceDependency(BaseModel):
+    """A dependency between two services — service A calls service B."""
+
+    model_config = ConfigDict(frozen=True)
+
+    consumer_service: str = Field(description="Service that makes the call")
+    provider_service: str = Field(description="Service that handles the call")
+    endpoint_path: str = Field(description="Which endpoint is called")
+    method: HttpMethod = HttpMethod.ANY
+
+    # How the call is made
+    call_pattern: str = Field(
+        default="",
+        description="How it's called: 'httpx.get(URL)', 'requests.post()', etc.",
+    )
+    file_path: str = Field(default="", description="Where the call is made")
+    line_number: int | None = None
+
+    # Risk assessment
+    is_critical: bool = Field(
+        default=False,
+        description="True if this dependency is in a critical path (auth, payment)",
+    )
+    has_fallback: bool = Field(
+        default=False,
+        description="True if there's a fallback/retry mechanism",
+    )
+    has_circuit_breaker: bool = Field(
+        default=False,
+        description="True if circuit breaker pattern is implemented",
+    )
+
+
+class CrossRepoImpact(BaseModel):
+    """Impact analysis result — what breaks across services when something changes."""
+
+    changed_service: str
+    changed_endpoint: str
+    changed_file: str = ""
+    affected_services: list[ServiceDependency] = Field(default_factory=list)
+    risk_level: str = Field(
+        default="low",
+        description="low / medium / high / critical",
+    )
+    recommendation: str = ""
+
+    @property
+    def affected_count(self) -> int:
+        return len(self.affected_services)
+
+    def to_context_string(self) -> str:
+        lines = [
+            f"## Cross-Service Impact: {self.changed_service}",
+            f"Changed: {self.changed_endpoint}",
+            f"Risk: **{self.risk_level.upper()}** — {self.affected_count} services affected",
+            "",
+        ]
+        for dep in self.affected_services:
+            critical = " [CRITICAL]" if dep.is_critical else ""
+            fallback = " (has fallback)" if dep.has_fallback else " (NO fallback)"
+            lines.append(
+                f"- **{dep.consumer_service}** calls this endpoint{critical}{fallback}"
+            )
+            if dep.file_path:
+                lines.append(f"  at {dep.file_path}:{dep.line_number or '?'}")
+
+        if self.recommendation:
+            lines.append(f"\n**Recommendation:** {self.recommendation}")
+
+        return "\n".join(lines)