devcouncil 0.1.0 → 0.2.0

package/src/devcouncil/live/signals.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ReviewSignal(BaseModel):
+    client: str = "generic"
+    payload: dict[str, Any] = Field(default_factory=dict)
+    transcript_path: str | None = None
+    session_id: str | None = None
+    task_id: str | None = None
+    created_at: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    review_command: str | None = None
+    path: str | None = None
+
+
+def signal_dir(project_root: Path) -> Path:
+    return project_root / ".devcouncil" / "live" / "signals"
+
+
+def processed_signal_dir(project_root: Path) -> Path:
+    return signal_dir(project_root) / "processed"
+
+
+def write_signal(project_root: Path, client: str, payload: dict[str, Any]) -> Path:
+    directory = signal_dir(project_root)
+    directory.mkdir(parents=True, exist_ok=True)
+    transcript_path = extract_transcript_path(payload)
+    session_id = _string_value(payload, "session_id", "sessionId", "session", "cwd")
+    task_id = extract_task_id(payload)
+    signal = ReviewSignal(
+        client=client.lower(),
+        payload=payload,
+        transcript_path=transcript_path,
+        session_id=session_id,
+        task_id=task_id,
+        review_command=_review_command(client.lower(), transcript_path, task_id),
+    )
+    key = transcript_path or session_id or json.dumps(payload, sort_keys=True, default=str)
+
+    digest = hashlib.sha256(key.encode("utf-8", errors="replace")).hexdigest()[:12]
+    path = directory / f"{client.lower()}-{digest}.json"
+    signal.path = str(path)
+    path.write_text(signal.model_dump_json(indent=2) + "\n", encoding="utf-8")
+    return path
+
+
+def load_signals(project_root: Path) -> list[ReviewSignal]:
+    directory = signal_dir(project_root)
+    if not directory.exists():
+        return []
+    signals: list[ReviewSignal] = []
+    for path in sorted(directory.glob("*.json"), key=lambda item: item.stat().st_mtime, reverse=True):
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+            signal = ReviewSignal.model_validate(raw)
+            signal.path = str(path)
+            signals.append(signal)
+        except Exception:
+            continue
+    return signals
+
+
+def mark_processed(signal: ReviewSignal, project_root: Path) -> Path | None:
+    if not signal.path:
+        return None
+    source = Path(signal.path)
+    if not source.exists():
+        return None
+    target_dir = processed_signal_dir(project_root)
+    target_dir.mkdir(parents=True, exist_ok=True)
+    target = target_dir / source.name
+    if target.exists():
+        target.unlink()
+    source.replace(target)
+    return target
+
+
+def extract_transcript_path(payload: dict[str, Any]) -> str | None:
+    direct = _string_value(
+        payload,
+        "transcript_path",
+        "transcriptPath",
+        "transcript",
+        "conversation_path",
+        "conversationPath",
+        "file",
+        "path",
+    )
+    if direct:
+        return direct
+    for key in ("session", "message", "hook_event", "event"):
+        nested = payload.get(key)
+        if isinstance(nested, dict):
+            value = extract_transcript_path(nested)
+            if value:
+                return value
+    return None
+
+
+def extract_task_id(payload: dict[str, Any]) -> str | None:
+    direct = _string_value(payload, "task_id", "taskId", "task", "active_task", "activeTask")
+    if direct:
+        return direct
+    for key in ("session", "message", "hook_event", "event", "metadata"):
+        nested = payload.get(key)
+        if isinstance(nested, dict):
+            value = extract_task_id(nested)
+            if value:
+                return value
+    return None
+
+
+def _string_value(payload: dict[str, Any], *keys: str) -> str | None:
+    for key in keys:
+        value = payload.get(key)
+        if isinstance(value, str) and value.strip():
+            return value
+    return None
+
+
+def _review_command(client: str, transcript_path: str | None, task_id: str | None = None) -> str:
+    if transcript_path:
+        command = f"dev watch review --client {client} --transcript {transcript_path}"
+    else:
+        command = f"dev watch pending --client {client}"
+    if task_id:
+        command += f" --task-id {task_id}"
+    return command

package/src/devcouncil/live/summary.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from devcouncil.live.cards import load_cards, unresolved_blocking_cards
+from devcouncil.live.signals import load_signals
+from devcouncil.live.tasks import active_task_id
+
+
+def live_review_summary(project_root: Path, task_id: str | None = None) -> dict:
+    cards = load_cards(project_root)
+    signals = load_signals(project_root)
+    active_id = active_task_id(project_root)
+    scoped_task_id = task_id or active_id
+    blockers = unresolved_blocking_cards(project_root, task_id=scoped_task_id)
+    pending_signal_items = [signal.model_dump() for signal in signals]
+    return {
+        "active_task_id": active_id,
+        "scope_task_id": scoped_task_id,
+        "pending_signals": len(signals),
+        "pending_signal_items": pending_signal_items[:10],
+        "cards": {
+            "total": len(cards),
+            "open": len([card for card in cards if card.status == "open"]),
+            "resolved": len([card for card in cards if card.status == "resolved"]),
+            "ignored": len([card for card in cards if card.status == "ignored"]),
+            "critical_open": len([
+                card for card in cards
+                if card.status == "open" and card.verdict == "Critical Issues"
+            ]),
+        },
+        "blocking_cards": [card.model_dump() for card in blockers],
+        "recent_cards": [card.model_dump() for card in cards[:5]],
+    }

package/src/devcouncil/live/tasks.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import TaskRepository
+
+
+def active_task_id(project_root: Path) -> str | None:
+    """Return the single running DevCouncil task ID, if one is unambiguous."""
+    db = get_db(project_root)
+    if not db:
+        return None
+    with db.get_session() as session:
+        running = [task for task in TaskRepository(session).get_all() if task.status == "running"]
+    if len(running) != 1:
+        return None
+    return running[0].id

package/src/devcouncil/live/transcripts.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Iterable, Literal
+
+from devcouncil.live.models import AgentSession, AgentTurn, session_id_from_path
+
+RoleName = Literal["user", "assistant", "system", "tool", "unknown"]
+KNOWN_ROLES: set[RoleName] = {"user", "assistant", "system", "tool"}
+
+
+CLAUDE_TRANSCRIPT_ROOT = Path.home() / ".claude" / "projects"
+
+
+def discover_sessions(project_root: Path, client: str = "claude") -> list[AgentSession]:
+    """Find local coding-agent transcripts DevCouncil can review."""
+    client = client.lower()
+    if client == "claude":
+        candidates = _claude_transcript_candidates(project_root)
+    else:
+        candidates = sorted((project_root / ".devcouncil" / "live" / client).glob("*.jsonl"))
+
+    sessions: list[AgentSession] = []
+    for path in candidates:
+        if not path.exists() or not path.is_file():
+            continue
+        stat = path.stat()
+        sessions.append(AgentSession(
+            id=session_id_from_path(path),
+            client=client,
+            transcript_path=str(path),
+            updated_at=str(stat.st_mtime),
+            turns=sum(1 for _ in _safe_lines(path)),
+        ))
+    return sorted(sessions, key=lambda item: item.updated_at or "", reverse=True)
+
+
+def load_turns(path: Path, client: str = "generic") -> list[AgentTurn]:
+    """Parse a transcript into normalized turns.
+
+    Supports Claude Code JSONL plus generic JSONL records with role/content fields.
+    """
+    turns: list[AgentTurn] = []
+    session_id = session_id_from_path(path)
+    for index, raw in enumerate(_read_jsonl(path)):
+        turn = _turn_from_record(raw, session_id=session_id, turn_index=index, client=client)
+        if turn and turn.content.strip():
+            turns.append(turn)
+    return turns
+
+
+def latest_assistant_turn(path: Path, client: str = "generic") -> AgentTurn | None:
+    for turn in reversed(load_turns(path, client=client)):
+        if turn.role == "assistant":
+            return turn
+    return None
+
+
+def _claude_transcript_candidates(project_root: Path) -> list[Path]:
+    local_runtime = project_root / ".devcouncil" / "live" / "claude"
+    candidates = list(local_runtime.glob("*.jsonl"))
+    if CLAUDE_TRANSCRIPT_ROOT.exists():
+        candidates.extend(CLAUDE_TRANSCRIPT_ROOT.rglob("*.jsonl"))
+    return sorted(set(candidates), key=lambda path: path.stat().st_mtime if path.exists() else 0, reverse=True)
+
+
+def _safe_lines(path: Path) -> Iterable[str]:
+    try:
+        return path.read_text(encoding="utf-8", errors="replace").splitlines()
+    except OSError:
+        return []
+
+
+def _read_jsonl(path: Path) -> Iterable[dict[str, Any]]:
+    for line in _safe_lines(path):
+        if not line.strip():
+            continue
+        try:
+            value = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(value, dict):
+            yield value
+
+
+def _turn_from_record(raw: dict[str, Any], session_id: str, turn_index: int, client: str) -> AgentTurn | None:
+    role = _role(raw)
+    content = _content(raw)
+    if not content:
+        return None
+    turn_id = str(raw.get("uuid") or raw.get("id") or raw.get("message_id") or f"turn-{turn_index}")
+    return AgentTurn(
+        session_id=str(raw.get("sessionId") or raw.get("session_id") or session_id),
+        turn_id=turn_id,
+        source=client,
+        role=role,
+        content=content,
+        timestamp=raw.get("timestamp") or raw.get("created_at"),
+        raw=raw,
+    )
+
+
+def _role(raw: dict[str, Any]) -> RoleName:
+    role = raw.get("role")
+    if isinstance(role, str):
+        return role if role in KNOWN_ROLES else "unknown"
+    message = raw.get("message")
+    if isinstance(message, dict):
+        nested = message.get("role")
+        if isinstance(nested, str):
+            return nested if nested in KNOWN_ROLES else "unknown"
+    record_type = raw.get("type")
+    if record_type in KNOWN_ROLES:
+        return record_type
+    return "unknown"
+
+
+def _content(raw: dict[str, Any]) -> str:
+    direct = raw.get("content") or raw.get("text")
+    if isinstance(direct, str):
+        return direct
+    message = raw.get("message")
+    if isinstance(message, dict):
+        nested = message.get("content")
+        if isinstance(nested, str):
+            return nested
+        if isinstance(nested, list):
+            return "\n".join(_content_block_text(block) for block in nested).strip()
+    if isinstance(direct, list):
+        return "\n".join(_content_block_text(block) for block in direct).strip()
+    return ""
+
+
+def _content_block_text(block: Any) -> str:
+    if isinstance(block, str):
+        return block
+    if isinstance(block, dict):
+        value = block.get("text") or block.get("content")
+        return value if isinstance(value, str) else ""
+    return ""

package/src/devcouncil/llm/__init__.py

@@ -1 +1 @@
-
+

package/src/devcouncil/llm/cache.py

@@ -1,38 +1,42 @@
-import json
-import hashlib
-from pathlib import Path
-from typing import Optional
-from devcouncil.llm.provider import LLMResponse
-
-class LLMCache:
-    def __init__(self, project_root: Path):
-        self.cache_dir = project_root / ".devcouncil" / "cache" / "llm"
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-
-    def _get_key(self, model: str, messages: list, temp: float, json_mode: bool) -> str:
-        data = {
-            "model": model,
-            "messages": messages,
-            "temp": temp,
-            "json_mode": json_mode
-        }
-        s = json.dumps(data, sort_keys=True)
-        return hashlib.sha256(s.encode("utf-8")).hexdigest()
-
-    def get(self, model: str, messages: list, temp: float, json_mode: bool) -> Optional[LLMResponse]:
-        key = self._get_key(model, messages, temp, json_mode)
-        cache_file = self.cache_dir / f"{key}.json"
-        if cache_file.exists():
-            try:
-                with open(cache_file, "r") as f:
-                    data = json.load(f)
-                    return LLMResponse(**data)
-            except Exception:
-                pass
-        return None
-
-    def set(self, model: str, messages: list, temp: float, json_mode: bool, response: LLMResponse):
-        key = self._get_key(model, messages, temp, json_mode)
-        cache_file = self.cache_dir / f"{key}.json"
-        with open(cache_file, "w") as f:
-            json.dump(response.model_dump(), f)
+import json
+import hashlib
+from pathlib import Path
+from typing import Optional
+from devcouncil.llm.provider import LLMResponse
+
+class LLMCache:
+    def __init__(self, project_root: Path):
+        self.cache_dir = project_root / ".devcouncil" / "cache" / "llm"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_key(self, model: str, messages: list, temp: float, json_mode: bool, provider_fingerprint: str = "") -> str:
+        data = {
+            "model": model,
+            "messages": messages,
+            "temp": temp,
+            "json_mode": json_mode,
+            # Provider-specific knobs that change the output for an identical prompt
+            # (e.g. Ollama's num_ctx / base_url). Empty for providers without such knobs,
+            # so their cache keys are unchanged.
+            "provider": provider_fingerprint,
+        }
+        s = json.dumps(data, sort_keys=True)
+        return hashlib.sha256(s.encode("utf-8")).hexdigest()
+
+    def get(self, model: str, messages: list, temp: float, json_mode: bool, provider_fingerprint: str = "") -> Optional[LLMResponse]:
+        key = self._get_key(model, messages, temp, json_mode, provider_fingerprint)
+        cache_file = self.cache_dir / f"{key}.json"
+        if cache_file.exists():
+            try:
+                with open(cache_file, "r") as f:
+                    data = json.load(f)
+                    return LLMResponse(**data)
+            except Exception:
+                pass
+        return None
+
+    def set(self, model: str, messages: list, temp: float, json_mode: bool, response: LLMResponse, provider_fingerprint: str = ""):
+        key = self._get_key(model, messages, temp, json_mode, provider_fingerprint)
+        cache_file = self.cache_dir / f"{key}.json"
+        with open(cache_file, "w") as f:
+            json.dump(response.model_dump(), f)

package/src/devcouncil/llm/model_defaults.yaml

@@ -0,0 +1,44 @@
+openrouter:
+  spec_writer: anthropic/claude-sonnet-4.6
+  prompt_enhancer: anthropic/claude-sonnet-4.6
+  planner_a: anthropic/claude-sonnet-4.6
+  planner_b: google/gemini-2.5-pro
+  critic_a: openai/gpt-5.5
+  critic_b: anthropic/claude-opus-4.8
+  arbiter: openai/gpt-5.5
+  native_agent: anthropic/claude-sonnet-4.6
+  implementation_reviewer: openai/gpt-5.5
+  live_reviewer: openai/gpt-5.5
+vertexai:
+  spec_writer: google/gemini-2.5-flash
+  prompt_enhancer: google/gemini-2.5-flash
+  planner_a: google/gemini-2.5-flash
+  planner_b: google/gemini-2.5-flash
+  critic_a: google/gemini-2.5-flash
+  critic_b: google/gemini-2.5-flash
+  arbiter: google/gemini-2.5-flash
+  native_agent: google/gemini-2.5-flash
+  implementation_reviewer: google/gemini-2.5-flash
+  live_reviewer: google/gemini-2.5-flash
+doubleword:
+  spec_writer: deepseek/deepseek-v4
+  prompt_enhancer: deepseek/deepseek-v4
+  planner_a: deepseek/deepseek-v4
+  planner_b: deepseek/deepseek-v4
+  critic_a: deepseek/deepseek-v4
+  critic_b: deepseek/deepseek-v4
+  arbiter: deepseek/deepseek-v4
+  native_agent: deepseek/deepseek-v4
+  implementation_reviewer: deepseek/deepseek-v4
+  live_reviewer: deepseek/deepseek-v4
+ollama:
+  spec_writer: qwen2.5-coder:7b
+  prompt_enhancer: qwen2.5-coder:7b
+  planner_a: qwen2.5-coder:7b
+  planner_b: qwen2.5-coder:7b
+  critic_a: qwen2.5-coder:7b
+  critic_b: qwen2.5-coder:7b
+  arbiter: qwen2.5-coder:7b
+  native_agent: qwen2.5-coder:7b
+  implementation_reviewer: qwen2.5-coder:7b
+  live_reviewer: qwen2.5-coder:7b