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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencontext-cli
-Version: 0.1.0
+Version: 0.3.0
 Summary: CLI adapter for OpenContext Runtime
 Author: OpenContext Runtime maintainers
 License-Expression: MIT

opencontext_cli-0.3.0/opencontext_cli/__main__.py

@@ -0,0 +1,5 @@
+"""CLI entry point for `python -m opencontext_cli`."""
+
+from opencontext_cli.main import main
+
+main()

opencontext_cli-0.3.0/opencontext_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command modules for OpenContext."""

opencontext_cli-0.3.0/opencontext_cli/commands/ci_check_cmd.py

@@ -0,0 +1,191 @@
+"""CI check CLI commands."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from opencontext_core.dx.console_styles import console
+from opencontext_core.quality.ci_checks import CheckRunner
+
+CONTEXTBENCH_WORKFLOW = """\
+# OpenContext ContextBench CI
+# Auto-generated by `opencontext ci-check init`
+name: OpenContext ContextBench
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  contextbench:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install OpenContext
+        run: pip install opencontext-cli
+      - name: Initialize checks
+        run: opencontext ci-check init
+      - name: Run ContextBench checks
+        run: opencontext ci-check run --json > contextbench-report.json
+      - name: Upload report
+        uses: actions/upload-artifact@v4
+        with:
+          name: contextbench-report
+          path: contextbench-report.json
+      - name: Fail on errors
+        run: |
+          python3 -c "
+          import json
+          with open('contextbench-report.json') as f:
+              report = json.load(f)
+          summary = report.get('summary', {})
+          if summary.get('failed', 0) > 0:
+              print('❌ ContextBench checks failed')
+              exit(1)
+          print('✅ All ContextBench checks passed')
+          "
+"""
+
+
+def add_ci_check_parser(subparsers: Any) -> None:
+    """Add ci-check command parsers."""
+    check_parser = subparsers.add_parser("ci-check", help="CI check management.")
+    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."
+    )
+    check_init.add_argument(
+        "--no-workflow", action="store_true", help="Skip GitHub Actions workflow generation."
+    )
+    check_sub.add_parser("list", help="List discovered checks.")
+    check_run = check_sub.add_parser("run", help="Run all checks.")
+    check_run.add_argument("--file", help="Run on specific file only.")
+    check_run.add_argument("--json", action="store_true")
+    check_create = check_sub.add_parser("create", help="Create a new check template.")
+    check_create.add_argument("name", help="Check name.")
+    check_create.add_argument("--description", default="", help="Check description.")
+    check_gh = check_sub.add_parser(
+        "github-actions", help="Generate ContextBench GitHub Actions workflow."
+    )
+    check_gh.add_argument("--force", action="store_true", help="Overwrite existing workflow file.")
+
+
+def handle_ci_check(args: Any) -> None:
+    """Handle ci-check commands."""
+    command = args.ci_check_command
+    name = getattr(args, "name", None)
+    file = getattr(args, "file", None)
+    json_output = getattr(args, "json", False)
+
+    runner = CheckRunner()
+
+    if command == "init":
+        path = runner.init_checks_directory()
+        console.success(f"Initialized checks directory: {path}")
+        skip_workflow = getattr(args, "no_workflow", False)
+        if not skip_workflow:
+            workflow_path = _generate_contextbench_workflow()
+            console.success(f"Generated ContextBench workflow: {workflow_path}")
+    elif command == "github-actions":
+        force = getattr(args, "force", False)
+        workflow_path = Path(".github/workflows/opencontext-contextbench.yml")
+        if workflow_path.exists() and not force:
+            console.warning(f"Workflow already exists: {workflow_path}. Use --force to overwrite.")
+            return
+        _write_contextbench_workflow(workflow_path)
+        console.success(f"Generated ContextBench workflow: {workflow_path}")
+    elif command == "list":
+        checks = runner.discover_checks()
+        if json_output:
+            data = [
+                {"name": c.name, "description": c.description, "severity": c.severity.value}
+                for c in checks
+            ]
+            print(json.dumps(data, indent=2))
+        else:
+            console.header("CI Checks")
+            if not checks:
+                console.dim("No checks found. Run 'opencontext ci-check init'")
+            else:
+                console.table(
+                    "Discovered Checks",
+                    ["Name", "Severity", "Description"],
+                    [[c.name, c.severity.value, c.description] for c in checks],
+                )
+    elif command == "run":
+        files = [file] if file else None
+        with console.progress("Running checks...") as progress:
+            task = progress.add_task("Running checks...", total=None)
+            results = runner.run_all_checks(files)
+            progress.update(task, completed=True)
+        report = runner.generate_report(results)
+        if json_output:
+            print(json.dumps(report, indent=2))
+        else:
+            _display_check_report(report)
+    elif command == "create" and name:
+        template = runner.create_check_template(name, "Custom check")
+        console.print(template)
+    else:
+        console.error(f"Unknown ci-check command: {command}")
+
+
+def _display_check_report(report: dict[str, Any]) -> None:
+    """Display a formatted check report."""
+    summary = report.get("summary", {})
+    total = summary.get("total_checks", 0)
+    passed = summary.get("passed", 0)
+    failed = summary.get("failed", 0)
+    warnings = summary.get("warnings", 0)
+    errors = summary.get("errors", 0)
+    success = summary.get("success", False)
+
+    console.header("Check Report")
+
+    if success:
+        console.success(f"All {total} checks passed")
+    else:
+        console.error(f"{failed}/{total} checks failed")
+
+    console.table(
+        "Summary",
+        ["Metric", "Count"],
+        [
+            ["Total", str(total)],
+            ["Passed", str(passed)],
+            ["Failed", str(failed)],
+            ["Warnings", str(warnings)],
+            ["Errors", str(errors)],
+        ],
+    )
+
+    # Show failed results
+    failed_results = [r for r in report.get("results", []) if r["status"] != "passed"]
+    if failed_results:
+        console.section("Failed Checks")
+        for r in failed_results:
+            severity_color = "#FF6F91" if r["severity"] in ("error", "critical") else "#FFC75F"
+            msg = f"  [bold {severity_color}]{r['severity'].upper()}[/]"
+            msg += f" {r['check']}: {r['message']}"
+            console.print(msg)
+            if r.get("file"):
+                console.print(f"    [dim]File: {r['file']}:{r.get('line', 'N/A')}[/]")
+            if r.get("suggestion"):
+                console.print(f"    [dim]Suggestion: {r['suggestion']}[/]")
+
+
+def _generate_contextbench_workflow() -> Path:
+    """Generate the ContextBench GitHub Actions workflow as part of init."""
+    workflow_path = Path(".github/workflows/opencontext-contextbench.yml")
+    _write_contextbench_workflow(workflow_path)
+    return workflow_path
+
+
+def _write_contextbench_workflow(workflow_path: Path) -> None:
+    """Write the ContextBench workflow file."""
+    workflow_path.parent.mkdir(parents=True, exist_ok=True)
+    workflow_path.write_text(CONTEXTBENCH_WORKFLOW)

opencontext_cli-0.3.0/opencontext_cli/commands/config_cmd.py

@@ -0,0 +1,323 @@
+"""Configuration management CLI commands.
+
+Provides wizard, show, reset, reconfigure, backup,
+restore, and cleanup subcommands for managing
+OpenContext user preferences.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+from opencontext_core.state import ConfigBackupManager
+from opencontext_core.user_prefs import UserConfigStore
+from opencontext_core.wizard import (
+    reconfigure,
+    reset_config,
+    run_wizard,
+    show_config,
+)
+
+
+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)
+
+    # Wizard
+    wizard_parser = config_sub.add_parser("wizard", help="Run configuration wizard.")
+    wizard_parser.add_argument(
+        "--non-interactive", action="store_true", help="Use defaults without prompts."
+    )
+
+    # Show
+    config_sub.add_parser("show", help="Display current configuration.")
+
+    # Reset
+    config_sub.add_parser("reset", help="Reset to factory defaults.")
+
+    # Reconfigure section
+    reconf_parser = config_sub.add_parser("reconfigure", help="Reconfigure a specific section.")
+    reconf_parser.add_argument(
+        "section",
+        choices=["security", "features", "tokens", "agents", "plugins"],
+        help="Section to reconfigure.",
+    )
+
+    # Set individual values
+    set_parser = config_sub.add_parser("set", help="Set a configuration value.")
+    set_parser.add_argument("key", help="Configuration key (dot notation).")
+    set_parser.add_argument("value", help="Value to set.")
+
+    # Get individual values
+    get_parser = config_sub.add_parser("get", help="Get a configuration value.")
+    get_parser.add_argument("key", help="Configuration key (dot notation).")
+
+    # Backup
+    config_sub.add_parser("backup", help="Create a manual backup of configuration.")
+
+    # List backups
+    config_sub.add_parser("backups", help="List saved configuration backups.")
+
+    # Restore
+    restore_parser = config_sub.add_parser("restore", help="Restore configuration from a backup.")
+    restore_parser.add_argument("id", help="Backup ID to restore.")
+
+    # Cleanup old backups
+    cleanup_parser = config_sub.add_parser("cleanup", help="Remove old backups.")
+    cleanup_parser.add_argument(
+        "--keep-days", type=int, default=30, help="Keep backups newer than this many days."
+    )
+
+
+def handle_config(args: Any) -> None:
+    """Handle config commands."""
+
+    command = args.config_command
+
+    if command == "wizard":
+        use_tui = not getattr(args, "non_interactive", False)
+        if use_tui:
+            from opencontext_core.wizard import run_wizard_menu
+
+            run_wizard_menu()
+        else:
+            run_wizard(non_interactive=True)
+    elif command == "show":
+        show_config()
+    elif command == "reset":
+        reset_config()
+    elif command == "reconfigure":
+        reconfigure(args.section)
+    elif command == "set":
+        _config_set(args.key, args.value)
+    elif command == "get":
+        _config_get(args.key)
+    elif command == "backup":
+        _config_backup()
+    elif command == "backups":
+        _config_backups()
+    elif command == "restore":
+        _config_restore(args.id)
+    elif command == "cleanup":
+        _config_cleanup(args.keep_days)
+
+
+# ── Dot-notation config paths ──────────────────────────────────────────────
+
+# Schema of configurable paths: "path" -> (type, description)
+CONFIG_PATHS: dict[str, tuple[type, str]] = {
+    # Flat keys
+    "security_mode": (str, "Security mode: private_project, enterprise, or air-gapped"),
+    "default_token_budget": (int, "Default token budget per operation"),
+    "max_input_tokens": (int, "Maximum input tokens"),
+    "reserve_output_tokens": (int, "Reserved output tokens"),
+    "check_updates": (bool, "Check for updates automatically"),
+    "auto_optimize": (bool, "Auto-optimize token budgets based on usage"),
+    "first_run": (bool, "Whether this is the first run"),
+    "default_provider": (str, "Default LLM provider"),
+    "default_model": (str, "Default LLM model"),
+    # Nested: features.*
+    "features.knowledge_graph": (bool, "Knowledge Graph (code indexing & search)"),
+    "features.call_graph": (bool, "Call Graph (function call analysis)"),
+    "features.learning_system": (bool, "Learning System (auto-optimize)"),
+    "features.governance": (bool, "Governance (audit trails & policies)"),
+    "features.mcp_server": (bool, "MCP Server (agent integration)"),
+    "features.git_integration": (bool, "Git Integration"),
+    "features.embeddings": (bool, "Embeddings (semantic search)"),
+    "features.semantic_search": (bool, "Semantic Search"),
+    # Nested: sdd.*
+    "sdd.tdd_mode": (str, "TDD mode: ask, strict, or off"),
+    "sdd.sdd_model_profile": (str, "SDD model profile: default, cheap, hybrid, premium"),
+    "sdd.orchestrator_profile": (
+        str,
+        "Orchestrator profile: solo-compact, multi-phase, subagent-native",
+    ),
+    # Nested: agents.*
+    "agents.default_client": (str, "Default agent client"),
+    "agents.active_clients": (list, "Active agent clients (comma-separated)"),
+}
+
+
+def _resolve_config_path(prefs: Any, dotted: str) -> tuple[Any, str] | None:
+    """Resolve a dotted path to (parent_object, attr_name) or None if invalid.
+
+    Example: "features.knowledge_graph" -> (prefs.features, "knowledge_graph")
+    """
+    parts = dotted.split(".")
+    obj = prefs
+    for _i, part in enumerate(parts[:-1]):
+        if hasattr(obj, part):
+            obj = getattr(obj, part)
+        else:
+            return None
+    return (obj, parts[-1])
+
+
+def _get_all_config_paths() -> list[str]:
+    """Return all available config paths sorted."""
+    return sorted(CONFIG_PATHS.keys())
+
+
+def _coerce_value(value: str, target_type: type) -> object:
+    """Coerce a string value to the target type."""
+    if target_type is bool:
+        return value.lower() in ("true", "1", "yes", "on")
+    elif target_type is int:
+        return int(value)
+    elif target_type is list:
+        import json
+
+        try:
+            parsed = json.loads(value)
+            if isinstance(parsed, list):
+                return parsed
+        except (json.JSONDecodeError, TypeError):
+            pass
+        # Fallback: comma-separated
+        return [item.strip() for item in value.split(",") if item.strip()]
+    else:
+        return value
+
+
+def _config_set(key: str, value: str) -> None:
+    """Set a config value using dot notation."""
+
+    store = UserConfigStore()
+    prefs = store.load()
+
+    if key in CONFIG_PATHS:
+        _target_type, _description = CONFIG_PATHS[key]
+        resolved = _resolve_config_path(prefs, key)
+        if resolved is None:
+            print(f"Error: Cannot resolve path '{key}'")
+            return
+        parent, attr = resolved
+        try:
+            parsed = _coerce_value(value, _target_type)
+            setattr(parent, attr, parsed)
+            store.save(prefs)
+            print(f"Set {key} = {parsed}")
+        except (ValueError, TypeError) as exc:
+            print(f"Error: Cannot set '{key}' to '{value}': {exc}")
+            print(f"Expected type: {_target_type.__name__}")
+    else:
+        print(f"Unknown key: {key}")
+        print(f"Available paths ({len(CONFIG_PATHS)}):")
+        for path, (typ, desc) in sorted(CONFIG_PATHS.items()):
+            print(f"  {path}  ({typ.__name__})  {desc}")
+
+
+def _config_get(key: str) -> None:
+    """Get a config value by dot-notation key."""
+
+    store = UserConfigStore()
+    prefs = store.load()
+
+    if key in CONFIG_PATHS:
+        _target_type, _description = CONFIG_PATHS[key]
+        resolved = _resolve_config_path(prefs, key)
+        if resolved is None:
+            print(f"Error: Cannot resolve path '{key}'")
+            return
+        parent, attr = resolved
+        value = getattr(parent, attr, "<not set>")
+        print(f"{key} = {value}")
+    else:
+        print(f"Unknown key: {key}")
+        print(f"Available paths ({len(CONFIG_PATHS)}):")
+        for path, (typ, desc) in sorted(CONFIG_PATHS.items()):
+            print(f"  {path}  ({typ.__name__})  {desc}")
+
+
+def _config_backup() -> None:
+    """Create a manual backup."""
+
+    backup_id = ConfigBackupManager.create_backup(description="manual")
+    print(f"  ✓ Backup created: {backup_id}")
+    print(f"    Location: {ConfigBackupManager.BACKUP_DIR / backup_id}")
+
+
+def _config_backups() -> None:
+    """List backups."""
+
+    backups = ConfigBackupManager.list_backups()
+    if not backups:
+        print("  No backups found.")
+        print(f"  Backup directory: {ConfigBackupManager.BACKUP_DIR}")
+        return
+
+    print()
+    print(f"  {'Backup ID':<30} {'Timestamp':<25} {'Description':<20} {'Files'}")
+    print(f"  {'─' * 30} {'─' * 25} {'─' * 20} {'─' * 20}")
+    for b in backups:
+        files_str = ", ".join(b.files) if b.files else "—"
+        print(f"  {b.id:<30} {b.timestamp:<25} {b.description:<20} {files_str}")
+    print(f"\n  {len(backups)} backup(s) available")
+    print("\n  Restore: opencontext config restore <id>")
+
+
+def _config_restore(backup_id: str) -> None:
+    """Restore from a backup."""
+
+    if ConfigBackupManager.restore_backup(backup_id):
+        print(f"  ✓ Restored from backup: {backup_id}")
+    else:
+        print(f"  ✗ Backup not found: {backup_id}")
+        print("    List available: opencontext config backups")
+        sys.exit(1)
+
+
+def _config_cleanup(keep_days: int) -> None:
+    """Clean up old backups beyond keep_days."""
+
+    from datetime import datetime, timedelta
+
+    backups = ConfigBackupManager.list_backups()
+    cutoff = datetime.now() - timedelta(days=keep_days)
+    removed = 0
+
+    for b in backups:
+        try:
+            ts = datetime.strptime(b.timestamp, "%Y%m%dT%H%M%S")
+            if ts < cutoff:
+                backup_dir = ConfigBackupManager.BACKUP_DIR / b.id
+                if backup_dir.exists():
+                    import shutil
+
+                    shutil.rmtree(backup_dir)
+                removed += 1
+        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
+    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)
+                index.append(
+                    {
+                        "id": entry_dir.name,
+                        "timestamp": ts,
+                        "description": desc,
+                        "files": files,
+                    }
+                )
+            except OSError:
+                continue
+
+    ConfigBackupManager.INDEX_FILE.write_text(json.dumps(index, indent=2), encoding="utf-8")
+
+    print(f"  ✓ Removed {removed} backup(s) older than {keep_days} days")
+    print(f"    {len(index)} backup(s) remaining")

opencontext_cli-0.3.0/opencontext_cli/commands/git_cmd.py

@@ -0,0 +1,139 @@
+"""Git context CLI commands."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from opencontext_core.dx.console_styles import console
+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.")
+    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.")
+    git_history.add_argument("file", help="File path.")
+    git_history.add_argument("--json", action="store_true")
+    git_recent = git_sub.add_parser("recent", help="Show recent changes.")
+    git_recent.add_argument("--days", type=int, default=7)
+    git_recent.add_argument("--max-commits", type=int, default=20)
+    git_recent.add_argument("--json", action="store_true")
+    git_blame = git_sub.add_parser("blame", help="Show blame for file lines.")
+    git_blame.add_argument("file", help="File path.")
+    git_blame.add_argument("--start", type=int, default=1)
+    git_blame.add_argument("--end", type=int, default=10)
+    git_blame.add_argument("--json", action="store_true")
+
+
+def handle_git(args: Any) -> None:
+    """Handle git commands."""
+    command = args.git_command
+    file = getattr(args, "file", None)
+    start = getattr(args, "start", 1)
+    end = getattr(args, "end", 10)
+    days = getattr(args, "days", 7)
+    max_commits = getattr(args, "max_commits", 20)
+    json_output = getattr(args, "json", False)
+
+    provider = GitContextProvider()
+    if not provider.available:
+        console.error("Not a git repository")
+        return
+
+    if command == "status":
+        stats = provider.get_repo_stats()
+        if json_output:
+            print(json.dumps(stats, indent=2))
+        else:
+            console.header("Git Repository Stats")
+            console.print(_format_git_status(stats))
+    elif command == "history" and file:
+        info = provider.get_file_info(file)
+        if info:
+            if json_output:
+                data = {
+                    "path": info.path,
+                    "last_modified": info.last_modified.isoformat() if info.last_modified else None,
+                    "last_author": info.last_author,
+                    "commit_count": info.commit_count,
+                    "lines_added": info.lines_added,
+                    "lines_removed": info.lines_removed,
+                    "top_authors": info.top_authors,
+                }
+                print(json.dumps(data, indent=2))
+            else:
+                console.header(f"Git History: {file}")
+                console.print(_format_git_history(info))
+        else:
+            console.error(f"Could not get history for {file}")
+    elif command == "recent":
+        diffs = provider.get_recent_changes(days=days, max_commits=max_commits)
+        if json_output:
+            data = [
+                {
+                    "commit_hash": d.commit_hash,
+                    "author": d.author,
+                    "date": d.date.isoformat(),
+                    "message": d.message,
+                    "files_changed": d.files_changed,
+                }
+                for d in diffs
+            ]
+            print(json.dumps(data, indent=2))
+        else:
+            console.header(f"Recent Changes (last {days} days)")
+            console.print(_format_git_recent(diffs))
+    elif command == "blame" and file:
+        lines = provider.get_blame_for_symbol(file, start, end)
+        if json_output:
+            print(json.dumps(lines, indent=2))
+        else:
+            console.header(f"Blame: {file} (lines {start}-{end})")
+            console.print(_format_git_blame(lines))
+    else:
+        console.error(f"Unknown git command: {command}")
+
+
+def _format_git_status(stats: dict[str, Any]) -> str:
+    if not stats.get("available"):
+        return "Not a git repository."
+    lines = [
+        f"Commits: {stats.get('total_commits', 'N/A')}",
+        f"Contributors: {stats.get('contributors', 'N/A')}",
+        f"Branches: {stats.get('branches', 'N/A')}",
+    ]
+    return "\n".join(lines)
+
+
+def _format_git_history(info: Any) -> str:
+    lines = [
+        f"File: {info.path}",
+        f"Commits: {info.commit_count}",
+        f"Last author: {info.last_author or 'N/A'}",
+        f"Last modified: {info.last_modified.isoformat() if info.last_modified else 'N/A'}",
+        f"Lines added/removed: +{info.lines_added}/-{info.lines_removed}",
+        f"Top authors: {', '.join(info.top_authors) if info.top_authors else 'N/A'}",
+    ]
+    return "\n".join(lines)
+
+
+def _format_git_recent(diffs: list[Any]) -> str:
+    lines = []
+    for d in diffs:
+        lines.append(f"{d.commit_hash[:8]} {d.author} {d.date.isoformat()}")
+        lines.append(f"  {d.message}")
+        lines.append(f"  Files: {', '.join(d.files_changed[:5])}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def _format_git_blame(lines: list[dict[str, Any]]) -> str:
+    out = []
+    for line in lines:
+        author = line.get("author", "?")
+        code = line.get("code", "")
+        out.append(f"{author:20} {code}")
+    return "\n".join(out)