devcouncil 0.1.1 → 0.2.1

package/src/devcouncil/planning/prompt_enhancer_service.py

@@ -1,86 +0,0 @@
-from pydantic import BaseModel, Field
-
-from devcouncil.llm.router import ModelRouter
-
-
-class PromptEnhancement(BaseModel):
-    original_goal: str
-    enhanced_goal: str
-    codebase_context: list[str] = Field(default_factory=list)
-    debate_focus: list[str] = Field(default_factory=list)
-    constraints: list[str] = Field(default_factory=list)
-
-    def normalized(self, original_goal: str) -> "PromptEnhancement":
-        enhanced_goal = self.enhanced_goal.strip() or original_goal
-        return self.model_copy(
-            update={
-                "original_goal": original_goal,
-                "enhanced_goal": enhanced_goal,
-                "codebase_context": _clean_items(self.codebase_context),
-                "debate_focus": _clean_items(self.debate_focus),
-                "constraints": _clean_items(self.constraints),
-            }
-        )
-
-    def debate_prompt(self) -> str:
-        sections = [
-            "# Enhanced Planning Prompt",
-            "",
-            "## Original user goal",
-            self.original_goal,
-            "",
-            "## Codebase-specific goal",
-            self.enhanced_goal,
-        ]
-        if self.codebase_context:
-            sections.extend(["", "## Relevant codebase context"])
-            sections.extend(f"- {item}" for item in self.codebase_context)
-        if self.constraints:
-            sections.extend(["", "## Constraints to preserve"])
-            sections.extend(f"- {item}" for item in self.constraints)
-        if self.debate_focus:
-            sections.extend(["", "## Debate focus"])
-            sections.extend(f"- {item}" for item in self.debate_focus)
-        return "\n".join(sections)
-
-
-class PromptEnhancerService:
-    def __init__(self, router: ModelRouter):
-        self.router = router
-
-    async def enhance_prompt(
-        self,
-        goal: str,
-        repo_map_json: str,
-        graph_context_json: str | None = None,
-    ) -> PromptEnhancement:
-        prompt = f"""
-Original user goal:
-{goal}
-
-Repository map:
-{repo_map_json}
-
-Code review graph context:
-{graph_context_json or "{}"}
-
-You are DevCouncil's codebase-specific prompt enhancer.
-Rewrite the user goal into a better planning prompt before it is sent to the council debate.
-
-Requirements:
-- Preserve the user's intent exactly; do not add unrelated features.
-- Make the goal specific to the mapped repository architecture, languages, tests, and likely ownership boundaries.
-- Identify constraints the planners and critics must preserve.
-- Identify debate focus areas that should force useful disagreement between pragmatic and production-readiness plans.
-- Keep the enhanced_goal concise enough to be used as the goal for spec, planning, critique, and arbitration.
-"""
-        enhancement = await self.router.complete_structured(
-            role="prompt_enhancer",
-            messages=[{"role": "user", "content": prompt}],
-            schema=PromptEnhancement,
-        )
-        return enhancement.normalized(goal)
-
-
-def _clean_items(items: list[str]) -> list[str]:
-    return [item.strip() for item in items if item.strip()]

package/src/devcouncil/planning/repair_service.py

@@ -1,39 +0,0 @@
-from typing import List
-import json
-from pydantic import BaseModel
-from devcouncil.domain.gap import Gap
-from devcouncil.domain.task import Task
-from devcouncil.llm.router import ModelRouter
-
-class RepairOutput(BaseModel):
-    suggested_tasks: List[Task]
-
-class RepairService:
-    """Uses LLM to infer focused repair tasks from blocking gaps."""
-    
-    def __init__(self, router: ModelRouter):
-        self.router = router
-
-    async def generate_repair_plan(self, gaps: List[Gap], project_context: str) -> RepairOutput:
-        prompt = f"""
-The following blocking gaps were detected during verification.
-Gaps:
-{json.dumps([g.model_dump() for g in gaps], indent=2)}
-
-Project Context:
-{project_context}
-
-Your task is to generate focused implementation tasks to fix these gaps.
-- Each task must have a clear description and recommended fix.
-- Specify 'planned_files' that need modification (infer from gap evidence).
-- Link each task to the relevant 'requirement_id' mentioned in the gap.
-
-Return a JSON object with 'suggested_tasks'.
-"""
-        messages = [{"role": "user", "content": prompt}]
-        
-        return await self.router.complete_structured(
-            role="planner_a",  # Pragmatic tech lead is best suited for repair task generation
-            messages=messages,
-            schema=RepairOutput
-        )

package/src/devcouncil/planning/spec_service.py

@@ -1,44 +0,0 @@
-from typing import List
-from pydantic import BaseModel
-from devcouncil.domain.requirement import Requirement
-from devcouncil.domain.assumption import Assumption
-from devcouncil.llm.router import ModelRouter
-
-class BlockingQuestion(BaseModel):
-    id: str
-    question: str
-    reason: str
-
-class SpecOutput(BaseModel):
-    requirements: List[Requirement]
-    assumptions: List[Assumption]
-    blocking_questions: List[BlockingQuestion]
-
-class SpecService:
-    def __init__(self, router: ModelRouter):
-        self.router = router
-
-    async def generate_spec(self, goal: str, repo_map_json: str) -> SpecOutput:
-        prompt = f"""
-Goal: {goal}
-
-Repository Map:
-{repo_map_json}
-
-Your task is to draft the initial software specification for this goal.
-1. Identify functional and non-functional requirements.
-2. Extract any assumptions you are making about the codebase or architecture.
-3. List any blocking questions that the user must answer before implementation can proceed.
-
-Each requirement MUST have clear acceptance criteria with verification methods.
-Each assumption MUST have a confidence and impact level.
-"""
-        messages = [
-            {"role": "user", "content": prompt}
-        ]
-        
-        return await self.router.complete_structured(
-            role="spec_writer",
-            messages=messages,
-            schema=SpecOutput
-        )

package/src/devcouncil/reporting/github_check.py

@@ -1,32 +0,0 @@
-from devcouncil.artifacts.graph import ArtifactGraph
-
-class GitHubCheckGenerator:
-    """Generates GitHub Checks API payloads."""
-    
-    @staticmethod
-    def generate(graph: ArtifactGraph) -> dict:
-        summary = graph.coverage_summary()
-        blocking_gaps = graph.blocking_gaps()
-        
-        status = "completed"
-        conclusion = "failure" if summary["blocking_gaps"] > 0 else "success"
-        
-        text = f"**Requirements**: {summary['total_requirements']} | "
-        text += f"**Tasks**: {summary['total_tasks']} | "
-        text += f"**Gaps**: {summary['blocking_gaps']} blocking\n\n"
-        
-        if blocking_gaps:
-            text += "### Blocking Gaps\n"
-            for gap in blocking_gaps:
-                text += f"- **{gap.id}**: {gap.description}\n"
-                
-        return {
-            "name": "DevCouncil Verification",
-            "status": status,
-            "conclusion": conclusion,
-            "output": {
-                "title": f"DevCouncil: {conclusion.capitalize()}",
-                "summary": f"Found {summary['blocking_gaps']} blocking gaps.",
-                "text": text
-            }
-        }

package/src/devcouncil/reporting/json_report.py

@@ -1,20 +0,0 @@
-import json
-from devcouncil.artifacts.graph import ArtifactGraph
-
-class JsonReportGenerator:
-    """Generates a JSON evidence report."""
-    
-    @staticmethod
-    def generate(graph: ArtifactGraph, live_review: dict | None = None) -> str:
-        summary = graph.coverage_summary()
-        live_blockers = len((live_review or {}).get("blocking_cards", []))
-        
-        report = {
-            "verdict": "blocked" if summary["blocking_gaps"] > 0 or live_blockers > 0 else "passed",
-            "coverage_summary": summary,
-            "blocking_gaps": [g.model_dump() for g in graph.blocking_gaps()]
-        }
-        if live_review is not None:
-            report["live_review"] = live_review
-        
-        return json.dumps(report, indent=2)

package/src/devcouncil/reporting/markdown_report.py

@@ -1,68 +0,0 @@
-from devcouncil.artifacts.graph import ArtifactGraph
-
-class MarkdownReportGenerator:
-    """Generates a Markdown evidence report."""
-
-    MAX_INLINE_GAPS = 25
-    
-    @staticmethod
-    def generate(graph: ArtifactGraph, live_review: dict | None = None) -> str:
-        summary = graph.coverage_summary()
-        live_blockers = (live_review or {}).get("blocking_cards", [])
-
-        md_output = "# DevCouncil Report\n\n"
-        md_output += "## Verdict\n"
-        if summary["blocking_gaps"] > 0 or live_blockers:
-            parts = []
-            if summary["blocking_gaps"] > 0:
-                parts.append(f"{summary['blocking_gaps']} high-severity gap(s)")
-            if live_blockers:
-                parts.append(f"{len(live_blockers)} live-review blocker(s)")
-            md_output += f"**Blocked**: {', '.join(parts)} remain.\n\n"
-        else:
-            md_output += "**Passed**: Ready for release.\n\n"
-
-        md_output += "## Coverage Summary\n"
-        md_output += f"- **Requirements**: {summary['total_requirements']} ({summary['requirements_without_tasks']} unmapped)\n"
-        md_output += f"- **Tasks**: {summary['total_tasks']} ({summary['tasks_without_requirements']} orphaned)\n"
-        md_output += f"- **Evidence**: {summary['total_ac'] - summary['ac_without_evidence']}/{summary['total_ac']} AC verified\n\n"
-
-        md_output += "## Requirements Coverage Table\n"
-        md_output += "| Requirement | Task Mapping | Status |\n"
-        md_output += "|---|---|---|\n"
-        
-        for req in graph.requirements.values():
-            linked_tasks = [t for t in graph.tasks.values() if req.id in t.requirement_ids]
-            task_str = ", ".join([t.id for t in linked_tasks]) if linked_tasks else "*None*"
-            status_str = "Covered" if linked_tasks else "**Unmapped**"
-            md_output += f"| {req.id} {req.title} | {task_str} | {status_str} |\n"
-                    
-        md_output += "\n## Blocking Gaps\n"
-        blocking_gaps = graph.blocking_gaps()
-        if not blocking_gaps:
-            md_output += "None.\n"
-        else:
-            for gap in blocking_gaps[:MarkdownReportGenerator.MAX_INLINE_GAPS]:
-                md_output += f"### {gap.id}: {gap.description}\n"
-                md_output += f"**Recommended fix**: {gap.recommended_fix}\n\n"
-            if len(blocking_gaps) > MarkdownReportGenerator.MAX_INLINE_GAPS:
-                remaining = len(blocking_gaps) - MarkdownReportGenerator.MAX_INLINE_GAPS
-                md_output += f"_Omitted {remaining} additional blocking gap(s). Use JSON output for the full list._\n"
-
-        if live_review is not None:
-            md_output += "\n## Live Review\n"
-            cards = live_review.get("cards", {})
-            md_output += f"- **Pending signals**: {live_review.get('pending_signals', 0)}\n"
-            md_output += f"- **Open cards**: {cards.get('open', 0)}\n"
-            md_output += f"- **Open critical cards**: {cards.get('critical_open', 0)}\n"
-            if not live_blockers:
-                md_output += "- **Blocking cards in scope**: None.\n"
-            else:
-                md_output += "\n### Blocking Live-Review Cards\n"
-                for card in live_blockers[:MarkdownReportGenerator.MAX_INLINE_GAPS]:
-                    md_output += f"- **{card['id']}**"
-                    if card.get("task_id"):
-                        md_output += f" (`{card['task_id']}`)"
-                    md_output += f": {card['summary']}\n"
-                
-        return md_output

package/src/devcouncil/reporting/report_builder.py

@@ -1,14 +0,0 @@
-from devcouncil.artifacts.graph import ArtifactGraph
-from devcouncil.reporting.markdown_report import MarkdownReportGenerator
-from devcouncil.reporting.json_report import JsonReportGenerator
-
-class ReportBuilder:
-    """Builds reports in various formats from the artifact graph."""
-    
-    @staticmethod
-    def build_markdown(graph: ArtifactGraph, live_review: dict | None = None) -> str:
-        return MarkdownReportGenerator.generate(graph, live_review=live_review)
-
-    @staticmethod
-    def build_json(graph: ArtifactGraph, live_review: dict | None = None) -> str:
-        return JsonReportGenerator.generate(graph, live_review=live_review)

package/src/devcouncil/storage/db.py

@@ -1,66 +0,0 @@
-from contextlib import contextmanager
-
-from sqlmodel import SQLModel, create_engine, Session
-from sqlalchemy.exc import OperationalError
-from pathlib import Path
-from typing import Optional
-
-from devcouncil.storage.models import SchemaVersionModel
-
-
-SCHEMA_VERSION = 1
-
-
-class Database:
-    def __init__(self, db_path: Path):
-        self.db_path = db_path
-        self.engine = create_engine(f"sqlite:///{db_path}")
-
-    def create_db_and_tables(self):
-        self._create_tables()
-        self.ensure_schema_version()
-
-    def ensure_schema_version(self):
-        self._create_tables()
-        with Session(self.engine) as session:
-            current = session.get(SchemaVersionModel, "singleton")
-            if current is None:
-                session.add(SchemaVersionModel(id="singleton", version=SCHEMA_VERSION))
-                session.commit()
-                return
-            if current.version != SCHEMA_VERSION:
-                raise RuntimeError(
-                    f"Unsupported DevCouncil schema version {current.version}; "
-                    f"expected {SCHEMA_VERSION}."
-                )
-
-    def _create_tables(self):
-        try:
-            SQLModel.metadata.create_all(self.engine)
-        except OperationalError as exc:
-            if "already exists" not in str(exc):
-                raise
-
-    @contextmanager
-    def get_session(self):
-        """Yield a session with automatic commit/rollback/close."""
-        session = Session(self.engine)
-        try:
-            yield session
-            session.commit()
-        except Exception:
-            session.rollback()
-            raise
-        finally:
-            session.close()
-
-
-def get_db(project_root: Path = Path(".")) -> Optional[Database]:
-    dev_dir = project_root / ".devcouncil"
-    if not dev_dir.exists():
-        return None
-    
-    db_path = dev_dir / "state.sqlite"
-    db = Database(db_path)
-    db.ensure_schema_version()
-    return db

package/src/devcouncil/storage/models.py

@@ -1,83 +0,0 @@
-from sqlmodel import SQLModel, Field
-from typing import Optional
-
-
-class SchemaVersionModel(SQLModel, table=True):
-    __tablename__ = "schema_version"
-    id: str = Field(primary_key=True, default="singleton")
-    version: int
-
-class RequirementModel(SQLModel, table=True):
-    __tablename__ = "requirements"
-    id: str = Field(primary_key=True)
-    title: str
-    description: str
-    priority: str
-    source: str
-    # Store complex lists as JSON strings for simplicity in SQLite
-    acceptance_criteria_json: str = Field(default="[]")
-
-class AssumptionModel(SQLModel, table=True):
-    __tablename__ = "assumptions"
-    id: str = Field(primary_key=True)
-    statement: str
-    confidence: str
-    impact: str
-    reversible: bool
-    requires_user_confirmation: bool
-    linked_requirement_ids_json: str = Field(default="[]")
-    status: str = "open"
-
-class TaskModel(SQLModel, table=True):
-    __tablename__ = "tasks"
-    id: str = Field(primary_key=True)
-    title: str
-    description: str
-    requirement_ids_json: str = Field(default="[]")
-    acceptance_criterion_ids_json: str = Field(default="[]")
-    planned_files_json: str = Field(default="[]")
-    expected_tests_json: str = Field(default="[]")
-    allowed_commands_json: str = Field(default="[]")
-    forbidden_changes_json: str = Field(default="[]")
-    status: str = "planned"
-
-class EvidenceModel(SQLModel, table=True):
-    __tablename__ = "evidence"
-    id: Optional[int] = Field(default=None, primary_key=True)
-    type: str  # "command", "diff", "test"
-    task_id: Optional[str] = None
-    requirement_id: Optional[str] = None
-    acceptance_criterion_id: Optional[str] = None
-    data_json: str
-
-class GapModel(SQLModel, table=True):
-    __tablename__ = "gaps"
-    id: str = Field(primary_key=True)
-    severity: str
-    gap_type: str
-    requirement_id: Optional[str] = None
-    task_id: Optional[str] = None
-    description: str
-    evidence_json: str = Field(default="[]")
-    recommended_fix: str
-    blocking: bool
-
-class CritiqueFindingModel(SQLModel, table=True):
-    __tablename__ = "critique_findings"
-    id: str = Field(primary_key=True)
-    source_agent: str
-    target_plan_id: str
-    severity: str
-    finding_type: str
-    claim: str
-    linked_requirement_id: Optional[str] = None
-    suggested_requirement: Optional[str] = None
-    suggested_task: Optional[str] = None
-    falsifiable_check: str
-    status: str = "open"
-
-class ProjectStateModel(SQLModel, table=True):
-    __tablename__ = "project_state"
-    id: str = Field(primary_key=True, default="singleton")
-    current_phase: str
-    history_json: str = Field(default="[]")