core-runtime 0.1.1__py3-none-any.whl

cli/logic/agent.py

@@ -0,0 +1,110 @@
+# src/cli/logic/agent.py
+
+"""
+Provides a CLI interface for human operators to directly invoke autonomous agent capabilities like application scaffolding.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import typer
+
+from body.project_lifecycle.scaffolding_service import Scaffolder
+from shared.ai.prompt_model import PromptModel
+from shared.context import CoreContext
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+agent_app = typer.Typer(help="Directly invoke autonomous agent capabilities.")
+
+
+def _extract_json_from_response(text: str) -> Any:
+    """Helper to extract JSON from LLM responses for scaffolding."""
+    import re
+
+    match = re.search(
+        "```json\\s*(\\{[\\s\\S]*?\\}|\\[[\\s\\S]*?\\])\\s*```", text, re.DOTALL
+    )
+    if match:
+        return json.loads(match.group(1))
+    return json.loads(text)
+
+
+# ID: d3bdf128-7f90-401d-aab8-3f985fd70fb8
+async def scaffold_new_application(
+    context: CoreContext, project_name: str, goal: str, initialize_git: bool = False
+) -> tuple[bool, str]:
+    """Uses an LLM to plan and generate a new, multi-file application."""
+    logger.info("? Starting to scaffold new application '%s'...", project_name)
+    cognitive_service = context.cognitive_service
+    await cognitive_service.initialize()
+    model = PromptModel.load("scaffold_new_application_prompt")
+    try:
+        planner_client = await cognitive_service.aget_client_for_role(
+            model.manifest.role
+        )
+        response_text = await model.invoke(
+            context={"goal": goal}, client=planner_client, user_id="scaffolding_agent"
+        )
+        file_structure = _extract_json_from_response(response_text)
+        if not isinstance(file_structure, dict):
+            raise ValueError("LLM did not return a valid JSON object of files.")
+        logger.info("   -> LLM planned a structure with %s files.", len(file_structure))
+        scaffolder = Scaffolder(project_name=project_name)
+        scaffolder.scaffold_base_structure()
+        for rel_path, content in file_structure.items():
+            scaffolder.write_file(rel_path, content)
+        logger.info("   -> Adding starter test and CI workflow...")
+        test_template_path = scaffolder.starter_kit_path / "test_main.py.template"
+        ci_template_path = scaffolder.starter_kit_path / "ci.yml.template"
+        if test_template_path.exists():
+            test_content = test_template_path.read_text(encoding="utf-8").format(
+                project_name=project_name
+            )
+            scaffolder.write_file("tests/test_main.py", test_content)
+        if ci_template_path.exists():
+            ci_content = ci_template_path.read_text(encoding="utf-8")
+            scaffolder.write_file(".github/workflows/ci.yml", ci_content)
+        if initialize_git:
+            git_service = context.git_service
+            logger.info(
+                "   -> Initializing new Git repository in %s...",
+                scaffolder.project_root,
+            )
+            git_service.init(scaffolder.project_root)
+            scoped_git_service = context.git_service.__class__(scaffolder.project_root)
+            scoped_git_service.add_all()
+            scoped_git_service.commit(
+                f"feat(scaffold): Initial commit for '{project_name}'"
+            )
+        return (True, f"? Successfully scaffolded '{project_name}'.")
+    except Exception as e:
+        logger.error("? Scaffolding failed: %s", e, exc_info=True)
+        return (False, f"Scaffolding failed: {e!s}")
+
+
+@agent_app.command("scaffold")
+# ID: 92a60ec4-ea5d-41b9-a36d-9687f3faaeda
+async def agent_scaffold(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., help="The directory name for the new application."),
+    goal: str = typer.Argument(..., help="A high-level goal for the application."),
+    git_init: bool = typer.Option(
+        True, "--git/--no-git", help="Initialize a Git repository."
+    ),
+):
+    """Uses an LLM agent to autonomously scaffold a new application."""
+    logger.info("? Invoking Agent to scaffold application '%s'...", name)
+    logger.info("   -> Goal: '%s'", goal)
+    core_context: CoreContext = ctx.obj
+    success, message = await scaffold_new_application(
+        context=core_context, project_name=name, goal=goal, initialize_git=git_init
+    )
+    if success:
+        typer.secho(f"\n{message}", fg=typer.colors.GREEN)
+    else:
+        typer.secho(f"\n{message}", fg=typer.colors.RED)
+        raise typer.Exit(code=1)

cli/logic/audit_capability_domains.py

@@ -0,0 +1,106 @@
+# src/cli/logic/audit_capability_domains.py
+"""
+Provides functionality for the audit_capability_domains module.
+"""
+
+from __future__ import annotations
+
+import typer
+from sqlalchemy import text
+
+from shared.infrastructure.database.session_manager import get_session
+
+
+async def _audit_queries(limit: int):
+    """Audit capabilities database for data quality issues,
+    returning counts of total capabilities and lists of keys with
+    zero tags, multiple primary domains, legacy domain mismatches,
+    and inactive domain tags."""
+    async with get_session() as session:
+        total = (
+            await session.execute(
+                text("select count(*) as c from body.services.capabilities")
+            )
+        ).scalar_one()
+
+        zero_tags_stmt = text(
+            """
+            select c.key
+            from body.services.capabilities c
+            where not exists (
+              select 1 from core.capability_domains d
+              where d.capability_key = c.key
+            )
+            limit :lim
+            """
+        ).bindparams(lim=limit)
+        zero_tags_rows = (await session.execute(zero_tags_stmt)).scalars().all()
+
+        multi_primary_stmt = text(
+            """
+            select capability_key
+            from core.capability_domains
+            group by capability_key
+            having sum(case when is_primary then 1 else 0 end) > 1
+            limit :lim
+            """
+        ).bindparams(lim=limit)
+        multi_primary_rows = (await session.execute(multi_primary_stmt)).scalars().all()
+
+        legacy_mismatch_stmt = text(
+            """
+            select c.key
+            from body.services.capabilities c
+            where c.domain is not null
+              and not exists (
+                select 1 from core.capability_domains d
+                where d.capability_key = c.key
+                  and d.domain_key = c.domain
+              )
+            limit :lim
+            """
+        ).bindparams(lim=limit)
+        legacy_mismatch_rows = (
+            (await session.execute(legacy_mismatch_stmt)).scalars().all()
+        )
+
+        inactive_domain_tags_stmt = text(
+            """
+            select distinct d.capability_key
+            from core.capability_domains d
+            join core.domains dm on dm.key = d.domain_key
+            where dm.status != 'active'
+            limit :lim
+            """
+        ).bindparams(lim=limit)
+        inactive_tag_rows = (
+            (await session.execute(inactive_domain_tags_stmt)).scalars().all()
+        )
+
+        return (
+            total,
+            zero_tags_rows,
+            multi_primary_rows,
+            legacy_mismatch_rows,
+            inactive_tag_rows,
+        )
+
+
+# ID: a2d0d438-253f-49ba-82be-10eb2a2a7749
+def audit_capability_domains(
+    limit: int = typer.Option(
+        20, "--limit", help="Max sample keys to show for each finding"
+    ),
+):
+    """Audit capability domains for common tagging issues and display findings with sample keys."""
+    total, zero_tags, multi_primary, legacy_mismatch, inactive_tags = typer.run(
+        _audit_queries, limit
+    )
+
+    typer.echo(f"Total capabilities: {total}")
+    typer.echo(f"Zero tags: {len(zero_tags)}  {zero_tags}")
+    typer.echo(f"Multiple primary tags: {len(multi_primary)}  {multi_primary}")
+    typer.echo(
+        f"Legacy domain not among tags: {len(legacy_mismatch)}  {legacy_mismatch}"
+    )
+    typer.echo(f"Tags on INACTIVE domains: {len(inactive_tags)}  {inactive_tags}")

cli/logic/audit_renderer.py

@@ -0,0 +1,150 @@
+# src/cli/logic/audit_renderer.py
+"""Facade/orchestrator for audit report rendering.
+
+Orchestrates grouping and delegated rendering; preserves original behavior.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from cli.renderers.audit_detail import render_details as _render_details_groups
+from cli.renderers.audit_overview import render_overview as _render_overview_groups
+from shared.logger import getLogger
+from shared.models import AuditFinding, AuditSeverity
+from shared.models.audit_rendering import SeverityGroup
+from shared.utils.audit_grouping import SEVERITY_ORDER, get_max_severity, group_findings
+
+
+_SEVERITY_MAP = {str(s): s for s in AuditSeverity}
+
+
+# ID: ae8e7546-39a6-4b9b-a7ab-7f41162116f1
+def to_audit_finding(raw: dict) -> AuditFinding:
+    """Build an AuditFinding from a raw finding dict.
+
+    Lives here (and not in src/cli/resources/code/audit.py) so the
+    ADR-054 D4 CLI files can keep their imports inside `api.*` and
+    `cli.*` — the shared.models dependency is centralised in this
+    renderer module which already needs it for its own typing.
+    """
+    severity = _SEVERITY_MAP.get(
+        str(raw.get("severity", "info")).lower(), AuditSeverity.INFO
+    )
+    return AuditFinding(
+        check_id=raw.get("check_id") or raw.get("rule_id") or "unknown",
+        severity=severity,
+        message=raw.get("message", ""),
+        file_path=raw.get("file_path"),
+        line_number=raw.get("line_number"),
+        context=raw.get("context", {}),
+    )
+
+
+logger = getLogger(__name__)
+console = Console()
+
+
+@dataclass
+# ID: a010d8e0-b1db-4b16-acfe-733c996c7248
+class AuditStats:
+    """Execution statistics for a constitutional audit run."""
+
+    total_rules: int = 0
+    executed_rules: int = 0
+    coverage_percent: float = 0
+    total_declared_rules: int = 0
+    crashed_rules: int = 0
+    unmapped_rules: int = 0
+    effective_coverage_percent: float = 0
+    # ADR-076 D4: effective per-rule dispatch mode counts
+    context_level_rules: int = 0
+    per_file_rules: int = 0
+
+
+# ID: 0b88103e-949f-4a1d-9daf-c2042c6346b9
+def render_overview(
+    console: Console,
+    findings: list[AuditFinding],
+    stats: AuditStats,
+    duration: float,
+    passed: bool,
+    verdict_str: str | None = None,
+) -> None:
+    """Render audit stats panel + severity overview table."""
+    stats_table = Table.grid(expand=True, padding=(0, 2))
+    stats_table.add_row(
+        f"Rules declared: [cyan]{stats.total_declared_rules}[/cyan]",
+        f"Rules executed: [cyan]{stats.executed_rules}[/cyan]",
+        f"Coverage: [cyan]{stats.coverage_percent:.1f}%[/cyan]",
+    )
+    stats_table.add_row(
+        f"Effective coverage: [cyan]{stats.effective_coverage_percent:.1f}%[/cyan]",
+        f"Crashed: [red]{stats.crashed_rules}[/red]",
+        f"Unmapped: [yellow]{stats.unmapped_rules}[/yellow]",
+    )
+    stats_table.add_row(
+        f"Duration: [dim]{duration:.2f}s[/dim]",
+        f"Total findings: [cyan]{len(findings)}[/cyan]",
+        f"Dispatch: [cyan]{stats.context_level_rules}[/cyan] context-level · "
+        f"[cyan]{stats.per_file_rules}[/cyan] per-file",
+    )
+    console.print(
+        Panel(stats_table, title="[bold]Audit Execution Stats[/bold]", expand=False)
+    )
+    console.print()
+    groups: list[SeverityGroup] = group_findings(findings)
+    _render_overview_groups(console, groups)
+    console.print()
+    _render_verdict(console, groups, verdict_str=verdict_str, passed=passed)
+
+
+# ID: 74348bb7-e619-4392-84e6-2d90203f709f
+def render_detail(console: Console, findings: list[AuditFinding]) -> None:
+    """Render detailed findings tables grouped by severity."""
+    groups: list[SeverityGroup] = group_findings(findings)
+    _render_details_groups(console, groups)
+
+
+def _render_verdict(
+    console: Console,
+    groups: list[SeverityGroup],
+    verdict_str: str | None = None,
+    passed: bool | None = None,
+) -> None:
+    """Render final verdict panel."""
+    max_sev = get_max_severity(groups)
+    if passed is not None:
+        is_passed = passed
+    else:
+        is_passed = max_sev is None or SEVERITY_ORDER.get(max_sev, 0) < 3
+    if verdict_str:
+        label = verdict_str
+    else:
+        label = "PASSED" if is_passed else "FAILED"
+    # DEGRADED is a tri-state distinct from PASS/FAIL: the instrument
+    # couldn't check some rules, so compliance is UNKNOWN. Render it in
+    # yellow to signal "instrument compromised" rather than collapsing
+    # into either green (pass) or red (fail).
+    if label.upper() == "DEGRADED":
+        style = "bold yellow"
+        panel_style = "yellow"
+    elif is_passed:
+        style = "bold green"
+        panel_style = "green"
+    else:
+        style = "bold red"
+        panel_style = "red"
+    console.print(
+        Panel(
+            Text(label, style=style),
+            title="[bold white]Final Verdict[/bold white]",
+            style=panel_style,
+            expand=False,
+        )
+    )

cli/logic/autonomy/actions.py

@@ -0,0 +1,36 @@
+# src/cli/logic/autonomy/actions.py
+
+"""Refactored logic for src/body/cli/logic/autonomy/actions.py."""
+
+from __future__ import annotations
+
+
+# ID: 2b856f28-158c-45e4-95f1-ad85db4bb203
+def parse_action_options(action_strs: list[str]) -> list[dict]:
+    """Parse CLI action strings (action_id:key=val) into plain dicts.
+
+    Returns dicts with keys {action_id, parameters, order} matching the
+    POST /v1/proposals action body schema. Preserves input order.
+    """
+    proposal_actions: list[dict] = []
+    for i, action_str in enumerate(action_strs):
+        if ":" in action_str:
+            action_id, params_str = action_str.split(":", 1)
+            parameters: dict[str, str] = {}
+            for param in params_str.split(","):
+                if "=" in param:
+                    key, value = param.split("=", 1)
+                    parameters[key.strip()] = value.strip()
+        else:
+            action_id = action_str
+            parameters = {}
+
+        proposal_actions.append(
+            {"action_id": action_id, "parameters": parameters, "order": i}
+        )
+    return proposal_actions
+
+
+# ID: de1a1d12-a10b-49a8-a121-f58003db7f26
+def get_action_help_text() -> str:
+    return "Available actions: fix.format, fix.ids, fix.headers, fix.docstrings, fix.logging"

cli/logic/autonomy/views.py

@@ -0,0 +1,116 @@
+# src/cli/logic/autonomy/views.py
+"""Refactored logic for src/body/cli/logic/autonomy/views.py."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from rich.console import Console
+from rich.table import Table
+
+
+console = Console()
+STATUS_COLORS = {
+    "draft": "white",
+    "pending": "yellow",
+    "approved": "green",
+    "executing": "blue",
+    "completed": "green",
+    "failed": "red",
+    "rejected": "red",
+}
+RISK_COLORS = {"safe": "green", "moderate": "yellow", "high": "red"}
+
+
+# ID: 1d435482-a764-45be-a51d-c5c70eff6c9a
+def render_list_table(proposals: list[dict], title: str) -> Table:
+    table = Table(title=title)
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Goal", style="white")
+    table.add_column("Status", style="bold")
+    table.add_column("Actions", justify="center")
+    table.add_column("Risk", justify="center")
+    table.add_column("Created", style="dim")
+    for p in proposals:
+        status = p["status"]
+        s_color = STATUS_COLORS.get(status, "white")
+        risk_level = p["risk"]["overall_risk"] if p.get("risk") else "unknown"
+        r_color = RISK_COLORS.get(risk_level, "white")
+        created = datetime.fromisoformat(p["created_at"]).strftime("%Y-%m-%d %H:%M")
+        goal = p.get("goal") or ""
+        table.add_row(
+            p["proposal_id"][:8] + "...",
+            goal[:50] + ("..." if len(goal) > 50 else ""),
+            f"[{s_color}]{status}[/{s_color}]",
+            str(len(p.get("actions", []))),
+            f"[{r_color}]{risk_level}[/{r_color}]",
+            created,
+        )
+    return table
+
+
+# ID: 94d02f4b-3d3a-4fd5-8332-132eb7980974
+def print_detailed_info(p: dict):
+    console.print(f"\n[bold cyan]Proposal: {p['proposal_id']}[/bold cyan]\n")
+    console.print(f"[bold]Goal:[/bold] {p.get('goal', '')}")
+    console.print(f"[bold]Status:[/bold] {p['status']}")
+    console.print(f"[bold]Created:[/bold] {p['created_at']}")
+    console.print(f"[bold]Created By:[/bold] {p.get('created_by', '')}\n")
+    risk = p.get("risk")
+    if risk:
+        console.print("[bold]Risk Assessment:[/bold]")
+        console.print(f"  Overall: {risk['overall_risk']}")
+        approval = "Yes" if p.get("approval_required") else "No"
+        console.print(f"  Approval Required: {approval}")
+        for factor in risk.get("risk_factors", []):
+            console.print(f"    - {factor}")
+        console.print("")
+    actions = p.get("actions", [])
+    console.print(f"[bold]Actions ({len(actions)}):[/bold]")
+    for a in sorted(actions, key=lambda x: x.get("order", 0)):
+        ref = a.get("action_id") or a.get("flow_id") or "?"
+        console.print(f"  {a.get('order', 0) + 1}. {ref}")
+        if a.get("parameters"):
+            console.print(f"     Parameters: {a['parameters']}")
+    scope = p.get("scope") or {}
+    files = scope.get("files") or []
+    modules = scope.get("modules") or []
+    if files or modules:
+        console.print("\n[bold]Scope:[/bold]")
+        if files:
+            console.print(f"  Files: {len(files)}")
+        if modules:
+            console.print(f"  Modules: {', '.join(modules)}")
+    started = p.get("execution_started_at")
+    completed = p.get("execution_completed_at")
+    if started:
+        console.print("\n[bold]Execution:[/bold]")
+        console.print(f"  Started: {started}")
+        if completed:
+            dur = (
+                datetime.fromisoformat(completed) - datetime.fromisoformat(started)
+            ).total_seconds()
+            console.print(f"  Completed: {completed}")
+            console.print(f"  Duration: {dur}s")
+    failure_reason = p.get("failure_reason")
+    if failure_reason:
+        console.print(f"\n[red]Failure Reason: {failure_reason}[/red]")
+
+
+# ID: a649ba15-71d8-46ee-b4cd-9888207ed45d
+def print_execution_summary(result: dict):
+    if not result.get("ok") and "actions_executed" not in result:
+        # Early-exit result from executor (proposal not approved, not found, etc.)
+        console.print(f"Error: {result.get('error', 'Unknown error')}")
+        return
+    console.print(f"Actions executed: {result.get('actions_executed', 0)}")
+    console.print(f"Succeeded: {result.get('actions_succeeded', 0)}")
+    console.print(f"Failed: {result.get('actions_failed', 0)}")
+    console.print(f"Duration: {result.get('duration_sec', 0)}s\n")
+    console.print("[bold]Action Results:[/bold]")
+    for action_id, res in result.get("action_results", {}).items():
+        mark = "[green]✓[/green]" if res["ok"] else "[red]✗[/red]"
+        console.print(f"  {mark} {action_id}: {res['duration_sec']}s")
+        if not res["ok"]:
+            err = res.get("data", {}).get("error", "Unknown error")
+            console.print(f"      [red]{err}[/red]")

cli/logic/body_contracts_checker.py

@@ -0,0 +1,23 @@
+# src/cli/logic/body_contracts_checker.py
+"""
+DEPRECATED — moved to body/governance/body_contracts_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 original Body Contracts Checker (check_body_contracts, Violation, and
+internal helpers) now lives at:
+
+    body.governance.body_contracts_service
+"""
+
+from __future__ import annotations
+
+from body.governance.body_contracts_service import (
+    Violation,
+    check_body_contracts,
+)
+
+
+__all__ = ["Violation", "check_body_contracts"]

cli/logic/build.py

@@ -0,0 +1,27 @@
+# src/cli/logic/build.py
+"""
+Registers and implements the 'build' command group for generating
+artifacts from the database or constitution.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from body.introspection.generate_capability_docs import (
+    main as generate_capability_docs_impl,
+)
+from shared.infrastructure.database.session_manager import get_session
+
+
+build_app = typer.Typer(
+    help="Commands to build artifacts (e.g., documentation) from the database."
+)
+
+
+@build_app.command("capability-docs")
+# ID: 361a766b-e26f-4271-b43e-99967689a7c5
+async def generate_capability_docs():
+    """Generate the capability reference documentation from the DB."""
+    async with get_session() as session:
+        await generate_capability_docs_impl(session)