devcouncil 0.2.0 → 0.2.1

package/src/devcouncil/live/signals.py

@@ -1,135 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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 +0,0 @@
-

package/src/devcouncil/llm/cache.py

@@ -1,42 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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