core-runtime 0.1.1__py3-none-any.whl

cli/resources/vectors/query.py

@@ -0,0 +1,105 @@
+# src/cli/resources/vectors/query.py
+"""
+Vector query command.
+
+Semantic search in vector collections.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from cli.utils import core_command
+from shared.context import CoreContext
+from shared.infrastructure.clients.qdrant_client import QdrantService
+from shared.infrastructure.vector.cognitive_adapter import CognitiveEmbedderAdapter
+from shared.infrastructure.vector.vector_index_service import VectorIndexService
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("query")
+@core_command(requires_context=True)
+# ID: 44056798-de41-4934-8bba-97e6f88ce1f0
+async def query_vectors(
+    ctx: typer.Context,
+    query: str = typer.Argument(..., help="Natural language query"),
+    collection: str = typer.Option(
+        "policies",
+        "--collection",
+        "-c",
+        help="Collection to query: 'policies', 'patterns', or 'specs'",
+    ),
+    limit: int = typer.Option(5, "--limit", "-n", help="Max results to return"),
+) -> None:
+    """
+    Semantic search in vector collections.
+
+    Search constitutional documents using natural language queries.
+
+    Examples:
+        # Search policies
+        core-admin vectors query "file access rules"
+
+        # Search patterns with limit
+        core-admin vectors query "atomic actions" --collection patterns --limit 3
+
+        # Search both
+        core-admin vectors query "governance" --collection policies
+    """
+    console.print(f"[bold cyan]🔍 Querying {collection}[/bold cyan]")
+    console.print(f"Query: {query}")
+    console.print()
+    try:
+        core_context: CoreContext = ctx.obj
+        qdrant_service = core_context.qdrant_service or QdrantService()
+        collection_name = (
+            "core_policies"
+            if collection == "policies"
+            else "core-patterns"
+            if collection == "patterns"
+            else "core_specs"
+        )
+        embedder = CognitiveEmbedderAdapter(core_context.cognitive_service)
+        service = VectorIndexService(
+            qdrant_service=qdrant_service,
+            collection_name=collection_name,
+            embedder=embedder,
+        )
+        results = await service.query(query, limit=limit)
+        if not results:
+            console.print("[yellow]No results found[/yellow]")
+            return
+        console.print(f"[bold]Top {len(results)} results:[/bold]")
+        console.print("")
+        for i, result in enumerate(results, 1):
+            score = result.get("score", 0.0)
+            content = (
+                result.get("content")
+                or result.get("text")
+                or result.get("payload", {}).get("content")
+                or result.get("payload", {}).get("text")
+                or ""
+            )
+            doc_id = (
+                result.get("doc_id")
+                or result.get("id")
+                or result.get("payload", {}).get("doc_id")
+                or result.get("payload", {}).get("chunk_id")
+                or "Unknown"
+            )
+            content_preview = content[:200] if content else "[No content available]"
+            console.print(f"[bold cyan]{i}. {doc_id}[/bold cyan] (score: {score})")
+            console.print(f"   {content_preview}...")
+            console.print("")
+    except Exception as e:
+        logger.error("Vector query failed", exc_info=True)
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)

cli/resources/vectors/status.py

@@ -0,0 +1,30 @@
+# src/cli/resources/vectors/status.py
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from cli.utils import core_command
+
+from .hub import app
+
+
+console = Console()
+
+
+@app.command("status")
+@core_command(dangerous=False, requires_context=True)
+# ID: 61334967-75a9-4a0a-96aa-00e53698b7e8
+async def status_vectors(ctx: typer.Context) -> None:
+    """Show vector store health and collection statistics."""
+    qdrant = ctx.obj.qdrant_service
+    try:
+        collections = await qdrant.client.get_collections()
+        table = Table(title="Qdrant Collections")
+        table.add_column("Collection", style="cyan")
+        table.add_column("Status", justify="center")
+        for coll in collections.collections:
+            table.add_row(coll.name, "🟢 Active")
+        console.print(table)
+    except Exception as e:
+        console.print(f"[bold red]❌ Qdrant Connection Failed:[/bold red] {e}")
+        raise typer.Exit(1)

cli/resources/vectors/sync.py

@@ -0,0 +1,57 @@
+# src/cli/resources/vectors/sync.py
+"""Thin client over POST /v1/sync/vectors (ADR-058 D2)."""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("sync")
+@command_meta(
+    canonical_name="vectors.sync",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.BODY,
+    summary="Synchronize constitutional documents to vector collections.",
+    dangerous=True,
+)
+@core_command(requires_context=False, dangerous=True)
+# ID: 558c245a-7663-4a87-bf2d-4e3c612498bd
+async def sync_vectors(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Apply changes to Qdrant."),
+    target: str = typer.Option(
+        "all", "--target", "-t", help="Target: policies, patterns, or all"
+    ),
+) -> None:
+    """Synchronize constitutional documents to vector collections."""
+    _ = ctx
+    console.print(
+        f"[bold cyan]🧠 Vector Sync (Constitution): "
+        f"{'WRITE' if write else 'DRY-RUN'}[/bold cyan]"
+    )
+    client = CoreApiClient()
+    initial = await client.sync_vectors(write=write, target=target)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]❌ sync_vectors failed to dispatch: {initial}[/red]")
+        raise typer.Exit(1)
+    final = await client.poll_sync_run(run_id)
+    if final.get("status") != "completed":
+        console.print(
+            f"[red]❌ Vector sync failed: {final.get('error') or final}[/red]"
+        )
+        raise typer.Exit(1)
+    console.print("[green]✅ Vector sync completed[/green]")

cli/resources/vectors/sync_code.py

@@ -0,0 +1,67 @@
+# src/cli/resources/vectors/sync_code.py
+"""Thin client over POST /v1/sync/code-vectors (ADR-058 D2)."""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+from shared.cli.command_meta import CommandBehavior, CommandLayer, command_meta
+
+from .hub import app
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@app.command("sync-code")
+@command_meta(
+    canonical_name="vectors.sync-code",
+    behavior=CommandBehavior.MUTATE,
+    layer=CommandLayer.BODY,
+    summary="Synchronize codebase symbol embeddings.",
+    dangerous=True,
+)
+@core_command(dangerous=True, requires_context=False)
+# ID: 6489b6df-f2d8-4480-b0e2-e3054c9c11dc
+async def sync_code_cmd(
+    ctx: typer.Context,
+    write: bool = typer.Option(False, "--write", help="Commit vectors to Qdrant."),
+    force: bool = typer.Option(
+        False, "--force", help="Force re-vectorization of all symbols."
+    ),
+) -> None:
+    """Synchronize codebase symbol embeddings with the vector database."""
+    _ = ctx
+    mode = "SYNCING" if write else "ANALYZING"
+    if force and write:
+        console.print(
+            "[bold yellow]⚡ --force: re-embedding all artifacts[/bold yellow]"
+        )
+    console.print(f"[bold cyan]🧠 {mode} codebase vectors...[/bold cyan]")
+    client = CoreApiClient()
+    initial = await client.sync_code_vectors(write=write, force=force)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]❌ sync_code_vectors failed to dispatch: {initial}[/red]")
+        raise typer.Exit(1)
+    final = await client.poll_sync_run(run_id)
+    if final.get("status") != "completed":
+        console.print(
+            f"[red]❌ Code vector sync failed: {final.get('error') or final}[/red]"
+        )
+        raise typer.Exit(1)
+    action_data = (final.get("result") or {}).get("data") or {}
+    if action_data.get("status") == "partial":
+        remaining = action_data.get("pending_remaining", "?")
+        console.print(
+            f"[yellow]⚠ Embed cap reached — {remaining} artifact(s) still "
+            f"pending. Re-run sync-code or wait for RepoEmbedderWorker.[/yellow]"
+        )
+    else:
+        console.print("[green]✅ Code vector sync completed[/green]")

cli/resources/workers/__init__.py

@@ -0,0 +1,13 @@
+# src/cli/resources/workers/__init__.py
+"""Workers resource — constitutional worker management commands."""
+
+from __future__ import annotations
+
+import typer
+
+from .blackboard import workers_blackboard_cmd
+from .remediate import remediate_cmd
+from .run import workers_app
+
+
+app = workers_app

cli/resources/workers/blackboard.py

@@ -0,0 +1,253 @@
+# src/cli/resources/workers/blackboard.py
+"""Blackboard inspection and maintenance commands for the worker coordination ledger."""
+
+from __future__ import annotations
+
+import json
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from cli.utils.decorators import core_command
+from shared.infrastructure.database.session_manager import get_session
+
+from .run import workers_app
+
+
+console = Console()
+
+
+@workers_app.command("blackboard")
+@core_command(dangerous=False)
+# ID: 4a064a13-ac50-45be-aba5-dc9ce99540b6
+async def workers_blackboard_cmd(
+    ctx: typer.Context,
+    filter: str | None = typer.Option(
+        None,
+        "--filter",
+        "-f",
+        help="Filter by subject prefix (e.g. 'ai.prompt.model_required').",
+    ),
+    status: str | None = typer.Option(
+        None,
+        "--status",
+        "-s",
+        help="Filter by status: open | claimed | resolved | abandoned.",
+    ),
+    entry_type: str | None = typer.Option(
+        None,
+        "--type",
+        "-t",
+        help="Filter by entry_type: finding | report | heartbeat | claim | proposal.",
+    ),
+    limit: int = typer.Option(
+        50, "--limit", "-n", help="Maximum number of entries to display."
+    ),
+    show_payload: bool = typer.Option(
+        False, "--payload", "-p", help="Show full JSON payload for each entry."
+    ),
+) -> None:
+    """Inspect the constitutional worker blackboard (read-only)."""
+    from sqlalchemy import text
+
+    clauses = ["1=1"]
+    params: dict[str, object] = {}
+    if filter:
+        clauses.append("subject LIKE :subject_prefix")
+        params["subject_prefix"] = f"%{filter}%"
+    if status:
+        clauses.append("status = :status")
+        params["status"] = status
+    if entry_type:
+        clauses.append("entry_type = :entry_type")
+        params["entry_type"] = entry_type
+    where = " AND ".join(clauses)
+    query = text(
+        f"\n        SELECT id, entry_type, status, subject, worker_uuid, created_at, payload\n        FROM core.blackboard_entries\n        WHERE {where}\n        ORDER BY created_at DESC\n        LIMIT :limit\n        "
+    )
+    params["limit"] = limit
+    async with get_session() as session:
+        result = await session.execute(query, params)
+        rows = result.fetchall()
+    if not rows:
+        console.print("[yellow]No blackboard entries found.[/yellow]")
+        raise typer.Exit()
+    table = Table(
+        title=f"Blackboard — {len(rows)} entr{('y' if len(rows) == 1 else 'ies')}",
+        show_lines=show_payload,
+    )
+    table.add_column("Type", style="cyan", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Subject")
+    table.add_column("Worker UUID", style="dim", no_wrap=True)
+    table.add_column("Created", style="dim", no_wrap=True)
+    if show_payload:
+        table.add_column("Payload")
+    _STATUS_STYLE = {
+        "open": "green",
+        "claimed": "yellow",
+        "resolved": "blue",
+        "abandoned": "red",
+        "indeterminate": "magenta",
+        "dry_run_complete": "cyan",
+    }
+    for row in rows:
+        _entry_id, etype, estatus, subject, worker_uuid, created_at, payload = row
+        status_style = _STATUS_STYLE.get(estatus, "white")
+        status_str = f"[{status_style}]{estatus}[/{status_style}]"
+        created_str = created_at.strftime("%Y-%m-%d %H:%M:%S") if created_at else "-"
+        worker_str = str(worker_uuid)[:8] + "..." if worker_uuid else "-"
+        row_cells = [etype, status_str, subject, worker_str, created_str]
+        if show_payload:
+            raw = payload if isinstance(payload, dict) else json.loads(payload or "{}")
+            row_cells.append(json.dumps(raw, indent=2))
+        table.add_row(*row_cells)
+    console.print(table)
+
+
+@workers_app.command("purge")
+@core_command(dangerous=True)
+# ID: b2b41188-284f-47e7-8524-1a3027955755
+async def workers_blackboard_purge_cmd(
+    ctx: typer.Context,
+    status: str = typer.Option(
+        ...,
+        "--status",
+        "-s",
+        help="Filter by status (required): open | claimed | resolved | abandoned.",
+    ),
+    rule: str | None = typer.Option(
+        None,
+        "--rule",
+        "-r",
+        help="Filter by rule ID prefix in subject (e.g. 'style.import_order').",
+    ),
+    before: int | None = typer.Option(
+        None,
+        "--before",
+        "-b",
+        help="Only purge entries older than this many hours.",
+    ),
+    write: bool = typer.Option(
+        False, "--write", "-w", help="Apply deletion. Dry-run by default."
+    ),
+) -> None:
+    """Purge blackboard entries by status, with optional rule and age filters."""
+    from sqlalchemy import text
+
+    clauses = ["status = :status"]
+    params: dict[str, object] = {"status": status}
+    if rule:
+        clauses.append("subject LIKE :subject_prefix")
+        params["subject_prefix"] = f"{rule}%"
+    if before is not None:
+        clauses.append("created_at < NOW() - MAKE_INTERVAL(hours => :hours)")
+        params["hours"] = before
+    where = " AND ".join(clauses)
+
+    # Preview matching entries
+    preview_query = text(
+        f"""
+        SELECT id, entry_type, status, subject, worker_uuid, created_at
+        FROM core.blackboard_entries
+        WHERE {where}
+        ORDER BY created_at DESC
+        """
+    )
+    async with get_session() as session:
+        result = await session.execute(preview_query, params)
+        rows = result.fetchall()
+
+    if not rows:
+        console.print("[yellow]No blackboard entries match the given filters.[/yellow]")
+        raise typer.Exit()
+
+    table = Table(
+        title=f"Purge preview — {len(rows)} entr{('y' if len(rows) == 1 else 'ies')}",
+    )
+    table.add_column("Type", style="cyan", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Subject")
+    table.add_column("Worker UUID", style="dim", no_wrap=True)
+    table.add_column("Created", style="dim", no_wrap=True)
+
+    _STATUS_STYLE = {
+        "open": "green",
+        "claimed": "yellow",
+        "resolved": "blue",
+        "abandoned": "red",
+        "indeterminate": "magenta",
+        "dry_run_complete": "cyan",
+    }
+    for row in rows:
+        _entry_id, etype, estatus, subject, worker_uuid, created_at = row
+        status_style = _STATUS_STYLE.get(estatus, "white")
+        status_str = f"[{status_style}]{estatus}[/{status_style}]"
+        created_str = created_at.strftime("%Y-%m-%d %H:%M:%S") if created_at else "-"
+        worker_str = str(worker_uuid)[:8] + "..." if worker_uuid else "-"
+        table.add_row(etype, status_str, subject, worker_str, created_str)
+    console.print(table)
+
+    if not write:
+        console.print(
+            f"\n[dim]Dry run:[/dim] {len(rows)} entries would be deleted. "
+            "Pass [bold]--write[/bold] to apply."
+        )
+        return
+
+    delete_query = text(
+        f"""
+        DELETE FROM core.blackboard_entries
+        WHERE {where}
+        """
+    )
+    async with get_session() as session:
+        result = await session.execute(delete_query, params)
+        await session.commit()
+        deleted = result.rowcount
+
+    console.print(f"\n[bold green]Purged {deleted} blackboard entries.[/bold green]")
+
+
+@workers_app.command("resolve")
+@core_command(dangerous=False)
+# ID: 0dcd5509-ff34-42aa-b866-de1d76c242ae
+async def workers_blackboard_resolve_cmd(
+    ctx: typer.Context,
+    entry_id: str = typer.Argument(..., help="Blackboard entry UUID."),
+    reason: str = typer.Option(
+        ..., "--reason", "-r", help="Why this finding is being closed."
+    ),
+    by: str = typer.Option("cli_admin", "--by", help="Operator identity."),
+    authority: str = typer.Option(
+        "human.cli_operator",
+        "--authority",
+        help="Authority under which the resolution is recorded (URS NFR.5).",
+    ),
+) -> None:
+    """
+    Close an indeterminate blackboard finding with an operator-provided reason.
+
+    Symmetric counterpart to 'proposals reject' for findings the audit sensor
+    delegated to the governor. Flips status to 'resolved', stamps the
+    operator attribution into payload, and stops counting against the
+    Governor Inbox.
+    """
+    from body.services.blackboard_service.blackboard_service import BlackboardService
+
+    updated = await BlackboardService().resolve_indeterminate_entry(
+        entry_id=entry_id,
+        reason=reason,
+        resolved_by=by,
+        resolution_authority=authority,
+    )
+    if updated == 0:
+        console.print(
+            f"[yellow]No change: entry {entry_id} is not in 'indeterminate' "
+            "status or does not exist.[/yellow]"
+        )
+        raise typer.Exit(1)
+    console.print(
+        f"[green]✅ Finding {entry_id} RESOLVED by {by} under {authority}.[/green]"
+    )