devcouncil 0.1.0

package/src/devcouncil/indexing/repo_mapper.py

@@ -0,0 +1,204 @@
+import json
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import List, Dict
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+class RepoMap(BaseModel):
+    languages: List[str]
+    frameworks: List[str]
+    package_managers: List[str]
+    test_commands: List[str]
+    important_files: List[str]
+    candidate_files: List[Dict[str, str]]
+
+class RepoMapper:
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def _is_runtime_or_generated_file(self, path: str) -> bool:
+        normalized = path.replace("\\", "/")
+        parts = set(normalized.split("/"))
+        if "__pycache__" in parts or normalized.endswith(".pyc"):
+            return True
+        if parts.intersection({".git", ".devcouncil", ".pytest_cache", ".ruff_cache", ".mypy_cache", ".venv"}):
+            return True
+        if normalized.startswith("dist/") or normalized.startswith("build/"):
+            return True
+        return False
+
+    def get_git_files(self) -> List[str]:
+        try:
+            output = subprocess.check_output(
+                ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+                cwd=self.project_root,
+                stderr=subprocess.DEVNULL
+            ).decode().splitlines()
+            return [path for path in output if not self._is_runtime_or_generated_file(path)]
+        except Exception:
+            # Fallback to os.walk if not a git repo or git missing
+            files = []
+            for root, _, filenames in os.walk(self.project_root):
+                for f in filenames:
+                    rel_path = os.path.relpath(os.path.join(root, f), self.project_root)
+                    if not rel_path.startswith(".") and not self._is_runtime_or_generated_file(rel_path):
+                        files.append(rel_path)
+            return files
+
+    def detect_languages(self, files: List[str]) -> List[str]:
+        exts = {os.path.splitext(f)[1] for f in files}
+        lang_map = {
+            ".py": "python",
+            ".ts": "typescript",
+            ".tsx": "typescript",
+            ".js": "javascript",
+            ".jsx": "javascript",
+            ".go": "go",
+            ".rs": "rust",
+            ".java": "java",
+            ".c": "c",
+            ".cpp": "cpp",
+        }
+        return sorted(list({lang_map[ext] for ext in exts if ext in lang_map}))
+
+    def detect_frameworks(self, files: List[str]) -> List[str]:
+        frameworks = []
+        file_set = set(files)
+        if "package.json" in file_set:
+            content = (self.project_root / "package.json").read_text()
+            if "next" in content:
+                frameworks.append("nextjs")
+            if "react" in content:
+                frameworks.append("react")
+            if "vue" in content:
+                frameworks.append("vue")
+            if "express" in content:
+                frameworks.append("express")
+        
+        if "requirements.txt" in file_set or "pyproject.toml" in file_set:
+            try:
+                content = ""
+                if "requirements.txt" in file_set:
+                    content += (self.project_root / "requirements.txt").read_text()
+                if "pyproject.toml" in file_set:
+                    content += (self.project_root / "pyproject.toml").read_text()
+                
+                if "fastapi" in content.lower():
+                    frameworks.append("fastapi")
+                if "flask" in content.lower():
+                    frameworks.append("flask")
+                if "django" in content.lower():
+                    frameworks.append("django")
+            except Exception as e:
+                logger.debug("Failed to read Python config files: %s", e)
+        return frameworks
+
+    def detect_package_managers(self, files: List[str]) -> List[str]:
+        managers = []
+        file_set = set(files)
+        if "package-lock.json" in file_set:
+            managers.append("npm")
+        elif "package.json" in file_set:
+            managers.append("npm")
+        if "yarn.lock" in file_set:
+            managers.append("yarn")
+        if "pnpm-lock.yaml" in file_set:
+            managers.append("pnpm")
+        if "requirements.txt" in file_set:
+            managers.append("pip")
+        if "uv.lock" in file_set:
+            managers.append("uv")
+        if "go.sum" in file_set:
+            managers.append("go mod")
+        return managers
+
+    def detect_test_commands(self, files: List[str]) -> List[str]:
+        """Detect test, lint, and typecheck commands from project config."""
+        commands: List[str] = []
+        file_set = set(files)
+
+        # Node.js projects: read scripts from package.json
+        if "package.json" in file_set:
+            try:
+                pkg = json.loads((self.project_root / "package.json").read_text())
+                scripts = pkg.get("scripts", {})
+                pm = "pnpm" if "pnpm-lock.yaml" in file_set else (
+                    "yarn" if "yarn.lock" in file_set else "npm"
+                )
+                for key in ["test", "lint", "typecheck", "check", "type-check"]:
+                    if key in scripts:
+                        if pm == "npm" and key != "test":
+                            commands.append(f"npm run {key}")
+                        else:
+                            commands.append(f"{pm} {key}")
+            except Exception as e:
+                logger.debug("Failed to parse package.json scripts: %s", e)
+
+        # Python projects
+        if "pyproject.toml" in file_set or "setup.py" in file_set:
+            if any(f.startswith("tests/") or f.startswith("test_") for f in files):
+                commands.append("pytest")
+            commands.append("ruff check .")
+            commands.append("mypy .")
+
+        # Go projects
+        if "go.mod" in file_set:
+            commands.append("go test ./...")
+            commands.append("go vet ./...")
+
+        # Rust projects
+        if "Cargo.toml" in file_set:
+            commands.append("cargo test")
+            commands.append("cargo clippy")
+
+        return commands
+
+    def _ripgrep_search(self, goal: str, files: List[str]) -> List[Dict[str, str]]:
+        """Use ripgrep for goal-keyword search if available, else fall back to naive matching."""
+        candidates: List[Dict[str, str]] = []
+        try:
+            # Try ripgrep first for better matching
+            result = subprocess.run(
+                ["rg", "--files-with-matches", "--ignore-case", "--glob", "!.git", goal],
+                capture_output=True, text=True, cwd=self.project_root, timeout=10,
+            )
+            if result.returncode == 0:
+                for line in result.stdout.strip().splitlines()[:10]:
+                    candidates.append({"path": line.strip(), "reason": f"ripgrep match for '{goal}'"})
+                return candidates
+        except Exception:
+            pass  # Fall back to naive matching
+
+        # Naive keyword matching fallback
+        goal_words = set(goal.lower().split())
+        for f in files:
+            f_lower = f.lower()
+            score = sum(1 for word in goal_words if word in f_lower)
+            if score > 0:
+                candidates.append({"path": f, "reason": f"Matches goal keywords (score: {score})"})
+        candidates = sorted(candidates, key=lambda x: x.get("reason", ""), reverse=True)[:10]
+        return candidates
+
+    def map_repo(self, goal: str = "") -> RepoMap:
+        files = self.get_git_files()
+
+        candidates: List[Dict[str, str]] = []
+        if goal:
+            candidates = self._ripgrep_search(goal, files)
+
+        return RepoMap(
+            languages=self.detect_languages(files),
+            frameworks=self.detect_frameworks(files),
+            package_managers=self.detect_package_managers(files),
+            test_commands=self.detect_test_commands(files),
+            important_files=[f for f in files if f in [
+                "package.json", "pyproject.toml", "README.md", "go.mod",
+                "Cargo.toml", "Makefile", "Dockerfile", ".github/workflows",
+            ]],
+            candidate_files=candidates,
+        )

package/src/devcouncil/integrations/code_review_graph.py

@@ -0,0 +1,163 @@
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Iterable
+
+from pydantic import BaseModel, Field
+
+from devcouncil.app.config import load_config
+
+
+class CodeReviewGraphContext(BaseModel):
+    available: bool
+    summary: str
+    command: str = "code-review-graph"
+    changed_files: list[str] = Field(default_factory=list)
+    impacted_files: list[str] = Field(default_factory=list)
+    related_tests: list[str] = Field(default_factory=list)
+    raw: str = ""
+
+
+class CodeReviewGraphAdapter:
+    """Optional shell adapter for code-review-graph without a hard dependency."""
+
+    def __init__(self, project_root: Path, command: str | None = None):
+        self.project_root = project_root
+        self.command = command or self._configured_command()
+
+    def is_enabled(self) -> bool:
+        try:
+            return load_config(self.project_root).integrations.code_review_graph.enabled
+        except Exception:
+            return False
+
+    def is_available(self) -> bool:
+        return shutil.which(self.command) is not None
+
+    def get_context(self, files: Iterable[str] = ()) -> CodeReviewGraphContext:
+        changed_files = [file for file in files if file]
+        if not self.is_enabled():
+            return CodeReviewGraphContext(
+                available=False,
+                summary="code-review-graph integration is disabled.",
+                command=self.command,
+                changed_files=changed_files,
+            )
+        if not self.is_available():
+            return CodeReviewGraphContext(
+                available=False,
+                summary="code-review-graph command was not found on PATH.",
+                command=self.command,
+                changed_files=changed_files,
+            )
+
+        commands = self._candidate_commands(changed_files)
+        errors: list[str] = []
+        for command in commands:
+            result = self._run(command)
+            if result.returncode == 0 and result.output.strip():
+                return self._parse_context(result.output, changed_files)
+            errors.append(result.output.strip() or f"exit {result.returncode}")
+
+        return CodeReviewGraphContext(
+            available=True,
+            summary="code-review-graph ran but did not return context.",
+            command=self.command,
+            changed_files=changed_files,
+            raw="\n".join(errors),
+        )
+
+    def prompt_section(self, files: Iterable[str] = ()) -> str:
+        context = self.get_context(files)
+        if not context.available:
+            return ""
+
+        lines = ["## Structural graph context", context.summary]
+        if context.impacted_files:
+            lines.append("\nImpacted files:")
+            lines.extend(f"- `{path}`" for path in context.impacted_files[:20])
+        if context.related_tests:
+            lines.append("\nRelated tests:")
+            lines.extend(f"- `{path}`" for path in context.related_tests[:20])
+        return "\n".join(lines).strip() + "\n"
+
+    def _configured_command(self) -> str:
+        try:
+            return load_config(self.project_root).integrations.code_review_graph.command
+        except Exception:
+            return "code-review-graph"
+
+    def _candidate_commands(self, files: list[str]) -> list[list[str]]:
+        commands = [[self.command, "detect-changes", "--json"]]
+        if files:
+            commands.append([self.command, "get-review-context", "--json", *files])
+        commands.append([self.command, "status", "--json"])
+        return commands
+
+    def _parse_context(self, output: str, changed_files: list[str]) -> CodeReviewGraphContext:
+        data: dict[str, Any] = {}
+        try:
+            parsed = json.loads(output)
+            if isinstance(parsed, dict):
+                data = parsed
+        except json.JSONDecodeError:
+            pass
+
+        impacted = self._string_list(
+            data.get("impacted_files")
+            or data.get("impact_radius")
+            or data.get("files")
+            or []
+        )
+        tests = self._string_list(data.get("related_tests") or data.get("tests") or [])
+        summary = str(data.get("summary") or "code-review-graph context available.")
+        return CodeReviewGraphContext(
+            available=True,
+            summary=summary,
+            command=self.command,
+            changed_files=changed_files,
+            impacted_files=impacted,
+            related_tests=tests,
+            raw=output,
+        )
+
+    def _string_list(self, value: Any) -> list[str]:
+        if isinstance(value, list):
+            results: list[str] = []
+            for item in value:
+                if isinstance(item, (str, int)):
+                    results.append(str(item))
+                elif isinstance(item, dict):
+                    path = item.get("path") or item.get("file") or item.get("name") or item.get("id")
+                    if path:
+                        results.append(str(path))
+            return results
+        if isinstance(value, dict):
+            if "path" in value or "file" in value:
+                return [str(value.get("path") or value.get("file"))]
+            return [str(key) for key in value.keys()]
+        return []
+
+    def _run(self, command: list[str]) -> "_RunResult":
+        try:
+            result = subprocess.run(
+                command,
+                cwd=self.project_root,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=20,
+            )
+            return _RunResult(
+                returncode=result.returncode,
+                output=(result.stdout or "") + (result.stderr or ""),
+            )
+        except Exception as exc:
+            return _RunResult(returncode=1, output=str(exc))
+
+
+class _RunResult(BaseModel):
+    returncode: int
+    output: str

package/src/devcouncil/integrations/github.py

@@ -0,0 +1,39 @@
+import httpx
+import logging
+from devcouncil.artifacts.graph import ArtifactGraph
+from devcouncil.reporting.github_check import GitHubCheckGenerator
+
+logger = logging.getLogger(__name__)
+
+class GitHubIntegration:
+    """Manages interactions with GitHub API, specifically PR Checks."""
+    
+    def __init__(self, github_token: str, repository: str, commit_sha: str):
+        self.github_token = github_token
+        self.repository = repository
+        self.commit_sha = commit_sha
+        self.base_url = f"https://api.github.com/repos/{repository}"
+
+    async def report_verification(self, graph: ArtifactGraph):
+        """Creates or updates a GitHub Check Run with the current verification status."""
+        payload = GitHubCheckGenerator.generate(graph)
+        payload["head_sha"] = self.commit_sha
+        
+        headers = {
+            "Authorization": f"Bearer {self.github_token}",
+            "Accept": "application/vnd.github.v3+json",
+            "Content-Type": "application/json"
+        }
+        
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/check-runs",
+                    headers=headers,
+                    json=payload
+                )
+                response.raise_for_status()
+                logger.info(f"GitHub PR Check updated for {self.repository} at {self.commit_sha}")
+            except Exception as e:
+                logger.error(f"Failed to report to GitHub: {e}")
+                raise

package/src/devcouncil/integrations/gitnexus.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+from rich.console import Console
+from devcouncil.indexing.graph_index import GraphIndex
+
+console = Console()
+
+class GitNexusIntegration:
+    """
+    Integration for GitNexus: Codebase knowledge graph and structural awareness.
+    """
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def initialize(self):
+        console.print("[cyan]Initializing GitNexus context...[/cyan]")
+        nexus_dir = self.project_root / ".devcouncil" / "nexus"
+        nexus_dir.mkdir(exist_ok=True)
+        # Mock initialization logic
+        (nexus_dir / "index_config.json").write_text('{"mode": "structural", "version": "1.0"}')
+        console.print("  - GitNexus structural awareness active.")
+
+    def sync_graph(self, graph_index: GraphIndex):
+        """
+        Export DevCouncil artifact graph to GitNexus.
+        """
+        console.print("  - Syncing DevCouncil artifacts to GitNexus...")
+        pass

package/src/devcouncil/integrations/graphify.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from rich.console import Console
+
+console = Console()
+
+class GraphifyIntegration:
+    """
+    Integration for graphify: Always-on graph context and multi-agent integration.
+    """
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def initialize(self):
+        console.print("[magenta]Initializing Graphify engine...[/magenta]")
+        graphify_config = self.project_root / ".devcouncil" / "graphify.yaml"
+        # Create a default graphify config
+        content = """
+graph:
+  engine: internal
+  persist: true
+agents:
+  shared_context: true
+hooks:
+  enabled: true
+"""
+        graphify_config.write_text(content.strip())
+        console.print("  - Graphify engine configured and ready.")
+
+    def apply_rules(self):
+        """
+        Apply graph-based rules to implementation plans.
+        """
+        console.print("  - Graphify checking architectural rules...")
+        pass

package/src/devcouncil/integrations/mcp/server.py

@@ -0,0 +1,146 @@
+import asyncio
+import os
+from pathlib import Path
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import TaskRepository, ArtifactGraphRepository, StateRepository
+from devcouncil.reporting.report_builder import ReportBuilder
+from devcouncil.integrations.code_review_graph import CodeReviewGraphAdapter
+
+app = Server("devcouncil")
+
+
+def _project_root() -> Path:
+    configured = os.environ.get("DEVCOUNCIL_PROJECT_ROOT")
+    return Path(configured).expanduser().resolve() if configured else Path(".")
+
+
+def _computed_phase(graph) -> str:
+    reqs = list(graph.requirements.values())
+    tasks = list(graph.tasks.values())
+    blocking_gaps = graph.blocking_gaps()
+    if not reqs and not tasks:
+        return "NEW"
+    if reqs and not tasks:
+        return "REQUIREMENTS_DRAFTED"
+    if blocking_gaps:
+        return "TASK_BLOCKED"
+    if tasks:
+        statuses = {task.status for task in tasks}
+        if "running" in statuses:
+            return "TASK_EXECUTING"
+        if "blocked" in statuses:
+            return "TASK_BLOCKED"
+        if all(status in {"verified", "done"} for status in statuses):
+            return "PROJECT_DONE"
+        return "PLAN_APPROVED"
+    return "NEW"
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    return [
+        Tool(
+            name="devcouncil_status",
+            description="Get the current status of the DevCouncil project, including phase, tasks, and gaps.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+        Tool(
+            name="devcouncil_report",
+            description="Get the full coverage report and a list of all requirements and blocking gaps.",
+            inputSchema={
+                "type": "object",
+                "properties": {}
+            }
+        ),
+        Tool(
+            name="devcouncil_get_task",
+            description="Get details, constraints, and requirements for a specific implementation task.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "task_id": {
+                        "type": "string",
+                        "description": "The ID of the task, e.g. TASK-001"
+                    }
+                },
+                "required": ["task_id"]
+            }
+        ),
+        Tool(
+            name="devcouncil_graph_context",
+            description="Get optional code-review-graph structural context for changed or planned files.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "files": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Repository-relative files to contextualize.",
+                    }
+                },
+            },
+        ),
+    ]
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+    db = get_db(_project_root())
+    if not db:
+        return [TextContent(type="text", text="Error: DevCouncil not initialized in this directory.")]
+
+    if name == "devcouncil_status":
+        with db.get_session() as session:
+            graph_repo = ArtifactGraphRepository(session)
+            graph = graph_repo.load_graph()
+            summary = graph.coverage_summary()
+            state = StateRepository(session).get_state()
+            phase = state.current_phase if state else _computed_phase(graph)
+            
+            status_str = f"Phase: {phase}\n"
+            status_str += f"Requirements: {summary['total_requirements']} ({summary['requirements_without_tasks']} unmapped)\n"
+            status_str += f"Tasks: {summary['total_tasks']} ({summary['tasks_without_requirements']} orphaned)\n"
+            status_str += f"Gaps: {summary['total_gaps']} ({summary['blocking_gaps']} blocking)\n"
+            
+            return [TextContent(type="text", text=status_str)]
+
+    elif name == "devcouncil_report":
+        with db.get_session() as session:
+            graph_repo = ArtifactGraphRepository(session)
+            graph = graph_repo.load_graph()
+            markdown_report = ReportBuilder.build_markdown(graph)
+            return [TextContent(type="text", text=markdown_report)]
+            
+    elif name == "devcouncil_get_task":
+        task_id = arguments.get("task_id")
+        if not task_id:
+            return [TextContent(type="text", text="Error: Missing task_id")]
+            
+        with db.get_session() as session:
+            task_repo = TaskRepository(session)
+            task = task_repo.get_by_id(task_id)
+            if not task:
+                return [TextContent(type="text", text=f"Error: Task {task_id} not found.")]
+            
+            return [TextContent(type="text", text=task.model_dump_json(indent=2))]
+
+    elif name == "devcouncil_graph_context":
+        files = arguments.get("files", [])
+        if not isinstance(files, list):
+            files = []
+        context = CodeReviewGraphAdapter(_project_root()).get_context([str(file) for file in files])
+        return [TextContent(type="text", text=context.model_dump_json(indent=2))]
+
+    return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+async def run():
+    # Use stdio to communicate
+    async with stdio_server() as (read_stream, write_stream):
+        await app.run(read_stream, write_stream, app.create_initialization_options())
+
+if __name__ == "__main__":
+    asyncio.run(run())

package/src/devcouncil/llm/__init__.py

@@ -0,0 +1 @@
+

package/src/devcouncil/llm/cache.py

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