devcouncil 0.1.1 → 0.2.1

package/src/devcouncil/live/transcripts.py

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

package/src/devcouncil/llm/cache.py

@@ -1,38 +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) -> 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,146 +0,0 @@
-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}}]}
-        )

package/src/devcouncil/llm/router.py

@@ -1,125 +0,0 @@
-from typing import List, Dict, Any, Type, Optional
-import copy
-import json
-import logging
-import asyncio
-from pathlib import Path
-
-from pydantic import BaseModel
-from devcouncil.llm.provider import Provider
-from devcouncil.llm.cache import LLMCache
-from devcouncil.telemetry.tracker import TelemetryTracker
-
-logger = logging.getLogger(__name__)
-
-class ModelRouter:
-    def __init__(self, provider: Provider, role_config: Dict[str, Dict[str, Any]]):
-        self.provider = provider
-        self.role_config = role_config
-
-    async def complete_structured(
-        self,
-        role: str,
-        messages: List[Dict[str, str]],
-        schema: Type[BaseModel],
-        temperature: Optional[float] = None,
-        run_id: Optional[str] = None,
-    ) -> BaseModel:
-        config = self.role_config.get(role)
-        if not config:
-            raise ValueError(f"No config found for role: {role}")
-        
-        model = config["model"]
-        temp = temperature if temperature is not None else config.get("temperature", 0.0)
-        
-        # Deep-copy to avoid mutating the caller's messages list
-        msgs = copy.deepcopy(messages)
-        
-        # Add schema instructions to system or user message
-        schema_json = json.dumps(schema.model_json_schema(), indent=2)
-        instruction = f"\n\nYou MUST output a JSON object matching this schema:\n{schema_json}"
-        
-        found_system = False
-        for msg in msgs:
-            if msg["role"] == "system":
-                msg["content"] += instruction
-                found_system = True
-                break
-        
-        if not found_system:
-            msgs.insert(0, {"role": "system", "content": f"You are a helpful assistant.{instruction}"})
-
-        logger.info("LLM call: role=%s model=%s run_id=%s", role, model, run_id)
-
-        project_root = Path(".")
-        cache = LLMCache(project_root)
-        tracker = TelemetryTracker(project_root)
-
-        # Check cache first
-        response = cache.get(model, msgs, temp, True)
-        cache_hit = response is not None
-
-        if not response:
-            for attempt in range(3):
-                try:
-                    response = await self.provider.complete(
-                        model=model,
-                        messages=msgs,
-                        temperature=temp,
-                        json_mode=True
-                    )
-                    cache.set(model, msgs, temp, True, response)
-                    break
-                except Exception as e:
-                    if attempt == 2:
-                        raise
-                    logger.warning(f"LLM request failed (attempt {attempt+1}): {e}. Retrying...")
-                    await asyncio.sleep(2 ** attempt)
-
-        if not cache_hit:
-            tracker.log_usage(model, response.usage)
-
-        logger.info(
-            "LLM response: role=%s model=%s tokens=%s",
-            role, response.model, response.usage,
-        )
-        
-        try:
-            # Attempt to find JSON block if it's wrapped in markdown
-            content = response.content.strip()
-            if "```json" in content:
-                content = content.split("```json")[1].split("```")[0].strip()
-            elif "```" in content:
-                content = content.split("```")[1].split("```")[0].strip()
-                
-            data = json.loads(content)
-            return schema.model_validate(data)
-        except Exception as e:
-            logger.warning(f"Initial parse failed for {role}, attempting healing: {e}")
-            
-            # Healing attempt: Ask the model to fix its own JSON
-            healing_prompt = f"""
-The following JSON was returned but failed to parse or validate against the schema.
-Error: {str(e)}
-Content:
-{response.content}
-
-Please return the corrected JSON object only. No prose.
-"""
-            # We use a lower temperature for healing
-            healed_response = await self.provider.complete(
-                model=model,
-                messages=[{"role": "user", "content": healing_prompt}],
-                temperature=0.0,
-                json_mode=True
-            )
-            
-            try:
-                healed_content = healed_response.content.strip()
-                if "```json" in healed_content:
-                    healed_content = healed_content.split("```json")[1].split("```")[0].strip()
-                data = json.loads(healed_content)
-                return schema.model_validate(data)
-            except Exception as final_e:
-                logger.error(f"Healing failed for {role}: {final_e}")
-                raise ValueError(f"Failed to parse or validate LLM response after healing: {final_e}\nContent (truncated): {response.content[:200]}...")

package/src/devcouncil/planning/__init__.py

@@ -1 +0,0 @@
-

package/src/devcouncil/planning/arbiter_service.py

@@ -1,57 +0,0 @@
-from typing import List, Dict
-from pydantic import BaseModel
-from devcouncil.domain.requirement import Requirement
-from devcouncil.domain.task import Task
-from devcouncil.llm.router import ModelRouter
-
-class ArbiterDecision(BaseModel):
-    accepted_finding_ids: List[str]
-    rejected_finding_ids: List[Dict[str, str]] # id, reason
-    final_requirements: List[Requirement]
-    final_tasks: List[Task]
-
-class ArbiterService:
-    def __init__(self, router: ModelRouter):
-        self.router = router
-
-    async def arbitrate(
-        self, 
-        goal: str, 
-        requirements_json: str, 
-        plan_a_json: str, 
-        plan_b_json: str, 
-        critique_a_json: str, 
-        critique_b_json: str,
-        rebuttal_a_json: str,
-        rebuttal_b_json: str
-    ) -> ArbiterDecision:
-        prompt = f"""
-Goal: {goal}
-
-Initial Requirements:
-{requirements_json}
-
-Plan A: {plan_a_json}
-Plan B: {plan_b_json}
-
-Critique of Plan B by Critic A: {critique_a_json}
-Critique of Plan A by Critic B: {critique_b_json}
-
-Rebuttal of Critic B by Planner A: {rebuttal_a_json}
-Rebuttal of Critic A by Planner B: {rebuttal_b_json}
-
-You are the arbiter engineering manager. Your goal is to produce the final, definitive set of requirements and tasks.
-- You do not decide by vibes.
-- High-severity unrefuted findings from critics must be incorporated into the final requirements or tasks.
-- If a planner successfully rebutted a finding, you may skip it.
-- Produce a single, coherent task graph.
-"""
-        messages = [
-            {"role": "user", "content": prompt}
-        ]
-        
-        return await self.router.complete_structured(
-            role="arbiter",
-            messages=messages,
-            schema=ArbiterDecision
-        )

package/src/devcouncil/planning/critique_service.py

@@ -1,66 +0,0 @@
-from typing import List
-from pydantic import BaseModel
-from devcouncil.domain.critique import CritiqueFinding
-from devcouncil.llm.router import ModelRouter
-
-class CritiqueOutput(BaseModel):
-    findings: List[CritiqueFinding]
-
-class RebuttalItem(BaseModel):
-    finding_id: str
-    decision: str # "accepted", "rejected"
-    reason: str
-    suggested_change: str | None = None
-
-class RebuttalOutput(BaseModel):
-    rebuttals: List[RebuttalItem]
-
-class CritiqueService:
-    def __init__(self, router: ModelRouter):
-        self.router = router
-
-    async def generate_critique(self, role: str, target_plan_json: str, requirements_json: str) -> CritiqueOutput:
-        prompt = f"""
-Requirements:
-{requirements_json}
-
-Target Plan:
-{target_plan_json}
-
-You are a hostile staff engineer reviewing another team's implementation plan.
-Find missing requirements, bad assumptions, missing tests, security risks, migration risks, and unverifiable claims.
-Do not praise. Do not rewrite the plan.
-Every finding must include a falsifiable_check.
-"""
-        messages = [
-            {"role": "user", "content": prompt}
-        ]
-        
-        return await self.router.complete_structured(
-            role=role,
-            messages=messages,
-            schema=CritiqueOutput
-        )
-
-    async def generate_rebuttal(self, role: str, original_plan_json: str, findings_json: str) -> RebuttalOutput:
-        prompt = f"""
-Original Plan:
-{original_plan_json}
-
-Critique Findings:
-{findings_json}
-
-You are the planner who created the original plan. Review the critique findings.
-- A finding can be rejected only with artifact evidence or strong justification.
-- A finding can be accepted and converted into a requirement/task/test.
-- No hand-wavy rebuttals.
-"""
-        messages = [
-            {"role": "user", "content": prompt}
-        ]
-        
-        return await self.router.complete_structured(
-            role=role,
-            messages=messages,
-            schema=RebuttalOutput
-        )

package/src/devcouncil/planning/plan_service.py

@@ -1,46 +0,0 @@
-from typing import List
-from pydantic import BaseModel
-from devcouncil.domain.task import Task
-from devcouncil.llm.router import ModelRouter
-
-class PlanOutput(BaseModel):
-    id: str
-    rationale: str
-    tasks: List[Task]
-
-class PlanService:
-    def __init__(self, router: ModelRouter):
-        self.router = router
-
-    async def generate_plan(self, role: str, goal: str, requirements_json: str, repo_map_json: str) -> PlanOutput:
-        prompt = f"""
-Goal: {goal}
-
-Requirements:
-{requirements_json}
-
-Repository Map:
-{repo_map_json}
-
-Your task is to create a detailed implementation plan.
-- Break down the requirements into atomic implementation tasks.
-- For each task, specify which files will be created or modified.
-- Specify which tests are expected to verify the task.
-- Ensure each task maps back to at least one requirement.
-
-Role-specific instructions:
-"""
-        if role == "planner_a":
-            prompt += "You are the pragmatic tech lead. Optimize for simplicity and minimal dependencies."
-        else:
-            prompt += "You are the production-readiness architect. Optimize for security, performance, and edge cases."
-
-        messages = [
-            {"role": "user", "content": prompt}
-        ]
-        
-        return await self.router.complete_structured(
-            role=role,
-            messages=messages,
-            schema=PlanOutput
-        )