devcouncil 0.1.0 → 0.1.1

package/src/devcouncil/live/transcripts.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Iterable
+
+from devcouncil.live.models import AgentSession, AgentTurn, session_id_from_path
+
+
+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]) -> str:
+    role = raw.get("role")
+    if isinstance(role, str):
+        return role if role in {"user", "assistant", "system", "tool"} else "unknown"
+    message = raw.get("message")
+    if isinstance(message, dict):
+        nested = message.get("role")
+        if isinstance(nested, str):
+            return nested if nested in {"user", "assistant", "system", "tool"} else "unknown"
+    record_type = raw.get("type")
+    if record_type in {"user", "assistant", "system"}:
+        return str(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,38 @@
-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) -> 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)

package/src/devcouncil/llm/provider.py

@@ -1,125 +1,146 @@
-from abc import ABC, abstractmethod
-import copy
-from typing import List, Dict, Any, Optional
-from pydantic import BaseModel
-import httpx
-import json
-from pathlib import Path
-
-class LLMResponse(BaseModel):
-    content: str
-    model: str
-    usage: Dict[str, int]
-    raw_response: Dict[str, Any]
-
-class Provider(ABC):
-    @abstractmethod
-    async def complete(
-        self, 
-        model: str, 
-        messages: List[Dict[str, str]], 
-        temperature: float = 0.0,
-        json_mode: bool = False
-    ) -> LLMResponse:
-        pass
-
-class OpenRouterProvider(Provider):
-    def __init__(self, api_key: str):
-        self.api_key = api_key
-        self.base_url = "https://openrouter.ai/api/v1"
-
-    async def complete(
-        self, 
-        model: str, 
-        messages: List[Dict[str, str]], 
-        temperature: float = 0.0,
-        json_mode: bool = False
-    ) -> LLMResponse:
-        # Deep-copy to avoid mutating the caller's messages list
-        msgs = copy.deepcopy(messages)
-
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "https://github.com/devcouncil/devcouncil", # Optional
-            "X-Title": "DevCouncil", # Optional
-        }
-        
-        payload = {
-            "model": model,
-            "messages": msgs,
-            "temperature": temperature,
-        }
-        
-        if json_mode:
-            payload["response_format"] = {"type": "json_object"}
-            # Ensure the user message mentions JSON
-            if msgs[-1]["role"] == "user":
-                msgs[-1]["content"] += "\n\nOutput must be a valid JSON object."
-
-        async with httpx.AsyncClient(timeout=180.0) as client:
-            response = await client.post(
-                f"{self.base_url}/chat/completions",
-                headers=headers,
-                json=payload
-            )
-            response.raise_for_status()
-            data = response.json()
-            
-            resp = LLMResponse(
-                content=data["choices"][0]["message"]["content"],
-                model=data["model"],
-                usage=data.get("usage", {}),
-                raw_response=data
-            )
-            
-            # Log the call
-            try:
-                from devcouncil.utils.redaction import redact_dict
-                log_dir = Path(".devcouncil/logs")
-                log_dir.mkdir(parents=True, exist_ok=True)
-                log_file = log_dir / "model_calls.jsonl"
-                
-                # Create a redacted copy of both request and response for logging
-                log_payload = {
-                    "request": redact_dict(payload),
-                    "response": redact_dict(data),
-                    "usage": resp.usage,
-                }
-                with open(log_file, "a", encoding="utf-8") as f:
-                    f.write(json.dumps(log_payload) + "\n")
-            except Exception as e:
-                import logging as _log
-                _log.getLogger(__name__).debug("Failed to log model call: %s", e)
-                
-            return resp
-
-class MockProvider(Provider):
-    """Mock provider for dry runs and testing."""
-    def __init__(self, responses: Optional[Dict[str, Any]] = None):
-        # responses can be a dict of model -> str OR model -> list of str
-        self.responses = responses or {}
-        self._counts: Dict[str, int] = {}
-
-    async def complete(
-        self, 
-        model: str, 
-        messages: List[Dict[str, str]], 
-        temperature: float = 0.0,
-        json_mode: bool = False
-    ) -> LLMResponse:
-        res = self.responses.get(model, '{"mock": "response"}')
-        
-        if isinstance(res, list):
-            count = self._counts.get(model, 0)
-            content = res[min(count, len(res)-1)]
-            self._counts[model] = count + 1
-        else:
-            content = res
-            
-        return LLMResponse(
-            content=content,
-            model=f"mock/{model}",
-            usage={"prompt_tokens": 10, "completion_tokens": 10, "total_tokens": 20},
-            raw_response={"choices": [{"message": {"content": content}}]}
-        )
+from abc import ABC, abstractmethod
+import copy
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+import httpx
+import json
+from pathlib import Path
+
+SUPPORTED_MODEL_PROVIDERS = ("openrouter",)
+
+
+class LLMResponse(BaseModel):
+    content: str
+    model: str
+    usage: Dict[str, int]
+    raw_response: Dict[str, Any]
+
+class Provider(ABC):
+    @abstractmethod
+    async def complete(
+        self, 
+        model: str, 
+        messages: List[Dict[str, str]], 
+        temperature: float = 0.0,
+        json_mode: bool = False
+    ) -> LLMResponse:
+        pass
+
+
+def validate_model_provider(provider_name: str) -> str:
+    normalized = provider_name.strip().lower()
+    if normalized in SUPPORTED_MODEL_PROVIDERS:
+        return normalized
+    supported = ", ".join(SUPPORTED_MODEL_PROVIDERS)
+    raise ValueError(
+        f"Unsupported model provider '{provider_name}'. "
+        f"Supported providers: {supported}."
+    )
+
+
+def create_provider(provider_name: str, api_key: str) -> Provider:
+    normalized = validate_model_provider(provider_name)
+    if normalized == "openrouter":
+        return OpenRouterProvider(api_key)
+    raise AssertionError(f"Provider validation passed for unhandled provider: {normalized}")
+
+class OpenRouterProvider(Provider):
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.base_url = "https://openrouter.ai/api/v1"
+
+    async def complete(
+        self, 
+        model: str, 
+        messages: List[Dict[str, str]], 
+        temperature: float = 0.0,
+        json_mode: bool = False
+    ) -> LLMResponse:
+        # Deep-copy to avoid mutating the caller's messages list
+        msgs = copy.deepcopy(messages)
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://github.com/devcouncil/devcouncil", # Optional
+            "X-Title": "DevCouncil", # Optional
+        }
+        
+        payload = {
+            "model": model,
+            "messages": msgs,
+            "temperature": temperature,
+        }
+        
+        if json_mode:
+            payload["response_format"] = {"type": "json_object"}
+            # Ensure the user message mentions JSON
+            if msgs[-1]["role"] == "user":
+                msgs[-1]["content"] += "\n\nOutput must be a valid JSON object."
+
+        async with httpx.AsyncClient(timeout=180.0) as client:
+            response = await client.post(
+                f"{self.base_url}/chat/completions",
+                headers=headers,
+                json=payload
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+            resp = LLMResponse(
+                content=data["choices"][0]["message"]["content"],
+                model=data["model"],
+                usage=data.get("usage", {}),
+                raw_response=data
+            )
+            
+            # Log the call
+            try:
+                from devcouncil.utils.redaction import redact_dict
+                log_dir = Path(".devcouncil/logs")
+                log_dir.mkdir(parents=True, exist_ok=True)
+                log_file = log_dir / "model_calls.jsonl"
+                
+                # Create a redacted copy of both request and response for logging
+                log_payload = {
+                    "request": redact_dict(payload),
+                    "response": redact_dict(data),
+                    "usage": resp.usage,
+                }
+                with open(log_file, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(log_payload) + "\n")
+            except Exception as e:
+                import logging as _log
+                _log.getLogger(__name__).debug("Failed to log model call: %s", e)
+                
+            return resp
+
+class MockProvider(Provider):
+    """Mock provider for dry runs and testing."""
+    def __init__(self, responses: Optional[Dict[str, Any]] = None):
+        # responses can be a dict of model -> str OR model -> list of str
+        self.responses = responses or {}
+        self._counts: Dict[str, int] = {}
+
+    async def complete(
+        self, 
+        model: str, 
+        messages: List[Dict[str, str]], 
+        temperature: float = 0.0,
+        json_mode: bool = False
+    ) -> LLMResponse:
+        res = self.responses.get(model, '{"mock": "response"}')
+        
+        if isinstance(res, list):
+            count = self._counts.get(model, 0)
+            content = res[min(count, len(res)-1)]
+            self._counts[model] = count + 1
+        else:
+            content = res
+            
+        return LLMResponse(
+            content=content,
+            model=f"mock/{model}",
+            usage={"prompt_tokens": 10, "completion_tokens": 10, "total_tokens": 20},
+            raw_response={"choices": [{"message": {"content": content}}]}
+        )