@guanlin4924/devflow-pi 0.1.77 → 0.1.78

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/registry.py

@@ -1,3 +1,4 @@
+from .capabilities import load_capability_manifest
 from .generic_text import GenericTextAdapter
 from .go_ast import GoAstAdapter
 from .java_ast import JavaAstAdapter
@@ -5,37 +6,11 @@ from .native_process import UnavailableNativeAdapter
 from .php_ast import PhpAstAdapter
 from .python_ast import PythonAstAdapter
 from .structured_scope import StructuredScopeAdapter
+from .tree_sitter_wasm import TreeSitterWasmAdapter
 from .typescript_ast import TypeScriptAstAdapter
 
 
-UNAVAILABLE_NATIVE = {
-    "ruby": ("prism-ast", "Ruby Prism integration is not installed"),
-    "rust": ("rust-analyzer-ast", "rust-analyzer/syn integration is not installed"),
-    "kotlin": ("kotlin-psi-ast", "Kotlin PSI/compiler integration is not installed"),
-    "c": ("clang-ast", "Clang libTooling integration is not installed"),
-    "cpp": ("clang-ast", "Clang libTooling integration is not installed"),
-    "csharp": ("roslyn-ast", "Roslyn integration is not installed"),
-    "swift": ("swift-syntax-ast", "SwiftSyntax integration is not installed"),
-    "dart": ("dart-analyzer-ast", "Dart analyzer integration is not installed"),
-    "scala": ("scalameta-ast", "Scalameta integration is not installed"),
-    "lua": ("tree-sitter-lua-ast", "tree-sitter-lua integration is not installed"),
-    "shell": ("tree-sitter-bash-ast", "tree-sitter-bash integration is not installed"),
-    "vue": ("vue-compiler-ast", "Vue compiler integration is not installed"),
-    "svelte": ("svelte-compiler-ast", "Svelte compiler integration is not installed"),
-    "sql": ("sqlglot-ast", "SQLGlot integration is not installed"),
-    "html": ("html-parser-ast", "HTML syntax adapter is not installed"),
-    "css": ("postcss-ast", "PostCSS integration is not installed"),
-    "json": ("json-syntax-tree", "JSON syntax adapter is not installed"),
-    "yaml": ("yaml-syntax-tree", "YAML syntax adapter is not installed"),
-    "toml": ("toml-syntax-tree", "TOML syntax adapter is not installed"),
-    "xml": ("xml-syntax-tree", "XML syntax adapter is not installed"),
-    "graphql": ("graphql-ast", "GraphQL parser integration is not installed"),
-    "protobuf": ("protobuf-parser-ast", "Protobuf parser integration is not installed"),
-    "hcl": ("hcl-parser-ast", "HCL parser integration is not installed"),
-    "terraform": ("hcl-parser-ast", "HCL parser integration is not installed"),
-    "dockerfile": ("dockerfile-parser-ast", "Dockerfile parser integration is not installed"),
-    "markdown": ("markdown-parser-ast", "Markdown syntax adapter is not installed"),
-}
+CAPABILITY_MANIFEST = load_capability_manifest()
 
 
 class AdapterRegistry:
@@ -61,9 +36,16 @@ class AdapterRegistry:
             "ruby", "rust", "kotlin", "c", "cpp", "csharp", "swift",
             "dart", "scala", "lua", "shell", "vue", "svelte",
         }
-        for language, (expected, reason) in UNAVAILABLE_NATIVE.items():
+        for language, declaration in CAPABILITY_MANIFEST["languages"].items():
+            if language in self.language_adapters:
+                continue
+            expected = declaration["parser"]
+            reason = declaration.get("todo") or f"{expected} integration is not installed"
             fallback = self.structured if language in structured_languages else self.generic
-            self.language_adapters[language] = UnavailableNativeAdapter(language, expected, fallback, reason)
+            if declaration.get("strategy") == "tree-sitter-wasm":
+                self.language_adapters[language] = TreeSitterWasmAdapter(language, fallback)
+            else:
+                self.language_adapters[language] = UnavailableNativeAdapter(language, expected, fallback, reason)
 
     def adapter_for_file(self, codebase, file_record):
         language = file_record.get("language")
@@ -76,7 +58,14 @@ class AdapterRegistry:
         return [self.adapter_for_file(codebase, {"language": self._language(path)}) for path in files]
 
     def capabilities(self):
-        return {language: adapter.capability() for language, adapter in sorted(self.language_adapters.items())}
+        capabilities = {}
+        for language, adapter in sorted(self.language_adapters.items()):
+            declaration = dict(CAPABILITY_MANIFEST["languages"].get(language, {}))
+            runtime = adapter.capability()
+            declaration["declaredStatus"] = declaration.pop("status", "unknown")
+            declaration.update(runtime)
+            capabilities[language] = declaration
+        return capabilities
 
     @staticmethod
     def _language(path):

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/tree_sitter_wasm.py

@@ -0,0 +1,253 @@
+"""Optional Tree-sitter WASM adapter.
+
+The indexer remains usable without a grammar bundle.  In that case this
+adapter deliberately returns the configured fallback and a diagnostic; it
+never labels lexical facts as Tree-sitter facts.  A grammar is supplied by the
+runtime (or DEVFLOW_TREE_SITTER_WASM_GRAMMAR_<LANG>) so the npm package does
+not silently depend on a machine-specific native installation.
+"""
+
+import json
+import hashlib
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Dict, Tuple
+
+from adapters.base import Adapter, ParseResult
+from adapters.capabilities import load_capability_manifest
+from adapters.generic_text import _relation, _symbol
+
+
+HELPER = Path(__file__).resolve().parent / "helpers" / "tree_sitter_wasm_helper.mjs"
+
+
+class TreeSitterWasmAdapter(Adapter):
+    name = "tree-sitter-wasm"
+
+    def __init__(self, language: str, fallback: Adapter):
+        self.language = language
+        self.fallback = fallback
+        self.declaration = load_capability_manifest()["languages"].get(language, {})
+        self._availability: Tuple[bool, str] | None = None
+
+    def version(self) -> str:
+        return str(self.declaration.get("adapter_version", 1))
+
+    @property
+    def parser_id(self) -> str:
+        grammar = self.declaration.get("grammar", {}).get("id", self.language)
+        return f"tree-sitter-wasm:{grammar}@{self.version()}"
+
+    def parser_for_file(self, codebase, file_record) -> str:
+        available, _ = self._availability_for(codebase)
+        return self.parser_id if available else self.fallback.parser_for_file(codebase, file_record)
+
+    def check_available(self, codebase=None) -> Tuple[bool, str]:
+        grammar = self._grammar_path(codebase)
+        if not grammar:
+            return False, "Tree-sitter WASM grammar is not configured"
+        pin = self._grammar_pin()
+        if not pin["version"] or not pin["sha256"]:
+            return False, "Tree-sitter WASM grammar is unpinned; configure version and sha256"
+        actual_hash = self._sha256(grammar)
+        expected_hash = pin["sha256"].removeprefix("sha256:").lower()
+        if actual_hash != expected_hash:
+            return False, f"Tree-sitter WASM grammar hash mismatch: expected {expected_hash}, got {actual_hash}"
+        runtime = self._runtime()
+        if runtime is None:
+            return False, "Node/Bun runtime is not available"
+        if not self._module_available(runtime):
+            return False, "web-tree-sitter module is not importable"
+        if not HELPER.is_file():
+            return False, "Tree-sitter WASM helper is missing"
+        return True, f"Tree-sitter WASM grammar available: {grammar} ({pin['version']}, sha256:{actual_hash})"
+
+    def capability(self) -> Dict:
+        available, reason = self._availability_for(None)
+        grammar = dict(self.declaration.get("grammar", {}))
+        return {
+            "parser": self.parser_id,
+            "strategy": "tree-sitter-wasm",
+            "native": False,
+            "available": available,
+            "status": "implemented" if available else "parser_unavailable",
+            "support_level": "supported" if available else ("unpinned" if self._grammar_path(None) else "parser_unavailable"),
+            "pin": self._grammar_pin(),
+            "reason": reason,
+            "grammar": grammar,
+            "fallback": self.fallback.parser_id,
+            "scope": "Tree-sitter WASM syntax tree; framework semantics remain a separate linker stage",
+        }
+
+    def parse_file(self, codebase, file_record, text) -> ParseResult:
+        if file_record.get("language") != self.language:
+            return self.fallback.parse_file(codebase, file_record, text)
+        available, reason = self._availability_for(codebase)
+        if not available:
+            result = self.fallback.parse_file(codebase, file_record, text)
+            result.diagnostics.append({
+                "codebase": codebase.name,
+                "path": file_record["path"],
+                "line": 1,
+                "severity": "warning",
+                "kind": "parser_unavailable",
+                "message": f"Tree-sitter WASM unavailable for {self.language}; fallback used: {reason}",
+                "parser": self.parser_id,
+                "metadata": {"support_level": "parser_unavailable", "fallback_parser": self.fallback.parser_id},
+            })
+            return result
+        try:
+            payload = self._parse(codebase, file_record, text)
+        except Exception as error:
+            result = self.fallback.parse_file(codebase, file_record, text)
+            result.diagnostics.append({
+                "codebase": codebase.name, "path": file_record["path"], "line": 1,
+                "severity": "error", "kind": "parse_failed",
+                "message": f"Tree-sitter WASM parse failed; fallback used: {error}",
+                "parser": self.parser_id,
+            })
+            return result
+        return self._convert(codebase, file_record, text, payload)
+
+    def _availability_for(self, codebase=None):
+        # A grammar/runtime is global for a scan.  Codebase-specific grammar
+        # overrides are intentionally checked only when parsing that codebase.
+        if codebase is not None:
+            return self.check_available(codebase)
+        if self._availability is None:
+            self._availability = self.check_available(None)
+        return self._availability
+
+    def _grammar_path(self, codebase=None):
+        key = f"DEVFLOW_TREE_SITTER_WASM_GRAMMAR_{self.language.upper().replace('-', '_')}"
+        configured = os.environ.get(key) or self.declaration.get("grammar", {}).get("path")
+        if configured:
+            path = Path(configured)
+            if not path.is_absolute() and codebase is not None:
+                path = Path(codebase.root) / path
+            return str(path.resolve()) if path.is_file() else None
+        package = self.declaration.get("grammar", {}).get("package")
+        package_path = self._resolve_package_grammar(package) if package else None
+        return package_path
+
+    @staticmethod
+    def _resolve_package_grammar(package):
+        """Resolve a declared npm grammar without downloading at runtime.
+
+        The package is an installation-time dependency.  Searching the
+        workspace and adapter ancestors keeps this working from both a
+        checkout and an installed plugin while ensuring no network fallback
+        can occur during indexing.
+        """
+        if not package:
+            return None
+        roots = [Path.cwd(), Path(__file__).resolve()]
+        seen = set()
+        for root in roots:
+            for candidate in [root, *root.parents]:
+                package_root = candidate / "node_modules" / package
+                candidates = [package_root / "grammar.wasm"]
+                if package_root.is_dir():
+                    candidates.extend(sorted(package_root.glob("*.wasm")))
+                for node_modules in candidates:
+                    key = str(node_modules)
+                    if key in seen:
+                        continue
+                    seen.add(key)
+                    if node_modules.is_file():
+                        return str(node_modules.resolve())
+        return None
+
+    def _grammar_pin(self):
+        grammar = self.declaration.get("grammar", {})
+        prefix = f"DEVFLOW_TREE_SITTER_GRAMMAR_{self.language.upper().replace('-', '_')}"
+        return {
+            "version": os.environ.get(f"{prefix}_VERSION") or grammar.get("version"),
+            "sha256": os.environ.get(f"{prefix}_SHA256") or grammar.get("sha256"),
+        }
+
+    @staticmethod
+    def _sha256(path):
+        digest = hashlib.sha256()
+        with Path(path).open("rb") as handle:
+            for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+                digest.update(chunk)
+        return digest.hexdigest()
+
+    @staticmethod
+    def _module_available(runtime):
+        # Probe the module before claiming availability.  The helper import is
+        # deliberately not the first place this is discovered: otherwise the
+        # snapshot would advertise a parser which only fails per file.
+        try:
+            probe = subprocess.run(
+                [runtime, "--input-type=module", "-e",
+                 "import('web-tree-sitter').then(()=>process.exit(0)).catch(()=>process.exit(1))"],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                timeout=5, check=False,
+            )
+        except (OSError, subprocess.TimeoutExpired):
+            return False
+        return probe.returncode == 0
+
+    @staticmethod
+    def _runtime():
+        configured = os.environ.get("DEVFLOW_TREE_SITTER_WASM_RUNTIME")
+        if configured:
+            return configured if shutil.which(configured) else None
+        return shutil.which("bun") or shutil.which("node")
+
+    def _parse(self, codebase, record, text):
+        runtime = self._runtime()
+        grammar = self._grammar_path(codebase)
+        max_bytes = int(os.environ.get("DEVFLOW_TREE_SITTER_WASM_MAX_BYTES", str(2 * 1024 * 1024)))
+        source_bytes = len(text.encode("utf-8"))
+        if source_bytes > max_bytes:
+            raise RuntimeError(f"source exceeds Tree-sitter WASM limit ({source_bytes} > {max_bytes} bytes)")
+        timeout = float(os.environ.get("DEVFLOW_TREE_SITTER_WASM_TIMEOUT", "10"))
+        proc = subprocess.run(
+            [runtime, str(HELPER), grammar],
+            input=json.dumps({"path": record["path"], "source": text}, ensure_ascii=False) + "\n",
+            text=True, encoding="utf-8", stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            timeout=timeout, check=False,
+        )
+        if proc.returncode != 0:
+            raise RuntimeError(proc.stderr.strip()[:500] or f"helper exited {proc.returncode}")
+        payload = json.loads(proc.stdout.splitlines()[-1])
+        if not payload.get("ok"):
+            raise RuntimeError(payload.get("error") or "Tree-sitter helper returned no result")
+        return payload
+
+    def _convert(self, codebase, record, text, payload):
+        path, content_hash = record["path"], record["content_hash"]
+        file_symbol = _symbol(codebase.name, record["language"], "file", Path(path).name, path, 1,
+                              max(1, len(text.splitlines())), content_hash, qualified_name=path,
+                              parser=self.parser_id)
+        symbols = [file_symbol]
+        by_key = {"": file_symbol}
+        for item in payload.get("declarations", []):
+            parent = by_key.get(str(item.get("parent") or ""), file_symbol)
+            symbol = _symbol(codebase.name, record["language"], item.get("kind", "symbol"),
+                             item.get("name", "anonymous"), path, max(1, int(item.get("line_start", 1))),
+                             max(1, int(item.get("line_end", item.get("line_start", 1)))), content_hash,
+                             qualified_name=item.get("qualified_name") or f"{parent['qualified_name']}::{item.get('name', 'anonymous')}",
+                             parser=self.parser_id)
+            symbol["container_id"] = parent["id"]
+            symbol["metadata"].update({"parse_status": payload.get("parse_status", "complete"), "grammar": self.declaration.get("grammar", {})})
+            symbols.append(symbol)
+            by_key[str(item.get("key"))] = symbol
+        relations = []
+        for symbol in symbols[1:]:
+            relations.append(_relation(symbol["container_id"], "contains", path, symbol["line_start"], self.parser_id, "exact", to_id=symbol["id"]))
+        for item in payload.get("calls", []):
+            owner = by_key.get(str(item.get("owner") or ""), file_symbol)
+            relations.append(_relation(owner["id"], "calls", path, max(1, int(item.get("line", 1))), self.parser_id,
+                                        "heuristic", to_external=f"call:{item.get('target', 'unknown')}"))
+        diagnostics = list(payload.get("diagnostics", []))
+        if payload.get("parse_status") != "complete":
+            diagnostics.append({"codebase": codebase.name, "path": path, "line": 1, "severity": "warning",
+                                "kind": "parse_partial", "message": "Tree-sitter grammar produced a partial tree",
+                                "parser": self.parser_id, "metadata": payload.get("metadata", {})})
+        return ParseResult(symbols=symbols, relations=relations, diagnostics=diagnostics, actual_parser=self.parser_id)

package/plugins/devflow-intel/skills/workflow-code-index/scripts/code_index.py

@@ -22,6 +22,7 @@ if str(SCRIPT_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPT_DIR))
 
 from adapters.generic_text import language_for_path
+from adapters.capabilities import confidence_for_parser
 from adapters.registry import AdapterRegistry
 from semantic import SEMANTIC_EXTRACTOR_VERSION, build_semantic_facts
 from core.discovery import discover_codebases
@@ -286,15 +287,27 @@ def command_scan(args) -> int:
                         "parser": "pending",
                     }
                     adapter = registry.adapter_for_file(codebase, file_record)
-                    file_record["parser"] = adapter.parser_for_file(codebase, file_record)
+                    parser_for_file = getattr(adapter, "parser_for_file", None)
+                    file_record["parser"] = parser_for_file(codebase, file_record) if parser_for_file else adapter.parser_id
                     result = adapter.parse_file(codebase, file_record, text)
                     file_record["parser"] = result.actual_parser or file_record["parser"]
                     files.append(file_record)
                     symbols.extend(result.symbols)
                     relations.extend(result.relations)
                     diagnostics.extend(result.diagnostics)
-                    adapter_entities.extend(getattr(result, "entities", []) or [])
-                    adapter_flows.extend(getattr(result, "flows", []) or [])
+                    for entity in getattr(result, "entities", []) or []:
+                        entity = dict(entity)
+                        entity.setdefault("extractor", file_record["parser"])
+                        entity.setdefault("confidence", confidence_for_parser(file_record["parser"], "symbol"))
+                        entity.setdefault("metadata", {})
+                        adapter_entities.append(entity)
+                    for flow in getattr(result, "flows", []) or []:
+                        flow = dict(flow)
+                        flow.setdefault("extractor", file_record["parser"])
+                        flow.setdefault("confidence", "heuristic")
+                        flow.setdefault("evidence_level", "syntax")
+                        flow.setdefault("metadata", {})
+                        adapter_flows.append(flow)
                     parsed += 1
                     if parsed == 1 or parsed % 250 == 0 or parsed == len(all_files):
                         progress.emit("parse", f"parsed {parsed}/{len(all_files)} files in {codebase.name}", codebase=codebase.name, parsed=parsed, total=len(all_files))
@@ -316,12 +329,19 @@ def command_scan(args) -> int:
         staging = Path(tempfile.mkdtemp(prefix=f".{output.name}.build-", dir=str(output.parent)))
         try:
             generation = str(uuid.uuid4())
-            workspace_state = _workspace_state(root, files, changed, discovered_paths, registry.capabilities())
+            registry_capabilities = getattr(registry, "capabilities", None)
+            workspace_state = _workspace_state(
+                root, files, changed, discovered_paths,
+                registry_capabilities() if registry_capabilities else {},
+            )
             workspace_state["generatedAt"] = datetime.now(timezone.utc).isoformat()
             workspace_state["semanticExtractor"] = SEMANTIC_EXTRACTOR_VERSION
             workspace_state["extractorSetHash"] = _hash_lines([*workspace_state.get("extractors", []), SEMANTIC_EXTRACTOR_VERSION])
             progress.emit("semantic", "building semantic facts")
-            semantic_entities, semantic_flows, feature_bindings = build_semantic_facts(root, files, symbols, relations)
+            semantic_stats = {}
+            semantic_entities, semantic_flows, feature_bindings = build_semantic_facts(root, files, symbols, relations, stats=semantic_stats)
+            workspace_state["semanticScan"] = semantic_stats
+            progress.emit("semantic", "semantic facts completed", **semantic_stats)
             semantic_entities.extend(adapter_entities)
             semantic_flows.extend(adapter_flows)
             write_jsonl(staging / INDEX_FILES["files"], files)
@@ -481,7 +501,7 @@ def command_relations(args) -> int:
             truncated = len(rows) > limit
             for row in rows[:limit]:
                 item = dict(row)
-                if args.change_type:
+                if getattr(args, "change_type", None):
                     item["impact_kind"] = args.change_type
                     item["severity"] = _impact_severity(args.change_type, item["flow_type"])
                 print(json.dumps(item, ensure_ascii=False, sort_keys=True))

package/plugins/devflow-intel/skills/workflow-code-index/scripts/semantic.py

@@ -5,31 +5,58 @@ does not replace framework parsers; it gives the relational index a stable
 schema so API, database, UI and feature facts can be linked incrementally.
 """
 import re
+import time
 from pathlib import Path
 from typing import Dict, Iterable, List, Tuple
 
 from core.schema import short_hash, stable_key
 from core.hashing import file_sha256
 
-SEMANTIC_EXTRACTOR_VERSION = "semantic-linker@1"
+SEMANTIC_EXTRACTOR_VERSION = "semantic-linker@2"
+SEMANTIC_MAX_BYTES = 512_000
+SEMANTIC_FILE_BUDGET_SECONDS = 2.0
+SEMANTIC_MAX_LINE_CHARS = 100_000
+SEMANTIC_LANGUAGES = {
+    "python", "javascript", "typescript", "vue", "svelte", "go", "rust",
+    "php", "java", "kotlin", "dart", "c", "cpp", "csharp", "ruby",
+    "swift", "scala", "lua", "shell", "sql", "html", "css",
+}
+SEMANTIC_LOCK_FILES = {
+    "package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock",
+    "composer.lock", "cargo.lock", "poetry.lock", "pdm.lock", "go.sum",
+}
+SEMANTIC_GENERATED_DIRS = {
+    "node_modules", "vendor", "dist", "build", "coverage", "target", ".next",
+    ".nuxt", "_nuxt", ".cache", "generated", ".generated", "__generated__", "snapshots",
+}
 
 
 def build_semantic_facts(root: Path, files: Iterable[dict], symbols: Iterable[dict],
-                         relations: Iterable[dict]) -> Tuple[List[dict], List[dict], List[dict]]:
+                         relations: Iterable[dict], stats: Dict | None = None) -> Tuple[List[dict], List[dict], List[dict]]:
     entities: List[dict] = []
     flows: List[dict] = []
     bindings: List[dict] = []
     records = list(files)
+    summary = {"processed": 0, "timedOut": 0, "skipped": {}}
     symbol_by_path = {}
     for symbol in symbols:
         symbol_by_path.setdefault(symbol.get("path"), []).append(symbol)
 
     for file_number, file_record in enumerate(records, 1):
         if file_number == 1 or file_number % 250 == 0 or file_number == len(records):
-            print(f"[code-index][semantic] processed {file_number}/{len(records)} files", flush=True)
+            skipped_total = sum(summary["skipped"].values())
+            print(f"[code-index][semantic] visited {file_number}/{len(records)} files; processed={summary['processed']} skipped={skipped_total} timed_out={summary['timedOut']}", flush=True)
         path = file_record["path"]
+        skip_reason = semantic_skip_reason(file_record)
+        if skip_reason:
+            summary["skipped"][skip_reason] = summary["skipped"].get(skip_reason, 0) + 1
+            continue
         source = _read(root, path)
         if source is None:
+            summary["skipped"]["unreadable"] = summary["skipped"].get("unreadable", 0) + 1
+            continue
+        if _looks_minified_or_compressed(path, source):
+            summary["skipped"]["minified_or_compressed"] = summary["skipped"].get("minified_or_compressed", 0) + 1
             continue
         try:
             if file_sha256(root / path) != file_record.get("content_hash"):
@@ -38,21 +65,36 @@ def build_semantic_facts(root: Path, files: Iterable[dict], symbols: Iterable[di
                 continue
         except OSError:
             continue
+        deadline = time.monotonic() + SEMANTIC_FILE_BUDGET_SECONDS
+        file_entities: List[dict] = []
+        file_flows: List[dict] = []
+        file_bindings: List[dict] = []
         language = file_record.get("language", "")
         feature = _feature_from_path(path)
         if feature:
             feature_id = f"feature:{stable_key(feature)}"
-            entities.append(_entity(feature_id, "feature", feature, file_record, 1, 1,
-                                    "heuristic", "path_feature_inference"))
+            file_entities.append(_entity(feature_id, "feature", feature, file_record, 1, 1,
+                                         "heuristic", "path_feature_inference"))
             for symbol in symbol_by_path.get(path, []):
                 if symbol.get("kind") in {"route", "component", "class", "function", "method"}:
-                    bindings.append(_binding(feature_id, symbol["id"], "static_inferred", "heuristic", path, symbol.get("line_start", 1)))
+                    file_bindings.append(_binding(feature_id, symbol["id"], "static_inferred", "heuristic", path, symbol.get("line_start", 1)))
 
         state_ids = set()
+        timed_out = False
         for line_no, line in enumerate(source.splitlines(), 1):
-            _extract_api(line, path, file_record, line_no, entities, flows)
-            _extract_db(line, path, file_record, line_no, entities, flows)
-            _extract_ui(line, path, file_record, line_no, entities, flows, state_ids)
+            if time.monotonic() > deadline:
+                timed_out = True
+                break
+            _extract_api(line, path, file_record, line_no, file_entities, file_flows)
+            _extract_db(line, path, file_record, line_no, file_entities, file_flows)
+            _extract_ui(line, path, file_record, line_no, file_entities, file_flows, state_ids)
+        if timed_out:
+            summary["timedOut"] += 1
+            continue
+        entities.extend(file_entities)
+        flows.extend(file_flows)
+        bindings.extend(file_bindings)
+        summary["processed"] += 1
 
     # Existing structural relations remain the source of method call edges;
     # expose them in the semantic graph without changing their meaning.
@@ -67,11 +109,48 @@ def build_semantic_facts(root: Path, files: Iterable[dict], symbols: Iterable[di
                 "line_start": relation.get("evidence_line"),
                 "confidence": relation.get("confidence", "heuristic"),
                 "evidence_level": "syntax",
+                "extractor": relation.get("parser", "unknown"),
                 "metadata": relation.get("metadata", {}),
             })
+    if stats is not None:
+        stats.clear()
+        stats.update(summary)
     return _dedupe_entities(entities), _dedupe_flows(flows), _dedupe_bindings(bindings)
 
 
+def semantic_skip_reason(record: dict):
+    path = Path(record.get("path", ""))
+    parts = tuple(part.lower() for part in path.parts)
+    name = path.name.lower()
+    if name in SEMANTIC_LOCK_FILES or name.endswith((".lock", ".lockb")):
+        return "lock_file"
+    if any(part in SEMANTIC_GENERATED_DIRS for part in parts):
+        return "generated_path"
+    path_text = "/".join(parts)
+    if any(marker in path_text for marker in ("public/assets/", "public/build/", "public/_nuxt/")):
+        return "generated_path"
+    if "public" in parts:
+        public_index = parts.index("public")
+        if any(part in {"assets", "build", "dist", "static", "_nuxt"} for part in parts[public_index + 1:-1]):
+            return "generated_path"
+    if name.endswith((".min.js", ".min.css", ".bundle.js", ".chunk.js", ".map", ".g.dart", ".freezed.dart", ".pb.go", ".pb.cc", "_pb2.py", ".designer.cs")) or ".generated." in name:
+        return "generated_asset"
+    if int(record.get("size_bytes") or 0) > SEMANTIC_MAX_BYTES:
+        return "too_large"
+    if record.get("language", "") not in SEMANTIC_LANGUAGES:
+        return "unsupported_language"
+    return None
+
+
+def _looks_minified_or_compressed(path: str, source: str) -> bool:
+    if not source:
+        return False
+    lines = source.splitlines()
+    if any(len(line) > SEMANTIC_MAX_LINE_CHARS for line in lines):
+        return True
+    return len(source) > 100_000 and len(lines) <= 5
+
+
 def _extract_api(line, path, record, line_no, entities, flows):
     # Framework-neutral route declarations and client URLs.
     match = re.search(r"(?:@(?:app|router|api)\.(get|post|put|patch|delete)\s*\(|(?:GET|POST|PUT|PATCH|DELETE)\s+)(['\"])(/[^'\"]+)\2", line, re.I)
@@ -144,15 +223,17 @@ def _extract_ui(line, path, record, line_no, entities, flows, state_ids=None):
 
 
 def _entity(entity_id, entity_type, name, record, start, end, confidence, extractor, metadata=None):
-    return {"id": entity_id, "entity_type": entity_type, "name": name, "codebase": record["codebase"], "path": record["path"], "line_start": start, "line_end": end, "content_hash": record["content_hash"], "confidence": confidence, "extractor": extractor, "metadata": metadata or {}}
+    extractor_id = extractor if "@" in extractor else f"{SEMANTIC_EXTRACTOR_VERSION}:{extractor}"
+    return {"id": entity_id, "entity_type": entity_type, "name": name, "codebase": record["codebase"], "path": record["path"], "line_start": start, "line_end": end, "content_hash": record["content_hash"], "confidence": confidence, "extractor": extractor_id, "metadata": metadata or {}}
 
 
 def _flow(source_id, target_id, flow_type, path, line, confidence, extractor, metadata=None):
-    return {"source_id": source_id, "target_id": target_id, "flow_type": flow_type, "source_path": path, "line_start": line, "confidence": confidence, "evidence_level": "static_source", "extractor": extractor, "metadata": metadata or {}}
+    extractor_id = extractor if "@" in extractor else f"{SEMANTIC_EXTRACTOR_VERSION}:{extractor}"
+    return {"source_id": source_id, "target_id": target_id, "flow_type": flow_type, "source_path": path, "line_start": line, "confidence": confidence, "evidence_level": "static_source", "extractor": extractor_id, "metadata": metadata or {}}
 
 
 def _binding(feature_id, entity_id, source, confidence, path, line):
-    return {"feature_id": feature_id, "entity_id": entity_id, "binding_type": source, "confidence": confidence, "source_path": path, "line_start": line}
+    return {"feature_id": feature_id, "entity_id": entity_id, "binding_type": source, "confidence": confidence, "source_path": path, "line_start": line, "extractor": f"{SEMANTIC_EXTRACTOR_VERSION}:path_feature_binding"}
 
 
 def _read(root, path):