devcouncil 0.1.0 → 0.1.1

package/src/devcouncil/planning/repair_service.py

@@ -1,39 +1,39 @@
-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
-        )
+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 +1,44 @@
-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
-        )
+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 +1,32 @@
-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
-            }
-        }
+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,17 +1,20 @@
-import json
-from devcouncil.artifacts.graph import ArtifactGraph
-
-class JsonReportGenerator:
-    """Generates a JSON evidence report."""
-    
-    @staticmethod
-    def generate(graph: ArtifactGraph) -> str:
-        summary = graph.coverage_summary()
-        
-        report = {
-            "verdict": "blocked" if summary["blocking_gaps"] > 0 else "passed",
-            "coverage_summary": summary,
-            "blocking_gaps": [g.model_dump() for g in graph.blocking_gaps()]
-        }
-        
-        return json.dumps(report, indent=2)
+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,46 +1,68 @@
-from devcouncil.artifacts.graph import ArtifactGraph
-
-class MarkdownReportGenerator:
-    """Generates a Markdown evidence report."""
-
-    MAX_INLINE_GAPS = 25
-    
-    @staticmethod
-    def generate(graph: ArtifactGraph) -> str:
-        summary = graph.coverage_summary()
-
-        md_output = "# DevCouncil Report\n\n"
-        md_output += "## Verdict\n"
-        if summary["blocking_gaps"] > 0:
-            md_output += f"**Blocked**: {summary['blocking_gaps']} high-severity gaps 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"
-                
-        return md_output
+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 +1,14 @@
-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) -> str:
-        return MarkdownReportGenerator.generate(graph)
-
-    @staticmethod
-    def build_json(graph: ArtifactGraph) -> str:
-        return JsonReportGenerator.generate(graph)
+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 +1,66 @@
-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
+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