devcouncil 0.2.0 → 0.2.2

package/src/devcouncil/gating/policy.py

@@ -1,338 +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]
-
-
-def _find_dependency_cycle(tasks: List[Task]) -> Optional[List[str]]:
-    """Return one dependency cycle as an id path (e.g. [A, B, A]), or None. Only edges
-    to known task ids are followed; unknown deps are reported separately."""
-    ids = {t.id for t in tasks}
-    graph = {t.id: [d for d in t.depends_on if d in ids] for t in tasks}
-    WHITE, GREY, BLACK = 0, 1, 2
-    color = {tid: WHITE for tid in graph}
-    stack: List[str] = []
-
-    def visit(node: str) -> Optional[List[str]]:
-        color[node] = GREY
-        stack.append(node)
-        for nxt in graph.get(node, []):
-            if color[nxt] == GREY:
-                return stack[stack.index(nxt):] + [nxt]
-            if color[nxt] == WHITE:
-                found = visit(nxt)
-                if found:
-                    return found
-        stack.pop()
-        color[node] = BLACK
-        return None
-
-    for tid in graph:
-        if color[tid] == WHITE:
-            found = visit(tid)
-            if found:
-                return found
-    return None
-
-
-def topological_order(tasks: List[Task]) -> List[Task]:
-    """Order tasks so every task follows the ones it depends on. Stable: preserves the
-    given order among independent tasks. Falls back to the original order if a cycle
-    makes a full ordering impossible (the plan gate blocks cycles separately)."""
-    by_id = {t.id: t for t in tasks}
-    indegree = {t.id: 0 for t in tasks}
-    dependents: dict[str, List[str]] = {t.id: [] for t in tasks}
-    for task in tasks:
-        for dep in task.depends_on:
-            if dep in by_id:
-                indegree[task.id] += 1
-                dependents[dep].append(task.id)
-    # Kahn's algorithm, seeded in original order for stability.
-    ready = [t.id for t in tasks if indegree[t.id] == 0]
-    ordered: List[str] = []
-    while ready:
-        current = ready.pop(0)
-        ordered.append(current)
-        for child in dependents[current]:
-            indegree[child] -= 1
-            if indegree[child] == 0:
-                ready.append(child)
-    if len(ordered) != len(tasks):  # cycle — fall back to original order
-        return list(tasks)
-    return [by_id[tid] for tid in ordered]
-
-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,
-                ))
-
-        # Surface read-only-only tasks at PLANNING time (advisory): a task that declares
-        # planned files but none writable can implement nothing, and was previously only
-        # caught at execution by the task-readiness gate.
-        for task in tasks:
-            if task.planned_files and not any(
-                pf.allowed_change in ("create", "modify", "delete") for pf in task.planned_files
-            ):
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{task.id}-READ-ONLY",
-                    severity="medium",
-                    gap_type="task_not_implemented",
-                    task_id=task.id,
-                    description=(
-                        f"Task {task.id} declares planned files but none are writable "
-                        "(all read_only); it cannot implement any change. Expected only if "
-                        "this is an analysis-only task."
-                    ),
-                    recommended_fix=(
-                        "Grant 'create', 'modify', or 'delete' to at least one planned file, "
-                        "or confirm the task is intentionally analysis-only."
-                    ),
-                    blocking=False,
-                ))
-
-        # Surface overlapping ownership (advisory): when 2+ tasks each declare a
-        # writable (create/modify/delete) change to the SAME file, the plan is
-        # over-decomposed — the later task tends to duplicate or conflict with the
-        # earlier one (e.g. both add the same function), which then fails per-task
-        # verification. Consolidating a file's work into one task avoids this.
-        writers_by_file: dict[str, list[str]] = {}
-        for task in tasks:
-            for pf in task.planned_files:
-                if pf.allowed_change in ("create", "modify", "delete"):
-                    path = pf.path.replace("\\", "/")
-                    writers_by_file.setdefault(path, [])
-                    if task.id not in writers_by_file[path]:
-                        writers_by_file[path].append(task.id)
-        for path, owners in writers_by_file.items():
-            if len(owners) > 1:
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-OVERLAP-{owners[0]}-{path.replace('/', '_')}",
-                    severity="medium",
-                    gap_type="task_not_implemented",
-                    description=(
-                        f"{len(owners)} tasks ({', '.join(owners)}) each declare writable "
-                        f"changes to {path}; overlapping ownership over-decomposes the plan "
-                        "and tends to cause duplicate/conflicting edits at execution."
-                    ),
-                    recommended_fix=(
-                        f"Consolidate the work on {path} into a single task, or scope the "
-                        "others to read_only."
-                    ),
-                    blocking=False,
-                ))
-
-        # Validate the task dependency DAG: unknown depends_on ids and cycles would make
-        # execution ordering impossible / stall the run, so block the plan on them.
-        gaps.extend(self._validate_task_dependencies(tasks))
-
-        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. Surface a missing execution/verification contract — but do NOT block
-        # execution on it. The executor still needs to run to implement the code,
-        # and the evidence requirement is genuinely enforced at verify time
-        # (acceptance_criteria_unproven / NOAC gaps). Blocking here only prevents
-        # implementation and stalls multi-task plans when the planner under-specs a
-        # task; these stay advisory so the work can proceed and be judged on output.
-        if not task.allowed_commands and not task.expected_tests:
-            gaps.append(Gap(
-                id=f"GAP-{task.id}-NO-COMMANDS",
-                severity="medium",
-                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 or expected_tests so verification can prove the acceptance criteria.",
-                blocking=False,
-            ))
-
-        if not task.expected_tests:
-            gaps.append(Gap(
-                id=f"GAP-{task.id}-NO-EXPECTED-EVIDENCE",
-                severity="medium",
-                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=False,
-            ))
-
-        return GateResult(
-            passed=len([g for g in gaps if g.blocking]) == 0,
-            gaps=gaps
-        )
-
-    def _validate_task_dependencies(self, tasks: List[Task]) -> List[Gap]:
-        """Block on a malformed dependency DAG: unknown depends_on ids and cycles."""
-        gaps: List[Gap] = []
-        ids = {t.id for t in tasks}
-        for task in tasks:
-            unknown = [dep for dep in task.depends_on if dep not in ids]
-            if unknown:
-                gaps.append(Gap(
-                    id=f"GAP-PLAN-{task.id}-UNKNOWN-DEP",
-                    severity="high",
-                    gap_type="task_not_implemented",
-                    task_id=task.id,
-                    description=f"Task {task.id} depends on unknown task(s): {', '.join(unknown)}.",
-                    recommended_fix="Reference only task IDs that exist in this plan, or remove the dependency.",
-                    blocking=True,
-                ))
-        cycle = _find_dependency_cycle(tasks)
-        if cycle:
-            gaps.append(Gap(
-                id="GAP-PLAN-DEP-CYCLE",
-                severity="high",
-                gap_type="task_not_implemented",
-                description=f"Task dependency cycle detected: {' -> '.join(cycle)}.",
-                recommended_fix="Break the cycle so the tasks can be ordered and executed.",
-                blocking=True,
-            ))
-        return gaps

package/src/devcouncil/hardware.py

@@ -1,184 +0,0 @@
-"""Host hardware detection used to size local (Ollama) models.
-
-DevCouncil runs the council roles against whatever LLM provider is configured.
-For the local ``ollama`` provider the model has to fit in host memory. On Apple
-Silicon Macs that memory is *unified* (shared by CPU/GPU/OS), so total RAM is the
-ceiling. On a host with a discrete GPU (NVIDIA), Ollama offloads to VRAM, so the
-*VRAM* is the practical ceiling instead — a 64 GB box with an 8 GB GPU should not be
-told to run a model that only fits in system RAM. This module exposes small, pure
-helpers so ``dev doctor`` and ``dev setup`` can recommend a model that will actually
-run instead of a one-size-fits-all default, on macOS, Linux and Windows.
-
-Everything here is best-effort and stdlib-only: detection failures return
-``None`` rather than raising, so callers degrade to the static default.
-"""
-
-from __future__ import annotations
-
-import os
-import platform
-import shutil
-import subprocess
-from dataclasses import dataclass
-
-# Recommended Ollama context window for DevCouncil's large planning prompts.
-# Kept in sync with the value surfaced by `dev doctor`.
-RECOMMENDED_NUM_CTX = 16384
-
-# Fallback model when the host is unknown or has little memory. Matches the
-# static defaults in ``llm/model_defaults.yaml``.
-DEFAULT_OLLAMA_MODEL = "qwen2.5-coder:7b"
-
-# RAM (GiB) -> recommended qwen2.5-coder size. Highest matching tier wins.
-# Sizes are chosen so the quantized weights plus a 16k context comfortably fit
-# alongside the OS in Apple Silicon unified memory.
-_OLLAMA_MODEL_TIERS: tuple[tuple[float, str], ...] = (
-    (48.0, "qwen2.5-coder:32b"),
-    (24.0, "qwen2.5-coder:14b"),
-    (0.0, "qwen2.5-coder:7b"),
-)
-
-
-def is_macos() -> bool:
-    return platform.system() == "Darwin"
-
-
-def is_apple_silicon() -> bool:
-    """True on Apple-Silicon (arm64) Macs."""
-    return is_macos() and platform.machine() == "arm64"
-
-
-def mac_chip_brand() -> str | None:
-    """Marketing CPU string on macOS (e.g. ``Apple M3 Pro``), else None."""
-    if not is_macos():
-        return None
-    try:
-        out = subprocess.check_output(
-            ["sysctl", "-n", "machdep.cpu.brand_string"],
-            text=True,
-            timeout=5,
-        ).strip()
-        return out or None
-    except Exception:
-        return None
-
-
-def total_ram_gb() -> float | None:
-    """Total physical RAM in GiB, or None if it cannot be determined."""
-    try:
-        if is_macos():
-            out = subprocess.check_output(
-                ["sysctl", "-n", "hw.memsize"], text=True, timeout=5
-            ).strip()
-            return int(out) / (1024**3)
-        # POSIX (Linux): pages * page size.
-        pages = os.sysconf("SC_PHYS_PAGES")
-        page_size = os.sysconf("SC_PAGE_SIZE")
-        return (pages * page_size) / (1024**3)
-    except (OSError, ValueError, AttributeError, subprocess.SubprocessError):
-        return None
-
-
-def nvidia_vram_gb() -> float | None:
-    """Total VRAM (GiB) of the largest NVIDIA GPU via ``nvidia-smi``, else ``None``.
-
-    On hosts with a discrete NVIDIA GPU this is the real ceiling for Ollama, since the
-    model is offloaded to VRAM. Returns ``None`` when ``nvidia-smi`` is absent (no GPU,
-    Apple Silicon, or an unsupported vendor), so callers fall back to total RAM."""
-    if not shutil.which("nvidia-smi"):
-        return None
-    try:
-        out = subprocess.check_output(
-            ["nvidia-smi", "--query-gpu=memory.total", "--format=csv,noheader,nounits"],
-            text=True,
-            timeout=5,
-            stderr=subprocess.DEVNULL,
-        ).strip()
-    except (OSError, subprocess.SubprocessError):
-        return None
-    sizes_mib: list[float] = []
-    for line in out.splitlines():
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            sizes_mib.append(float(line))
-        except ValueError:
-            continue
-    if not sizes_mib:
-        return None
-    return max(sizes_mib) / 1024.0  # MiB -> GiB
-
-
-def recommend_ollama_model(ram_gb: float | None = None, vram_gb: float | None = None) -> str:
-    """Largest qwen2.5-coder size expected to run on the host.
-
-    When a discrete GPU's ``vram_gb`` is known it is the ceiling (Ollama offloads to
-    VRAM); otherwise total system RAM is used (correct for unified-memory Macs and
-    CPU-only hosts)."""
-    if ram_gb is None:
-        ram_gb = total_ram_gb()
-    effective = vram_gb if vram_gb is not None else ram_gb
-    if effective is None:
-        return DEFAULT_OLLAMA_MODEL
-    for floor, model in _OLLAMA_MODEL_TIERS:
-        if effective >= floor:
-            return model
-    return DEFAULT_OLLAMA_MODEL
-
-
-@dataclass(frozen=True)
-class HostSummary:
-    """A snapshot of the host relevant to local-model sizing."""
-
-    is_macos: bool
-    is_apple_silicon: bool
-    chip: str | None
-    ram_gb: float | None
-    recommended_ollama_model: str
-    vram_gb: float | None = None
-
-    @property
-    def ram_label(self) -> str:
-        return f"{self.ram_gb:.0f} GB" if self.ram_gb is not None else "unknown RAM"
-
-    @property
-    def vram_label(self) -> str | None:
-        return f"{self.vram_gb:.0f} GB VRAM" if self.vram_gb is not None else None
-
-    @property
-    def chip_label(self) -> str:
-        if self.chip:
-            return self.chip
-        if self.is_apple_silicon:
-            return "Apple Silicon"
-        if self.vram_gb is not None:
-            return "discrete GPU host"
-        return "this host"
-
-    @property
-    def platform_label(self) -> str:
-        """Human label for the sizing row across OSes."""
-        if self.is_macos:
-            return "Apple Silicon" if self.is_apple_silicon else "Mac (Intel)"
-        system = platform.system()
-        return system or "Host"
-
-    @property
-    def memory_label(self) -> str:
-        """Memory ceiling used for the recommendation (VRAM if discrete GPU, else RAM)."""
-        vram = self.vram_label
-        return f"{vram} (GPU)" if vram else self.ram_label
-
-
-def describe_host() -> HostSummary:
-    ram = total_ram_gb()
-    vram = nvidia_vram_gb()
-    return HostSummary(
-        is_macos=is_macos(),
-        is_apple_silicon=is_apple_silicon(),
-        chip=mac_chip_brand(),
-        ram_gb=ram,
-        vram_gb=vram,
-        recommended_ollama_model=recommend_ollama_model(ram, vram),
-    )

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  # type: ignore[import-not-found]  # 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"