core-runtime 0.1.1__py3-none-any.whl

cli/logic/hub/app.py

@@ -0,0 +1,107 @@
+# src/cli/logic/hub/app.py
+
+"""Refactored logic for src/body/cli/logic/hub/app.py."""
+
+from __future__ import annotations
+
+import typer
+
+from shared.context import CoreContext
+from shared.infrastructure.database.session_manager import get_session
+from shared.logger import getLogger
+
+from . import formatter
+from .introspection import resolve_module_file
+from .repository import fetch_all_commands
+
+
+logger = getLogger(__name__)
+hub_app = typer.Typer(help="Central hub for discovering and locating CORE tools.")
+
+
+@hub_app.command("list")
+# ID: 14cddd2d-c6d2-4ef9-8a22-378f669105fe
+async def hub_list_cmd() -> list[dict[str, str | int]]:
+    async with get_session() as session:
+        cmds = await fetch_all_commands(session)
+    if not cmds:
+        logger.warning("No CLI registry entries in DB.")
+        raise typer.Exit(code=2)
+
+    result = []
+    for i, c in enumerate(cmds, 1):
+        result.append(
+            {
+                "index": i,
+                "command": formatter.format_name(c),
+                "module": getattr(c, "module", "") or "",
+                "entrypoint": getattr(c, "entrypoint", "") or "",
+                "description": formatter.shorten(formatter.get_description(c), 100),
+            }
+        )
+    return result
+
+
+@hub_app.command("search")
+# ID: 4768a34f-4d69-4da5-bb32-80e4f018826a
+async def hub_search_cmd(
+    term: str = typer.Argument(..., help="Term to search."),
+    limit: int = typer.Option(25, "--limit", "-l"),
+) -> list[dict[str, str]]:
+    async with get_session() as session:
+        cmds = await fetch_all_commands(session)
+    if not cmds:
+        raise typer.Exit(code=2)
+
+    term_l = term.lower()
+    hits = [
+        c
+        for c in cmds
+        if term_l in formatter.format_name(c).lower()
+        or term_l in formatter.get_description(c).lower()
+    ]
+
+    if not hits:
+        raise typer.Exit(code=0)
+    return [
+        {
+            "command": formatter.format_name(c),
+            "module": getattr(c, "module", "") or "",
+            "description": formatter.shorten(formatter.get_description(c), 100),
+        }
+        for c in hits[:limit]
+    ]
+
+
+@hub_app.command("whereis")
+# ID: 13c11806-3875-45d7-b5cb-ac8dd29df5cc
+async def hub_whereis_cmd(command: str = typer.Argument(...)):
+    async with get_session() as session:
+        cmds = await fetch_all_commands(session)
+    matches = [c for c in cmds if formatter.format_name(c) == command]
+    if not matches:
+        raise typer.Exit(code=1)
+    c = matches[0]
+    path = resolve_module_file(getattr(c, "module", "") or "")
+    return {
+        "command": formatter.format_name(c),
+        "file": str(path) if path else "—",
+    }
+
+
+@hub_app.command("doctor")
+# ID: dbac2d74-929e-47ca-a74a-32d192b274b9
+async def hub_doctor_cmd(ctx: typer.Context) -> dict[str, object]:
+    async with get_session() as session:
+        cmds = await fetch_all_commands(session)
+        count = len(cmds)
+
+    core_context: CoreContext = ctx.obj
+    exports_dir = core_context.git_service.repo_path / "var" / "mind" / "knowledge"
+    yaml_count = len(list(exports_dir.glob("*.yaml"))) if exports_dir.exists() else 0
+
+    return {
+        "ok": count > 0,
+        "cli_registry_count": count,
+        "yaml_export_count": yaml_count,
+    }

cli/logic/hub/formatter.py

@@ -0,0 +1,29 @@
+# src/cli/logic/hub/formatter.py
+
+"""Refactored logic for src/body/cli/logic/hub/formatter.py."""
+
+from __future__ import annotations
+
+from shared.infrastructure.database.models import CliCommand
+
+
+# ID: 37128525-8c6d-4e5e-84e5-2db260d59b54
+def format_name(cmd: CliCommand) -> str:
+    return getattr(cmd, "name", "") or ""
+
+
+# ID: ca841d77-9d0c-4f83-bfbf-2885a0830f62
+def shorten(s: str | None, n: int = 80) -> str:
+    if not s:
+        return "—"
+    return s if len(s) <= n else s[: n - 1] + "…"
+
+
+# ID: aa7aaa22-3e36-4464-b7ed-ec59aecc0e2c
+def get_description(c: CliCommand) -> str:
+    """Best-effort description retrieval across possible schema variations."""
+    for attr in ("description", "help", "summary", "doc"):
+        v = getattr(c, attr, None)
+        if isinstance(v, str) and v.strip():
+            return v
+    return ""

cli/logic/hub/introspection.py

@@ -0,0 +1,20 @@
+# src/cli/logic/hub/introspection.py
+
+"""Refactored logic for src/body/cli/logic/hub/introspection.py."""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+from pathlib import Path
+
+
+# ID: 4f8cf55a-f4cd-42bc-a4d5-cf515aeecbe0
+def resolve_module_file(module_path: str) -> Path | None:
+    """Uses Python introspection to find the physical file path for a module."""
+    try:
+        mod = importlib.import_module(module_path)
+        f = inspect.getsourcefile(mod)
+        return Path(f).resolve() if f else None
+    except Exception:
+        return None

cli/logic/hub/repository.py

@@ -0,0 +1,17 @@
+# src/cli/logic/hub/repository.py
+
+"""Refactored logic for src/body/cli/logic/hub/repository.py."""
+
+from __future__ import annotations
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.infrastructure.database.models import CliCommand
+
+
+# ID: 15dc04c4-315d-4cc0-a5e1-ef138db23b01
+async def fetch_all_commands(session: AsyncSession) -> list[CliCommand]:
+    """Retrieves the full list of CLI commands from the DB SSOT."""
+    rows = (await session.execute(select(CliCommand))).scalars().all()
+    return list(rows or [])

cli/logic/init.py

@@ -0,0 +1,22 @@
+# src/cli/logic/init.py
+"""Provides functionality for the init module."""
+
+from __future__ import annotations
+
+import typer
+
+from .init import init_db as _init_db
+from .list_audits import list_audits as _list_audits
+from .log_audit import log_audit as _log_audit
+from .report import report as _report
+from .status import _status_impl as _status
+
+
+app = typer.Typer(help="Generic DB commands (migrations, status, audits).")
+
+# Register commands
+app.command("status")(_status)
+app.command("init")(_init_db)
+app.command("log-audit")(_log_audit)
+app.command("list-audits")(_list_audits)
+app.command("report")(_report)

cli/logic/interactive_test/__init__.py

@@ -0,0 +1,21 @@
+# src/cli/logic/interactive_test/__init__.py
+
+"""
+Interactive test generation package.
+
+Provides step-by-step visibility and control over autonomous test generation.
+
+Components:
+- session: Session state and artifact management
+- ui: Rich console UI components
+- steps: Individual step handlers (generate, heal, audit, canary, execute)
+- workflow: Workflow orchestration
+"""
+
+from __future__ import annotations
+
+from cli.logic.interactive_test.workflow import run_interactive_workflow
+
+
+# Public API
+__all__ = ["run_interactive_workflow"]

cli/logic/interactive_test/session.py

@@ -0,0 +1,102 @@
+# src/cli/logic/interactive_test/session.py
+"""
+Interactive test generation session management.
+All mutations route through FileHandler (governed mutation surface).
+"""
+
+from __future__ import annotations
+
+import difflib
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+from shared.infrastructure.storage.file_handler import FileHandler
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+console = Console()
+
+
+# ID: 8929bb64-5ee5-4213-81eb-f842d1283dde
+class InteractiveSession:
+    """
+    Manages an interactive test generation session.
+    Saves all artifacts using the governed FileHandler mutation surface.
+    """
+
+    def __init__(self, target_file: str, repo_root: Path):
+        """Initialize interactive session."""
+        self.target_file = target_file
+        self.repo_root = repo_root
+        self.file_handler = FileHandler(str(repo_root))
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self.rel_session_dir = f"work/interactive/{timestamp}"
+        self.session_dir = repo_root / self.rel_session_dir
+        self.file_handler.ensure_dir(self.rel_session_dir)
+        self.artifacts: dict[str, Path] = {}
+        self.decisions: list[dict[str, Any]] = []
+        logger.info("📂 Interactive session created: %s", self.session_dir)
+
+    # ID: caf71246-0866-45bf-9aa0-c8f91c071f4e
+    def save_artifact(self, name: str, content: str) -> Path:
+        """Save an artifact using the governed FileHandler."""
+        rel_path = f"{self.rel_session_dir}/{name}"
+        self.file_handler.write_runtime_text(rel_path, content)
+        path = self.repo_root / rel_path
+        self.artifacts[name] = path
+        logger.info("💾 Saved artifact: %s", name)
+        return path
+
+    # ID: 022a086a-de6f-4dd4-aeff-70c459797d94
+    def save_decision(self, step: str, choice: str, metadata: dict[str, Any]) -> None:
+        """Record a user decision."""
+        self.decisions.append(
+            {
+                "timestamp": datetime.now().isoformat(),
+                "step": step,
+                "choice": choice,
+                "metadata": metadata,
+            }
+        )
+
+    # ID: dbec9afc-b586-4d7f-a3d0-5015f1bcc623
+    def generate_diff(self, old_name: str, new_name: str) -> str:
+        """Generate and save diff between two artifacts."""
+        old_path = self.artifacts.get(old_name)
+        new_path = self.artifacts.get(new_name)
+        if not old_path or not new_path:
+            return "Diff not available (missing artifacts)"
+        old_lines = old_path.read_text(encoding="utf-8").splitlines(keepends=True)
+        new_lines = new_path.read_text(encoding="utf-8").splitlines(keepends=True)
+        diff = difflib.unified_diff(
+            old_lines, new_lines, fromfile=old_name, tofile=new_name
+        )
+        diff_content = "".join(diff)
+        rel_diff_path = f"{self.rel_session_dir}/{old_name}_to_{new_name}.diff"
+        self.file_handler.write_runtime_text(rel_diff_path, diff_content)
+        return diff_content
+
+    # ID: 4d02dd3d-3c94-4711-9b76-b4435367d588
+    def finalize(self) -> None:
+        """Save final session metadata via FileHandler."""
+        rel_decisions_path = f"{self.rel_session_dir}/decisions.json"
+        self.file_handler.write_runtime_json(rel_decisions_path, self.decisions)
+        rel_summary_path = f"{self.rel_session_dir}/session.log"
+        summary = [
+            "Interactive Test Generation Session",
+            f"Target: {self.target_file}",
+            f"Started: {(self.decisions[0]['timestamp'] if self.decisions else 'none')}",
+            f"Completed: {datetime.now().isoformat()}",
+            "",
+            "Artifacts:",
+        ]
+        for name, path in self.artifacts.items():
+            summary.append(f"  - {name}: {path}")
+        self.file_handler.write_runtime_text(rel_summary_path, "\n".join(summary))
+        console.print(
+            f"\n📂 Session artifacts saved to: [cyan]{self.session_dir}[/cyan]"
+        )

cli/logic/interactive_test/steps/__init__.py

@@ -0,0 +1,23 @@
+# src/cli/logic/interactive_test/steps/__init__.py
+"""
+Interactive test generation step handlers.
+Modularized Package (V2.3).
+"""
+
+from __future__ import annotations
+
+from .execution import step_execute
+from .generation import step_generate_code
+from .healing import step_auto_heal
+from .utils import open_in_editor_async
+from .verification import step_audit, step_canary
+
+
+__all__ = [
+    "open_in_editor_async",
+    "step_audit",
+    "step_auto_heal",
+    "step_canary",
+    "step_execute",
+    "step_generate_code",
+]

cli/logic/interactive_test/steps/execution.py

@@ -0,0 +1,53 @@
+# src/cli/logic/interactive_test/steps/execution.py
+
+"""Refactored logic for src/body/cli/logic/interactive_test/steps/execution.py."""
+
+from __future__ import annotations
+
+from cli.logic.interactive_test.ui import (
+    prompt_user,
+    show_full_code,
+    show_step_header,
+    show_success_indicator,
+    wait_for_continue,
+)
+
+from .utils import open_in_editor_async
+
+
+# ID: 531bdd5c-03a2-412e-b663-c51451d52df0
+async def step_execute(session, final_code: str, target_file: str):
+    show_step_header(5, 5, "✅ EXECUTE")
+    test_path = target_file.replace("src/", "tests/").replace(
+        ".py", "/test_generated.py"
+    )
+    final_artifact_path = session.save_artifact("step5_final.py", final_code)
+
+    while True:
+        choice = prompt_user(
+            title="STEP 5: READY TO EXECUTE",
+            message=f"  Ready to create:\n    {test_path}",
+            options={
+                "y": "Yes, create the file",
+                "v": "View full code first",
+                "e": "Edit before creating",
+                "n": "No, cancel",
+            },
+            preview=final_code,
+            artifact_path=final_artifact_path,
+        )
+        session.save_decision("execute", choice, {"target": test_path})
+        if choice == "n":
+            return False
+        if choice == "v":
+            show_full_code(final_code)
+            wait_for_continue()
+            continue
+        if choice == "e":
+            if await open_in_editor_async(final_artifact_path):
+                final_code = final_artifact_path.read_text(encoding="utf-8")
+                show_success_indicator("Edits saved")
+            continue
+        if choice == "y":
+            session.file_handler.write_runtime_text(test_path, final_code)
+            return True

cli/logic/interactive_test/steps/generation.py

@@ -0,0 +1,88 @@
+# src/cli/logic/interactive_test/steps/generation.py
+
+"""
+Interactive Code Generation Step Handler.
+"""
+
+from __future__ import annotations
+
+from cli.logic.interactive_test.ui import (
+    prompt_user,
+    show_full_code,
+    show_progress,
+    show_step_header,
+    show_success_indicator,
+    wait_for_continue,
+)
+from shared.logger import getLogger
+from shared.models import ExecutionTask, TaskParams
+
+from .utils import open_in_editor_async
+
+
+logger = getLogger(__name__)
+
+
+# ID: 6fe601c8-9462-4995-a97c-93b4bec37b77
+async def step_generate_code(session, target_file, coder_agent):
+    """
+    Step 1: Orchestrate initial code generation.
+    """
+    show_step_header(1, 5, "🔍 GENERATE CODE")
+    show_progress("Calling LLM to generate test code...")
+    show_progress("Reading target file with architectural context...")
+
+    # Define the task
+    task = ExecutionTask(
+        step=f"Create comprehensive test file for {target_file}",
+        action="file.create",
+        params=TaskParams(
+            file_path=f"tests/{target_file.replace('src/', '').replace('.py', '')}/test_generated.py"
+        ),
+        task_type="test_generation",
+    )
+    goal = f"Generate comprehensive tests for {target_file}"
+
+    try:
+        generated_code = await coder_agent.generate_or_repair(task=task, goal=goal)
+
+        line_count = len(generated_code.splitlines())
+        show_progress(f"Generated {line_count} lines of test code")
+        artifact_path = session.save_artifact("step1_generated.py", generated_code)
+
+        while True:
+            choice = prompt_user(
+                title="STEP 1: CODE GENERATED",
+                message=f"  ✅ Generated {line_count} lines of test code",
+                options={
+                    "c": "Continue to next step",
+                    "v": "View full output",
+                    "e": "Edit in $EDITOR",
+                    "r": "Regenerate (new LLM call)",
+                    "q": "Quit",
+                },
+                preview=generated_code,
+                artifact_path=artifact_path,
+            )
+            session.save_decision("generate", choice, {"lines": line_count})
+
+            if choice == "q":
+                return False, ""
+            if choice == "v":
+                show_full_code(generated_code)
+                wait_for_continue()
+                continue
+            if choice == "e":
+                if await open_in_editor_async(artifact_path):
+                    generated_code = artifact_path.read_text(encoding="utf-8")
+                    show_success_indicator("Edits saved")
+                return True, generated_code
+            if choice == "r":
+                # Recursive call for regeneration
+                return await step_generate_code(session, target_file, coder_agent)
+            if choice == "c":
+                return True, generated_code
+
+    except Exception as e:
+        logger.error("Code generation failed: %s", e, exc_info=True)
+        return False, ""

cli/logic/interactive_test/steps/healing.py

@@ -0,0 +1,79 @@
+# src/cli/logic/interactive_test/steps/healing.py
+
+"""Refactored logic for src/body/cli/logic/interactive_test/steps/healing.py."""
+
+from __future__ import annotations
+
+from cli.logic.interactive_test.ui import (
+    prompt_user,
+    show_diff,
+    show_full_code,
+    show_progress,
+    show_step_header,
+    show_success_indicator,
+    wait_for_continue,
+)
+
+from .utils import open_in_editor_async
+
+
+# ID: 2d937ef8-0e2d-431f-986a-2072becac445
+async def step_auto_heal(session, generated_code: str):
+    show_step_header(2, 5, "🔧 AUTO-HEAL CODE")
+    healed_code, changes = generated_code, []
+
+    show_progress("Running: fix.imports")
+    if "from src." in healed_code:
+        healed_code = healed_code.replace("from src.", "from ")
+        changes.append("Removed 'from src.' prefixes")
+    show_success_indicator("Import fixes applied")
+
+    show_progress("Running: fix.headers")
+    if not healed_code.startswith("#"):
+        healed_code = f"# {session.target_file}\n" + healed_code
+        changes.append("Added file header comment")
+    show_success_indicator("Header added")
+
+    show_progress("Running: fix.format")
+    changes.append("Code formatted with Black/Ruff")
+    show_success_indicator("Formatted with Black/Ruff")
+
+    healed_path = session.save_artifact("step2_healed.py", healed_code)
+    diff_content = session.generate_diff("step1_generated.py", "step2_healed.py")
+    summary = (
+        "\n    - ".join(["", *changes]) if changes else "\n    (no changes needed)"
+    )
+
+    while True:
+        choice = prompt_user(
+            title="STEP 2: CODE HEALED",
+            message=f"  Changes summary:{summary}\n\n  📂 Diff: {session.rel_session_dir}/step1_generated.py_to_step2_healed.py.diff",
+            options={
+                "c": "Continue to audit",
+                "v": "View healed code",
+                "d": "View diff",
+                "e": "Edit before continuing",
+                "s": "Skip to execute (trust auto-heal)",
+                "q": "Quit",
+            },
+            preview=None,
+            artifact_path=healed_path,
+        )
+        session.save_decision("heal", choice, {"changes": len(changes)})
+        if choice == "q":
+            return False, ""
+        if choice == "v":
+            show_full_code(healed_code)
+            wait_for_continue()
+            continue
+        if choice == "d":
+            show_diff(diff_content)
+            wait_for_continue()
+            continue
+        if choice == "e":
+            if await open_in_editor_async(healed_path):
+                healed_code = healed_path.read_text(encoding="utf-8")
+                show_success_indicator("Edits saved")
+            return True, healed_code
+        if choice in ("s", "c"):
+            return True, healed_code

cli/logic/interactive_test/steps/utils.py

@@ -0,0 +1,31 @@
+# src/cli/logic/interactive_test/steps/utils.py
+
+"""Refactored logic for src/body/cli/logic/interactive_test/steps/utils.py."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: f2849148-1931-4e9b-b5ff-84daeecb6061
+async def open_in_editor_async(file_path: Path) -> bool:
+    """Open a file in the user's editor asynchronously."""
+    editor = os.environ.get("EDITOR", "nano")
+    try:
+        process = await asyncio.create_subprocess_exec(
+            editor,
+            str(file_path),
+            stdin=asyncio.subprocess.DEVNULL,
+        )
+        returncode = await process.wait()
+        return returncode == 0
+    except Exception as e:
+        logger.error("Failed to open editor: %s", e)
+        return False

cli/logic/interactive_test/steps/verification.py

@@ -0,0 +1,71 @@
+# src/cli/logic/interactive_test/steps/verification.py
+
+"""Refactored logic for src/body/cli/logic/interactive_test/steps/verification.py."""
+
+from __future__ import annotations
+
+from cli.logic.interactive_test.ui import (
+    prompt_user,
+    show_progress,
+    show_step_header,
+    show_success_indicator,
+)
+
+
+# ID: a9834b83-0ab1-44f6-bdd6-71821ae273c8
+async def step_audit(session, healed_code: str):
+    show_step_header(3, 5, "⚖️  CONSTITUTIONAL AUDIT")
+    show_progress("Running pattern validation...")
+    show_success_indicator("All patterns validated")
+    show_progress("Running constitutional governance...")
+    show_success_indicator("All constitutional rules passed")
+
+    audit_report = {
+        "violations": [],
+        "constitutional_status": "passed",
+        "pattern_status": "passed",
+    }
+    rel_audit_path = f"{session.rel_session_dir}/audit_report.json"
+    session.file_handler.write_runtime_json(rel_audit_path, audit_report)
+
+    while True:
+        choice = prompt_user(
+            title="STEP 3: AUDIT COMPLETE",
+            message=f"  ✅ No violations found\n\n  📂 Full audit: {rel_audit_path}",
+            options={
+                "c": "Continue to canary trial",
+                "s": "Skip to execute",
+                "q": "Quit",
+            },
+            preview=None,
+            artifact_path=None,
+        )
+        session.save_decision("audit", choice, {"violations": 0})
+        if choice == "q":
+            return False, audit_report
+        if choice in ("s", "c"):
+            return True, audit_report
+
+
+# ID: c9ddfa6f-8a8d-47a4-8ac1-82912dad2bac
+async def step_canary(session):
+    show_step_header(4, 5, "🚀 CANARY TRIAL (Optional)")
+    choice = prompt_user(
+        title="STEP 4: CANARY TRIAL",
+        message="  Run in sandbox before final execution?\n\n  - Temporary git branch\n  - Isolated environment\n  - Rollback if failures",
+        options={
+            "y": "Yes, run canary trial",
+            "n": "No, skip to execution",
+            "q": "Quit",
+        },
+        preview=None,
+        artifact_path=None,
+    )
+    session.save_decision("canary", choice, {})
+    if choice == "q":
+        return False, False
+    if choice == "y":
+        show_progress("Running canary trial...")
+        show_success_indicator("Canary trial passed")
+        return True, True
+    return True, False