@guanlin4924/devflow-pi 0.1.77 → 0.1.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanlin4924/devflow-pi",
-  "version": "0.1.77",
+  "version": "0.1.79",
   "type": "module",
   "description": "Devflow 专项研发 Pi，基于固定版本 OMP Runtime 组装研发状态机、代码智能、设计、实现与质量门禁。",
   "license": "UNLICENSED",
@@ -20,7 +20,14 @@
     "bun": ">=1.3.14"
   },
   "dependencies": {
-    "@oh-my-pi/pi-coding-agent": "17.2.7"
+    "@oh-my-pi/pi-coding-agent": "17.2.7",
+    "@plurnk/plurnk-mimetypes-grammar-cpp": "1.16.1",
+    "@plurnk/plurnk-mimetypes-grammar-kotlin": "1.16.1",
+    "@plurnk/plurnk-mimetypes-grammar-ruby": "1.16.1",
+    "@plurnk/plurnk-mimetypes-grammar-scala": "1.16.1",
+    "@plurnk/plurnk-mimetypes-grammar-yaml": "1.16.1",
+    "tree-sitter-graphql-grammar-wasm": "1.1.0",
+    "web-tree-sitter": "0.25.10"
   },
   "devDependencies": {
     "@types/bun": "^1.3.14",

package/plugins/devflow-intel/extensions/devflow-intel.ts

@@ -53,9 +53,11 @@ export default function devflowIntel(pi: ExtensionAPI) {
     label: "Devflow Code Index",
     description: "Scan, validate, audit, or query the deterministic project code index.",
     parameters: z.object({
-      action: z.enum(["scan", "validate", "audit", "query", "relations"]),
+      action: z.enum(["scan", "validate", "audit", "query", "relations", "impact"]),
       term: z.string().optional(),
       object: z.string().optional(),
+      entity: z.string().optional(),
+      changeType: z.enum(["remove_field", "rename_field", "change_type", "optional_to_required", "required_to_optional", "change_nullability", "change_enum"]).optional(),
       snapshot: z.string().optional(),
       depth: z.number().int().min(0).max(20).default(3),
       includeHeuristic: z.boolean().default(false),
@@ -76,8 +78,10 @@ export default function devflowIntel(pi: ExtensionAPI) {
         if (params.changedFiles.length > 0) args.push("--changed-files", ...params.changedFiles);
       } else if (params.action === "validate") {
         args.push("--index", ".planning/code-index");
+        if (params.snapshot) args.push("--snapshot", params.snapshot);
       } else if (params.action === "audit") {
         args.push("--root", ctx.cwd, "--index", ".planning/code-index", "--skill-root", skillRoot);
+        if (params.snapshot) args.push("--snapshot", params.snapshot);
       } else if (params.action === "query") {
         if (!params.term) {
           return render({ ok: false, exitCode: 2, stdout: "", stderr: "term is required" }, {});
@@ -85,6 +89,13 @@ export default function devflowIntel(pi: ExtensionAPI) {
         args.push("--index", ".planning/code-index", "--term", params.term, "--limit", String(params.limit));
         if (params.snapshot) args.push("--snapshot", params.snapshot);
       } else {
+        if (params.action === "impact") {
+          if (!params.entity) return render({ ok: false, exitCode: 2, stdout: "", stderr: "entity is required" }, {});
+          args.push("--index", ".planning/code-index", "--entity", params.entity, "--depth", String(params.depth), "--limit", String(params.limit));
+          if (params.snapshot) args.push("--snapshot", params.snapshot);
+          if (params.changeType) args.push("--change-type", params.changeType);
+          return render(await run(args, ctx.cwd), { action: params.action });
+        }
         if (!params.object) return render({ ok: false, exitCode: 2, stdout: "", stderr: "object is required" }, {});
         args.push("--index", ".planning/code-index", "--object", params.object, "--depth", String(params.depth), "--limit", String(params.limit));
         if (params.snapshot) args.push("--snapshot", params.snapshot);

package/plugins/devflow-intel/skills/code-index-query/SKILL.md

@@ -32,6 +32,14 @@ devflow_code_index(action="scan")
 devflow_code_index(action="audit")
 ```
 
+Impact analysis uses the same immutable SQLite snapshot:
+
+```text
+devflow_code_index(action="impact", entity="{entity_id}", changeType="remove_field")
+```
+
+The result carries `_meta.snapshot`, coverage, and truncation status. Older structural-only snapshots return an explicit semantic capability-unavailable result; they remain valid for symbol and relation queries.
+
 ## Query Patterns
 
 For more detailed query patterns, read `references/query-patterns.md`.

package/plugins/devflow-intel/skills/workflow-code-index/SKILL.md

@@ -44,6 +44,7 @@ Use the OMP runtime tool:
 devflow_code_index(action="scan")
 devflow_code_index(action="validate")
 devflow_code_index(action="audit")
+devflow_code_index(action="impact", entity="api:orders", changeType="remove_field")
 ```
 
 For changed-file indexing:
@@ -66,3 +67,7 @@ Blocking findings are stale file hashes, missing indexed files, dangling `to_id`
 - Do not mark dynamic or string-based matches as `exact`.
 - If adapter support is missing, emit diagnostics and fall back to generic indexing.
 - Query answers must read source files at evidence paths before making factual claims.
+- The root `SNAPSHOT.json` is only a pointer. Queries, validation, audit, and impact resolve it to the immutable `snapshots/{generation}` directory before reading facts.
+- Query results include snapshot and parser provenance. A historical snapshot may be queried with `snapshot`; it is not freshness-checked against the current worktree.
+- `impact` is a typed semantic query. It returns `unavailable` with `semantic_capability_unavailable` when an older structural-only snapshot has no semantic tables; it never executes arbitrary SQL.
+- Query limits are bounded by the runtime. Negative or oversized limits are normalized safely.

package/plugins/devflow-intel/skills/workflow-code-index/references/adapter-contract.md

@@ -18,6 +18,9 @@ The result contains:
 - `symbols`
 - `relations`
 - `diagnostics`
+- `actual_parser` — parser that produced the returned facts; required when a
+  selected native adapter falls back after a dependency or per-file parse
+  failure
 
 ## Resolution Rules
 
@@ -36,3 +39,8 @@ The result contains:
 
 Core schema and writers must not change when a new adapter is added.
 
+Declared and runtime parser capabilities are recorded in
+`scripts/adapters/parser-capabilities.json` and the snapshot capability map.
+An unavailable native or Tree-sitter parser must report its fallback and emit
+an `adapter_missing` diagnostic; structured lexical output must never be
+labelled as native AST output.

package/plugins/devflow-intel/skills/workflow-code-index/references/data-model.md

@@ -34,6 +34,7 @@ All adapters must emit these records. Examples use placeholders only; do not rep
   "language": "{language_id}",
   "content_hash": "sha256:{hash}",
   "visibility": "{optional_visibility}",
+  "parser": "{adapter}@{version}",
   "metadata": {}
 }
 ```
@@ -71,4 +72,3 @@ Symbol IDs must not depend on line numbers. Use language, codebase, stable quali
   "parser": "{adapter}@{version}"
 }
 ```
-

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

@@ -0,0 +1,26 @@
+import json
+from pathlib import Path
+from typing import Dict
+
+
+MANIFEST_PATH = Path(__file__).resolve().parent / "parser-capabilities.json"
+
+
+def load_capability_manifest() -> Dict:
+    manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+    if manifest.get("schemaVersion") != 1 or not isinstance(manifest.get("languages"), dict):
+        raise ValueError("invalid parser capability manifest")
+    return manifest
+
+
+def confidence_for_parser(parser: str, kind: str = "symbol") -> str:
+    """Map extractor provenance to the strongest defensible confidence."""
+    if kind == "file":
+        return "exact"
+    if parser.startswith(("python-ast@", "typescript-compiler-ast@", "go-parser-ast@", "javac-tree-ast@", "nikic-php-parser-ast@")):
+        return "exact"
+    if parser.startswith("tree-sitter-"):
+        return "exact"
+    if parser.startswith("structured-scope@"):
+        return "inferred"
+    return "heuristic"

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

@@ -95,8 +95,9 @@ class GenericTextAdapter(Adapter):
                     path,
                     symbol["line_start"],
                     self.parser_id,
-                    confidence="exact",
+                    confidence="heuristic",
                     to_id=symbol["id"],
+                    metadata={"extraction": "text_pattern"},
                 )
             )
 
@@ -289,6 +290,7 @@ def _symbol(codebase, language, kind, name, path, line_start, line_end, content_
         "language": language,
         "content_hash": content_hash,
         "visibility": visibility,
+        "parser": parser,
         "metadata": {"parser": parser} if parser else {},
     }
 

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/helpers/tree_sitter_wasm_helper.mjs

@@ -0,0 +1,50 @@
+// Optional helper for web-tree-sitter. It is intentionally dependency-free at
+// package install time; the runtime reports parser_unavailable when the module
+// or grammar is absent.
+import fs from "node:fs";
+import process from "node:process";
+
+const grammarPath = process.argv[2];
+const input = JSON.parse(fs.readFileSync(0, "utf8").trim());
+try {
+  const mod = await import("web-tree-sitter");
+  const Parser = mod.default ?? mod.Parser;
+  const Language = mod.Language;
+  await Parser.init();
+  const language = await Language.load(grammarPath);
+  const parser = new Parser();
+  parser.setLanguage(language);
+  const tree = parser.parse(input.source);
+  const declarations = [];
+  const calls = [];
+  const declarationTypes = /(function|method|class|struct|interface|trait|enum|module|namespace|impl|object|type)/i;
+  const named = (node, field) => {
+    const child = node.childForFieldName?.(field);
+    return child ? child.text : "";
+  };
+  const walk = (node, parent = "") => {
+    const type = String(node.type || "");
+    const key = `${node.startIndex}:${node.endIndex}:${type}`;
+    if (declarationTypes.test(type) && !/(identifier|name|parameter)/i.test(type)) {
+      const name = named(node, "name") || named(node, "declarator") || `${type}@${node.startPosition.row + 1}`;
+      declarations.push({key, parent, kind: type, name, line_start: node.startPosition.row + 1, line_end: node.endPosition.row + 1});
+      parent = key;
+    }
+    if (/call|invocation|command_substitution/i.test(type)) {
+      const fn = named(node, "function") || named(node, "name") || node.firstNamedChild?.text || type;
+      calls.push({owner: parent, target: fn, line: node.startPosition.row + 1});
+    }
+    for (const child of node.namedChildren ?? []) walk(child, parent);
+  };
+  walk(tree.rootNode);
+  // web-tree-sitter exposes hasError as a boolean property (older releases
+  // exposed a method), so support both without treating a valid parse as a
+  // helper failure.
+  const hasErrorValue = tree.rootNode.hasError;
+  const hasError = typeof hasErrorValue === "function" ? hasErrorValue.call(tree.rootNode) : Boolean(hasErrorValue);
+  console.log(JSON.stringify({ok: true, parse_status: hasError ? "partial" : "complete", declarations, calls,
+    diagnostics: [], metadata: {grammar: grammarPath, error_tree: hasError}}));
+} catch (error) {
+  console.log(JSON.stringify({ok: false, error: String(error?.message || error)}));
+  process.exitCode = 2;
+}