devcouncil 0.1.1 → 0.2.1

package/src/devcouncil/gating/checks/planned_files_check.py

@@ -1,32 +0,0 @@
-from devcouncil.domain.task import Task
-from devcouncil.domain.gap import Gap
-
-class PlannedFilesCheck:
-    """Ensures a task has legitimate files planned for modification."""
-    
-    def check(self, task: Task) -> list[Gap]:
-        gaps = []
-        if not task.planned_files:
-            gaps.append(Gap(
-                id=f"GAP-{task.id}-NO-FILES",
-                severity="high",
-                gap_type="task_not_implemented",
-                task_id=task.id,
-                description=f"Task {task.id} has no planned files. Agents won't know where to write code.",
-                recommended_fix="Update the task to include at least one planned file path.",
-                blocking=True
-            ))
-        
-        has_modify = any(pf.allowed_change in ["create", "modify", "delete"] for pf in task.planned_files)
-        if task.planned_files and not has_modify:
-            gaps.append(Gap(
-                id=f"GAP-{task.id}-READ-ONLY",
-                severity="medium",
-                gap_type="task_not_implemented",
-                task_id=task.id,
-                description=f"Task {task.id} only has read-only files. No changes can be made.",
-                recommended_fix="Grant 'modify' or 'create' permissions to at least one file.",
-                blocking=True
-            ))
-            
-        return gaps

package/src/devcouncil/gating/checks/requirement_coverage.py

@@ -1,26 +0,0 @@
-from devcouncil.domain.requirement import Requirement
-from devcouncil.domain.task import Task
-from devcouncil.domain.gap import Gap
-from typing import List
-
-class RequirementCoverageCheck:
-    """Detects requirements that are not mapped to any tasks."""
-    
-    def check(self, requirements: List[Requirement], tasks: List[Task]) -> List[Gap]:
-        task_req_ids = set()
-        for t in tasks:
-            task_req_ids.update(t.requirement_ids)
-            
-        gaps = []
-        for req in requirements:
-            if req.id not in task_req_ids:
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{req.id}-UNMAPPED",
-                    severity="high",
-                    gap_type="requirement_not_planned",
-                    requirement_id=req.id,
-                    description=f"Requirement '{req.title}' is not covered by any task.",
-                    recommended_fix="Decompose this requirement into one or more implementation tasks.",
-                    blocking=True
-                ))
-        return gaps

package/src/devcouncil/gating/checks/secret_scan_check.py

@@ -1,34 +0,0 @@
-from typing import List
-from devcouncil.domain.gap import Gap
-from devcouncil.utils.redaction import SECRET_PATTERNS, redact_string
-
-class SecretScanner:
-    """Scans code diffs for potential secrets (API keys, tokens, etc.)."""
-    
-    def scan_diff(self, diff_content: str, task_id: str) -> List[Gap]:
-        gaps = []
-        lines = diff_content.splitlines()
-        current_file = "unknown_file"
-        
-        for i, line in enumerate(lines):
-            if line.startswith("+++ b/"):
-                current_file = line[6:]
-                continue
-                
-            # Only scan added lines in diff
-            if not line.startswith("+") or line.startswith("+++"):
-                continue
-                
-            for key_type, pattern in SECRET_PATTERNS.items():
-                if pattern.search(line):
-                    gaps.append(Gap(
-                        id=f"GAP-{task_id}-SECRET-{key_type.upper()}-{i}",
-                        severity="critical",
-                        gap_type="security_risk",
-                        task_id=task_id,
-                        description=f"Potential {key_type} found in {current_file} (diff line {i+1}).",
-                        evidence=[redact_string(line.strip())],
-                        recommended_fix="Remove the secret and use environment variables or a secret manager.",
-                        blocking=True
-                    ))
-        return gaps

package/src/devcouncil/gating/policy.py

@@ -1,190 +0,0 @@
-from pydantic import BaseModel
-from typing import Any, List, Optional
-from pathlib import Path
-
-from devcouncil.domain.requirement import Requirement
-from devcouncil.domain.task import Task
-from devcouncil.domain.gap import Gap
-from devcouncil.domain.assumption import Assumption
-from devcouncil.domain.critique import CritiqueFinding
-from devcouncil.gating.checks.requirement_coverage import RequirementCoverageCheck
-from devcouncil.gating.checks.planned_files_check import PlannedFilesCheck
-from devcouncil.gating.checks.clean_git import CleanGitCheck
-
-class GateResult(BaseModel):
-    passed: bool
-    gaps: List[Gap]
-
-class GatePolicy:
-    """Central engine for executing project and task level quality gates."""
-    
-    def __init__(self):
-        self.req_coverage = RequirementCoverageCheck()
-        self.planned_files = PlannedFilesCheck()
-        self.clean_git = CleanGitCheck()
-
-    def check_plan_approval(
-        self,
-        requirements: List[Requirement],
-        tasks: List[Task],
-        assumptions: Optional[List[Assumption]] = None,
-        findings: Optional[List[CritiqueFinding]] = None,
-        blocking_questions: Optional[List[Any]] = None,
-    ) -> GateResult:
-        """Determines if the overall project plan is ready for execution."""
-        gaps = []
-        known_req_ids = {req.id for req in requirements}
-        known_ac_ids = {
-            ac.id
-            for req in requirements
-            for ac in req.acceptance_criteria
-        }
-        
-        # 1. Check requirement coverage
-        gaps.extend(self.req_coverage.check(requirements, tasks))
-        
-        # 2. Check for acceptance criteria presence
-        for req in requirements:
-            if not req.acceptance_criteria:
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{req.id}-NO-AC",
-                    severity="high",
-                    gap_type="requirement_not_planned",
-                    requirement_id=req.id,
-                    description=f"Requirement {req.id} has no acceptance criteria.",
-                    recommended_fix="Define at least one measurable AC.",
-                    blocking=True
-                ))
-
-            for ac in req.acceptance_criteria:
-                if not ac.verification_method:
-                    gaps.append(Gap(
-                        id=f"GAP-PLAN-{ac.id}-NO-VERIFY",
-                        severity="high",
-                        gap_type="acceptance_criteria_unproven",
-                        requirement_id=req.id,
-                        description=f"Acceptance criterion {ac.id} has no verification method.",
-                        recommended_fix="Define a deterministic verification method for this AC.",
-                        blocking=True,
-                    ))
-
-        for task in tasks:
-            if not task.requirement_ids:
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{task.id}-NO-REQ",
-                    severity="high",
-                    gap_type="requirement_not_planned",
-                    task_id=task.id,
-                    description=f"Task {task.id} is not mapped to any requirement.",
-                    recommended_fix="Map each task to at least one requirement.",
-                    blocking=True,
-                ))
-
-            unknown_req_ids = [req_id for req_id in task.requirement_ids if req_id not in known_req_ids]
-            if unknown_req_ids:
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{task.id}-UNKNOWN-REQ",
-                    severity="high",
-                    gap_type="requirement_not_planned",
-                    task_id=task.id,
-                    description=f"Task {task.id} references unknown requirement(s): {', '.join(unknown_req_ids)}.",
-                    recommended_fix="Remove invalid requirement links or add the missing requirements.",
-                    blocking=True,
-                ))
-
-            unknown_ac_ids = [ac_id for ac_id in task.acceptance_criterion_ids if ac_id not in known_ac_ids]
-            if unknown_ac_ids:
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{task.id}-UNKNOWN-AC",
-                    severity="high",
-                    gap_type="acceptance_criteria_unproven",
-                    task_id=task.id,
-                    description=f"Task {task.id} references unknown acceptance criteria: {', '.join(unknown_ac_ids)}.",
-                    recommended_fix="Link tasks only to acceptance criteria declared by requirements.",
-                    blocking=True,
-                ))
-
-        for assumption in assumptions or []:
-            if (
-                assumption.impact == "high"
-                and assumption.status == "open"
-                and assumption.requires_user_confirmation
-            ):
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{assumption.id}-OPEN",
-                    severity="high",
-                    gap_type="assumption_violated",
-                    requirement_id=assumption.linked_requirement_ids[0] if assumption.linked_requirement_ids else None,
-                    description=f"High-impact assumption {assumption.id} is still open: {assumption.statement}",
-                    recommended_fix="Confirm, reject, or convert this assumption before approving the plan.",
-                    blocking=True,
-                ))
-
-        for finding in findings or []:
-            if finding.severity in {"high", "critical"} and finding.status == "open":
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{finding.id}-OPEN",
-                    severity=finding.severity,
-                    gap_type="architecture_drift",
-                    requirement_id=finding.linked_requirement_id,
-                    description=f"Open {finding.severity} critique finding remains: {finding.claim}",
-                    recommended_fix="Convert, rebut with evidence, or mark this finding resolved before approval.",
-                    blocking=True,
-                ))
-
-        for question in blocking_questions or []:
-            question_id = getattr(question, "id", "QUESTION")
-            question_text = getattr(question, "question", str(question))
-            gaps.append(Gap(
-                id=f"GAP-PLAN-{question_id}-BLOCKING",
-                severity="high",
-                gap_type="requirement_not_planned",
-                description=f"Blocking question remains unanswered: {question_text}",
-                recommended_fix="Answer or convert the blocking question before approving the plan.",
-                blocking=True,
-            ))
-
-        return GateResult(
-            passed=len([g for g in gaps if g.blocking]) == 0, 
-            gaps=gaps
-        )
-
-    def check_task_ready(self, task: Task, project_root: Path) -> GateResult:
-        """Determines if a specific task can begin execution."""
-        gaps = []
-        
-        # 1. Check Git state
-        gaps.extend(self.clean_git.check(project_root, task.id))
-        
-        # 2. Check planned files
-        gaps.extend(self.planned_files.check(task))
-
-        # 3. Check execution/verification evidence contract
-        if not task.allowed_commands:
-            gaps.append(Gap(
-                id=f"GAP-{task.id}-NO-COMMANDS",
-                severity="high",
-                gap_type="missing_test",
-                task_id=task.id,
-                description=f"Task {task.id} has no allowed commands for execution or verification.",
-                recommended_fix="Add explicit allowed_commands for the task before execution.",
-                blocking=True,
-            ))
-
-        if not task.expected_tests:
-            gaps.append(Gap(
-                id=f"GAP-{task.id}-NO-EXPECTED-EVIDENCE",
-                severity="high",
-                gap_type="missing_test",
-                task_id=task.id,
-                description=f"Task {task.id} has no expected verification evidence.",
-                recommended_fix="Add expected_tests or targeted static/manual review commands that prove the acceptance criteria.",
-                blocking=True,
-            ))
-
-        # 4. Check for task dependencies (if implemented)
-        
-        return GateResult(
-            passed=len([g for g in gaps if g.blocking]) == 0, 
-            gaps=gaps
-        )

package/src/devcouncil/indexing/__init__.py

@@ -1 +0,0 @@
-

package/src/devcouncil/indexing/ast_matcher.py

@@ -1,168 +0,0 @@
-from __future__ import annotations
-
-import ast
-import re
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass(frozen=True)
-class AstMatch:
-    path: str
-    language: str
-    kind: str
-    name: str
-    line: int
-    text: str
-    engine: str
-
-    def model_dump(self) -> dict[str, object]:
-        return {
-            "path": self.path,
-            "language": self.language,
-            "kind": self.kind,
-            "name": self.name,
-            "line": self.line,
-            "text": self.text,
-            "engine": self.engine,
-        }
-
-
-class AstMatcher:
-    """Tree-sitter-style structural search with optional tree_sitter and deterministic fallbacks."""
-
-    _EXT_LANGUAGE = {
-        ".py": "python",
-        ".ts": "typescript",
-        ".tsx": "typescript",
-        ".js": "javascript",
-        ".jsx": "javascript",
-        ".go": "go",
-        ".rs": "rust",
-    }
-
-    _SYMBOL_PATTERNS: dict[str, re.Pattern[str]] = {
-        "typescript": re.compile(
-            r"^\s*(?:export\s+)?(?:(?:async\s+)?(?:function|class|interface|type)\s+|const\s+)([A-Za-z_$][\w$]*)"
-        ),
-        "javascript": re.compile(
-            r"^\s*(?:export\s+)?(?:(?:async\s+)?(?:function|class)\s+|const\s+)([A-Za-z_$][\w$]*)"
-        ),
-        "go": re.compile(r"^\s*func\s+(?:\([^)]+\)\s*)?([A-Za-z_]\w*)\s*\("),
-        "rust": re.compile(r"^\s*(?:pub\s+)?(?:async\s+)?(?:fn|struct|enum|trait)\s+([A-Za-z_]\w*)"),
-    }
-    _IGNORED_DIRS = {".git", ".devcouncil", "__pycache__", ".venv", "node_modules", "dist", "build", "target", "vendor"}
-
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-        self.tree_sitter_available = self._has_tree_sitter()
-
-    def _has_tree_sitter(self) -> bool:
-        try:
-            import tree_sitter  # noqa: F401
-        except Exception:
-            return False
-        return True
-
-    def match(
-        self,
-        *,
-        query: str = "",
-        language: str | None = None,
-        kind: str | None = None,
-        limit: int = 100,
-    ) -> list[AstMatch]:
-        language = language.lower() if language else None
-        kind = kind.lower() if kind else None
-        limit = max(1, limit)
-        matches: list[AstMatch] = []
-        for path in self._candidate_files(language):
-            try:
-                text = path.read_text(encoding="utf-8")
-            except (OSError, UnicodeDecodeError):
-                continue
-            rel = path.relative_to(self.project_root).as_posix()
-            file_language = self._EXT_LANGUAGE.get(path.suffix.lower(), path.suffix.lower().lstrip("."))
-            matches.extend(self._match_file(rel, file_language, text, query=query, kind=kind))
-            if len(matches) >= limit:
-                return matches[:limit]
-        return matches[:limit]
-
-    def _candidate_files(self, language: str | None) -> list[Path]:
-        allowed_exts = {
-            ext for ext, ext_language in self._EXT_LANGUAGE.items()
-            if language is None or ext_language == language
-        }
-        files: list[Path] = []
-        try:
-            for path in self.project_root.rglob("*"):
-                if not path.is_file() or path.suffix.lower() not in allowed_exts:
-                    continue
-                if any(part in self._IGNORED_DIRS for part in path.parts):
-                    continue
-                files.append(path)
-        except OSError:
-            return files
-        return sorted(files)
-
-    def _match_file(self, rel: str, language: str, text: str, *, query: str, kind: str | None) -> list[AstMatch]:
-        if language == "python":
-            return self._match_python(rel, text, query=query, kind=kind)
-        pattern = self._SYMBOL_PATTERNS.get(language)
-        if not pattern:
-            return []
-        results: list[AstMatch] = []
-        for lineno, line in enumerate(text.splitlines(), start=1):
-            match = pattern.match(line)
-            if not match:
-                continue
-            symbol_name = match.group(1)
-            symbol_kind = self._line_kind(line)
-            if kind and kind != symbol_kind:
-                continue
-            if query and query.lower() not in symbol_name.lower() and query.lower() not in line.lower():
-                continue
-            results.append(AstMatch(rel, language, symbol_kind, symbol_name, lineno, line.strip(), self._engine()))
-        return results
-
-    def _match_python(self, rel: str, text: str, *, query: str, kind: str | None) -> list[AstMatch]:
-        try:
-            tree = ast.parse(text)
-        except SyntaxError:
-            return []
-        lines = text.splitlines()
-        results: list[AstMatch] = []
-        for node in ast.walk(tree):
-            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                symbol_kind = "function"
-            elif isinstance(node, ast.ClassDef):
-                symbol_kind = "class"
-            else:
-                continue
-            symbol_name = node.name
-            source = lines[node.lineno - 1].strip() if 0 < node.lineno <= len(lines) else symbol_name
-            if kind and kind != symbol_kind:
-                continue
-            if query and query.lower() not in symbol_name.lower() and query.lower() not in source.lower():
-                continue
-            results.append(AstMatch(rel, "python", symbol_kind, symbol_name, node.lineno, source, self._engine()))
-        return sorted(results, key=lambda item: (item.path, item.line))
-
-    def _line_kind(self, line: str) -> str:
-        stripped = line.strip()
-        if "class " in stripped:
-            return "class"
-        if stripped.startswith(("type ", "export type ")):
-            return "type"
-        if stripped.startswith(("interface ", "export interface ")):
-            return "interface"
-        if stripped.startswith(("struct ", "pub struct ")):
-            return "struct"
-        if stripped.startswith(("enum ", "pub enum ")):
-            return "enum"
-        if stripped.startswith(("trait ", "pub trait ")):
-            return "trait"
-        return "function"
-
-    def _engine(self) -> str:
-        return "tree-sitter-optional" if self.tree_sitter_available else "fallback-ast"

package/src/devcouncil/indexing/graph_index.py

@@ -1,48 +0,0 @@
-from typing import List, Dict, Any, Set
-from pydantic import BaseModel, Field
-from pathlib import Path
-
-class GraphNode(BaseModel):
-    id: str
-    type: str # "file", "symbol", "requirement", "task"
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-
-class GraphEdge(BaseModel):
-    source: str
-    target: str
-    relation: str # "imports", "implements", "validates", "contains"
-
-class KnowledgeGraph(BaseModel):
-    nodes: List[GraphNode] = []
-    edges: List[GraphEdge] = []
-
-class GraphIndex:
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-        self.graph = KnowledgeGraph()
-
-    def build_initial_graph(self, files: List[str]):
-        """
-        Bootstrap the graph from file list.
-        """
-        for f in files:
-            self.graph.nodes.append(GraphNode(
-                id=f,
-                type="file",
-                metadata={"extension": Path(f).suffix}
-            ))
-
-    def add_relation(self, source: str, target: str, relation: str):
-        self.graph.edges.append(GraphEdge(source=source, target=target, relation=relation))
-
-    def get_context_for_file(self, file_path: str) -> Set[str]:
-        """
-        Retrieve related paths for a given file.
-        """
-        related = {file_path}
-        for edge in self.graph.edges:
-            if edge.source == file_path:
-                related.add(edge.target)
-            if edge.target == file_path:
-                related.add(edge.source)
-        return related

package/src/devcouncil/indexing/lsp.py

@@ -1,120 +0,0 @@
-from __future__ import annotations
-
-import json
-import shutil
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-
-@dataclass(frozen=True)
-class LspServerCandidate:
-    language: str
-    command: list[str]
-    available: bool
-    reason: str
-
-
-class LspInspector:
-    """Starter LSP integration focused on discovery and safe initialize payloads."""
-
-    _LANGUAGE_SERVERS: dict[str, list[list[str]]] = {
-        "python": [["pyright-langserver", "--stdio"], ["pylsp"]],
-        "typescript": [["typescript-language-server", "--stdio"]],
-        "javascript": [["typescript-language-server", "--stdio"]],
-        "go": [["gopls"]],
-        "rust": [["rust-analyzer"]],
-    }
-
-    _EXTENSIONS: dict[str, str] = {
-        ".py": "python",
-        ".ts": "typescript",
-        ".tsx": "typescript",
-        ".js": "javascript",
-        ".jsx": "javascript",
-        ".go": "go",
-        ".rs": "rust",
-    }
-    _IGNORED_DIRS = {".git", ".devcouncil", "__pycache__", ".venv", "node_modules", "dist", "build", "target", "vendor"}
-
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-
-    def _is_ignored_path(self, file: str) -> bool:
-        return any(part in self._IGNORED_DIRS for part in Path(file).parts)
-
-    def detect_languages(self, files: list[str] | None = None) -> list[str]:
-        if files is None:
-            try:
-                discovered: list[str] = []
-                for path in self.project_root.rglob("*"):
-                    if path.is_file() and not any(part in self._IGNORED_DIRS for part in path.parts):
-                        discovered.append(str(path.relative_to(self.project_root)))
-                files = discovered
-            except OSError:
-                files = []
-        languages = {
-            self._EXTENSIONS[Path(file).suffix.lower()]
-            for file in files
-            if Path(file).suffix.lower() in self._EXTENSIONS and not self._is_ignored_path(file)
-        }
-        return sorted(languages)
-
-    def server_candidates(self, files: list[str] | None = None) -> list[LspServerCandidate]:
-        candidates: list[LspServerCandidate] = []
-        for language in self.detect_languages(files):
-            for command in self._LANGUAGE_SERVERS.get(language, []):
-                executable = command[0]
-                available = shutil.which(executable) is not None
-                candidates.append(
-                    LspServerCandidate(
-                        language=language,
-                        command=command,
-                        available=available,
-                        reason="found on PATH" if available else "not found on PATH",
-                    )
-                )
-        return candidates
-
-    def initialize_request(self, language: str) -> dict[str, Any]:
-        return {
-            "jsonrpc": "2.0",
-            "id": 1,
-            "method": "initialize",
-            "params": {
-                "processId": None,
-                "rootUri": self.project_root.resolve().as_uri(),
-                "capabilities": {
-                    "textDocument": {
-                        "publishDiagnostics": {"relatedInformation": True},
-                        "definition": {"linkSupport": True},
-                        "references": {},
-                        "documentSymbol": {"hierarchicalDocumentSymbolSupport": True},
-                    },
-                    "workspace": {"symbol": {}},
-                },
-                "initializationOptions": {"language": language},
-            },
-        }
-
-    def summary(self, files: list[str] | None = None) -> dict[str, Any]:
-        candidates = self.server_candidates(files)
-        return {
-            "languages": self.detect_languages(files),
-            "servers": [
-                {
-                    "language": candidate.language,
-                    "command": candidate.command,
-                    "available": candidate.available,
-                    "reason": candidate.reason,
-                }
-                for candidate in candidates
-            ],
-            "initialize_requests": {
-                language: self.initialize_request(language)
-                for language in sorted({candidate.language for candidate in candidates})
-            },
-        }
-
-    def summary_json(self, files: list[str] | None = None) -> str:
-        return json.dumps(self.summary(files), indent=2)