codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/cli/commands/plugin_cmd.py

@@ -0,0 +1,275 @@
+"""CLI command: plugin — manage and scaffold plugins."""
+
+from __future__ import annotations
+
+import json as json_mod
+import textwrap
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+    print_success,
+)
+
+logger = get_logger("cli.plugin")
+
+
+PLUGIN_TEMPLATE = textwrap.dedent('''\
+    """CodexA plugin: {name}
+
+    {description}
+    """
+
+    from __future__ import annotations
+
+    from typing import Any
+
+    from semantic_code_intelligence.plugins import PluginBase, PluginHook, PluginMetadata
+
+
+    class {class_name}(PluginBase):
+        """Plugin implementation for {name}."""
+
+        def metadata(self) -> PluginMetadata:
+            return PluginMetadata(
+                name="{name}",
+                version="0.1.0",
+                description="{description}",
+                author="{author}",
+                hooks=[{hooks}],
+            )
+
+        def activate(self, context: dict[str, Any]) -> None:
+            """Called when the plugin is activated."""
+
+        def deactivate(self) -> None:
+            """Called when the plugin is deactivated."""
+
+        def on_hook(self, hook: PluginHook, data: dict[str, Any]) -> dict[str, Any]:
+            """Process hook events.
+
+            Args:
+                hook: The hook that fired.
+                data: Hook-specific data. Modify and return.
+            """
+            # Add your logic here
+            return data
+
+
+    def create_plugin() -> {class_name}:
+        """Factory function for plugin discovery."""
+        return {class_name}()
+''')
+
+
+@click.group("plugin")
+def plugin_cmd() -> None:
+    """Manage CodexA plugins."""
+
+
+@plugin_cmd.command("new")
+@click.argument("name")
+@click.option(
+    "--description",
+    "-d",
+    default="A CodexA plugin",
+    help="Plugin description.",
+)
+@click.option(
+    "--author",
+    "-a",
+    default="",
+    help="Plugin author name.",
+)
+@click.option(
+    "--hooks",
+    "-H",
+    default="POST_SEARCH",
+    help="Comma-separated hook names (e.g. POST_SEARCH,POST_AI).",
+)
+@click.option(
+    "--output",
+    "-o",
+    default=None,
+    type=click.Path(file_okay=False),
+    help="Output directory (default: .codexa/plugins/).",
+)
+def plugin_new(name: str, description: str, author: str, hooks: str, output: str | None) -> None:
+    """Scaffold a new plugin from template.
+
+    Creates a ready-to-use plugin file with the correct structure.
+
+    Examples:
+
+        codexa plugin new my-formatter
+
+        codexa plugin new lint-checker --hooks CUSTOM_VALIDATION,POST_AI
+
+        codexa plugin new metrics -o ./plugins/ -a "Your Name"
+    """
+    # Validate hook names
+    from semantic_code_intelligence.plugins import PluginHook
+
+    hook_names = [h.strip().upper() for h in hooks.split(",") if h.strip()]
+    valid_hooks = {h.name for h in PluginHook}
+    for h in hook_names:
+        if h not in valid_hooks:
+            print_error(f"Unknown hook: {h}. Valid hooks: {', '.join(sorted(valid_hooks))}")
+            return
+
+    hook_refs = ", ".join(f"PluginHook.{h}" for h in hook_names)
+
+    # Build class name from plugin name
+    class_name = "".join(part.capitalize() for part in name.replace("-", "_").split("_")) + "Plugin"
+
+    content = PLUGIN_TEMPLATE.format(
+        name=name,
+        description=description,
+        author=author,
+        class_name=class_name,
+        hooks=hook_refs,
+    )
+
+    # Determine output path
+    if output:
+        out_dir = Path(output).resolve()
+    else:
+        out_dir = Path(".codexa/plugins").resolve()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    filename = name.replace("-", "_") + ".py"
+    filepath = out_dir / filename
+
+    if filepath.exists():
+        print_error(f"File already exists: {filepath}")
+        return
+
+    filepath.write_text(content, encoding="utf-8")
+    print_success(f"Created plugin: {filepath}")
+    print_info(f"Register it by placing it in .codexa/plugins/ or calling PluginManager.register()")
+
+
+@plugin_cmd.command("list")
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output results in JSON format.",
+)
+def plugin_list(path: str, json_mode: bool) -> None:
+    """List available plugins in the project.
+
+    Scans .codexa/plugins/ for discoverable plugin files.
+
+    Examples:
+
+        codexa plugin list
+
+        codexa plugin list --json
+    """
+    from semantic_code_intelligence.plugins import PluginManager
+
+    plugin_dir = Path(path) / ".codexa" / "plugins"
+    mgr = PluginManager()
+
+    if plugin_dir.is_dir():
+        count = mgr.discover_from_directory(plugin_dir)
+    else:
+        count = 0
+
+    plugins = []
+    for name in mgr.registered_plugins:
+        info = mgr.get_plugin_info(name)
+        if info:
+            plugins.append(info)
+
+    if json_mode:
+        click.echo(json_mod.dumps({"plugins": plugins, "count": len(plugins)}, indent=2))
+        return
+
+    if not plugins:
+        print_info(f"No plugins found in {plugin_dir}/")
+        print_info("Create one with: codexa plugin new <name>")
+        return
+
+    from rich.table import Table
+
+    table = Table(title="Discovered Plugins")
+    table.add_column("Name", style="bold")
+    table.add_column("Version")
+    table.add_column("Description")
+    table.add_column("Hooks")
+
+    for p in plugins:
+        table.add_row(
+            p["name"],
+            p["version"],
+            p["description"],
+            ", ".join(p.get("hooks", [])),
+        )
+
+    console.print(table)
+
+
+@plugin_cmd.command("info")
+@click.argument("name")
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output in JSON format.",
+)
+def plugin_info(name: str, path: str, json_mode: bool) -> None:
+    """Show details about a specific plugin.
+
+    Examples:
+
+        codexa plugin info my-formatter
+    """
+    from semantic_code_intelligence.plugins import PluginManager
+
+    plugin_dir = Path(path) / ".codexa" / "plugins"
+    mgr = PluginManager()
+
+    if plugin_dir.is_dir():
+        mgr.discover_from_directory(plugin_dir)
+
+    info = mgr.get_plugin_info(name)
+    if info is None:
+        print_error(f"Plugin '{name}' not found.")
+        return
+
+    if json_mode:
+        click.echo(json_mod.dumps(info, indent=2))
+        return
+
+    console.print(f"[bold]{info['name']}[/bold] v{info['version']}")
+    if info.get("description"):
+        console.print(f"  {info['description']}")
+    if info.get("author"):
+        console.print(f"  Author: {info['author']}")
+    console.print(f"  Hooks: {', '.join(info.get('hooks', []))}")
+    console.print(f"  Active: {info.get('active', False)}")

semantic_code_intelligence/cli/commands/pr_summary_cmd.py

@@ -0,0 +1,178 @@
+"""CLI command: pr-summary — generate PR intelligence report."""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+)
+
+logger = get_logger("cli.pr_summary")
+
+
+def _find_changed_files(root: Path) -> list[str]:
+    """Discover changed files using simple heuristics.
+
+    Checks for:
+    1. Git diff (if inside a git repo).
+    2. Falls back to all supported source files.
+    """
+    import subprocess
+
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", "HEAD~1", "HEAD"],
+            capture_output=True,
+            text=True,
+            cwd=str(root),
+            timeout=10,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            files = []
+            for line in result.stdout.strip().splitlines():
+                fpath = root / line.strip()
+                if fpath.exists():
+                    files.append(str(fpath))
+            if files:
+                return files
+    except Exception:
+        logger.debug("git diff-tree failed; falling back to full file scan")
+
+    # Fallback: list all supported source files
+    from semantic_code_intelligence.parsing.parser import EXTENSION_TO_LANGUAGE
+    files = []
+    for f in root.rglob("*"):
+        if f.is_file() and f.suffix in EXTENSION_TO_LANGUAGE:
+            parts = f.relative_to(root).parts
+            if any(p.startswith(".") or p in ("__pycache__", "node_modules") for p in parts):
+                continue
+            files.append(str(f))
+    return files
+
+
+@click.command("pr-summary")
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output in JSON format.",
+)
+@click.option(
+    "--files",
+    "-f",
+    multiple=True,
+    help="Specific files to analyze (can be repeated).",
+)
+@click.option(
+    "--pipe",
+    is_flag=True,
+    default=False,
+    help="Plain text output for piping / CI.",
+)
+@click.pass_context
+def pr_summary_cmd(
+    ctx: click.Context,
+    path: str,
+    json_mode: bool,
+    files: tuple[str, ...],
+    pipe: bool,
+) -> None:
+    """Generate a Pull Request intelligence report.
+
+    Analyzes changed files to produce a change summary, semantic impact
+    analysis, suggested reviewer domains, and risk scoring.
+
+    All output is advisory — CodexA never modifies repository code.
+
+    Examples:
+
+        codexa pr-summary
+
+        codexa pr-summary --json
+
+        codexa pr-summary -f src/main.py -f src/utils.py
+    """
+    from semantic_code_intelligence.ci.pr import generate_pr_report
+
+    root = Path(path).resolve()
+    changed = list(files) if files else _find_changed_files(root)
+
+    if not changed:
+        if json_mode:
+            click.echo(json_mod.dumps({"error": "No changed files found"}, indent=2))
+        else:
+            print_info("No changed files found")
+        return
+
+    report = generate_pr_report(changed, root)
+
+    if json_mode:
+        click.echo(json_mod.dumps(report.to_dict(), indent=2))
+        return
+
+    cs = report.change_summary
+    if pipe:
+        click.echo(f"Changed: {cs.files_changed} files  Languages: {', '.join(cs.languages) or 'none'}")
+        click.echo(f"Symbols: +{cs.total_symbols_added} -{cs.total_symbols_removed} ~{cs.total_symbols_modified}")
+        if report.risk:
+            click.echo(f"Risk: {report.risk.level} ({report.risk.score}/100)")
+            for f in report.risk.factors:
+                click.echo(f"  - {f}")
+        return
+
+    # Rich output
+    console.print(f"\n[bold cyan]PR Summary[/bold cyan]\n")
+    console.print(f"  Files changed: {cs.files_changed}")
+    console.print(f"  Languages: {', '.join(cs.languages) or 'none'}")
+    console.print(f"  Symbols: [green]+{cs.total_symbols_added}[/green] [red]-{cs.total_symbols_removed}[/red] [yellow]~{cs.total_symbols_modified}[/yellow]\n")
+
+    if cs.file_details:
+        console.print("[bold]File Details:[/bold]")
+        for fd in cs.file_details:
+            lang_tag = f" [{fd.language}]" if fd.language else ""
+            console.print(f"  {fd.path}{lang_tag}")
+            if fd.symbols_added:
+                console.print(f"    [green]+ {', '.join(fd.symbols_added)}[/green]")
+            if fd.symbols_removed:
+                console.print(f"    [red]- {', '.join(fd.symbols_removed)}[/red]")
+            if fd.symbols_modified:
+                console.print(f"    [yellow]~ {', '.join(fd.symbols_modified)}[/yellow]")
+        console.print()
+
+    if report.impact:
+        imp = report.impact
+        if imp.affected_symbols:
+            console.print("[bold]Impact — Affected Symbols:[/bold]")
+            for s in imp.affected_symbols[:20]:
+                console.print(f"  {s}")
+            console.print()
+
+    if report.reviewers:
+        console.print("[bold]Suggested Reviewer Domains:[/bold]")
+        for r in report.reviewers[:10]:
+            console.print(f"  {r['domain']} ({r['file_count']} file(s))")
+        console.print()
+
+    if report.risk:
+        color = {"low": "green", "medium": "yellow", "high": "red", "critical": "bold red"}
+        c = color.get(report.risk.level, "white")
+        console.print(f"[{c}]Risk: {report.risk.level.upper()} ({report.risk.score}/100)[/{c}]")
+        for f in report.risk.factors:
+            console.print(f"  - {f}")
+        console.print()

semantic_code_intelligence/cli/commands/quality_cmd.py

@@ -0,0 +1,208 @@
+"""CLI command: quality — run code quality analysis."""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_success,
+)
+
+if TYPE_CHECKING:
+    from semantic_code_intelligence.ci.quality import QualityReport
+    from semantic_code_intelligence.llm.safety import SafetyResult
+
+logger = get_logger("cli.quality")
+
+
+# ------------------------------------------------------------------
+# Output helpers — each handles one output format
+# ------------------------------------------------------------------
+
+
+def _output_safety(safety: "SafetyResult", count: int, *, json_mode: bool, pipe: bool) -> None:
+    """Emit safety-only results in the requested format."""
+    if json_mode:
+        click.echo(json_mod.dumps({
+            "files_analyzed": count,
+            "safety": safety.to_dict(),
+        }, indent=2))
+    elif pipe:
+        if safety.safe:
+            click.echo(f"PASS  {count} files scanned, no safety issues")
+        else:
+            click.echo(f"FAIL  {count} files scanned, {len(safety.issues)} safety issue(s)")
+            for issue in safety.issues:
+                click.echo(f"  L{issue.line_number}: {issue.description}")
+    else:
+        if safety.safe:
+            print_success(f"Safety check passed — {count} files scanned")
+        else:
+            print_error(f"{len(safety.issues)} safety issue(s) found in {count} files")
+            for issue in safety.issues:
+                console.print(f"  [yellow]L{issue.line_number}[/yellow]: {issue.description}")
+
+
+def _output_report_pipe(report: "QualityReport") -> None:
+    """Emit full quality report in pipe-friendly plain text."""
+    mi_str = f"  MI: {report.maintainability_index:.1f}" if report.maintainability_index is not None else ""
+    click.echo(f"Files: {report.files_analyzed}  Symbols: {report.symbol_count}  Issues: {report.issue_count}{mi_str}")
+    for c in report.complexity_issues:
+        click.echo(f"  COMPLEXITY  {c.symbol_name} ({c.file_path}:{c.start_line}) score={c.complexity} [{c.rating}]")
+    for d in report.dead_code:
+        click.echo(f"  DEAD_CODE   {d.symbol_name} ({d.file_path}:{d.start_line}) kind={d.kind}")
+    for dup in report.duplicates:
+        click.echo(f"  DUPLICATE   {dup.symbol_a} ↔ {dup.symbol_b} sim={dup.similarity:.2f}")
+    for b in report.bandit_issues:
+        click.echo(f"  SECURITY    [{b.test_id}] {b.text} ({b.file_path}:{b.line}) sev={b.severity}")
+    if report.safety and not report.safety.safe:
+        for i in report.safety.issues:
+            click.echo(f"  SAFETY      L{i.line_number}: {i.description}")
+
+
+def _output_report_rich(report: "QualityReport", root: Path) -> None:
+    """Emit full quality report with Rich formatting."""
+    console.print(f"\n[bold cyan]Quality Report[/bold cyan] — {root}\n")
+    console.print(f"  Files analyzed: {report.files_analyzed}")
+    console.print(f"  Symbols: {report.symbol_count}")
+    console.print(f"  Issues: {report.issue_count}")
+    if report.maintainability_index is not None:
+        console.print(f"  Maintainability Index: {report.maintainability_index:.1f}")
+    console.print()
+
+    if report.complexity_issues:
+        console.print("[bold yellow]High Complexity Functions:[/bold yellow]")
+        for c in report.complexity_issues:
+            console.print(f"  {c.symbol_name} ({c.file_path}:{c.start_line}) — score {c.complexity} [{c.rating}]")
+        console.print()
+
+    if report.dead_code:
+        console.print("[bold yellow]Potentially Dead Code:[/bold yellow]")
+        for d in report.dead_code:
+            console.print(f"  {d.symbol_name} ({d.file_path}:{d.start_line}) — {d.kind}")
+        console.print()
+
+    if report.duplicates:
+        console.print("[bold yellow]Duplicate Logic:[/bold yellow]")
+        for dup in report.duplicates:
+            console.print(f"  {dup.symbol_a} ↔ {dup.symbol_b} — {dup.similarity:.0%} similar")
+        console.print()
+
+    if report.bandit_issues:
+        console.print("[bold red]Security Issues (Bandit):[/bold red]")
+        for b in report.bandit_issues:
+            console.print(f"  [{b.test_id}] {b.text} ({b.file_path}:{b.line}) — {b.severity}")
+        console.print()
+
+    if report.safety and not report.safety.safe:
+        console.print("[bold red]Safety Issues:[/bold red]")
+        for i in report.safety.issues:
+            console.print(f"  L{i.line_number}: {i.description}")
+        console.print()
+
+    if report.issue_count == 0:
+        print_success("No quality issues found")
+
+
+@click.command("quality")
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output in JSON format.",
+)
+@click.option(
+    "--complexity-threshold",
+    type=int,
+    default=10,
+    help="Minimum cyclomatic complexity to report (default: 10).",
+)
+@click.option(
+    "--safety-only",
+    is_flag=True,
+    default=False,
+    help="Run only the safety validator (fast mode).",
+)
+@click.option(
+    "--pipe",
+    is_flag=True,
+    default=False,
+    help="Plain text output for piping / CI.",
+)
+@click.pass_context
+def quality_cmd(
+    ctx: click.Context,
+    path: str,
+    json_mode: bool,
+    complexity_threshold: int,
+    safety_only: bool,
+    pipe: bool,
+) -> None:
+    """Analyze code quality — complexity, dead code, duplicates, security.
+
+    Scans the project for quality issues and produces a human-readable or
+    JSON report.  Useful for CI pipelines and local development.
+
+    Examples:
+
+        codexa quality
+
+        codexa quality --json
+
+        codexa quality --safety-only --pipe
+
+        codexa quality --complexity-threshold 15
+    """
+    from semantic_code_intelligence.ci.quality import analyze_project, QualityReport
+    from semantic_code_intelligence.llm.safety import SafetyValidator
+
+    root = Path(path).resolve()
+
+    if safety_only:
+        # Fast path: only safety scan
+        from semantic_code_intelligence.parsing.parser import EXTENSION_TO_LANGUAGE
+        code = ""
+        count = 0
+        for f in root.rglob("*"):
+            if f.is_file() and f.suffix in EXTENSION_TO_LANGUAGE:
+                parts = f.relative_to(root).parts
+                if any(p.startswith(".") or p in ("__pycache__", "node_modules") for p in parts):
+                    continue
+                try:
+                    code += f.read_text(encoding="utf-8", errors="replace") + "\n"
+                    count += 1
+                except Exception:
+                    logger.debug("Skipping unreadable file: %s", f)
+        validator = SafetyValidator()
+        safety = validator.validate(code)
+        _output_safety(safety, count, json_mode=json_mode, pipe=pipe)
+        return
+
+    # Full quality analysis
+    report = analyze_project(
+        root,
+        complexity_threshold=complexity_threshold,
+    )
+
+    if json_mode:
+        click.echo(json_mod.dumps(report.to_dict(), indent=2))
+    elif pipe:
+        _output_report_pipe(report)
+    else:
+        _output_report_rich(report, root)