core-runtime 0.1.1__py3-none-any.whl

cli/resources/dev/hub.py

@@ -0,0 +1,11 @@
+# src/cli/resources/dev/hub.py
+
+import typer
+
+
+# This hub allows sub-commands to import the app without creating a circular loop
+app = typer.Typer(
+    name="dev",
+    help="High-level developer workflows: synchronization, refactor, and stability tools.",
+    no_args_is_help=True,
+)

cli/resources/dev/refactor.py

@@ -0,0 +1,92 @@
+# src/cli/resources/dev/refactor.py
+"""
+Autonomous refactoring command.
+
+Wires the 'core-admin dev refactor' command to CORE's autonomous
+development engine (develop_from_goal_v2). This is the operator's
+entry point for letting CORE fix its own code.
+"""
+
+from __future__ import annotations
+
+import typer
+from dotenv import load_dotenv
+from rich.console import Console
+
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+from shared.context import CoreContext
+from shared.infrastructure.config_service import ConfigService
+from shared.infrastructure.database.session_manager import get_session
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("refactor")
+@command_meta(
+    canonical_name="dev.refactor",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.WILL,
+    summary="Invoke CORE's autonomous agent loop to refactor code toward a goal.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=True)
+# ID: df3bf750-e564-41cc-beb5-e6da5a97ebc1
+async def dev_refactor_cmd(
+    ctx: typer.Context,
+    goal: str = typer.Argument(..., help="High-level refactoring goal or file path."),
+    write: bool = typer.Option(
+        False, "--write", help="Apply changes. Default is dry-run."
+    ),
+    workflow: str = typer.Option(
+        "refactor_modularity",
+        "--workflow",
+        help="Workflow type: auto, refactor_modularity, coverage_remediation.",
+    ),
+) -> None:
+    """
+    Invoke CORE's autonomous agent loop on a refactoring goal.
+
+    CORE will use its own sensory tools (search_vectors, lookup_symbol,
+    read_file) to navigate the codebase and propose a fix — without
+    being handed code directly.
+
+    Examples:
+      core-admin dev refactor "Fix logic.logging.standard_only violations"
+      core-admin dev refactor src/shared/utils.py --write
+      core-admin dev refactor "Improve modularity of executor.py" --write
+    """
+    from will.autonomy.autonomous_developer import (
+        develop_from_goal,
+    )
+
+    context: CoreContext = ctx.obj
+    load_dotenv()
+    async with get_session() as session:
+        config = await ConfigService.create(session)
+        if not await config.get_bool("LLM_ENABLED", default=False):
+            console.print(
+                "[red]❌ LLM_ENABLED is False. Enable LLMs in database settings to use autonomous development.[/red]"
+            )
+            raise typer.Exit(code=1)
+    workflow_type = workflow
+    mode = "WRITE" if write else "DRY-RUN"
+    console.print(
+        f"[bold cyan]🤖 CORE Autonomous Refactor[/bold cyan] ([yellow]{workflow_type}[/yellow] / {mode})"
+    )
+    console.print(f"[dim]Goal: {goal}[/dim]\n")
+    success, message = await develop_from_goal(
+        context=context,
+        goal=goal,
+        workflow_type=workflow_type,
+        write=write,
+        task_id=None,
+    )
+    if success:
+        console.print(f"\n[bold green]✅ Success:[/bold green] {message}")
+    else:
+        console.print(f"\n[bold red]❌ Failed:[/bold red] {message}")
+        raise typer.Exit(code=1)

cli/resources/dev/stability.py

@@ -0,0 +1,60 @@
+# src/cli/resources/dev/stability.py
+"""
+Stability CLI Commands - Phase 2 Hardening.
+Orchestrates idempotency testing for atomic actions.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from body.maintenance.idempotency_harness import IdempotencyHarness
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("test-stability")
+@command_meta(
+    canonical_name="dev.test-stability",
+    behavior=CommandBehavior.VALIDATE,
+    layer=CommandLayer.WILL,
+    summary="Verify the idempotency (stability) of a specific atomic action.",
+)
+@core_command(dangerous=True, requires_context=True)
+# ID: b6bb979d-bb7f-4a4d-8518-1bd977634891
+async def dev_stability_cmd(
+    ctx: typer.Context,
+    action_id: str = typer.Argument(
+        ..., help="The ID of the action to test (e.g. fix.format)."
+    ),
+) -> None:
+    """
+    Runs a stability trial on an action:
+    1. Runs the action once to apply changes.
+    2. Snapshots the codebase.
+    3. Runs the action again.
+    4. Verifies that the second run resulted in ZERO changes.
+    """
+    core_context = ctx.obj
+    harness = IdempotencyHarness(core_context)
+    console.print(
+        f"\n[bold cyan]🧪 Initiating Stability Trial: {action_id}[/bold cyan]\n"
+    )
+    result = await harness.verify_action(action_id)
+    if result.ok:
+        console.print(
+            f"\n[bold green]✅ PROVEN:[/bold green] Action '{action_id}' is idempotent and stable."
+        )
+    else:
+        console.print(
+            f"\n[bold red]❌ FAILED:[/bold red] Action '{action_id}' is unstable (logic drift detected)."
+        )
+        for error in result.errors:
+            console.print(f"  [yellow]![/yellow] {error}")
+        raise typer.Exit(code=1)

cli/resources/dev/strategic_audit.py

@@ -0,0 +1,113 @@
+# src/cli/resources/dev/strategic_audit.py
+"""
+Strategic Audit command — CORE's self-awareness cycle.
+
+Wires 'core-admin dev strategic-audit' to the StrategicAuditor agent.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from dotenv import load_dotenv
+from rich.console import Console
+
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+from shared.context import CoreContext
+from shared.infrastructure.config_service import ConfigService
+from shared.infrastructure.database.session_manager import get_session
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("strategic-audit")
+@command_meta(
+    canonical_name="dev.strategic_audit",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.WILL,
+    summary="Run CORE's self-awareness cycle: audit → reason → campaign → (optionally) execute.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=True)
+# ID: 0261fa1c-e876-4f07-83c2-dab6742ae7e6
+async def strategic_audit_cmd(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Persist campaign to database."),
+    execute: bool = typer.Option(
+        False,
+        "--execute",
+        help="Immediately execute autonomous tasks (implies --write).",
+    ),
+) -> None:
+    """
+    Run CORE's strategic self-awareness cycle.
+
+    Reads the full system state (audit findings, knowledge graph, constitution,
+    git history), reasons about it as a whole, and produces a prioritised
+    remediation campaign.
+
+    Autonomous tasks are staged in PostgreSQL.
+    Tasks requiring .intent/ changes are flagged as escalations for your review.
+
+    Examples:
+      core-admin dev strategic-audit                    # dry-run: report only
+      core-admin dev strategic-audit --write            # persist campaign to DB
+      core-admin dev strategic-audit --write --execute  # persist + execute autonomously
+    """
+    from will.agents.strategic_auditor import StrategicAuditor
+
+    context: CoreContext = ctx.obj
+    load_dotenv()
+    if execute:
+        write = True
+    async with get_session() as session:
+        config = await ConfigService.create(session)
+        if not await config.get_bool("LLM_ENABLED", default=False):
+            console.print(
+                "[red]❌ LLM_ENABLED is False. Enable LLMs in database settings to use strategic audit.[/red]"
+            )
+            raise typer.Exit(code=1)
+    mode_parts = []
+    if write:
+        mode_parts.append("WRITE")
+    if execute:
+        mode_parts.append("EXECUTE")
+    mode = " + ".join(mode_parts) if mode_parts else "DRY-RUN"
+    console.print(
+        f"\n[bold cyan]🧠 CORE Strategic Audit[/bold cyan] [dim]({mode})[/dim]\n"
+    )
+    try:
+        cognitive_service = await context.registry.get_cognitive_service()
+        auditor = StrategicAuditor(context=context, cognitive_service=cognitive_service)
+        async with get_session() as session:
+            campaign = await auditor.run(
+                session=session, write=write, execute_autonomous=execute
+            )
+        if campaign.escalations:
+            console.print(
+                f"\n[bold yellow]📬 {campaign.escalation_count} escalation(s) require your review.[/bold yellow]"
+            )
+            console.print(
+                "[dim]These need .intent/ amendments — only you can approve them.[/dim]\n"
+            )
+            for i, e in enumerate(campaign.escalations, 1):
+                console.print(f"  [yellow]{i}.[/yellow] {e.root_cause}")
+                console.print(f"     [dim]{e.proposed_fix[:120]}[/dim]")
+        if write:
+            console.print(
+                f"\n[green]✅ Campaign persisted.[/green] [dim]ID: {campaign.campaign_id}[/dim]"
+            )
+        else:
+            console.print(
+                "\n[dim]Dry-run complete. Use --write to persist, --execute to act.[/dim]"
+            )
+    except Exception as e:
+        logger.exception("Strategic audit failed")
+        console.print(f"[red]❌ Strategic audit failed: {e}[/red]")
+        raise typer.Exit(code=1)

cli/resources/dev/sync.py

@@ -0,0 +1,51 @@
+# src/cli/resources/dev/sync.py
+import typer
+from rich.console import Console
+
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+from will.workflows.dev_sync_workflow import DevSyncWorkflow
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("sync")
+@command_meta(
+    canonical_name="dev.sync",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.WILL,
+    summary="Run complete developer synchronization workflow.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=True, confirmation=True)
+# ID: a3cfcc6d-0028-41fe-93d9-c14440a3c75b
+async def sync_workflow(
+    ctx: typer.Context,
+    write: bool = typer.Option(
+        False, "--write", help="Apply all fixes and sync state to DB/Vectors."
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip confirmation prompt for dangerous operations."
+    ),
+) -> None:
+    """
+    Run the complete developer synchronization workflow.
+
+    1. Fixes code (IDs, headers, formatting).
+    2. Syncs knowledge graph to PostgreSQL.
+    3. Syncs semantic vectors to Qdrant.
+    """
+    core_context = ctx.obj
+    mode = "WRITE" if write else "DRY-RUN"
+    console.print(f"[bold cyan]🔄 Running Dev-Sync Workflow ({mode})...[/bold cyan]")
+    workflow = DevSyncWorkflow(core_context)
+    result = await workflow.run(write=write)
+    if result.ok:
+        console.print("\n[bold green]✅ System synchronized successfully.[/bold green]")
+    else:
+        console.print(
+            "\n[bold red]❌ Sync failed during one or more phases.[/bold red]"
+        )

cli/resources/dev/test.py

@@ -0,0 +1,34 @@
+# src/cli/resources/dev/test.py
+import typer
+from rich.console import Console
+
+from cli.logic.interactive_test_logic import run_interactive_test_generation
+from cli.utils import core_command
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("test")
+@core_command(dangerous=True, requires_context=True)
+# ID: ffdee379-1a1e-429f-9dab-3ceaaa85ae1f
+async def test_interactive(
+    ctx: typer.Context,
+    target: str = typer.Argument(..., help="Path to the file you want to test."),
+) -> None:
+    """
+    Start an interactive test generation session for a specific file.
+
+    Allows you to review, edit, and approve test code step-by-step.
+    """
+    core_context = ctx.obj
+    console.print(
+        f"[bold cyan]🎯 Starting interactive test session for:[/bold cyan] {target}"
+    )
+    success = await run_interactive_test_generation(
+        target_file=target, core_context=core_context
+    )
+    if not success:
+        raise typer.Exit(1)

cli/resources/intent/__init__.py

@@ -0,0 +1,11 @@
+# src/cli/resources/intent/__init__.py
+"""Intent resource hub."""
+
+from __future__ import annotations
+
+# Register all neurons
+from . import sync_vocabulary
+from .hub import app
+
+
+__all__ = ["app"]

cli/resources/intent/hub.py

@@ -0,0 +1,9 @@
+# src/cli/resources/intent/hub.py
+import typer
+
+
+app = typer.Typer(
+    name="intent",
+    help="Constitutional intent operations (.intent/ projections).",
+    no_args_is_help=True,
+)