caudate-cli 0.1.0__py3-none-any.whl

core/statusline.py

@@ -0,0 +1,61 @@
+"""Status line — single-line status above the input prompt.
+
+The format is a Python `str.format` template pulled from settings
+(`statusline` key). Available placeholders:
+
+  {model}          active model id
+  {mood}           personality mood label or 'n/a'
+  {session}        full session id
+  {session_short}  first 8 chars of session id
+  {tokens}         total tokens this session
+  {cost}           total $ cost this session
+  {turn}           message count
+
+Missing fields render as the literal placeholder so a malformed template
+doesn't crash the prompt — render once, decide it's wrong, re-render.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class _SafeMap(dict):
+    def __missing__(self, key: str) -> str:
+        return "{" + key + "}"
+
+
+def render_statusline(template: str, values: dict[str, Any]) -> str:
+    """Format `template` using {placeholders}; missing keys are kept literal."""
+    try:
+        return template.format_map(_SafeMap(values))
+    except Exception:
+        return template
+
+
+def build_status_values(agent: Any) -> dict[str, Any]:
+    """Pull every documented placeholder value off a CognosAgent."""
+    from core.usage import get_global_tracker
+    tracker = get_global_tracker()
+    mood = "n/a"
+    try:
+        if agent.personality is not None:
+            mood = agent.personality.mood.label()
+    except Exception:
+        pass
+    session_id = ""
+    turn = 0
+    try:
+        session_id = agent.session.id
+        turn = len(agent.session.messages)
+    except Exception:
+        pass
+    return {
+        "model": getattr(agent.llm, "model", "?"),
+        "mood": mood,
+        "session": session_id,
+        "session_short": session_id[:8],
+        "tokens": tracker.total_tokens(),
+        "cost": tracker.total_cost(),
+        "turn": turn,
+    }

core/subagent.py

@@ -0,0 +1,300 @@
+"""Subagent manager — spawn, track, and collect isolated child agents.
+
+A subagent is a child AgenticLoop with its own message history, its own
+system prompt, and a restricted tool subset. It shares the parent's
+long-term memory (episodic/semantic) but in read-only mode — the subagent
+does not consolidate lessons back.
+
+Subagents can run sequentially or in parallel. Parallel execution is
+bounded by `max_concurrent` to avoid overloading local LLMs.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from dataclasses import dataclass, field
+from typing import Any
+
+from core.agentic_loop import AgenticLoop
+from core.hooks import HookEvent, HookManager
+from core.permissions import PermissionManager
+from core.worktree import Worktree, create_worktree
+from execution.executor import Executor
+from llm.provider import LLMProvider
+
+logger = logging.getLogger(__name__)
+
+
+SUBAGENT_PROFILES: dict[str, dict[str, Any]] = {
+    "general-purpose": {
+        "tools": ["Read", "Write", "Edit", "Glob", "Grep", "Bash", "PythonExec",
+                  "WebSearch", "WebFetch", "Think", "Respond"],
+        "system": (
+            "You are a general-purpose subagent. Focus narrowly on the task you "
+            "were given. Use tools as needed. When done, respond with a concise "
+            "summary — that summary is returned to your parent agent."
+        ),
+    },
+    "research": {
+        "tools": ["WebSearch", "WebFetch", "Think", "Respond"],
+        "system": (
+            "You are a research subagent. Search the web, fetch and read pages, "
+            "then synthesize findings. Cite sources. End with a concise summary."
+        ),
+    },
+    "code-review": {
+        "tools": ["Read", "Glob", "Grep", "Think", "Respond"],
+        "system": (
+            "You are a code-review subagent. Read the specified files, identify "
+            "bugs/smells/risks, and report a prioritized list with file:line "
+            "references. Do NOT modify files — review only."
+        ),
+    },
+    # Dual-brain roles — mirror /home/raveuk/src/prompts/system_prompts.json.
+    # `executor_brain_01` runs linear plans; on twice-failed validation
+    # it dispatches context to `critic_brain_02` through the inter-agent
+    # bus and waits for a reply. `critic_brain_02` reviews structural
+    # problems and outputs fixes exclusively as diff patches.
+    "executor_brain": {
+        "tools": ["Read", "Write", "Edit", "Glob", "Grep", "Bash", "PythonExec",
+                  "Think", "Respond", "Agent"],
+        "system": (
+            "ROLE: You are 'executor_brain_01'. Run tasks linearly. If "
+            "validation fails twice, escalate via inter_agent_bus to "
+            "critic_brain_02 with the failing context attached. Wait for "
+            "the critic's reply before retrying."
+        ),
+    },
+    "critic_brain": {
+        "tools": ["Read", "Glob", "Grep", "Think", "Respond"],
+        "system": (
+            "ROLE: You are 'critic_brain_02'. You review structural "
+            "problems and output fixes exclusively as diff patches. "
+            "Read the failing context, identify the root cause, and "
+            "emit a unified diff (`---/+++` headers, `@@` hunks) that "
+            "the executor can apply directly. Do not modify files "
+            "yourself — review only."
+        ),
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# Inter-agent bus — async queue channels between named agents.
+#
+# Mirrors /home/raveuk/src/communication/bus.py: one queue per registered
+# agent id, plus a futures dict for request/reply when the sender wants
+# to suspend until the recipient replies. Lives inline (no new file)
+# because it's tiny and only the SubagentManager wires it.
+# ---------------------------------------------------------------------------
+
+
+class InterAgentBus:
+    """Async message bus keyed by agent id (e.g. executor_brain_01)."""
+
+    def __init__(self, agent_ids: list[str] | None = None):
+        ids = agent_ids or ["executor_brain_01", "critic_brain_02"]
+        self.channels: dict[str, asyncio.Queue] = {a: asyncio.Queue() for a in ids}
+        self.pending: dict[str, asyncio.Future] = {}
+
+    def register(self, agent_id: str) -> None:
+        self.channels.setdefault(agent_id, asyncio.Queue())
+
+    async def send(
+        self,
+        sender_id: str,
+        recipient_id: str,
+        context: str,
+        suspend_sender: bool = False,
+    ) -> Any | None:
+        if recipient_id not in self.channels:
+            raise ValueError(f"Bus address '{recipient_id}' is not registered.")
+        payload: dict[str, Any] = {
+            "sender_id": sender_id,
+            "context": context,
+            "requires_reply": suspend_sender,
+        }
+        if suspend_sender:
+            loop = asyncio.get_event_loop()
+            fut: asyncio.Future = loop.create_future()
+            corr_id = f"{sender_id}->{recipient_id}:{id(fut)}"
+            payload["correlation_id"] = corr_id
+            self.pending[corr_id] = fut
+            await self.channels[recipient_id].put(payload)
+            try:
+                return await fut
+            finally:
+                self.pending.pop(corr_id, None)
+        await self.channels[recipient_id].put(payload)
+        return None
+
+    async def recv(self, agent_id: str) -> dict[str, Any]:
+        if agent_id not in self.channels:
+            raise ValueError(f"Bus address '{agent_id}' is not registered.")
+        return await self.channels[agent_id].get()
+
+    def reply(self, correlation_id: str, result: Any) -> bool:
+        fut = self.pending.get(correlation_id)
+        if fut is None or fut.done():
+            return False
+        fut.set_result(result)
+        return True
+
+
+@dataclass
+class SubagentRun:
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    subagent_type: str = "general-purpose"
+    task: str = ""
+    result: str | None = None
+    error: str | None = None
+    worktree_path: str | None = None
+    worktree_branch: str | None = None
+
+
+class SubagentManager:
+    """Spawns child agents with restricted tool sets."""
+
+    def __init__(
+        self,
+        llm: LLMProvider,
+        parent_executor: Executor,
+        episodic=None,
+        semantic=None,
+        permissions: PermissionManager | None = None,
+        hooks: HookManager | None = None,
+        max_concurrent: int = 3,
+        max_iterations: int = 10,
+    ):
+        self.llm = llm
+        self.parent_executor = parent_executor
+        self.episodic = episodic
+        self.semantic = semantic
+        self.permissions = permissions
+        self.hooks = hooks or HookManager()
+        self.max_concurrent = max_concurrent
+        self.max_iterations = max_iterations
+        self._semaphore = asyncio.Semaphore(max_concurrent)
+        # Inter-agent bus — pre-registers the two dual-brain addresses.
+        # Additional ids can be added via `self.bus.register(...)`.
+        self.bus = InterAgentBus()
+
+    async def dispatch(
+        self,
+        sender_id: str,
+        recipient_id: str,
+        context: str,
+        suspend_sender: bool = False,
+    ) -> Any | None:
+        """Send a message on the inter-agent bus.
+
+        When `suspend_sender` is True, awaits a reply from the recipient
+        and returns it. Otherwise fire-and-forget.
+        """
+        return await self.bus.send(sender_id, recipient_id, context, suspend_sender)
+
+    async def run_one(
+        self,
+        task: str,
+        subagent_type: str = "general-purpose",
+        isolation: str | None = None,
+    ) -> SubagentRun:
+        """Run a single subagent to completion.
+
+        `isolation="worktree"` creates a temporary git worktree the
+        subagent operates in. The worktree path is returned on the run
+        so the caller can review or discard it. If creation fails, the
+        run continues in the parent's working tree (best-effort).
+        """
+        profile = SUBAGENT_PROFILES.get(subagent_type, SUBAGENT_PROFILES["general-purpose"])
+        run = SubagentRun(subagent_type=subagent_type, task=task)
+
+        await self.hooks.emit(HookEvent.SUBAGENT_START, {
+            "subagent_id": run.id,
+            "subagent_type": subagent_type,
+            "task": task,
+            "isolation": isolation,
+        })
+
+        wt: Worktree | None = None
+        if isolation == "worktree":
+            wt = await create_worktree()
+            if wt is not None:
+                run.worktree_path = str(wt.path)
+                run.worktree_branch = wt.branch
+                logger.info(f"Subagent {run.id} running in worktree {wt.path}")
+
+        async with self._semaphore:
+            try:
+                child_executor = _restricted_executor(
+                    self.parent_executor, profile["tools"], self.llm,
+                )
+                child = AgenticLoop(
+                    llm=self.llm,
+                    executor=child_executor,
+                    episodic=self.episodic,
+                    semantic=self.semantic,
+                    system_prompt=profile["system"],
+                    max_iterations=self.max_iterations,
+                    permissions=self.permissions,
+                )
+                if wt is not None:
+                    # Tell tools the new working directory by chdir-ing
+                    # for the duration of this run. AgenticLoop is async
+                    # but we keep this call boundary serialized via the
+                    # semaphore, so a process-level chdir is OK here.
+                    import os
+                    prev_cwd = os.getcwd()
+                    os.chdir(wt.path)
+                    try:
+                        run.result = await child.run(task)
+                    finally:
+                        os.chdir(prev_cwd)
+                else:
+                    run.result = await child.run(task)
+            except Exception as e:
+                logger.warning(f"Subagent {run.id} failed: {e}")
+                run.error = str(e)
+            finally:
+                if wt is not None:
+                    await wt.cleanup(force=False)
+
+        await self.hooks.emit(HookEvent.SUBAGENT_STOP, {
+            "subagent_id": run.id,
+            "result": run.result,
+            "error": run.error,
+            "worktree_path": run.worktree_path,
+        })
+        return run
+
+    async def run_parallel(
+        self,
+        tasks: list[tuple[str, str]],
+        isolation: str | None = None,
+    ) -> list[SubagentRun]:
+        """Run multiple subagents concurrently. Each tuple = (task, subagent_type)."""
+        return await asyncio.gather(*(
+            self.run_one(task, t, isolation=isolation) for task, t in tasks
+        ))
+
+
+def _restricted_executor(
+    parent: Executor,
+    allowed_tools: list[str],
+    llm: LLMProvider,
+) -> Executor:
+    """Create a new executor exposing only the allowed tools.
+
+    Rather than deep-copying the parent, build a fresh Executor with the
+    allowed subset. This keeps the restriction airtight.
+    """
+    child = Executor.__new__(Executor)
+    child._tools = {}
+    child._llm = llm
+    for name in allowed_tools:
+        tool = parent.get_tool(name)
+        if tool is not None:
+            child._tools[tool.name] = tool
+    return child

core/thinking.py

@@ -0,0 +1,50 @@
+"""ThinkingManager — chain-of-thought reasoning before actions.
+
+Mirrors the Claude SDK "thinking" feature using a prompt-based protocol:
+the model is instructed to emit <thinking>...</thinking> blocks before any
+visible output or tool call. The manager strips those blocks from the
+user-facing content and exposes them separately so the UI can render them
+in a dimmed panel (or ignore them silently by default).
+"""
+
+from __future__ import annotations
+
+import re
+
+from core.schemas import ThinkingBlock
+
+THINKING_INSTRUCTION = (
+    "Before responding or calling any tool, you may reason step-by-step "
+    "inside a <thinking>...</thinking> block. Use it to plan your approach, "
+    "weigh options, and catch mistakes. Everything inside the block is "
+    "internal and will not be shown to the user. Keep it brief — one short "
+    "paragraph is usually enough. After the thinking block, either call a "
+    "tool or emit your final answer."
+)
+
+_THINKING_RE = re.compile(
+    r"<thinking>(.*?)</thinking>",
+    re.DOTALL | re.IGNORECASE,
+)
+
+
+class ThinkingManager:
+    """Injects thinking instructions into the system prompt and parses blocks."""
+
+    def __init__(self, enabled: bool = False):
+        self.enabled = enabled
+
+    def augment_system_prompt(self, system: str) -> str:
+        """Append the thinking instruction to a system prompt."""
+        if not self.enabled:
+            return system
+        return f"{system}\n\n{THINKING_INSTRUCTION}"
+
+    def parse(self, text: str) -> tuple[list[ThinkingBlock], str]:
+        """Extract thinking blocks from text. Returns (blocks, stripped_text)."""
+        blocks = [
+            ThinkingBlock(thinking=m.group(1).strip())
+            for m in _THINKING_RE.finditer(text)
+        ]
+        stripped = _THINKING_RE.sub("", text).strip()
+        return blocks, stripped

core/updater.py

@@ -0,0 +1,122 @@
+"""Auto-update — `cognos update` checks for and applies new versions.
+
+Two install modes are detected automatically:
+
+  1. **Git checkout** (the common case for a cloned repo) — runs
+     `git fetch && git pull --ff-only` on the project root. If the local
+     branch has diverged, refuses to merge and tells the user.
+
+  2. **Pip install** (if `cognos` was installed as a package) — runs
+     `pip install --upgrade cognos`. We detect this by looking for an
+     installed distribution metadata entry; absent → assume git mode.
+
+Returns a small report describing what changed, or why nothing did.
+"""
+
+from __future__ import annotations
+
+import logging
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class UpdateResult:
+    mode: str                # "git" | "pip" | "unknown"
+    changed: bool
+    summary: str
+    details: str = ""
+
+
+def _is_git_repo(path: Path) -> bool:
+    return (path / ".git").exists()
+
+
+def _pip_installed() -> bool:
+    try:
+        from importlib.metadata import distribution
+        distribution("cognos")
+        return True
+    except Exception:
+        return False
+
+
+def _run(cmd: list[str], cwd: Path | None = None, timeout: int = 120) -> tuple[int, str, str]:
+    proc = subprocess.run(
+        cmd,
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+    return proc.returncode, proc.stdout.strip(), proc.stderr.strip()
+
+
+def update_via_git(repo: Path) -> UpdateResult:
+    if shutil.which("git") is None:
+        return UpdateResult(mode="git", changed=False, summary="git not installed")
+
+    rc, before, _ = _run(["git", "rev-parse", "HEAD"], cwd=repo)
+    if rc != 0:
+        return UpdateResult(mode="git", changed=False, summary="not a git checkout")
+
+    rc, _, err = _run(["git", "fetch"], cwd=repo)
+    if rc != 0:
+        return UpdateResult(mode="git", changed=False, summary="fetch failed", details=err)
+
+    rc, out, err = _run(["git", "pull", "--ff-only"], cwd=repo)
+    if rc != 0:
+        return UpdateResult(
+            mode="git",
+            changed=False,
+            summary="local branch has diverged — resolve manually",
+            details=err or out,
+        )
+
+    rc, after, _ = _run(["git", "rev-parse", "HEAD"], cwd=repo)
+    if before == after:
+        return UpdateResult(mode="git", changed=False, summary="already up to date")
+    rc, log, _ = _run(
+        ["git", "log", "--oneline", f"{before}..{after}"], cwd=repo,
+    )
+    return UpdateResult(
+        mode="git",
+        changed=True,
+        summary=f"updated {before[:7]} → {after[:7]}",
+        details=log,
+    )
+
+
+def update_via_pip() -> UpdateResult:
+    rc, out, err = _run(
+        [sys.executable, "-m", "pip", "install", "--upgrade", "cognos"],
+        timeout=300,
+    )
+    if rc != 0:
+        return UpdateResult(mode="pip", changed=False, summary="pip upgrade failed", details=err or out)
+    changed = "already satisfied" not in (out + err).lower()
+    return UpdateResult(
+        mode="pip",
+        changed=changed,
+        summary="pip upgrade ok" if changed else "already up to date",
+        details=out,
+    )
+
+
+def update(project_root: Path | None = None) -> UpdateResult:
+    """Detect install mode and update accordingly."""
+    root = project_root or Path(__file__).resolve().parent.parent
+    if _is_git_repo(root):
+        return update_via_git(root)
+    if _pip_installed():
+        return update_via_pip()
+    return UpdateResult(
+        mode="unknown",
+        changed=False,
+        summary="not a git checkout and not pip-installed — cannot self-update",
+    )

core/usage.py

@@ -0,0 +1,109 @@
+"""Usage tracking — token counts and rough cost across an agent session.
+
+`UsageTracker` accumulates per-model token counts (prompt + completion)
+and computes cost from a static price table. Local Ollama models are
+priced at $0 by default. Cloud models use approximate prices that match
+their published rates as of early 2026 — adjust freely; the tracker just
+multiplies tokens × $/Mtok.
+
+The tracker is mutable shared state — `LLMProvider` calls `record()` on
+every successful response, so any consumer (status line, /cost slash
+command, end-of-session report) sees the live total.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+# Price per 1M tokens, USD. Best-effort, intentionally conservative.
+# Anything not listed defaults to 0 (treated as local/free).
+DEFAULT_PRICES: dict[str, tuple[float, float]] = {
+    # Anthropic
+    "anthropic/claude-opus-4-7":      (15.0, 75.0),
+    "anthropic/claude-sonnet-4-6":    (3.0, 15.0),
+    "anthropic/claude-haiku-4-5":     (0.80, 4.0),
+    "claude-opus-4-7":                (15.0, 75.0),
+    "claude-sonnet-4-6":              (3.0, 15.0),
+    "claude-haiku-4-5":               (0.80, 4.0),
+    # OpenAI rough rates
+    "openai/gpt-4o":                  (2.5, 10.0),
+    "openai/gpt-4o-mini":             (0.15, 0.6),
+    "gpt-4o":                         (2.5, 10.0),
+    "gpt-4o-mini":                    (0.15, 0.6),
+}
+
+
+@dataclass
+class ModelUsage:
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    requests: int = 0
+
+    @property
+    def total_tokens(self) -> int:
+        return self.prompt_tokens + self.completion_tokens
+
+
+@dataclass
+class UsageTracker:
+    """Accumulates usage across a session."""
+
+    by_model: dict[str, ModelUsage] = field(default_factory=dict)
+    prices: dict[str, tuple[float, float]] = field(
+        default_factory=lambda: dict(DEFAULT_PRICES),
+    )
+
+    def record(self, model: str, usage: dict[str, Any]) -> None:
+        """Record a single LLM call.
+
+        `usage` is the dict shape LLMProvider returns: {prompt_tokens,
+        completion_tokens, total_tokens}. Missing keys are treated as 0.
+        """
+        slot = self.by_model.setdefault(model, ModelUsage())
+        slot.prompt_tokens += int(usage.get("prompt_tokens") or 0)
+        slot.completion_tokens += int(usage.get("completion_tokens") or 0)
+        slot.requests += 1
+
+    def total_tokens(self) -> int:
+        return sum(u.total_tokens for u in self.by_model.values())
+
+    def total_cost(self) -> float:
+        total = 0.0
+        for model, u in self.by_model.items():
+            in_price, out_price = self.prices.get(model, (0.0, 0.0))
+            total += (u.prompt_tokens / 1_000_000) * in_price
+            total += (u.completion_tokens / 1_000_000) * out_price
+        return total
+
+    def report(self) -> dict[str, Any]:
+        return {
+            "total_tokens": self.total_tokens(),
+            "total_cost_usd": round(self.total_cost(), 6),
+            "by_model": {
+                m: {
+                    "prompt_tokens": u.prompt_tokens,
+                    "completion_tokens": u.completion_tokens,
+                    "requests": u.requests,
+                }
+                for m, u in self.by_model.items()
+            },
+        }
+
+
+# Process-wide tracker. Shared by LLMProvider so any agent in the process
+# accumulates into the same totals. Tests can replace this if isolation
+# matters.
+_GLOBAL = UsageTracker()
+
+
+def get_global_tracker() -> UsageTracker:
+    return _GLOBAL
+
+
+def reset_global_tracker() -> None:
+    _GLOBAL.by_model.clear()