commiter-cli 0.3.0__py3-none-any.whl

commiter/report/console.py

@@ -0,0 +1,254 @@
+"""Rich terminal output for repository documentation."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.columns import Columns
+from rich.tree import Tree as RichTree
+
+from commiter.models import RepoDocumentation
+
+
+def print_report(docs: list[RepoDocumentation], console: Console | None = None,
+                 sections: dict[str, str | None] | None = None) -> None:
+    """Print a formatted summary of all scanned repositories to the terminal."""
+    if console is None:
+        console = Console()
+
+    for doc in docs:
+        _print_repo(doc, console, sections)
+        console.print()
+
+
+def _show_section(sections: dict[str, str | None] | None, key: str) -> bool:
+    """Check if a section should be shown based on the sections config."""
+    if sections is None:
+        return True
+    return sections.get(key) is not None
+
+
+def _print_repo(doc: RepoDocumentation, console: Console,
+                sections: dict[str, str | None] | None = None) -> None:
+    """Print a single repository's documentation."""
+    # Header
+    header = Text(f"  {doc.repo_name}", style="bold cyan")
+    console.print(Panel(header, title="Repository", border_style="cyan"))
+
+    # Overview
+    overview = Table(show_header=False, box=None, padding=(0, 2))
+    overview.add_column("Key", style="bold")
+    overview.add_column("Value")
+    overview.add_row("Path", doc.repo_path)
+    overview.add_row("Languages", ", ".join(doc.languages) if doc.languages else "none detected")
+    overview.add_row("Frameworks", ", ".join(doc.frameworks) if doc.frameworks else "none detected")
+    overview.add_row("Files scanned", str(len(doc.file_classifications)))
+
+    # Summary counts
+    counts = []
+    if doc.endpoints:
+        counts.append(f"{len(doc.endpoints)} endpoints")
+    if doc.api_calls:
+        counts.append(f"{len(doc.api_calls)} API calls")
+    if doc.db_operations:
+        counts.append(f"{len(doc.db_operations)} DB operations")
+    if doc.dependencies:
+        counts.append(f"{len(doc.dependencies)} dependencies")
+    if counts:
+        overview.add_row("Summary", ", ".join(counts))
+
+    console.print(overview)
+    console.print()
+
+    # Dependencies
+    if doc.dependencies and _show_section(sections, "deps"):
+        _print_dependencies(doc, console)
+
+    # API Endpoints
+    if doc.endpoints and _show_section(sections, "endpoints"):
+        _print_endpoints(doc, console)
+
+    # API Calls (frontend)
+    if doc.api_calls and _show_section(sections, "calls"):
+        _print_api_calls(doc, console)
+
+    # DB Operations
+    if doc.db_operations and _show_section(sections, "db"):
+        _print_db_operations(doc, console)
+
+    # Shared DB relationships
+    shared_db = [r for r in doc.service_relationships if r.connection_type == "shared_db"]
+    if shared_db and _show_section(sections, "db"):
+        _print_shared_db(shared_db, console)
+
+
+def _print_dependencies(doc: RepoDocumentation, console: Console) -> None:
+    """Print dependency table."""
+    table = Table(title="Dependencies", title_style="bold magenta")
+    table.add_column("Package", style="green")
+    table.add_column("Version")
+    table.add_column("Source")
+    table.add_column("Dev?", justify="center")
+
+    runtime = [d for d in doc.dependencies if not d.dev_only]
+    dev = [d for d in doc.dependencies if d.dev_only]
+
+    for dep in sorted(runtime, key=lambda d: d.name.lower()):
+        source_short = dep.source_file.split("/")[-1] if "/" in dep.source_file else dep.source_file
+        table.add_row(dep.name, dep.version_constraint, source_short, "")
+
+    for dep in sorted(dev, key=lambda d: d.name.lower()):
+        source_short = dep.source_file.split("/")[-1] if "/" in dep.source_file else dep.source_file
+        table.add_row(dep.name, dep.version_constraint, source_short, "yes")
+
+    console.print(table)
+    console.print()
+
+
+def _print_endpoints(doc: RepoDocumentation, console: Console) -> None:
+    """Print API endpoints — compact table + detailed cards."""
+    # Summary table with just the essentials
+    table = Table(title="API Endpoints", title_style="bold magenta")
+    table.add_column("Method", style="bold yellow", no_wrap=True)
+    table.add_column("Route", style="green")
+    table.add_column("Handler")
+    table.add_column("File", style="dim")
+
+    for ep in doc.endpoints:
+        rel_path = _rel_path(ep.file_path, doc.repo_name)
+        table.add_row(ep.http_method.upper(), ep.route_pattern, ep.handler_name, f"{rel_path}:{ep.line}")
+
+    console.print(table)
+    console.print()
+
+    # Detailed cards for endpoints that have interesting details
+    has_details = any(
+        ep.parameters or ep.request_body_fields or ep.middleware or
+        ep.auth_decorators or ep.db_tables or ep.request_body_type
+        for ep in doc.endpoints
+    )
+
+    if has_details:
+        console.print(Text("  Endpoint Details", style="bold magenta"))
+        console.print()
+
+        for ep in doc.endpoints:
+            details = _build_endpoint_details(ep)
+            if not details:
+                continue
+
+            method_style = {
+                "GET": "green", "POST": "yellow", "PUT": "blue",
+                "DELETE": "red", "PATCH": "cyan",
+            }.get(ep.http_method.upper(), "white")
+
+            title = f"[bold {method_style}]{ep.http_method.upper()}[/bold {method_style}] [green]{ep.route_pattern}[/green]"
+            panel = Panel(
+                "\n".join(details),
+                title=title,
+                title_align="left",
+                border_style="dim",
+                padding=(0, 2),
+            )
+            console.print(panel)
+
+
+def _build_endpoint_details(ep) -> list[str]:
+    """Build detail lines for an endpoint panel."""
+    details = []
+
+    rel_path = ep.file_path.split("/")[-1] if "/" in ep.file_path else ep.file_path
+    details.append(f"[bold]Handler:[/bold] {ep.handler_name}  [dim]({rel_path}:{ep.line})[/dim]")
+
+    if ep.parameters:
+        params = ", ".join(f"[cyan]{p.name}[/cyan] ({p.source.value})" for p in ep.parameters)
+        details.append(f"[bold]Params:[/bold]  {params}")
+
+    if ep.request_body_type:
+        details.append(f"[bold]Body Type:[/bold] [cyan]{ep.request_body_type}[/cyan]")
+
+    if ep.request_body_fields:
+        fields = ", ".join(f"[cyan]{f}[/cyan]" for f in ep.request_body_fields)
+        details.append(f"[bold]Body:[/bold]     {fields}")
+
+    if ep.response_fields:
+        fields = ", ".join(f"[cyan]{f}[/cyan]" for f in ep.response_fields[:6])
+        suffix = f" (+{len(ep.response_fields) - 6} more)" if len(ep.response_fields) > 6 else ""
+        details.append(f"[bold]Response:[/bold] {fields}{suffix}")
+
+    if ep.auth_decorators:
+        auth = ", ".join(f"[yellow]{a}[/yellow]" for a in ep.auth_decorators)
+        details.append(f"[bold]Auth:[/bold]     {auth}")
+
+    if ep.middleware:
+        mw = ", ".join(f"[magenta]{m}[/magenta]" for m in ep.middleware)
+        details.append(f"[bold]Middleware:[/bold] {mw}")
+
+    if ep.db_tables:
+        tables = ", ".join(f"[blue]{t}[/blue]" for t in ep.db_tables)
+        details.append(f"[bold]DB Tables:[/bold] {tables}")
+
+    # Only return details if there's more than just the handler line
+    if len(details) <= 1:
+        return []
+
+    return details
+
+
+def _print_api_calls(doc: RepoDocumentation, console: Console) -> None:
+    """Print frontend API calls table."""
+    table = Table(title="Frontend API Calls", title_style="bold magenta")
+    table.add_column("Method", style="bold yellow", no_wrap=True)
+    table.add_column("URL", style="green")
+    table.add_column("Component/Page")
+    table.add_column("Traced From", style="dim")
+
+    for call in doc.api_calls:
+        traced = call.traced_from or "-"
+        table.add_row(call.http_method.upper(), call.url_pattern, call.component_or_page, traced)
+
+    console.print(table)
+    console.print()
+
+
+def _print_db_operations(doc: RepoDocumentation, console: Console) -> None:
+    """Print database operations table."""
+    table = Table(title="Database Operations", title_style="bold magenta")
+    table.add_column("Operation", style="bold yellow", no_wrap=True)
+    table.add_column("Table", style="green")
+    table.add_column("ORM")
+    table.add_column("File", style="dim")
+    table.add_column("Filters", style="dim")
+
+    for op in doc.db_operations:
+        rel_path = _rel_path(op.file_path, doc.repo_name)
+        filters = ", ".join(op.filters) if op.filters else "-"
+        table.add_row(op.operation_type.upper(), op.table_name, op.orm_library, f"{rel_path}:{op.line}", filters)
+
+    console.print(table)
+    console.print()
+
+
+def _print_shared_db(relationships: list, console: Console) -> None:
+    """Print shared database tables between repos."""
+    table = Table(title="Shared Database Tables", title_style="bold magenta")
+    table.add_column("Table", style="green")
+    table.add_column("Used In", style="cyan")
+    table.add_column("Also Used In", style="cyan")
+    table.add_column("Confidence", justify="center")
+
+    for rel in relationships:
+        table_name = rel.target_endpoint.replace("table:", "")
+        table.add_row(table_name, f"{rel.source_repo}/", f"{rel.target_repo}/", f"{rel.confidence:.0%}")
+
+    console.print(table)
+    console.print()
+
+
+def _rel_path(file_path: str, repo_name: str) -> str:
+    """Make a file path relative for display."""
+    if repo_name + "/" in file_path:
+        return file_path.split(repo_name + "/", 1)[-1]
+    return file_path

commiter/report/json_output.py

@@ -0,0 +1,122 @@
+"""Generate structured JSON output from scanned repositories."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+
+from commiter.models import RepoDocumentation
+
+
+def generate_json(docs: list[RepoDocumentation], indent: int = 2,
+                  sections: dict[str, str | None] | None = None) -> str:
+    """Generate a JSON string from the documentation results."""
+    output = []
+    for doc in docs:
+        repo_data = _serialize_repo(doc, sections)
+        output.append(repo_data)
+
+    return json.dumps(output, indent=indent, default=str)
+
+
+def _show(sections: dict | None, key: str) -> bool:
+    if sections is None:
+        return True
+    return sections.get(key) is not None
+
+
+def _serialize_repo(doc: RepoDocumentation, sections: dict | None = None) -> dict:
+    """Serialize a RepoDocumentation to a JSON-friendly dict."""
+    result = {
+        "repo_name": doc.repo_name,
+        "repo_path": doc.repo_path,
+        "languages": doc.languages,
+        "frameworks": doc.frameworks,
+        "summary": {
+            "total_files": len(doc.file_classifications),
+            "total_endpoints": len(doc.endpoints),
+            "total_api_calls": len(doc.api_calls),
+            "total_dependencies": len(doc.dependencies),
+            "total_db_operations": len(doc.db_operations),
+            "total_relationships": len(doc.service_relationships),
+        },
+    }
+
+    if _show(sections, "endpoints"):
+        result["endpoints"] = [
+            {
+                "http_method": ep.http_method,
+                "route_pattern": ep.route_pattern,
+                "handler_name": ep.handler_name,
+                "framework": ep.framework,
+                "file_path": ep.file_path,
+                "line": ep.line,
+                "parameters": [
+                    {"name": p.name, "source": p.source.value, "type_hint": p.type_hint, "required": p.required}
+                    for p in ep.parameters
+                ],
+                "request_body_fields": ep.request_body_fields,
+                "response_fields": ep.response_fields,
+                "auth_decorators": ep.auth_decorators,
+                "db_tables": ep.db_tables,
+                "request_body_type": ep.request_body_type,
+                "response_type": ep.response_type,
+                "middleware": ep.middleware,
+            }
+            for ep in doc.endpoints
+        ]
+
+    if _show(sections, "calls"):
+        result["api_calls"] = [
+            {
+                "http_method": call.http_method,
+                "url_pattern": call.url_pattern,
+                "component_or_page": call.component_or_page,
+                "client_library": call.client_library,
+                "file_path": call.file_path,
+                "line": call.line,
+                "traced_from": call.traced_from,
+                "response_type": call.response_type,
+                "body_type": call.body_type,
+            }
+            for call in doc.api_calls
+        ]
+
+    if _show(sections, "deps"):
+        result["dependencies"] = {
+            "runtime": [
+                {"name": d.name, "version": d.version_constraint, "source": d.source_file}
+                for d in doc.dependencies if not d.dev_only
+            ],
+            "dev": [
+                {"name": d.name, "version": d.version_constraint, "source": d.source_file}
+                for d in doc.dependencies if d.dev_only
+            ],
+        }
+
+    if _show(sections, "db"):
+        result["db_operations"] = [
+            {
+                "operation_type": op.operation_type,
+                "table_name": op.table_name,
+                "orm_library": op.orm_library,
+                "file_path": op.file_path,
+                "line": op.line,
+                "filters": op.filters,
+            }
+            for op in doc.db_operations
+        ]
+
+    result["service_relationships"] = [
+        {
+            "source_repo": rel.source_repo,
+            "target_repo": rel.target_repo,
+            "connection_type": rel.connection_type,
+            "source_file": rel.source_file,
+            "target_endpoint": rel.target_endpoint,
+            "confidence": rel.confidence,
+        }
+        for rel in doc.service_relationships
+    ]
+
+    return result

commiter/report/markdown.py

@@ -0,0 +1,163 @@
+"""Generate Markdown documentation from scanned repositories."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from commiter.models import RepoDocumentation
+
+
+def generate_markdown(docs: list[RepoDocumentation],
+                      sections: dict[str, str | None] | None = None) -> str:
+    """Generate a single Markdown document covering all scanned repos."""
+    lines: list[str] = []
+
+    lines.append("# Repository Documentation\n")
+    lines.append(f"*Generated by commiter — {len(docs)} repository(ies) scanned.*\n")
+    lines.append("---\n")
+
+    for doc in docs:
+        lines.extend(_repo_section(doc, sections))
+        lines.append("---\n")
+
+    return "\n".join(lines)
+
+
+def _show(sections: dict | None, key: str) -> bool:
+    if sections is None:
+        return True
+    return sections.get(key) is not None
+
+
+def _repo_section(doc: RepoDocumentation,
+                  sections: dict[str, str | None] | None = None) -> list[str]:
+    lines: list[str] = []
+
+    lines.append(f"## {doc.repo_name}\n")
+
+    # Overview table
+    lines.append("| Property | Value |")
+    lines.append("|----------|-------|")
+    lines.append(f"| Path | `{doc.repo_path}` |")
+    lines.append(f"| Languages | {', '.join(doc.languages) if doc.languages else 'none detected'} |")
+    lines.append(f"| Frameworks | {', '.join(doc.frameworks) if doc.frameworks else 'none detected'} |")
+    lines.append(f"| Files scanned | {len(doc.file_classifications)} |")
+    lines.append("")
+
+    # API Endpoints
+    if doc.endpoints and _show(sections, "endpoints"):
+        lines.extend(_endpoints_section(doc))
+
+    # Frontend API Calls
+    if doc.api_calls and _show(sections, "calls"):
+        lines.extend(_api_calls_section(doc))
+
+    # Dependencies
+    if doc.dependencies and _show(sections, "deps"):
+        lines.extend(_dependencies_section(doc))
+
+    # DB Operations
+    if doc.db_operations and _show(sections, "db"):
+        lines.extend(_db_operations_section(doc))
+
+    return lines
+
+
+def _endpoints_section(doc: RepoDocumentation) -> list[str]:
+    lines: list[str] = []
+    lines.append("### API Endpoints\n")
+    lines.append("| Method | Route | Handler | File | Auth |")
+    lines.append("|--------|-------|---------|------|------|")
+
+    for ep in doc.endpoints:
+        rel = _rel_path(ep.file_path, doc.repo_name)
+        auth = ", ".join(ep.auth_decorators) if ep.auth_decorators else "-"
+        lines.append(f"| `{ep.http_method}` | `{ep.route_pattern}` | `{ep.handler_name}` | `{rel}:{ep.line}` | {auth} |")
+
+    lines.append("")
+
+    # Endpoint details
+    for ep in doc.endpoints:
+        lines.append(f"#### `{ep.http_method} {ep.route_pattern}`\n")
+        lines.append(f"- **Handler**: `{ep.handler_name}` ({ep.framework})")
+        if ep.parameters:
+            params_str = ", ".join(f"`{p.name}` ({p.source.value})" for p in ep.parameters)
+            lines.append(f"- **Parameters**: {params_str}")
+        if ep.request_body_fields:
+            lines.append(f"- **Request body**: {', '.join(f'`{f}`' for f in ep.request_body_fields)}")
+        if ep.response_fields:
+            lines.append(f"- **Response fields**: {', '.join(f'`{f}`' for f in ep.response_fields)}")
+        if ep.auth_decorators:
+            lines.append(f"- **Auth**: {', '.join(f'`{a}`' for a in ep.auth_decorators)}")
+        if ep.request_body_type:
+            lines.append(f"- **Request body type**: `{ep.request_body_type}`")
+        if ep.response_type:
+            lines.append(f"- **Response type**: `{ep.response_type}`")
+        if ep.middleware:
+            lines.append(f"- **Middleware**: {', '.join(f'`{m}`' for m in ep.middleware)}")
+        if ep.db_tables:
+            lines.append(f"- **DB tables**: {', '.join(f'`{t}`' for t in ep.db_tables)}")
+        lines.append("")
+
+    return lines
+
+
+def _api_calls_section(doc: RepoDocumentation) -> list[str]:
+    lines: list[str] = []
+    lines.append("### Frontend API Calls\n")
+    lines.append("| Method | URL | Component/Page | Library | Traced From |")
+    lines.append("|--------|-----|----------------|---------|-------------|")
+
+    for call in doc.api_calls:
+        traced = call.traced_from or "-"
+        lines.append(f"| `{call.http_method}` | `{call.url_pattern}` | `{call.component_or_page}` | {call.client_library} | {traced} |")
+
+    lines.append("")
+    return lines
+
+
+def _dependencies_section(doc: RepoDocumentation) -> list[str]:
+    lines: list[str] = []
+    runtime = [d for d in doc.dependencies if not d.dev_only]
+    dev = [d for d in doc.dependencies if d.dev_only]
+
+    if runtime:
+        lines.append("### Dependencies (Runtime)\n")
+        lines.append("| Package | Version | Source |")
+        lines.append("|---------|---------|--------|")
+        for dep in sorted(runtime, key=lambda d: d.name.lower()):
+            source = Path(dep.source_file).name
+            lines.append(f"| `{dep.name}` | `{dep.version_constraint}` | {source} |")
+        lines.append("")
+
+    if dev:
+        lines.append("### Dependencies (Dev)\n")
+        lines.append("| Package | Version | Source |")
+        lines.append("|---------|---------|--------|")
+        for dep in sorted(dev, key=lambda d: d.name.lower()):
+            source = Path(dep.source_file).name
+            lines.append(f"| `{dep.name}` | `{dep.version_constraint}` | {source} |")
+        lines.append("")
+
+    return lines
+
+
+def _db_operations_section(doc: RepoDocumentation) -> list[str]:
+    lines: list[str] = []
+    lines.append("### Database Operations\n")
+    lines.append("| Operation | Table | ORM | File |")
+    lines.append("|-----------|-------|-----|------|")
+
+    for op in doc.db_operations:
+        rel = _rel_path(op.file_path, doc.repo_name)
+        lines.append(f"| `{op.operation_type}` | `{op.table_name}` | {op.orm_library} | `{rel}:{op.line}` |")
+
+    lines.append("")
+    return lines
+
+
+def _rel_path(file_path: str, repo_name: str) -> str:
+    """Make a file path relative to the repo for display."""
+    if repo_name + "/" in file_path:
+        return file_path.split(repo_name + "/", 1)[-1]
+    return file_path