core-runtime 0.1.1__py3-none-any.whl

body/workers/prompt_artifact_writer.py

@@ -0,0 +1,323 @@
+# src/body/workers/prompt_artifact_writer.py
+"""
+PromptArtifactWriter - Constitutional Compliance Acting Worker.
+
+Responsibility: For each approved prompt extraction on the blackboard,
+generate and write the three PromptModel artifact files to var/prompts/.
+
+Constitutional standing:
+- Declaration:      .intent/workers/prompt_artifact_writer.yaml
+- Class:            acting
+- Phase:            execution
+- Permitted tools:  llm.architect, file.write
+- Approval:         true
+
+LAYER: body/workers — acting worker. Writes to var/prompts/ only via
+FileHandler (IntentGuard enforced). No src/ writes.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from shared.ai.response_parser import extract_json
+from shared.infrastructure.intent.operational_config import load_operational_config
+from shared.logger import getLogger
+from shared.workers.base import Worker
+
+
+logger = getLogger(__name__)
+
+_SOURCE_SUBJECT = "prompt.extraction"
+_ARTIFACT_SUBJECT = "prompt.artifact"
+
+# Non-ASCII character filter for DB safety (PostgreSQL SQL_ASCII)
+_NON_ASCII_RE = re.compile(r"[^\x09\x0A\x0D\x20-\x7E]")
+
+_CFG = load_operational_config().workers.prompt_artifact_writer
+
+
+# ID: facf4728-e072-41e5-8464-6440b7c27554
+class PromptArtifactWriter(Worker):
+    """
+    Acting worker. Claims open prompt.extraction findings from the blackboard,
+    invokes the prompt_artifact_generator PromptModel to produce three artifact
+    files, writes them to var/prompts/<suggested_name>/ via FileHandler,
+    and posts a completion finding to the blackboard.
+
+    approval_required: true — writes to the filesystem.
+    """
+
+    declaration_name = "prompt_artifact_writer"
+
+    def __init__(self, core_context: Any) -> None:
+        """
+        Args:
+            core_context: Initialized CoreContext. Provides cognitive_service,
+                          file_handler, and git_service.
+        """
+        super().__init__()
+        self._core_context = core_context
+
+    # ID: 8e7827db-4478-47f0-b458-c8879c76b8e4
+    async def run(self) -> None:
+        """
+        Claim open extraction findings, generate PromptModel artifacts via
+        LLM, write files via FileHandler, post results to blackboard.
+        """
+        await self.post_heartbeat()
+
+        findings = await self._claim_open_extractions()
+
+        if not findings:
+            await self.post_report(
+                subject="prompt_artifact_writer.run.complete",
+                payload={
+                    "written": 0,
+                    "message": "No open extraction findings to process.",
+                },
+            )
+            logger.info("PromptArtifactWriter: no open extractions.")
+            return
+
+        logger.info("PromptArtifactWriter: %d extractions to process.", len(findings))
+
+        from shared.ai.prompt_model import PromptModel
+
+        model = PromptModel.load("prompt_artifact_generator")
+
+        client = await self._core_context.cognitive_service.aget_client_for_role(
+            model.manifest.role
+        )
+        file_handler = self._core_context.file_handler
+
+        written = 0
+        failed = 0
+
+        for finding in findings:
+            payload = finding["payload"]
+            extraction_id: str = finding["id"]
+            file_path: str = payload["file_path"]
+            line_number: int = payload["line_number"]
+            prompt_text: str = payload.get("prompt_text", "")
+            suggested_name: str = payload.get("suggested_name", "")
+            input_vars: list[str] = payload.get("input_vars", [])
+
+            if not suggested_name:
+                logger.warning(
+                    "PromptArtifactWriter: no suggested_name for %s:%s — skipping",
+                    file_path,
+                    line_number,
+                )
+                await self._mark_finding(extraction_id, "abandoned")
+                failed += 1
+                continue
+
+            cognitive_role = _infer_role(file_path)
+
+            try:
+                raw = await model.invoke(
+                    context={
+                        "file_path": file_path,
+                        "suggested_name": suggested_name,
+                        "prompt_text": prompt_text,
+                        "input_vars": json.dumps(input_vars),
+                        "cognitive_role": cognitive_role,
+                    },
+                    client=client,
+                    user_id="prompt_artifact_writer",
+                )
+            except Exception as e:
+                logger.warning(
+                    "PromptArtifactWriter: LLM invocation failed for %s — %s",
+                    suggested_name,
+                    e,
+                )
+                await self._mark_finding(extraction_id, "abandoned")
+                failed += 1
+                continue
+
+            try:
+                artifact = extract_json(raw)
+            except (json.JSONDecodeError, ValueError) as e:
+                logger.warning(
+                    "PromptArtifactWriter: JSON parse failed for %s — %s | raw[:200]=%r",
+                    suggested_name,
+                    e,
+                    raw[:200],
+                )
+                await self._mark_finding(extraction_id, "abandoned")
+                failed += 1
+                continue
+
+            model_yaml = _sanitize(artifact.get("model_yaml", ""))
+            system_txt = _sanitize(artifact.get("system_txt", ""))
+            user_txt = _sanitize(artifact.get("user_txt", ""))
+
+            if not model_yaml or not system_txt or not user_txt:
+                logger.warning(
+                    "PromptArtifactWriter: incomplete artifact for %s — skipping",
+                    suggested_name,
+                )
+                await self._mark_finding(extraction_id, "abandoned")
+                failed += 1
+                continue
+
+            try:
+                base = f"var/prompts/{suggested_name}"
+                file_handler.write_runtime_text(f"{base}/model.yaml", model_yaml)
+                file_handler.write_runtime_text(f"{base}/system.txt", system_txt)
+                file_handler.write_runtime_text(f"{base}/user.txt", user_txt)
+            except Exception as e:
+                logger.warning(
+                    "PromptArtifactWriter: file write failed for %s — %s",
+                    suggested_name,
+                    e,
+                )
+                await self._mark_finding(extraction_id, "abandoned")
+                failed += 1
+                continue
+
+            subject = f"{_ARTIFACT_SUBJECT}::{file_path}::{line_number}"
+            await self.post_finding(
+                subject=subject,
+                payload={
+                    "source_extraction_id": extraction_id,
+                    "file_path": file_path,
+                    "line_number": line_number,
+                    "artifact_name": suggested_name,
+                    "artifact_path": f"var/prompts/{suggested_name}",
+                    "cognitive_role": cognitive_role,
+                    "status": "written",
+                },
+            )
+
+            await self._mark_finding(extraction_id, "resolved")
+
+            written += 1
+            logger.info(
+                "PromptArtifactWriter: wrote var/prompts/%s/ (%s:%s)",
+                suggested_name,
+                file_path,
+                line_number,
+            )
+
+        await self.post_report(
+            subject="prompt_artifact_writer.run.complete",
+            payload={
+                "written": written,
+                "failed": failed,
+                "message": f"Run complete. {written} artifacts written, {failed} failed.",
+            },
+        )
+
+        logger.info("PromptArtifactWriter: %d written, %d failed.", written, failed)
+
+    # -------------------------------------------------------------------------
+    # Internal
+    # -------------------------------------------------------------------------
+
+    async def _claim_open_extractions(self) -> list[dict[str, Any]]:
+        """
+        Atomically claim open prompt.extraction findings.
+        Uses FOR UPDATE SKIP LOCKED to prevent double-claiming across
+        concurrent worker instances.
+        """
+        from sqlalchemy import text
+
+        from shared.infrastructure.database.session_manager import get_session
+
+        async with get_session() as session:
+            async with session.begin():
+                result = await session.execute(
+                    text(
+                        """
+                        UPDATE core.blackboard_entries
+                        SET status = 'claimed', updated_at = now()
+                        WHERE id IN (
+                            SELECT id FROM core.blackboard_entries
+                            WHERE entry_type = 'finding'
+                              AND subject LIKE :prefix
+                              AND status = 'open'
+                            ORDER BY created_at ASC
+                            LIMIT :limit
+                            FOR UPDATE SKIP LOCKED
+                        )
+                        RETURNING id, subject, payload
+                        """
+                    ),
+                    {"prefix": f"{_SOURCE_SUBJECT}::%", "limit": _CFG.claim_limit},
+                )
+                rows = result.fetchall()
+
+        findings = []
+        for row in rows:
+            raw_payload = row[2]
+            payload = (
+                raw_payload
+                if isinstance(raw_payload, dict)
+                else json.loads(raw_payload)
+            )
+            findings.append(
+                {
+                    "id": str(row[0]),
+                    "subject": row[1],
+                    "payload": payload,
+                }
+            )
+        return findings
+
+    async def _mark_finding(self, finding_id: str, status: str) -> None:
+        """Update the status of a blackboard finding by ID."""
+        from sqlalchemy import text
+
+        from shared.infrastructure.database.session_manager import get_session
+
+        async with get_session() as session:
+            await session.execute(
+                text(
+                    """
+                    UPDATE core.blackboard_entries
+                    SET status = :status,
+                        resolved_at = CASE
+                            WHEN :status IN ('resolved', 'abandoned', 'indeterminate')
+                                THEN now()
+                            ELSE resolved_at
+                        END,
+                        updated_at = now()
+                    WHERE id = :id
+                    """
+                ),
+                {"status": status, "id": finding_id},
+            )
+            await session.commit()
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _sanitize(value: str) -> str:
+    """Strip non-ASCII characters that PostgreSQL SQL_ASCII cannot store."""
+    if not isinstance(value, str):
+        return str(value)
+    return _NON_ASCII_RE.sub("?", value)
+
+
+def _infer_role(file_path: str) -> str:
+    """
+    Infer an appropriate cognitive role from the file path.
+    Conservative defaults: most tasks go to LocalCoder; strategic/governance
+    files get Architect.
+    """
+    if any(
+        seg in file_path
+        for seg in ("strategic_auditor", "assumption_extractor", "authority_package")
+    ):
+        return "Architect"
+    if any(seg in file_path for seg in ("planner", "orchestration", "interpreter")):
+        return "Planner"
+    return "LocalCoder"

cli/__init__.py

@@ -0,0 +1,4 @@
+# src/cli/__init__.py
+"""Provides functionality for the __init__ module."""
+
+from __future__ import annotations

cli/admin_cli.py

@@ -0,0 +1,98 @@
+# src/cli/admin_cli.py
+"""
+CORE Admin CLI - The Constitutional Command Center.
+
+Enforces Resource-First Architecture (v2.0) as defined in
+.intent/rules/cli/interface_design.json.
+
+UNIX Philosophy: CLI provides atomic resource actions; Makefile composes them.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from body.infrastructure.bootstrap import create_core_context
+from body.services.service_registry import service_registry
+from cli.commands.daemon import daemon_app
+from cli.commands.interactive_test import app as interactive_test_app
+from cli.commands.refactor import refactor_app
+from cli.commands.search import search_app
+from cli.commands.status import status_app
+from cli.interactive import launch_interactive_menu
+from cli.logic.tools import tools_app
+from cli.resources.admin import app as admin_app
+from cli.resources.code import app as code_app
+from cli.resources.coherence import app as coherence_app
+from cli.resources.constitution import app as constitution_app
+from cli.resources.context import app as context_app
+from cli.resources.database import app as database_app
+from cli.resources.dev import app as dev_app
+from cli.resources.intent import app as intent_app
+from cli.resources.project import app as project_app
+from cli.resources.proposals import app as proposals_app
+from cli.resources.runtime import app as runtime_app
+from cli.resources.secrets import app as secrets_app
+from cli.resources.symbols import app as symbols_app
+from cli.resources.vectors import app as vectors_app
+from cli.resources.workers import app as workers_app
+from shared.infrastructure.database.session_manager import get_session
+
+
+console = Console()
+app = typer.Typer(
+    name="core-admin",
+    help="CORE: The Self-Improving System Architect's Toolkit.",
+    no_args_is_help=False,
+)
+core_context = create_core_context(service_registry)
+
+
+# ID: ceac52ff-a86d-47f6-9c1e-2580932a3767
+def register_all_commands(app_instance: typer.Typer) -> None:
+    """
+    Register CLI commands according to the Resource-First hierarchy.
+    Legacy Verb-First groups (fix, check, inspect) have been purged.
+    """
+    app_instance.add_typer(admin_app, name="admin")
+    app_instance.add_typer(code_app, name="code")
+    app_instance.add_typer(context_app, name="context")
+    app_instance.add_typer(database_app, name="database")
+    app_instance.add_typer(runtime_app, name="runtime")
+    app_instance.add_typer(symbols_app, name="symbols")
+    app_instance.add_typer(vectors_app, name="vectors")
+    app_instance.add_typer(workers_app, name="workers")
+    app_instance.add_typer(constitution_app, name="constitution")
+    app_instance.add_typer(coherence_app, name="coherence")
+    app_instance.add_typer(proposals_app, name="proposals")
+    app_instance.add_typer(project_app, name="project")
+    app_instance.add_typer(dev_app, name="dev")
+    app_instance.add_typer(intent_app, name="intent")
+    app_instance.add_typer(interactive_test_app, name="interactive-test")
+    app_instance.add_typer(refactor_app, name="refactor")
+    app_instance.add_typer(tools_app, name="tools")
+    app_instance.add_typer(secrets_app, name="secrets")
+    app_instance.add_typer(daemon_app, name="daemon")
+    app_instance.add_typer(search_app, name="search")
+    app_instance.add_typer(status_app, name="status")
+
+
+register_all_commands(app)
+
+
+@app.callback(invoke_without_command=True)
+# ID: 1f5f3dc8-cbc5-426f-8049-271f45e155f5
+def main(ctx: typer.Context) -> None:
+    """Bootstrap services and launch TUI if no command given."""
+    service_registry.prime(get_session)
+    ctx.obj = core_context
+    if ctx.invoked_subcommand is None:
+        console.print(
+            "[bold green]🛏  CORE Admin Active. Resource-First Architecture v2.0 engaged.[/bold green]"
+        )
+        launch_interactive_menu()
+
+
+if __name__ == "__main__":
+    app()

cli/cli_user.py

@@ -0,0 +1,121 @@
+# src/cli/cli_user.py
+
+"""
+End-user conversational CLI interface for CORE.
+
+This module exposes the `core` command-line binary intended for
+non-technical or high-level users who wish to interact with CORE
+conversationally.
+
+Architectural Enforcement (Mind-Will-Body Separation):
+-------------------------------------------------------
+- User input is routed exclusively through the Will layer
+  (ConversationalAgent).
+- All proposals generated by the agent are validated by the Mind layer
+  (constitutional governance).
+- All execution is performed through Body atomic actions.
+
+No direct execution paths bypass governance.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+# Public CLI application
+app = typer.Typer(name="core", help="Chat with CORE about your codebase")
+
+
+@app.callback(invoke_without_command=True)
+# ID: 261ee005-2111-459b-9058-2f704448cc5b
+def main(
+    ctx: typer.Context,
+    message: str = typer.Argument(None, help="Your message to CORE"),
+) -> None:
+    """
+    Entry point for the `core` CLI command.
+
+    If invoked without subcommands, this function expects a single
+    natural-language message which will be processed by the
+    ConversationalAgent.
+
+    Examples:
+        core "analyze the CoreContext class"
+        core "what does ContextBuilder do?"
+        core "my tests are failing"
+        core "refactor this file for clarity"
+
+    Args:
+        ctx: Typer context (used to detect subcommand invocation).
+        message: Natural-language message provided by the user.
+
+    Raises:
+        typer.Exit: With status code 1 on usage error or failure.
+        typer.Exit: With status code 130 on user interruption.
+    """
+
+    # If a subcommand was invoked, defer execution
+    if ctx.invoked_subcommand is not None:
+        return
+
+    # Require a message when no subcommand is provided
+    if not message:
+        logger.info("Usage: core <message>")
+        logger.info('Example: core "what does ContextBuilder do?"')
+        raise typer.Exit(1)
+
+    logger.info("User message: %s", message)
+
+    try:
+        # Execute asynchronous handler inside event loop
+        asyncio.run(handle_message(message))
+
+    except KeyboardInterrupt:
+        logger.info("\n\n⚠️  Interrupted by user")
+        raise typer.Exit(130)
+
+    except Exception as exc:
+        logger.error("Failed to process message: %s", exc, exc_info=True)
+        logger.info("\n❌ Error: %s", exc)
+        raise typer.Exit(1)
+
+
+# ID: 401141cc-de0f-4c9c-ad73-a2704835f347
+async def handle_message(message: str) -> None:
+    """
+    Asynchronous conversational handler.
+
+    Initializes the ConversationalAgent (Will layer), processes the
+    user's message, and logs the response.
+
+    Execution Flow:
+        1. Instantiate conversational agent.
+        2. Delegate message processing to agent.
+        3. Log formatted response.
+
+    Args:
+        message: User's natural-language query.
+    """
+
+    from will.agents.conversational import create_conversational_agent
+
+    logger.info("🤖 CORE is thinking...\n")
+
+    agent = await create_conversational_agent()
+    response = await agent.process_message(message)
+
+    logger.info("─" * 70)
+    logger.info(response)
+    logger.info("─" * 70)
+    logger.info("")
+
+
+if __name__ == "__main__":
+    app()

cli/commands/__init__.py

@@ -0,0 +1,4 @@
+# src/cli/commands/__init__.py
+"""Package marker for the V2 CLI command structure."""
+
+from __future__ import annotations