patchi 0.7.5__py3-none-any.whl

patchi/core/brain/reasoning.py

@@ -0,0 +1,269 @@
+"""
+Reasoning Engine — Phase 3 of the Patchi super-agent.
+
+Sits *above* the Layered Brain and turns it into answers.  Given a change-set, a
+file, or a natural-language question, it reasons over the cached layer summaries
+(never re-reading raw source) and produces structured, human-readable output:
+
+    - impact_analysis(changed_files) → blast radius across layers
+    - explain(target)                → a layer's summary + its dependency context
+    - why(path)                      → why a file matters (dependents, purpose)
+    - ask(question)                  → NL answer built from layer summaries
+
+Everything is offline-safe (pure heuristics over the Layered Brain).  If an LLM
+is configured, :meth:`ReasoningEngine.ask` can optionally enrich the answer.
+
+This module is additive: it only reads the Layered Brain persisted at
+``.patchi/memory/layers.json`` and existing ``layered_brain`` helpers.
+"""
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from patchi.core.brain.brain_watcher import ChangeSet, affected_layers
+from patchi.core.brain.layered_brain import (
+    find_layers_for_file,
+    get_layer_context,
+    layers_from_dict,
+)
+
+_log = logging.getLogger("patchi.brain.reasoning")
+
+if TYPE_CHECKING:
+    from patchi.core.brain.layered_brain import Layer
+
+
+@dataclass
+class ImpactAnalysis:
+    """Structured result of reasoning about a change-set."""
+
+    changed_files: list[str] = field(default_factory=list)
+    affected_layers: list[str] = field(default_factory=list)  # directly touched
+    impacted_layers: list[str] = field(default_factory=list)  # blast radius (dependents)
+    summary: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "changed_files": self.changed_files,
+            "affected_layers": self.affected_layers,
+            "impacted_layers": self.impacted_layers,
+            "summary": self.summary,
+        }
+
+
+class ReasoningEngine:
+    """Answers questions using the cached Layered Brain (no raw-source reads)."""
+
+    def __init__(self, root: Path):
+        self.root = Path(root)
+        self.layers: dict[str, Layer] = self._load_layers()
+
+    def _load_layers(self) -> dict[str, Layer]:
+        from patchi.core import memory as mem
+
+        data = mem.get_layers(self.root) or {}
+        if not data.get("layers"):
+            return {}
+        return layers_from_dict(data)
+
+    # ── Impact analysis (blast radius) ──────────────────────────────────────────
+
+    def impact_analysis(self, changed_files: list[str]) -> ImpactAnalysis:
+        if not self.layers:
+            return ImpactAnalysis(
+                changed_files=changed_files,
+                summary="No layered brain available. Run `p scan` first to build it.",
+            )
+
+        changes = ChangeSet(changed=set(changed_files))
+        affected = affected_layers(changes, self.layers)
+
+        # Blast radius: transitively follow dependents of every affected layer.
+        impacted: set[str] = set()
+        stack = list(affected)
+        while stack:
+            cur = stack.pop()
+            layer = self.layers.get(cur)
+            if not layer:
+                continue
+            for dep in layer.dependents:
+                if dep in self.layers and dep not in impacted:
+                    impacted.add(dep)
+                    stack.append(dep)
+
+        blast = impacted - affected
+        summary = self._impact_summary(changed_files, affected, blast)
+        return ImpactAnalysis(
+            changed_files=changed_files,
+            affected_layers=sorted(affected),
+            impacted_layers=sorted(blast),
+            summary=summary,
+        )
+
+    def _impact_summary(self, changed, affected, blast) -> str:
+        if not changed:
+            return "No changes provided."
+        parts = [f"{len(changed)} file(s) changed"]
+        if affected:
+            parts.append(
+                f"{len(affected)} layer(s) directly affected: {', '.join(sorted(affected))}"
+            )
+        if blast:
+            parts.append(
+                f"{len(blast)} downstream layer(s) in the blast radius: {', '.join(sorted(blast))}"
+            )
+        else:
+            parts.append("no downstream layers depend on the changed code")
+        return "; ".join(parts) + "."
+
+    # ── Explain a layer / file ───────────────────────────────────────────────────
+
+    def explain(self, target: str) -> dict:
+        """Return a layer's summary plus its direct dependency context.
+
+        ``target`` may be a file path or a layer name.
+        """
+        if not self.layers:
+            return {"error": "No layered brain available. Run `p scan` first."}
+
+        # Resolve to a layer name.
+        if target in self.layers:
+            layer_name = target
+        else:
+            matches = find_layers_for_file(self.layers, target)
+            if not matches:
+                return {"error": f"No layer found for '{target}'."}
+            layer_name = matches[0]
+
+        layer = self.layers[layer_name]
+        context = get_layer_context(self.layers, layer_name, max_depth=1)
+        return {
+            "layer": layer_name,
+            "level": layer.level,
+            "summary": layer.summary,
+            "purpose": layer.purpose,
+            "depends_on": layer.depends_on,
+            "dependents": layer.dependents,
+            "context": {k: v for k, v in context.items() if k != layer_name},
+        }
+
+    # ── Why does a file matter ───────────────────────────────────────────────────
+
+    def why(self, path: str) -> dict:
+        """Explain why a file matters: its layer, dependents, and purpose."""
+        if not self.layers:
+            return {"error": "No layered brain available. Run `p scan` first."}
+
+        matches = find_layers_for_file(self.layers, path)
+        if not matches:
+            return {"error": f"'{path}' is not part of any known layer."}
+
+        layer_name = matches[0]
+        layer = self.layers[layer_name]
+        dependents = layer.dependents
+        importance = "critical" if dependents else ("shared" if len(layer.files) > 1 else "leaf")
+        return {
+            "file": path,
+            "layer": layer_name,
+            "layer_summary": layer.summary,
+            "purpose": layer.purpose,
+            "depended_on_by": dependents,
+            "importance": importance,
+            "files_in_layer": len(layer.files),
+        }
+
+    # ── Natural-language问答 (TF-IDF over layers + body_tags, LLM optional) ─
+
+    def ask(self, question: str, use_ai: bool = False, ask_ai: bool | None = None, **_) -> str:
+        """Answer a question from layer summaries. TF-IDF ranked, optionally LLM-synthesized.
+
+        Spec L3: RAG over cached layers[].summary built at scan time (layers.json rag_index),
+        query via cosine, ask_ai=True wraps RAG context + call_ai. use_ai is alias for backward compat.
+        """
+        if ask_ai is not None:
+            use_ai = bool(ask_ai)
+        if not self.layers:
+            return (
+                "I don't have a brain-map of this project yet. "
+                "Run `p scan` to build the layered brain, then ask again."
+            )
+
+        q = question.lower()
+        tokens = {t for t in re.findall(r"[a-z0-9_]+", q) if len(t) > 2}
+        if not tokens:
+            return "Could you rephrase? Try naming a subsystem (auth, api, data, ui…)."
+
+        # Try understander/body_tags boost if available
+        body_boost: dict[str, float] = {}
+        try:
+            from patchi.core.brain.body_tags import load_body_tags
+
+            tags = load_body_tags(self.root)
+            for _path, tag in tags.items():
+                layer_hint = tag.get("layer", "")
+                if layer_hint:
+                    body_boost[layer_hint] = max(body_boost.get(layer_hint, 0), float(tag.get("score", 0)) / 100.0)
+        except Exception:
+            body_boost = {}
+
+        # TF-IDF-ish: term freq * inverse doc freq approximation
+        doc_freq: dict[str, int] = {}
+        for t in tokens:
+            df = sum(1 for n, layer in self.layers.items() if t in f"{n} {layer.summary} {layer.purpose}".lower())
+            doc_freq[t] = max(1, df)
+        import math
+
+        scored: list[tuple[float, str, Layer]] = []
+        for name, layer in self.layers.items():
+            if layer.level == 4:
+                continue
+            text = f"{name} {layer.summary} {layer.purpose}".lower()
+            tfidf = 0.0
+            for t in tokens:
+                if t in text:
+                    tf = text.count(t)
+                    idf = math.log(len(self.layers) / doc_freq[t] + 1)
+                    tfidf += tf * idf
+            tfidf += body_boost.get(name, 0.0)
+            if tfidf > 0:
+                scored.append((tfidf, name, layer))
+
+        if not scored:
+            return (
+                "I couldn't match that to any layer I know. "
+                "Known layers: "
+                + ", ".join(sorted(n for n in self.layers if n != "__project__"))
+                + "."
+            )
+
+        scored.sort(key=lambda x: x[0], reverse=True)
+        top = scored[:3]
+        if use_ai:
+            try:
+                import os
+
+                if not os.environ.get("PATCHI_OFFLINE"):
+                    from patchi.core import config as cfg
+                    from patchi.core.ai.client import call_ai
+
+                    cfgd = cfg.load(self.root) if hasattr(cfg, "load") else {}
+                    ctx = "\n".join(f"[{n}] {lay.summary} — {lay.purpose}" for _, n, lay in top)
+                    ans = call_ai(cfgd, "You are Patchi understander. Answer from layered brain context.", f"Question: {question}\n\nContext:\n{ctx}", max_tokens=400)
+                    if ans:
+                        return ans
+            except Exception as _exc:
+                _log.debug("reasoning AI synthesis fallback: %s", _exc)
+        lines = [f"Based on the layered brain, here's what I know about '{question.strip()}':", ""]
+        for _, name, layer in top:
+            lines.append(f"[bold]{name}[/bold] ({_level_name(layer.level)}): {layer.summary}")
+        lines.append("")
+        lines.append("[dim]Answers are derived from cached layer summaries + body_tags ranking.[/dim]")
+        return "\n".join(lines)
+
+
+def _level_name(level: int) -> str:
+    return {1: "module", 2: "subsystem", 4: "project"}.get(level, f"L{level}")

patchi/core/brain/route_detector/__init__.py

@@ -0,0 +1,15 @@
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import (
+    _DETECTOR_REGISTRY,
+    detect_routes,
+    get_detector,
+    register_detector,
+)
+
+__all__ = [
+    "BaseRouteDetector",
+    "detect_routes",
+    "get_detector",
+    "register_detector",
+    "_DETECTOR_REGISTRY",
+]

patchi/core/brain/route_detector/base.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+
+
+class BaseRouteDetector(ABC):
+    @abstractmethod
+    def detect(self, content: str, file_path: str) -> list[dict]: ...
+
+    def _make_route(
+        self,
+        method: str,
+        path: str,
+        handler: str,
+        file_path: str,
+        line: int,
+        framework: str = "",
+        middleware: list[str] | None = None,
+        auth_required: bool | None = None,
+    ) -> dict:
+        return {
+            "method": method,
+            "path": path,
+            "handler": handler,
+            "file": file_path,
+            "line": line,
+            "middleware": middleware or [],
+            "auth_required": auth_required,
+            "framework": framework,
+        }
+
+    def _path_from_parts(self, parts: list[str]) -> str:
+        return "/" + "/".join(parts).replace("[", ":").replace("]", "")

patchi/core/brain/route_detector/csharp.py

@@ -0,0 +1,209 @@
+"""
+C# route detector — ASP.NET Core attribute-based routing.
+
+Node types below (attribute, attribute_list, attribute_argument_list,
+attribute_argument, method_declaration, class_declaration) were verified
+directly against the installed tree-sitter-c-sharp grammar, not assumed from
+generic documentation — including that both `method_declaration` and
+`attribute` expose a reliable `name` field via child_by_field_name, which is
+what this walker relies on instead of guessing child position.
+"""
+
+import logging
+import re
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+from patchi.core.brain.route_detector.registry import register_detector
+
+_log = logging.getLogger("patchi.brain.csharp")
+
+_HTTP_ATTRS = {
+    "httpget": "GET",
+    "httppost": "POST",
+    "httpput": "PUT",
+    "httpdelete": "DELETE",
+    "httppatch": "PATCH",
+    "httphead": "HEAD",
+    "httpoptions": "OPTIONS",
+}
+
+
+@register_detector("c_sharp")
+class CSharpRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes = self._detect_ts(content, file_path)
+        if routes:
+            return routes
+        return self._detect_fallback(content, file_path)
+
+    def _detect_ts(self, content: str, file_path: str) -> list[dict] | None:
+        try:
+            from patchi.core.brain.languages import Lang, get_parser
+
+            parser = get_parser(Lang.C_SHARP)
+            if parser is None:
+                return None
+            tree = parser.parse(content.encode("utf-8"))
+        except Exception as e:
+            _log.warning("CSharpRouteDetector._detect_ts failed: %s", e)
+            return None
+
+        routes: list[dict] = []
+        self._walk(tree.root_node, content, file_path, routes)
+        return routes
+
+    def _walk(self, node: object, content: str, file_path: str, routes: list[dict]) -> None:
+        ntype = getattr(node, "type", "")
+        if ntype == "method_declaration":
+            self._check_method(node, content, file_path, routes)
+        for child in getattr(node, "children", []):
+            self._walk(child, content, file_path, routes)
+
+    def _check_method(
+        self, method_node: object, content: str, file_path: str, routes: list[dict]
+    ) -> None:
+        http_method = None
+        route_suffix = ""
+        method_auth = False
+
+        for child in getattr(method_node, "children", []):
+            if child.type != "attribute_list":
+                continue
+            for attr in getattr(child, "children", []):
+                if attr.type != "attribute":
+                    continue
+                name = self._attr_name(attr, content).lower()
+                if name in _HTTP_ATTRS:
+                    http_method = _HTTP_ATTRS[name]
+                    route_suffix = self._attr_string_arg(attr, content)
+                elif name == "route" and http_method is None:
+                    http_method = "ANY"
+                    route_suffix = self._attr_string_arg(attr, content)
+                elif name in ("authorize",):
+                    method_auth = True
+
+        if http_method is None:
+            return
+
+        class_prefix, class_auth = self._enclosing_class_context(method_node, content)
+        path = self._combine_path(class_prefix, route_suffix)
+
+        name_node = (
+            method_node.child_by_field_name("name")
+            if hasattr(method_node, "child_by_field_name")
+            else None
+        )
+        handler = self._node_text(name_node, content) if name_node else ""
+        line = getattr(method_node, "start_point", (0, 0))[0] + 1
+
+        auth = method_auth or class_auth
+        routes.append(
+            self._make_route(
+                http_method,
+                path,
+                handler,
+                file_path,
+                line,
+                framework="ASP.NET Core",
+                auth_required=auth if auth else None,
+            )
+        )
+
+    def _enclosing_class_context(self, node: object, content: str) -> tuple[str, bool]:
+        """Walk up to the enclosing class_declaration for its [Route] prefix and [Authorize]."""
+        cur = node
+        for _ in range(10):
+            cur = getattr(cur, "parent", None)
+            if cur is None:
+                break
+            if getattr(cur, "type", "") == "class_declaration":
+                prefix = ""
+                auth = False
+                for child in getattr(cur, "children", []):
+                    if child.type != "attribute_list":
+                        continue
+                    for attr in getattr(child, "children", []):
+                        if attr.type != "attribute":
+                            continue
+                        name = self._attr_name(attr, content).lower()
+                        if name == "route":
+                            prefix = self._attr_string_arg(attr, content)
+                        elif name == "authorize":
+                            auth = True
+                return prefix, auth
+        return "", False
+
+    def _combine_path(self, prefix: str, suffix: str) -> str:
+        # [controller] is ASP.NET's token substitution for the class name minus
+        # "Controller" -- approximated here rather than resolved exactly, since
+        # getting it exact requires the class name, which is a reasonable
+        # follow-up refinement rather than a blocker for a first working version.
+        parts = [p.strip("/") for p in (prefix, suffix) if p]
+        return "/" + "/".join(parts) if parts else ""
+
+    def _attr_name(self, attr_node: object, content: str) -> str:
+        name_node = (
+            attr_node.child_by_field_name("name")
+            if hasattr(attr_node, "child_by_field_name")
+            else None
+        )
+        return self._node_text(name_node, content) if name_node else ""
+
+    def _attr_string_arg(self, attr_node: object, content: str) -> str:
+        for child in getattr(attr_node, "children", []):
+            if child.type != "attribute_argument_list":
+                continue
+            for arg in getattr(child, "children", []):
+                if arg.type == "attribute_argument":
+                    for lit in getattr(arg, "children", []):
+                        if lit.type == "string_literal":
+                            return self._node_text(lit, content).strip('"')
+        return ""
+
+    def _node_text(self, node: object, content: str) -> str:
+        try:
+            return content[node.start_byte : node.end_byte]
+        except Exception as e:
+            _log.debug("CSharpRouteDetector._node_text failed: %s", e)
+            return ""
+
+    def _detect_fallback(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        verb_names = "|".join(_HTTP_ATTRS)
+        pat = re.compile(rf'\[({verb_names}|Route)(?:\("([^"]*)"\))?\]', re.IGNORECASE)
+        auth_pat = re.compile(r"\[Authorize\]", re.IGNORECASE)
+
+        lines = content.splitlines()
+        for i, line in enumerate(lines, 1):
+            m = pat.search(line)
+            if not m:
+                continue
+            verb_raw = m.group(1).lower()
+            method = _HTTP_ATTRS.get(verb_raw, "ANY")
+            path = "/" + (m.group(2) or "").strip("/")
+
+            handler = ""
+            for j in range(i, min(i + 5, len(lines) + 1)):
+                hm = re.search(
+                    r"\b(?:public|private|protected)\s+\w+(?:<[\w,\s]+>)?\s+(\w+)\s*\(",
+                    lines[j - 1],
+                )
+                if hm:
+                    handler = hm.group(1)
+                    break
+
+            ctx = "\n".join(lines[max(0, i - 5) : i])
+            auth = bool(auth_pat.search(ctx))
+
+            routes.append(
+                self._make_route(
+                    method,
+                    path,
+                    handler,
+                    file_path,
+                    i,
+                    framework="ASP.NET Core",
+                    auth_required=auth if auth else None,
+                )
+            )
+        return routes

patchi/core/brain/route_detector/file_based.py

@@ -0,0 +1,81 @@
+import re
+from pathlib import PurePosixPath
+
+from patchi.core.brain.route_detector.base import BaseRouteDetector
+
+
+class NextJsRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        p = PurePosixPath(file_path)
+        parts = p.parts
+
+        if "pages" in parts and "api" in parts:
+            idx = parts.index("pages")
+            path_parts = parts[idx + 1 :]
+            url_path = "/" + "/".join(path_parts).replace("[", ":").replace("]", "")
+            url_path = re.sub(r"\.(?:js|ts|jsx|tsx)$", "", url_path)
+            if url_path.endswith("/index"):
+                url_path = url_path[:-6] or "/"
+            routes.append(
+                self._make_route("ANY", url_path, p.stem, file_path, 1, framework="Next.js")
+            )
+
+        elif "app" in parts and p.stem in ("route", "page"):
+            idx = parts.index("app")
+            path_parts = [x for x in parts[idx + 1 : -1] if not x.startswith("(")]
+            url_path = "/" + "/".join(path_parts).replace("[", ":").replace("]", "")
+            if not url_path:
+                url_path = "/"
+            routes.append(
+                self._make_route(
+                    "ANY" if p.stem == "route" else "GET",
+                    url_path,
+                    p.stem,
+                    file_path,
+                    1,
+                    framework="Next.js",
+                )
+            )
+
+        return routes
+
+
+class NuxtRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        p = PurePosixPath(file_path)
+        if "pages" not in p.parts:
+            return routes
+
+        idx = p.parts.index("pages")
+        path_parts = list(p.parts[idx + 1 :])
+        stem = PurePosixPath(path_parts[-1]).stem if path_parts else ""
+        path_parts[-1] = stem
+        url_path = "/" + "/".join(path_parts).replace("[", ":").replace("]", "")
+        if url_path.endswith("/index"):
+            url_path = url_path[:-6] or "/"
+        routes.append(self._make_route("GET", url_path, stem, file_path, 1, framework="Nuxt"))
+        return routes
+
+
+class SvelteKitRouteDetector(BaseRouteDetector):
+    def detect(self, content: str, file_path: str) -> list[dict]:
+        routes: list[dict] = []
+        p = PurePosixPath(file_path)
+        if "routes" not in p.parts:
+            return routes
+
+        idx = p.parts.index("routes")
+        path_parts = [x for x in p.parts[idx + 1 : -1] if not x.startswith("(")]
+        url_path = "/" + "/".join(path_parts).replace("[", ":").replace("]", "")
+        if not url_path:
+            url_path = "/"
+
+        method = (
+            "ANY" if (p.name.endswith("+server.ts") or p.name.endswith("+server.js")) else "GET"
+        )
+        routes.append(
+            self._make_route(method, url_path, p.stem, file_path, 1, framework="SvelteKit")
+        )
+        return routes