opencontext-cli 0.1.0__tar.gz → 0.2.1b0__tar.gz

{opencontext_cli-0.1.0 → opencontext_cli-0.2.1b0}/PKG-INFO

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

opencontext_cli-0.2.1b0/opencontext_cli/commands/__init__.py

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

opencontext_cli-0.2.1b0/opencontext_cli/commands/ci_check_cmd.py

@@ -0,0 +1,115 @@
+"""CI check CLI commands."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from opencontext_core.dx.console_styles import console
+from opencontext_core.quality.ci_checks import CheckRunner
+
+
+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_sub.add_parser("init", help="Initialize checks directory.")
+    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.")
+
+
+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}")
+    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']}[/]")

opencontext_cli-0.2.1b0/opencontext_cli/commands/config_cmd.py

@@ -0,0 +1,242 @@
+"""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":
+        run_wizard(non_interactive=getattr(args, "non_interactive", False))
+    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)
+
+
+def _config_set(key: str, value: str) -> None:
+    """Set a config value by key."""
+
+    store = UserConfigStore()
+    prefs = store.load()
+
+    # Simple key-value mapping
+    key_map: dict[str, tuple[str, type]] = {
+        "security_mode": ("security_mode", str),
+        "token_budget": ("default_token_budget", int),
+        "max_input_tokens": ("max_input_tokens", int),
+        "check_updates": ("check_updates", bool),
+        "auto_optimize": ("learning_auto_optimize", bool),
+    }
+
+    if key in key_map:
+        attr_name, attr_type = key_map[key]
+        if attr_type is bool:
+            parsed = value.lower() in ("true", "1", "yes", "on")
+        elif attr_type is int:
+            parsed = int(value)
+        else:
+            parsed = value
+        setattr(prefs, attr_name, parsed)
+        store.save(prefs)
+        print(f"Set {key} = {parsed}")
+    else:
+        print(f"Unknown key: {key}")
+        print(f"Available: {', '.join(key_map.keys())}")
+
+
+def _config_get(key: str) -> None:
+    """Get a config value by key."""
+
+    store = UserConfigStore()
+    prefs = store.load()
+
+    key_map = {
+        "security_mode": prefs.security_mode,
+        "token_budget": prefs.default_token_budget,
+        "max_input_tokens": prefs.max_input_tokens,
+        "check_updates": prefs.check_updates,
+        "auto_optimize": prefs.learning_auto_optimize,
+        "first_run": prefs.first_run,
+    }
+
+    if key in key_map:
+        print(f"{key} = {key_map[key]}")
+    else:
+        print(f"Unknown key: {key}")
+
+
+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.2.1b0/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)

opencontext_cli-0.2.1b0/opencontext_cli/commands/hints_cmd.py

@@ -0,0 +1,67 @@
+"""Agent hints CLI commands."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from opencontext_core.dx.agent_hints import AgentHintsManager
+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.")
+    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.")
+    hints_sub.add_parser("validate", help="Validate hints files.")
+
+
+def handle_hints(args: Any) -> None:
+    """Handle hints commands."""
+    command = args.hints_command
+    json_output = getattr(args, "json", False)
+
+    manager = AgentHintsManager()
+
+    if command == "init":
+        path = manager.init_hints_file()
+        if path:
+            console.success(f"Created {path}")
+            console.info("Edit the file to add your project conventions")
+        else:
+            console.warning(".opencontexthints already exists")
+    elif command == "show":
+        hints = manager.get_all_hints()
+        if hints:
+            ctx = manager.to_context_string(hints)
+            if json_output:
+                print(json.dumps({"hints": ctx}, indent=2))
+            else:
+                console.header("Agent Hints")
+                console.panel(ctx, title=hints.project_name or "Project Hints")
+        else:
+            console.warning("No hints found. Run 'opencontext hints init' to create them.")
+    elif command == "validate":
+        files = manager.discover_hints()
+        valid = []
+        invalid = []
+        for f in files:
+            parsed = manager.parse_hints_file(f)
+            if parsed:
+                valid.append(str(f))
+            else:
+                invalid.append(str(f))
+        if json_output:
+            print(json.dumps({"valid": valid, "invalid": invalid, "total": len(files)}, indent=2))
+        else:
+            console.header("Hints Validation")
+            console.success(f"Valid: {len(valid)}")
+            if invalid:
+                console.error(f"Invalid: {len(invalid)}")
+                for f in invalid:
+                    console.print(f"  [dim]✗ {f}[/]")
+            console.info(f"Total files checked: {len(files)}")
+    else:
+        console.error(f"Unknown hints command: {command}")