devcouncil 0.1.0 → 0.1.1

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

@@ -1,26 +1,26 @@
-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
+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 +1,34 @@
-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
+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,161 +1,161 @@
-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
-        )
-
+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))
-        
+        
+        # 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))
 
@@ -186,5 +186,5 @@ class GatePolicy:
         
         return GateResult(
             passed=len([g for g in gaps if g.blocking]) == 0, 
-            gaps=gaps
-        )
+            gaps=gaps
+        )

package/src/devcouncil/indexing/__init__.py

@@ -1 +1 @@
-
+

package/src/devcouncil/indexing/ast_matcher.py

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