opencontext-cli 0.2.1b0__tar.gz → 0.4.0b0__tar.gz

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

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

opencontext_cli-0.4.0b0/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.2.1b0 → opencontext_cli-0.4.0b0}/opencontext_cli/commands/ci_check_cmd.py

@@ -3,17 +3,64 @@
 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_sub.add_parser("init", help="Initialize checks directory.")
+    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.")
@@ -21,6 +68,10 @@ def add_ci_check_parser(subparsers: Any) -> None:
     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:
@@ -35,6 +86,18 @@ def handle_ci_check(args: Any) -> None:
     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:
@@ -113,3 +176,16 @@ def _display_check_report(report: dict[str, Any]) -> None:
                 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.2.1b0 → opencontext_cli-0.4.0b0}/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,10 +75,26 @@ 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":
-        run_wizard(non_interactive=getattr(args, "non_interactive", False))
+        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":
@@ -100,56 +115,131 @@ def handle_config(args: Any) -> None:
         _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 by key."""
+    """Set a config value using dot notation."""
 
     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}")
+    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: {', '.join(key_map.keys())}")
+        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 key."""
+    """Get a config value by dot-notation 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]}")
+    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: