opencontext-cli 0.3.0__tar.gz → 1.0.0__tar.gz

{opencontext_cli-0.3.0 → opencontext_cli-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencontext-cli
-Version: 0.3.0
+Version: 1.0.0
 Summary: CLI adapter for OpenContext Runtime
 Author: OpenContext Runtime maintainers
 License-Expression: MIT
@@ -9,7 +9,7 @@ Project-URL: Documentation, https://github.com/CesarMSFelipe/OpenContext-Runtime
 Project-URL: Issues, https://github.com/CesarMSFelipe/OpenContext-Runtime/issues
 Project-URL: Source, https://github.com/CesarMSFelipe/OpenContext-Runtime
 Keywords: ai,llm,context-engineering,cli,security
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -21,6 +21,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: opencontext-core>=0.1.0
 Requires-Dist: opencontext-profiles>=0.1.0
+Requires-Dist: argcomplete>=3.0.0
 Dynamic: license-file
 
 # opencontext-cli

opencontext_cli-1.0.0/opencontext_cli/commands/benchmark_cmd.py

@@ -0,0 +1,162 @@
+"""Benchmark CLI commands: run, list, and compare benchmarks."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from opencontext_core.dx.console_styles import console
+from opencontext_core.evaluation.benchmark_suite import (
+    BenchmarkSuite,
+    format_benchmark_report_markdown,
+    format_benchmark_result,
+    format_benchmark_result_json,
+    load_last_result,
+    save_result,
+)
+
+
+def add_benchmark_parser(subparsers: Any) -> None:
+    """Add benchmark command parsers."""
+    bm_parser = subparsers.add_parser("benchmark", help="Run and manage benchmarks.")
+    bm_sub = bm_parser.add_subparsers(dest="benchmark_command", required=True)
+
+    # benchmark list
+    list_parser = bm_sub.add_parser("list", help="List available benchmark cases.")
+    list_parser.add_argument("--category", default=None, help="Filter by category.")
+
+    # benchmark run
+    run_parser = bm_sub.add_parser("run", help="Run benchmark cases.")
+    run_parser.add_argument("--case", default=None, help="Specific case ID to run.")
+    run_parser.add_argument("--category", default=None, help="Filter by category.")
+    run_parser.add_argument(
+        "--format",
+        default="text",
+        choices=["text", "json", "markdown"],
+        help="Output format.",
+    )
+    run_parser.add_argument("--output", default=None, help="Output file (for markdown).")
+    run_parser.add_argument("--save", action="store_true", help="Save results.")
+
+    # benchmark compare
+    compare_parser = bm_sub.add_parser("compare", help="Compare against last baseline.")
+    compare_parser.add_argument(
+        "--output", default=None, help="Output file for markdown comparison."
+    )
+
+
+def handle_benchmark(args: Any) -> None:
+    """Handle benchmark commands."""
+    command = args.benchmark_command
+
+    if command == "list":
+        _handle_list(args)
+    elif command == "run":
+        _handle_run(args)
+    elif command == "compare":
+        _handle_compare(args)
+
+
+def _handle_list(args: Any) -> None:
+    """List available benchmark cases."""
+    suite = BenchmarkSuite()
+    cases = suite.list_cases(category=args.category)
+
+    if not cases:
+        console.print("[yellow]No benchmark cases found.[/]")
+        return
+
+    from rich.table import Table
+
+    table = Table(title=f"Benchmark Cases ({len(cases)})")
+    table.add_column("ID", style="cyan")
+    table.add_column("Name")
+    table.add_column("Category")
+    table.add_column("Min Score", justify="right")
+
+    for case in cases:
+        table.add_row(case.id, case.name, case.category, str(case.expected_min_score))
+
+    console.print(table)
+
+
+def _handle_run(args: Any) -> None:
+    """Run benchmark cases."""
+    suite = BenchmarkSuite()
+
+    if sys.stdout.encoding and "utf" not in sys.stdout.encoding.lower():
+        import io
+
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
+
+    # Determine which cases to run
+    if args.case:
+        case_ids = [args.case]
+    elif args.category:
+        cases = suite.list_cases(category=args.category)
+        case_ids = [c.id for c in cases]
+    else:
+        case_ids = None
+
+    with console.status("[bold green]Running benchmarks..."):
+        result = suite.run(case_ids=case_ids)
+
+    # Format output
+    if args.format == "json":
+        # Plain print to avoid Rich line wrapping breaking JSON
+        print(format_benchmark_result_json(result))
+    elif args.format == "markdown":
+        output = format_benchmark_report_markdown(result, output_path=args.output)
+        if not args.output:
+            console.print(output)
+    else:
+        console.print(format_benchmark_result(result))
+
+    if args.format == "markdown" and args.output:
+        console.print(f"[green]Report written to {args.output}[/]")
+
+    # Save baseline
+    if args.save:
+        path = save_result(result)
+        # Print to stderr so it doesn't mix with JSON/markdown stdout output
+        import sys as _sys
+
+        print(f"Baseline saved to {path}", file=_sys.stderr)
+
+    # Exit code
+    if result.failed > 0:
+        sys.exit(1)
+
+
+def _handle_compare(args: Any) -> None:
+    """Compare against last saved baseline."""
+    from opencontext_core.evaluation.benchmark_suite import compare_results
+
+    baseline = load_last_result()
+    if baseline is None:
+        console.print("[yellow]No baseline found. Run `opencontext benchmark run --save` first.[/]")
+        sys.exit(1)
+
+    suite = BenchmarkSuite()
+    with console.status("[bold green]Running current benchmarks..."):
+        current = suite.run()
+
+    output = compare_results(baseline, current)
+
+    if args.output:
+        Path(args.output).write_text(output, encoding="utf-8")
+        console.print(f"[green]Comparison written to {args.output}[/]")
+    else:
+        console.print(output)
+
+    # Check for regressions
+    regressions = 0
+    for r in current.results:
+        b_map = {r.case_id: r.score.overall for r in baseline.results}
+        if r.case_id in b_map and r.score.overall < b_map[r.case_id] - 2:
+            regressions += 1
+
+    if regressions:
+        console.print(f"[red]{regressions} regression(s) detected.[/]")
+        sys.exit(1)

opencontext_cli-1.0.0/opencontext_cli/commands/bridges_cmd.py

@@ -0,0 +1,151 @@
+"""Bridges CLI command — scan and display cross-language bridge boundaries."""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+from opencontext_core.indexing.bridge_detector import BridgeDetector
+
+console = Console()
+
+
+def add_bridges_parser(subparsers: Any) -> None:
+    """Add bridges command parser."""
+    bridges_parser = subparsers.add_parser(
+        "bridges",
+        help="Detect cross-language call boundaries in your project.",
+    )
+    bridges_sub = bridges_parser.add_subparsers(dest="bridges_command")
+
+    scan_parser = bridges_sub.add_parser("scan", help="Scan project for cross-language bridges.")
+    scan_parser.add_argument("root", nargs="?", default=".", help="Project root to scan.")
+    scan_parser.add_argument(
+        "--type",
+        default=None,
+        choices=["HTTP", "GRPC", "CLI_SUBPROCESS", "IPC"],
+        help="Filter by bridge type.",
+    )
+    scan_parser.add_argument(
+        "--min-confidence",
+        type=float,
+        default=0.0,
+        help="Minimum confidence threshold (0.0-1.0).",
+    )
+    scan_parser.add_argument(
+        "--json",
+        action="store_true",
+        dest="json",
+        help="Output as JSON.",
+    )
+
+    show_parser = bridges_sub.add_parser("show", help="Show bridges for a specific symbol or file.")
+    show_parser.add_argument("symbol", help="Symbol name or file path fragment to filter by.")
+    show_parser.add_argument("root", nargs="?", default=".", help="Project root to scan.")
+
+
+def handle_bridges(args: Any) -> None:
+    """Handle bridges commands."""
+    command = getattr(args, "bridges_command", None)
+    root = getattr(args, "root", ".")
+
+    if command is None:
+        import subprocess
+
+        subprocess.run(["opencontext", "bridges", "--help"])
+        return
+
+    if command == "scan":
+        _handle_scan(
+            root,
+            bridge_type=getattr(args, "type", None),
+            min_confidence=getattr(args, "min_confidence", 0.0),
+            output_json=getattr(args, "json", False),
+        )
+    elif command == "show":
+        _handle_show(root, symbol=args.symbol)
+
+
+def _handle_scan(
+    root: str,
+    bridge_type: str | None = None,
+    min_confidence: float = 0.0,
+    output_json: bool = False,
+) -> None:
+    """Scan and display all detected bridges."""
+    with console.status("[bold green]Scanning for cross-language bridges..."):
+        detector = BridgeDetector()
+        bridges = detector.scan(root)
+
+    if bridge_type:
+        bridges = [b for b in bridges if b.bridge_type == bridge_type]
+    if min_confidence > 0:
+        bridges = [b for b in bridges if b.confidence >= min_confidence]
+
+    if not bridges:
+        console.print("[dim]No cross-language bridges detected.[/]")
+        return
+
+    if output_json:
+        print(json.dumps([dataclasses.asdict(b) for b in bridges], indent=2))
+        return
+
+    table = Table(title=f"Cross-Language Bridges ({len(bridges)} found)")
+    table.add_column("File", style="cyan", max_width=40)
+    table.add_column("Line", justify="right")
+    table.add_column("Type", style="yellow")
+    table.add_column("Confidence", justify="right")
+    table.add_column("Target Hint", max_width=40)
+
+    for b in bridges:
+        conf_style = (
+            "green" if b.confidence >= 0.85 else ("yellow" if b.confidence >= 0.7 else "dim")
+        )
+        table.add_row(
+            b.source_file,
+            str(b.line),
+            b.bridge_type,
+            f"[{conf_style}]{b.confidence:.0%}[/]",
+            b.target_hint,
+        )
+
+    console.print(table)
+
+    type_counts: dict[str, int] = {}
+    for b in bridges:
+        type_counts[b.bridge_type] = type_counts.get(b.bridge_type, 0) + 1
+    summary = " | ".join(f"{t}: {c}" for t, c in sorted(type_counts.items()))
+    console.print(f"[dim]By type: {summary}[/]")
+
+
+def _handle_show(root: str, symbol: str) -> None:
+    """Show bridges filtered by symbol or file path fragment."""
+    detector = BridgeDetector()
+    bridges = detector.scan(root)
+    sym = symbol.lower()
+    filtered = [
+        b
+        for b in bridges
+        if sym in b.source_file.lower()
+        or sym in b.bridge_type.lower()
+        or sym in b.target_hint.lower()
+    ]
+
+    if not filtered:
+        console.print(f"[dim]No bridges found matching '{symbol}'.[/]")
+        return
+
+    table = Table(title=f"Bridges matching '{symbol}'")
+    table.add_column("File", style="cyan")
+    table.add_column("Line", justify="right")
+    table.add_column("Type", style="yellow")
+    table.add_column("Target Hint")
+
+    for b in filtered:
+        table.add_row(b.source_file, str(b.line), b.bridge_type, b.target_hint)
+
+    console.print(table)

{opencontext_cli-0.3.0 → opencontext_cli-1.0.0}/opencontext_cli/commands/ci_check_cmd.py

@@ -53,7 +53,9 @@ jobs:
 
 def add_ci_check_parser(subparsers: Any) -> None:
     """Add ci-check command parsers."""
-    check_parser = subparsers.add_parser("ci-check", help="CI check management.")
+    import argparse
+
+    check_parser = subparsers.add_parser("ci-check", help=argparse.SUPPRESS)
     check_sub = check_parser.add_subparsers(dest="ci_check_command", required=True)
     check_init = check_sub.add_parser(
         "init", help="Initialize checks directory and ContextBench workflow."

{opencontext_cli-0.3.0 → opencontext_cli-1.0.0}/opencontext_cli/commands/config_cmd.py

@@ -16,7 +16,6 @@ from opencontext_core.user_prefs import UserConfigStore
 from opencontext_core.wizard import (
     reconfigure,
     reset_config,
-    run_wizard,
     show_config,
 )
 
@@ -25,7 +24,7 @@ def add_config_parser(subparsers: Any) -> None:
     """Add config command parsers."""
 
     config_parser = subparsers.add_parser("config", help="Manage OpenContext configuration.")
-    config_sub = config_parser.add_subparsers(dest="config_command", required=True)
+    config_sub = config_parser.add_subparsers(dest="config_command")
 
     # Wizard
     wizard_parser = config_sub.add_parser("wizard", help="Run configuration wizard.")
@@ -76,7 +75,17 @@ def add_config_parser(subparsers: Any) -> None:
 def handle_config(args: Any) -> None:
     """Handle config commands."""
 
-    command = args.config_command
+    command = getattr(args, "config_command", None)
+
+    if command is None:
+        # No subcommand — run the interactive wizard by default
+        from opencontext_core.wizard import run_wizard, run_wizard_menu
+
+        try:
+            run_wizard_menu()
+        except Exception:
+            run_wizard(non_interactive=True)
+        return
 
     if command == "wizard":
         use_tui = not getattr(args, "non_interactive", False)
@@ -85,6 +94,8 @@ def handle_config(args: Any) -> None:
 
             run_wizard_menu()
         else:
+            from opencontext_core.wizard import run_wizard
+
             run_wizard(non_interactive=True)
     elif command == "show":
         show_config()
@@ -228,6 +239,12 @@ def _config_get(key: str) -> None:
         print(f"{key} = {value}")
     else:
         print(f"Unknown key: {key}")
+        # Suggest the closest key (replace dots with underscores for display)
+        candidates = sorted(CONFIG_PATHS.keys())
+        key_norm = key.lower().replace(".", "_")
+        suggestions = [c for c in candidates if key_norm in c.lower() or c.lower() in key_norm]
+        if suggestions:
+            print(f"Hint: did you mean {suggestions[0]!r}?")
         print(f"Available paths ({len(CONFIG_PATHS)}):")
         for path, (typ, desc) in sorted(CONFIG_PATHS.items()):
             print(f"  {path}  ({typ.__name__})  {desc}")
@@ -293,23 +310,18 @@ def _config_cleanup(keep_days: int) -> None:
         except (ValueError, OSError):
             continue
 
-    # Rebuild index
-    [b for b in backups if b.id not in [r.id for r in ConfigBackupManager.list_backups()]]
-    # Actually let's rebuild from disk
+    # Rebuild index from disk — removes stale index entries for deleted dirs
     index = []
     for entry_dir in sorted(ConfigBackupManager.BACKUP_DIR.iterdir()):
         if entry_dir.is_dir() and entry_dir.name.startswith("backup-"):
             try:
-                ts = entry_dir.name.replace("backup-", "")
-                desc = "auto-pre-change"  # rough default
-                files = []
-                for f in entry_dir.iterdir():
-                    if f.is_file():
-                        files.append(f.name)
+                ts_str = entry_dir.name.replace("backup-", "")
+                desc = "auto-pre-change"
+                files = sorted(f.name for f in entry_dir.iterdir() if f.is_file())
                 index.append(
                     {
                         "id": entry_dir.name,
-                        "timestamp": ts,
+                        "timestamp": ts_str,
                         "description": desc,
                         "files": files,
                     }

opencontext_cli-1.0.0/opencontext_cli/commands/extension_cmd.py

@@ -0,0 +1,145 @@
+"""Extension CLI command — search, install, list, and remove workflow extensions."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+from opencontext_core.workflow.extension_registry import ExtensionRegistry
+
+console = Console()
+
+
+def add_extension_parser(subparsers: Any) -> None:
+    """Add extension command parser."""
+    ext_parser = subparsers.add_parser(
+        "extension",
+        help="Manage OpenContext workflow extensions.",
+    )
+    ext_sub = ext_parser.add_subparsers(dest="extension_command", required=True)
+
+    search_parser = ext_sub.add_parser("search", help="Search available extensions.")
+    search_parser.add_argument("query", nargs="?", default="", help="Search query.")
+    search_parser.add_argument(
+        "--json",
+        action="store_true",
+        dest="json",
+        help="Output as JSON.",
+    )
+
+    install_parser = ext_sub.add_parser("install", help="Install an extension.")
+    install_parser.add_argument("name", help="Extension name to install.")
+    install_parser.add_argument("--root", default=".", help="Project root.")
+
+    list_parser = ext_sub.add_parser("list", help="List installed extensions.")
+    list_parser.add_argument("--root", default=".", help="Project root.")
+
+    info_parser = ext_sub.add_parser("info", help="Show details for an available extension.")
+    info_parser.add_argument("name", help="Extension name.")
+
+    remove_parser = ext_sub.add_parser("remove", help="Remove an installed extension.")
+    remove_parser.add_argument("name", help="Extension name to remove.")
+    remove_parser.add_argument("--root", default=".", help="Project root.")
+
+
+def handle_extension(args: Any) -> None:
+    """Handle extension commands."""
+    command = args.extension_command
+    registry = ExtensionRegistry()
+    root = getattr(args, "root", ".")
+
+    if command == "search":
+        _handle_search(
+            registry, getattr(args, "query", ""), output_json=getattr(args, "json", False)
+        )
+    elif command == "install":
+        _handle_install(registry, args.name, root)
+    elif command == "list":
+        _handle_list(registry, root)
+    elif command == "info":
+        _handle_info(registry, args.name)
+    elif command == "remove":
+        _handle_remove(registry, args.name, root)
+
+
+def _handle_search(registry: ExtensionRegistry, query: str, output_json: bool = False) -> None:
+    results = registry.search(query)
+    if not results:
+        console.print("[yellow]No extensions found.[/]")
+        return
+
+    if output_json:
+        print(json.dumps(results, indent=2))
+        return
+
+    table = Table(title=f"Extensions ({len(results)} found)")
+    table.add_column("Name", style="cyan")
+    table.add_column("Version")
+    table.add_column("Description")
+    table.add_column("Tags")
+    for ext in results:
+        table.add_row(
+            ext.get("name", ""),
+            ext.get("version", ""),
+            ext.get("description", ""),
+            ", ".join(ext.get("tags", [])),
+        )
+    console.print(table)
+
+
+def _handle_install(registry: ExtensionRegistry, name: str, root: str) -> None:
+    try:
+        path = registry.install(name, root=root)
+        console.print(f"[green]✓ Installed extension '{name}' to {path}[/]")
+    except ValueError as e:
+        console.print(f"[red]Error: {e}[/]")
+
+
+def _handle_list(registry: ExtensionRegistry, root: str) -> None:
+    installed = registry.list_installed(root=root)
+    if not installed:
+        console.print(
+            "[dim]No extensions installed. Use 'opencontext extension search' to find some.[/]"
+        )
+        return
+
+    table = Table(title="Installed Extensions")
+    table.add_column("Name", style="cyan")
+    table.add_column("Version")
+    table.add_column("Author")
+    table.add_column("Description")
+    for m in installed:
+        table.add_row(m.name, m.version, m.author, m.description)
+    console.print(table)
+
+
+def _handle_info(registry: ExtensionRegistry, name: str) -> None:
+    matches = [e for e in registry.search() if e.get("name") == name]
+    if not matches:
+        console.print(f"[red]Extension not found: {name}[/]")
+        return
+    ext = matches[0]
+    from rich.panel import Panel
+
+    content = "\n".join(
+        [
+            f"[bold]Name:[/]        {ext.get('name', '')}",
+            f"[bold]Version:[/]     {ext.get('version', '')}",
+            f"[bold]Author:[/]      {ext.get('author', '')}",
+            f"[bold]Description:[/] {ext.get('description', '')}",
+            f"[bold]Tags:[/]        {', '.join(ext.get('tags', []))}",
+            f"[bold]Requires:[/]    opencontext-core >= {ext.get('requires_version', 'any')}",
+        ]
+    )
+    console.print(Panel(content, title=f"Extension: {name}", border_style="cyan"))
+
+
+def _handle_remove(registry: ExtensionRegistry, name: str, root: str) -> None:
+    removed = registry.remove(name, root=root)
+    if removed:
+        console.print(f"[green]✓ Removed extension '{name}'[/]")
+    else:
+        console.print(f"[yellow]Extension '{name}' not found (already removed?)[/]")

{opencontext_cli-0.3.0 → opencontext_cli-1.0.0}/opencontext_cli/commands/git_cmd.py

@@ -11,7 +11,9 @@ from opencontext_core.indexing.git_context import GitContextProvider
 
 def add_git_parser(subparsers: Any) -> None:
     """Add git command parsers."""
-    git_parser = subparsers.add_parser("git", help="Git context and history.")
+    import argparse
+
+    git_parser = subparsers.add_parser("git", help=argparse.SUPPRESS)
     git_sub = git_parser.add_subparsers(dest="git_command", required=True)
     git_sub.add_parser("status", help="Show git repository stats.")
     git_history = git_sub.add_parser("history", help="Show git history for a file.")
@@ -72,7 +74,7 @@ def handle_git(args: Any) -> None:
     elif command == "recent":
         diffs = provider.get_recent_changes(days=days, max_commits=max_commits)
         if json_output:
-            data = [
+            recent_data: list[dict[str, Any]] = [
                 {
                     "commit_hash": d.commit_hash,
                     "author": d.author,
@@ -82,7 +84,7 @@ def handle_git(args: Any) -> None:
                 }
                 for d in diffs
             ]
-            print(json.dumps(data, indent=2))
+            print(json.dumps(recent_data, indent=2))
         else:
             console.header(f"Recent Changes (last {days} days)")
             console.print(_format_git_recent(diffs))

{opencontext_cli-0.3.0 → opencontext_cli-1.0.0}/opencontext_cli/commands/hints_cmd.py

@@ -11,7 +11,9 @@ from opencontext_core.dx.console_styles import console
 
 def add_hints_parser(subparsers: Any) -> None:
     """Add hints command parsers."""
-    hints_parser = subparsers.add_parser("hints", help="Agent hints management.")
+    import argparse
+
+    hints_parser = subparsers.add_parser("hints", help=argparse.SUPPRESS)
     hints_sub = hints_parser.add_subparsers(dest="hints_command", required=True)
     hints_sub.add_parser("init", help="Initialize .opencontexthints file.")
     hints_sub.add_parser("show", help="Show combined hints.")
@@ -45,8 +47,8 @@ def handle_hints(args: Any) -> None:
             console.warning("No hints found. Run 'opencontext hints init' to create them.")
     elif command == "validate":
         files = manager.discover_hints()
-        valid = []
-        invalid = []
+        valid: list[str] = []
+        invalid: list[str] = []
         for f in files:
             parsed = manager.parse_hints_file(f)
             if parsed:
@@ -60,8 +62,8 @@ def handle_hints(args: Any) -> None:
             console.success(f"Valid: {len(valid)}")
             if invalid:
                 console.error(f"Invalid: {len(invalid)}")
-                for f in invalid:
-                    console.print(f"  [dim]✗ {f}[/]")
+                for item in invalid:
+                    console.print(f"  [dim]✗ {item}[/]")
             console.info(f"Total files checked: {len(files)}")
     else:
         console.error(f"Unknown hints command: {command}")