core-runtime 0.1.1__py3-none-any.whl

cli/logic/diagnostics.py

@@ -0,0 +1,148 @@
+# src/cli/logic/diagnostics.py
+"""
+Logic layer for CLI diagnostics commands.
+
+Rules:
+- No Rich / Typer UI rendering here (command layer owns presentation).
+- Pure, testable functions where possible.
+- Defensive behavior: never crash CLI because of unexpected Typer internals.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from shared.context import CoreContext
+from shared.infrastructure.intent.intent_repository import get_intent_repository
+from shared.infrastructure.knowledge.knowledge_service import KnowledgeService
+from shared.logger import getLogger
+from shared.protocols.typer_protocols import (
+    TyperAppLike,
+)
+
+
+logger = getLogger(__name__)
+
+
+# ID: 3c7a1c34-8b36-4d2e-9b2b-3c94b7a8bb12
+def build_cli_tree_data(app: TyperAppLike) -> list[dict[str, Any]]:
+    """
+    Build a hierarchical representation of a Typer CLI app.
+    """
+
+    def _summary(help_text: str | None) -> str:
+        if not help_text:
+            return ""
+        return help_text.splitlines()[0].strip()
+
+    def _walk(node_app: TyperAppLike) -> list[dict[str, Any]]:
+        children: list[dict[str, Any]] = []
+
+        try:
+            groups = list(getattr(node_app, "registered_groups", []) or [])
+        except Exception:
+            groups = []
+
+        for grp in groups:
+            name = getattr(grp, "name", None)
+            sub_app = getattr(grp, "typer_instance", None)
+            if not name or sub_app is None:
+                continue
+
+            group_node: dict[str, Any] = {"name": str(name)}
+            grp_help = getattr(grp, "help", None)
+            if grp_help:
+                group_node["help"] = _summary(str(grp_help))
+
+            sub_children = _walk(sub_app)
+            if sub_children:
+                group_node["children"] = sub_children
+
+            children.append(group_node)
+
+        try:
+            commands = list(getattr(node_app, "registered_commands", []) or [])
+        except Exception:
+            commands = []
+
+        for cmd in commands:
+            name = getattr(cmd, "name", None)
+            if not name:
+                continue
+            cmd_node: dict[str, Any] = {"name": str(name)}
+            cmd_help = getattr(cmd, "help", None)
+            if cmd_help:
+                cmd_node["help"] = _summary(str(cmd_help))
+            children.append(cmd_node)
+
+        def _sort_key(n: dict[str, Any]) -> tuple[int, str]:
+            is_leaf = 0 if "children" in n else 1
+            return (is_leaf, n.get("name", ""))
+
+        return sorted(children, key=_sort_key)
+
+    return _walk(app)
+
+
+# ID: e9d2a1f3-5c4b-8a7e-9f1d-2b3c4d5e6f7a
+async def get_unassigned_symbols_logic(
+    core_context: CoreContext,
+) -> list[dict[str, Any]]:
+    """
+    Get symbols that have not been assigned a capability ID.
+    """
+    try:
+        knowledge_service = KnowledgeService(core_context.git_service.repo_path)
+        graph = await knowledge_service.get_graph()
+        symbols = graph.get("symbols", {})
+
+        unassigned = []
+        for key, symbol_data in symbols.items():
+            name = symbol_data.get("name")
+            if name is None:
+                continue
+
+            if name.startswith("_"):
+                continue
+
+            file_path = symbol_data.get("file_path", "")
+            if "tests/" in file_path or "/test" in file_path:
+                continue
+
+            if symbol_data.get("capability") == "unassigned":
+                symbol_data["key"] = key
+                unassigned.append(symbol_data)
+
+        return unassigned
+    except Exception as e:
+        logger.error("Error processing knowledge graph: %s", e)
+        return []
+
+
+# ID: 5086836c-c833-4099-a6da-2522eda85ec3
+def list_constitutional_files_logic() -> list[str]:
+    """
+    Returns the list of constitutional files discovered by the IntentRepository.
+    """
+    logger.info("Retrieving indexed constitutional files from IntentRepository...")
+
+    repo = get_intent_repository()
+    repo.initialize()  # Ensure current state is indexed
+
+    # 1. Collect all indexed policy and standard files
+    paths = [str(ref.path) for ref in repo.list_policies()]
+
+    # 2. Add structural META files (The "Contract" files)
+    # Using repo.root instead of settings.MIND to stay repo-local
+    core_structure = [
+        repo.root / "META" / "intent_tree.schema.json",
+        repo.root / "META" / "rule_document.schema.json",
+        repo.root / "META" / "enums.json",
+        repo.root / "constitution" / "precedence_rules.yaml",
+    ]
+
+    for cf in core_structure:
+        if cf.exists():
+            paths.append(str(cf))
+
+    return sorted(list(set(paths)))

cli/logic/diagnostics_policy.py

@@ -0,0 +1,100 @@
+# src/cli/logic/diagnostics_policy.py
+
+"""
+Logic for constitutional policy coverage auditing.
+
+Thin client over POST /v1/quality/policy-coverage. The audit runs
+server-side via mind.governance.PolicyCoverageService; this module
+calls the endpoint and owns rendering only.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import typer
+
+from api.cli import CoreApiClient
+
+
+logger = logging.getLogger(__name__)
+
+
+def _log_policy_coverage_summary(summary: dict[str, Any]) -> None:
+    """Log a compact summary of policy coverage metrics."""
+    logger.info("Constitutional Policy Coverage Summary")
+    logger.info("Policies Seen: %s", summary.get("policies_seen", 0))
+    logger.info("Rules Found: %s", summary.get("rules_found", 0))
+    logger.info("Rules (direct): %s", summary.get("rules_direct", 0))
+    logger.info("Rules (bound): %s", summary.get("rules_bound", 0))
+    logger.info("Rules (inferred): %s", summary.get("rules_inferred", 0))
+    logger.info("Uncovered Rules (all): %s", summary.get("uncovered_rules", 0))
+    logger.info("Uncovered ERROR Rules: %s", summary.get("uncovered_error_rules", 0))
+
+
+def _log_policy_coverage_table(records: list[dict[str, Any]]) -> None:
+    """Log all rules with their coverage type so gaps are visible."""
+    if not records:
+        logger.warning("No policy rules discovered; nothing to display.")
+        return
+    logger.info("Policy Rules Coverage")
+    sorted_records = sorted(
+        records,
+        key=lambda r: (
+            not r.get("covered", False),
+            r.get("policy_id", ""),
+            r.get("rule_id", ""),
+        ),
+    )
+    for rec in sorted_records:
+        logger.info(
+            "Policy: %s, Rule ID: %s, Enforcement: %s, Coverage: %s, Covered?: %s",
+            rec.get("policy_id", ""),
+            rec.get("rule_id", ""),
+            rec.get("enforcement", ""),
+            rec.get("coverage", "none"),
+            "Yes" if rec.get("covered", False) else "No",
+        )
+
+
+def _log_uncovered_policy_rules(records: list[dict[str, Any]]) -> None:
+    """Only log the rules that are not covered."""
+    uncovered = [r for r in records if not r.get("covered", False)]
+    if not uncovered:
+        return
+    logger.warning("Uncovered Policy Rules")
+    for rec in uncovered:
+        logger.warning(
+            "Policy: %s, Rule ID: %s, Enforcement: %s, Coverage: %s",
+            rec.get("policy_id", ""),
+            rec.get("rule_id", ""),
+            rec.get("enforcement", ""),
+            rec.get("coverage", "none"),
+        )
+
+
+# ID: 6eb5c3ca-cbbf-48d1-82a5-de01df839b6f
+async def policy_coverage() -> None:
+    """
+    Runs a meta-audit on all .intent/policies/ to ensure they are
+    well-formed and covered by the governance model.
+
+    Thin client over POST /v1/quality/policy-coverage; this function
+    fetches the report and renders it via the local _log_* helpers.
+    """
+    logger.info("Running Constitutional Policy Coverage Audit...")
+    client = CoreApiClient()
+    report = await client.quality_policy_coverage()
+    logger.info("Report ID: %s", report.get("report_id", ""))
+    summary = report.get("summary", {})
+    records = report.get("records", [])
+    _log_policy_coverage_summary(summary)
+    _log_policy_coverage_table(records)
+    if summary.get("uncovered_rules", 0) > 0:
+        _log_uncovered_policy_rules(records)
+    exit_code = report.get("exit_code", 0)
+    if exit_code != 0:
+        logger.error("Policy coverage audit failed with exit code: %s", exit_code)
+        raise typer.Exit(code=exit_code)
+    logger.info("All active policies are backed by implemented or inferred checks.")

cli/logic/diagnostics_registry.py

@@ -0,0 +1,165 @@
+# src/cli/logic/diagnostics_registry.py
+
+"""
+Logic for auditing domain manifests and legacy artifacts.
+Refactored to use the dynamic constitutional rule engine and PathResolver.
+"""
+
+from __future__ import annotations
+
+import json
+
+import jsonschema
+import typer
+import yaml
+
+from mind.governance.audit_context import AuditorContext
+from mind.governance.rule_executor import execute_rule
+from mind.governance.rule_extractor import extract_executable_rules
+from shared.context import CoreContext
+from shared.logger import getLogger
+from shared.models import AuditSeverity
+from shared.path_resolver import PathResolver
+
+
+logger = getLogger(__name__)
+
+
+# ID: 3a8ecff4-54d8-4fe1-8977-6c00d694db6f
+async def manifest_hygiene(ctx: typer.Context) -> None:
+    """
+    Checks for misplaced capabilities or structural drift in the knowledge base.
+    Uses the 'knowledge.database_ssot' constitutional rule.
+    """
+    core_context: CoreContext = ctx.obj
+    logger.info("🔍 Running manifest hygiene check (SSOT alignment)...")
+
+    # 1. Initialize AuditorContext
+    auditor_context = core_context.auditor_context or AuditorContext(
+        core_context.git_service.repo_path
+    )
+    await auditor_context.load_knowledge_graph()
+
+    # 2. Extract rules using the mandatory enforcement_loader
+    all_rules = extract_executable_rules(
+        auditor_context.policies, auditor_context.enforcement_loader
+    )
+
+    target_rule = next(
+        (r for r in all_rules if r.rule_id == "knowledge.database_ssot"), None
+    )
+
+    if not target_rule:
+        logger.warning(
+            "Constitutional rule 'knowledge.database_ssot' not found. Skipping hygiene check."
+        )
+        return
+
+    # 3. Execute and report
+    findings = await execute_rule(target_rule, auditor_context)
+
+    if not findings:
+        logger.info("✅ All capabilities correctly placed and synchronized with DB.")
+        return
+
+    # Sort findings by severity
+    errors = [f for f in findings if f.severity == AuditSeverity.BLOCK]
+    warnings = [f for f in findings if f.severity == AuditSeverity.HIGH]
+
+    if errors:
+        logger.error("❌ Found %s CRITICAL alignment errors:", len(errors))
+        for f in errors:
+            logger.error("  - %s", f.message)
+
+    if warnings:
+        logger.warning("⚠️  Found %s alignment warnings:", len(warnings))
+        for f in warnings:
+            logger.warning("  - %s", f.message)
+
+    if errors:
+        raise typer.Exit(code=1)
+
+
+# ID: 67db4c4d-4483-4d71-9044-a1464ae3a4b2
+def cli_registry(ctx: typer.Context) -> None:
+    """
+    Validates the *legacy* CLI registry YAML (if still present) against its schema.
+    """
+    # Use PathResolver to find standard locations
+    core_context: CoreContext = ctx.obj
+    path_resolver = PathResolver.from_repo(
+        repo_root=core_context.git_service.repo_path,
+        intent_root=core_context.git_service.repo_path / ".intent",
+    )
+
+    registry_path = path_resolver.knowledge_dir / "cli_registry.yaml"
+
+    try:
+        # Resolve schema via the unified policy/standard search
+        schema_path = path_resolver.policy("cli_registry_schema")
+    except FileNotFoundError:
+        logger.info(
+            "CLI registry schema not found via PathResolver; skipping validation."
+        )
+        return
+
+    if not registry_path.exists():
+        logger.info("Legacy CLI registry not found at %s; skipping.", registry_path)
+        return
+
+    try:
+        registry = yaml.safe_load(registry_path.read_text(encoding="utf-8")) or {}
+        schema = json.loads(schema_path.read_text(encoding="utf-8"))
+        jsonschema.validate(instance=registry, schema=schema)
+        logger.info("✅ Legacy CLI registry is valid: %s", registry_path.name)
+    except Exception as e:
+        logger.error("❌ CLI registry failed validation: %s", e)
+        raise typer.Exit(code=1)
+
+
+# ID: 03edb3b5-ca71-411e-8c90-5249d29a9543
+async def check_legacy_tags(ctx: typer.Context) -> None:
+    """
+    Runs a standalone check for obsolete capability tags using the 'purity' rule set.
+    """
+    core_context: CoreContext = ctx.obj
+    logger.info("🔍 Running standalone legacy tag check...")
+
+    # 1. Initialize AuditorContext
+    auditor_context = core_context.auditor_context or AuditorContext(
+        core_context.git_service.repo_path
+    )
+    await auditor_context.load_knowledge_graph()
+
+    # 2. Extract rules using the mandatory enforcement_loader
+    all_rules = extract_executable_rules(
+        auditor_context.policies, auditor_context.enforcement_loader
+    )
+
+    target_rule = next(
+        (r for r in all_rules if r.rule_id == "purity.no_descriptive_pollution"), None
+    )
+
+    if not target_rule:
+        logger.warning(
+            "Constitutional rule 'purity.no_descriptive_pollution' not found."
+        )
+        return
+
+    # 3. Execute
+    findings = await execute_rule(target_rule, auditor_context)
+
+    if not findings:
+        logger.info("✅ Success! No legacy tags found.")
+        return
+
+    logger.error("❌ Found %s instance(s) of legacy tags/pollution:", len(findings))
+    for finding in findings:
+        loc = (
+            f"{finding.file_path}:{finding.line_number}"
+            if finding.line_number
+            else finding.file_path
+        )
+        logger.error("  [%s] %s: %s", finding.severity.name, loc, finding.message)
+
+    raise typer.Exit(code=1)

cli/logic/duplicates.py

@@ -0,0 +1,19 @@
+# src/cli/logic/duplicates.py
+"""
+DEPRECATED — moved to body/self_healing/duplicates_service.py under ADR-050.
+
+This module retains a re-export shim so existing in-CLI imports continue to
+work during the CLI migration epic. Once all callers have been migrated to
+the body location, this file should be removed.
+
+The duplicate-code analysis logic (inspect_duplicates_async) now lives at:
+
+    body.self_healing.duplicates_service
+"""
+
+from __future__ import annotations
+
+from body.self_healing.duplicates_service import inspect_duplicates_async
+
+
+__all__ = ["inspect_duplicates_async"]

cli/logic/embeddings_cli.py

@@ -0,0 +1,43 @@
+# src/cli/logic/embeddings_cli.py
+
+"""
+CLI wiring for embeddings & vectorization commands.
+Exposes: `core-admin knowledge vectorize [--write|--dry-run]`
+"""
+
+from __future__ import annotations
+
+import typer
+
+from cli.utils import core_command
+from shared.context import CoreContext
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+app = typer.Typer(
+    name="knowledge", no_args_is_help=True, help="Knowledge graph & embeddings commands"
+)
+
+
+@app.command("vectorize")
+@core_command(dangerous=True)
+# ID: bd2d47b7-8dce-4e8c-93bd-0c31d0b13be0
+async def vectorize_cmd(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Persist vectors to Qdrant."),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Simulate only, do not upsert to Qdrant."
+    ),
+):
+    """
+    Vectorize codebase artifacts using the constitutional worker pipeline
+    (RepoCrawlerWorker + RepoEmbedderWorker).
+    """
+    context: CoreContext = ctx.obj
+
+    if dry_run:
+        write = False
+
+    logger.info("🚀 Starting vectorization via constitutional worker pipeline...")
+    await context.action_executor.execute("sync.vectors_code", write=write)

cli/logic/governance/__init__.py

@@ -0,0 +1,16 @@
+# src/cli/logic/governance/__init__.py
+
+"""Provides functionality for the __init__ module."""
+
+from __future__ import annotations
+
+from .engine import ensure_coverage_map, generate_coverage_map
+from .renderer import render_hierarchical, render_summary
+
+
+__all__ = [
+    "ensure_coverage_map",
+    "generate_coverage_map",
+    "render_hierarchical",
+    "render_summary",
+]