@guanlin4924/devflow-pi 0.1.76 → 0.1.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanlin4924/devflow-pi",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "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/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/base.py

@@ -12,6 +12,9 @@ class ParseResult:
     # in a separate linker pass.
     entities: List[Dict] = field(default_factory=list)
     flows: List[Dict] = field(default_factory=list)
+    # Parser that actually produced this result.  This can differ from the
+    # selected adapter when a native parser fails and a fallback is used.
+    actual_parser: str = ""
 
 
 class Adapter:
@@ -29,6 +32,23 @@ class Adapter:
     def version(self) -> str:
         return "0"
 
+    def parser_for_file(self, codebase, file_record) -> str:
+        """Return the parser that will actually produce this file's facts.
+
+        Native adapters override this when their runtime dependency is not
+        available and a declared fallback will be used instead.  Keeping this
+        separate from ``parser_id`` prevents fallback output from being
+        labelled as native AST output.
+        """
+        return self.parser_id
+
+    def capability(self) -> Dict:
+        return {
+            "parser": self.parser_id,
+            "native": False,
+            "available": True,
+        }
+
     @property
     def parser_id(self) -> str:
         return f"{self.name}@{self.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"},
                 )
             )
 
@@ -155,7 +156,7 @@ class GenericTextAdapter(Adapter):
                 }
             )
 
-        return ParseResult(symbols=symbols, relations=relations, diagnostics=diagnostics)
+        return ParseResult(symbols=symbols, relations=relations, diagnostics=diagnostics, actual_parser=self.parser_id)
 
     def _extract_symbols(self, codebase: str, language: str, path: str, text: str, content_hash: str) -> List[Dict]:
         symbols: List[Dict] = []
@@ -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/go_ast.py

@@ -0,0 +1,20 @@
+import shutil
+from typing import List, Tuple
+
+from adapters.native_process import HELPER_DIR, NativeProcessAdapter
+
+
+class GoAstAdapter(NativeProcessAdapter):
+    name = "go-parser-ast"
+    languages = ("go",)
+    native_description = "Go standard library go parser AST; declarations, imports, and calls"
+
+    def version(self) -> str:
+        return "1"
+
+    def check_available(self, codebase=None) -> Tuple[bool, str]:
+        go = shutil.which("go")
+        return (True, "go/parser available") if go else (False, "go executable not found")
+
+    def command(self, codebase=None) -> List[str]:
+        return [shutil.which("go") or "go", "run", str(HELPER_DIR / "go_ast_helper.go")]

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/helpers/DevflowJavaAstHelper.java

@@ -0,0 +1,96 @@
+import java.io.*;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import javax.tools.*;
+import javax.lang.model.element.Modifier;
+import com.sun.source.tree.*;
+import com.sun.source.util.*;
+
+public final class DevflowJavaAstHelper {
+  private static String json(String value) {
+    if (value == null) return "\"\"";
+    StringBuilder out = new StringBuilder("\"");
+    for (char c : value.toCharArray()) {
+      switch (c) {
+        case '\\': out.append("\\\\"); break;
+        case '"': out.append("\\\""); break;
+        case '\n': out.append("\\n"); break;
+        case '\r': out.append("\\r"); break;
+        case '\t': out.append("\\t"); break;
+        default:
+          if (c < 32) out.append(String.format("\\u%04x", (int)c)); else out.append(c);
+      }
+    }
+    return out.append('"').toString();
+  }
+
+  private static final class Source extends SimpleJavaFileObject {
+    final String text;
+    Source(String path, String text) { super(URI.create("string:///" + path.replace(' ', '_')), Kind.SOURCE); this.text = text; }
+    public CharSequence getCharContent(boolean ignoreEncodingErrors) { return text; }
+  }
+
+  private static final class Decl {
+    String key, parent, kind, name, signature, nativeKind, visibility; int start, end;
+    String toJson() { return "{\"key\":"+json(key)+",\"parent\":"+json(parent)+",\"kind\":"+json(kind)+",\"name\":"+json(name)+",\"line_start\":"+start+",\"line_end\":"+end+",\"signature\":"+json(signature)+",\"native_kind\":"+json(nativeKind)+",\"visibility\":"+json(visibility)+"}"; }
+  }
+  private static final class Rel {
+    String owner, type, target, confidence, resolution; int line;
+    String toJson() { return "{\"owner\":"+json(owner)+",\"type\":"+json(type)+",\"target\":"+json(target)+",\"line\":"+line+",\"confidence\":"+json(confidence)+",\"metadata\":{\"resolution\":"+json(resolution)+"}}"; }
+  }
+
+  private static String parse(String path, String sourceText) throws Exception {
+    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+    if (compiler == null) throw new IllegalStateException("JDK compiler API unavailable");
+    DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
+    JavacTask task = (JavacTask) compiler.getTask(null, null, diagnostics, List.of("-proc:none"), null, List.of(new Source(path, sourceText)));
+    CompilationUnitTree unit = task.parse().iterator().next();
+    Trees trees = Trees.instance(task); SourcePositions positions = trees.getSourcePositions(); LineMap lines = unit.getLineMap();
+    List<Decl> declarations = new ArrayList<>(); List<Rel> relations = new ArrayList<>();
+    new TreePathScanner<Void, String>() {
+      int next = 1;
+      int line(Tree tree) { long p = positions.getStartPosition(unit, tree); return p < 0 ? 1 : (int)lines.getLineNumber(p); }
+      int end(Tree tree) { long p = positions.getEndPosition(unit, tree); return p < 0 ? line(tree) : (int)lines.getLineNumber(Math.max(0, p - 1)); }
+      String visibility(Set<Modifier> modifiers) { if (modifiers.contains(Modifier.PUBLIC)) return "public"; if (modifiers.contains(Modifier.PROTECTED)) return "protected"; if (modifiers.contains(Modifier.PRIVATE)) return "private"; return ""; }
+      String addDecl(Tree tree, String parent, String kind, String name, String signature, Set<Modifier> modifiers) {
+        Decl d = new Decl(); d.key = String.valueOf(next++); d.parent = parent == null ? "" : parent; d.kind = kind; d.name = name; d.signature = signature; d.nativeKind = tree.getKind().name(); d.visibility = visibility(modifiers); d.start = line(tree); d.end = Math.max(d.start, end(tree)); declarations.add(d); return d.key;
+      }
+      void addRel(String owner, String type, String target, Tree tree, String confidence, String resolution) { Rel r = new Rel(); r.owner=owner==null?"":owner; r.type=type; r.target=target; r.line=line(tree); r.confidence=confidence; r.resolution=resolution; relations.add(r); }
+      @Override public Void visitClass(ClassTree node, String owner) {
+        String kind = node.getKind() == Tree.Kind.INTERFACE || node.getKind() == Tree.Kind.ANNOTATION_TYPE ? "interface" : "class";
+        String key = addDecl(node, owner, kind, node.getSimpleName().toString(), node.getSimpleName()+"()", node.getModifiers().getFlags());
+        if (node.getExtendsClause() != null) addRel(key, "extends", "type:"+node.getExtendsClause(), node.getExtendsClause(), "inferred", "syntax_name");
+        for (Tree inherited : node.getImplementsClause()) addRel(key, "implements", "type:"+inherited, inherited, "inferred", "syntax_name");
+        return super.visitClass(node, key);
+      }
+      @Override public Void visitMethod(MethodTree node, String owner) {
+        String name = node.getName().toString(); String kind = name.toLowerCase().startsWith("test") ? "test" : "method";
+        String key = addDecl(node, owner, kind, name, name+"("+String.join(", ", node.getParameters().stream().map(v -> v.getName().toString()).toList())+")", node.getModifiers().getFlags());
+        return super.visitMethod(node, key);
+      }
+      @Override public Void visitImport(ImportTree node, String owner) { addRel(owner, "imports", "import:"+node.getQualifiedIdentifier(), node, "exact", "import_tree"); return super.visitImport(node, owner); }
+      @Override public Void visitMethodInvocation(MethodInvocationTree node, String owner) {
+        String target=node.getMethodSelect().toString(); boolean receiver=target.contains("."); addRel(owner, "calls", "call:"+target, node, receiver?"heuristic":"inferred", receiver?"receiver_unresolved":"lexical_name"); return super.visitMethodInvocation(node, owner);
+      }
+      @Override public Void visitNewClass(NewClassTree node, String owner) { addRel(owner, "calls", "call:"+node.getIdentifier(), node, "inferred", "constructor_syntax"); return super.visitNewClass(node, owner); }
+    }.scan(unit, "");
+    StringBuilder out = new StringBuilder("{\"ok\":true,\"declarations\":[");
+    for (int i=0;i<declarations.size();i++) { if(i>0) out.append(','); out.append(declarations.get(i).toJson()); }
+    out.append("],\"relations\":["); for(int i=0;i<relations.size();i++){if(i>0)out.append(',');out.append(relations.get(i).toJson());}
+    out.append("],\"diagnostics\":["); boolean first=true; for(Diagnostic<? extends JavaFileObject> d: diagnostics.getDiagnostics()){if(!first)out.append(',');first=false;out.append("{\"line\":").append(Math.max(1,d.getLineNumber())).append(",\"severity\":\"warning\",\"kind\":\"parse_failed\",\"message\":").append(json(d.getMessage(Locale.ROOT))).append('}');}
+    return out.append("]}").toString();
+  }
+
+  public static void main(String[] args) throws Exception {
+    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8)); String line;
+    while ((line = reader.readLine()) != null) {
+      try {
+        String[] parts=line.split("\\t",2); if(parts.length!=2)throw new IllegalArgumentException("invalid request");
+        String path=new String(Base64.getDecoder().decode(parts[0]),StandardCharsets.UTF_8); String source=new String(Base64.getDecoder().decode(parts[1]),StandardCharsets.UTF_8);
+        System.out.println(parse(path,source));
+      } catch(Exception error) { System.out.println("{\"ok\":false,\"error\":"+json(error.toString())+"}"); }
+      System.out.flush();
+    }
+  }
+}

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/helpers/go_ast_helper.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+)
+
+type Request struct { Path string `json:"path"`; Source string `json:"source"` }
+type Declaration struct { Key string `json:"key"`; Parent string `json:"parent"`; Kind string `json:"kind"`; Name string `json:"name"`; LineStart int `json:"line_start"`; LineEnd int `json:"line_end"`; Signature string `json:"signature"`; NativeKind string `json:"native_kind"` }
+type Relation struct { Owner string `json:"owner"`; Type string `json:"type"`; Target string `json:"target"`; Line int `json:"line"`; Confidence string `json:"confidence"`; Metadata map[string]any `json:"metadata"` }
+type Diagnostic struct { Line int `json:"line"`; Severity string `json:"severity"`; Kind string `json:"kind"`; Message string `json:"message"` }
+type Response struct { Ok bool `json:"ok"`; Error string `json:"error,omitempty"`; Declarations []Declaration `json:"declarations,omitempty"`; Relations []Relation `json:"relations,omitempty"`; Diagnostics []Diagnostic `json:"diagnostics,omitempty"` }
+
+func expressionName(expr ast.Expr) string {
+	switch value := expr.(type) {
+	case *ast.Ident: return value.Name
+	case *ast.SelectorExpr:
+		parent := expressionName(value.X)
+		if parent != "" { return parent + "." + value.Sel.Name }
+		return value.Sel.Name
+	case *ast.IndexExpr: return expressionName(value.X)
+	case *ast.IndexListExpr: return expressionName(value.X)
+	}
+	return ""
+}
+
+func parseRequest(request Request) Response {
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, request.Path, request.Source, parser.AllErrors|parser.ParseComments)
+	response := Response{Ok: true, Declarations: []Declaration{}, Relations: []Relation{}, Diagnostics: []Diagnostic{}}
+	if err != nil {
+		line := 1
+		if list, ok := err.(interface{ Error() string }); ok { _ = list }
+		response.Diagnostics = append(response.Diagnostics, Diagnostic{Line: line, Severity: "warning", Kind: "parse_failed", Message: err.Error()})
+	}
+	if file == nil { response.Ok = false; response.Error = "go/parser produced no syntax tree"; return response }
+	keys := map[ast.Node]string{}
+	next := 1
+	for _, declaration := range file.Decls {
+		switch node := declaration.(type) {
+		case *ast.FuncDecl:
+			key := fmt.Sprintf("%d", next); next++
+			keys[node] = key
+			kind := "function"
+			if node.Recv != nil { kind = "method" }
+			if strings.HasPrefix(strings.ToLower(node.Name.Name), "test") { kind = "test" }
+			response.Declarations = append(response.Declarations, Declaration{Key:key, Kind:kind, Name:node.Name.Name, LineStart:fset.Position(node.Pos()).Line, LineEnd:fset.Position(node.End()).Line, Signature:node.Name.Name+"()", NativeKind:"FuncDecl"})
+		case *ast.GenDecl:
+			for _, spec := range node.Specs {
+				if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+					key := fmt.Sprintf("%d", next); next++
+					keys[typeSpec] = key
+					kind := "class"
+					native := "TypeSpec"
+					switch typeSpec.Type.(type) { case *ast.StructType: kind="struct"; native="StructType"; case *ast.InterfaceType: kind="interface"; native="InterfaceType" }
+					response.Declarations = append(response.Declarations, Declaration{Key:key, Kind:kind, Name:typeSpec.Name.Name, LineStart:fset.Position(typeSpec.Pos()).Line, LineEnd:fset.Position(typeSpec.End()).Line, Signature:typeSpec.Name.Name, NativeKind:native})
+				}
+			}
+		}
+	}
+	for _, imp := range file.Imports {
+		target := strings.Trim(imp.Path.Value, "\"")
+		response.Relations = append(response.Relations, Relation{Type:"imports", Target:"import:"+target, Line:fset.Position(imp.Pos()).Line, Confidence:"exact", Metadata:map[string]any{"resolution":"import_spec"}})
+	}
+	for _, declaration := range file.Decls {
+		owner := keys[declaration]
+		ast.Inspect(declaration, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok { return true }
+			name := expressionName(call.Fun)
+			if name == "" { return true }
+			confidence := "inferred"; resolution := "lexical_name"
+			if strings.Contains(name, ".") { confidence = "heuristic"; resolution = "receiver_unresolved" }
+			response.Relations = append(response.Relations, Relation{Owner:owner, Type:"calls", Target:"call:"+name, Line:fset.Position(call.Pos()).Line, Confidence:confidence, Metadata:map[string]any{"resolution":resolution}})
+			return true
+		})
+	}
+	return response
+}
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	buffer := make([]byte, 64*1024); scanner.Buffer(buffer, 64*1024*1024)
+	encoder := json.NewEncoder(os.Stdout)
+	for scanner.Scan() {
+		var request Request
+		if err := json.Unmarshal(scanner.Bytes(), &request); err != nil { encoder.Encode(Response{Ok:false, Error:err.Error()}); continue }
+		encoder.Encode(parseRequest(request))
+	}
+}

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/helpers/php_ast_helper.php

@@ -0,0 +1,91 @@
+<?php
+declare(strict_types=1);
+
+$autoload = $argv[1] ?? '';
+if (!$autoload || !is_file($autoload)) {
+    fwrite(STDOUT, json_encode(['ok' => false, 'error' => 'nikic/PHP-Parser autoload file not found']) . "\n");
+    exit(2);
+}
+require_once $autoload;
+
+function node_name($node): string {
+    if ($node instanceof PhpParser\Node\Name || $node instanceof PhpParser\Node\Identifier || $node instanceof PhpParser\Node\VarLikeIdentifier) {
+        return $node->toString();
+    }
+    if ($node instanceof PhpParser\Node\Expr\Variable && is_string($node->name)) return '$' . $node->name;
+    if (is_string($node)) return $node;
+    return '';
+}
+
+function relation_target($node): string {
+    if ($node instanceof PhpParser\Node\Name || $node instanceof PhpParser\Node\Identifier) return $node->toString();
+    if ($node instanceof PhpParser\Node\Expr\Variable) return node_name($node);
+    if ($node instanceof PhpParser\Node\Expr\PropertyFetch || $node instanceof PhpParser\Node\Expr\StaticPropertyFetch) {
+        return trim(relation_target($node->var ?? $node->class) . '->' . node_name($node->name), '->');
+    }
+    return '';
+}
+
+function parser_instance() {
+    $factory = new PhpParser\ParserFactory();
+    if (method_exists($factory, 'createForNewestSupportedVersion')) return $factory->createForNewestSupportedVersion();
+    return $factory->create(PhpParser\ParserFactory::PREFER_PHP7);
+}
+
+function parse_source(string $source): array {
+    $declarations = []; $relations = []; $diagnostics = []; $next = 1;
+    try { $nodes = parser_instance()->parse($source) ?? []; }
+    catch (PhpParser\Error $error) {
+        return ['ok' => true, 'declarations' => [], 'relations' => [], 'diagnostics' => [[
+            'line' => max(1, $error->getStartLine()), 'severity' => 'warning', 'kind' => 'parse_failed', 'message' => $error->getMessage()
+        ]]];
+    }
+    $walk = function ($node, string $owner = '') use (&$walk, &$declarations, &$relations, &$next): void {
+        if (!$node instanceof PhpParser\Node) return;
+        $current = $owner; $kind = null; $name = '';
+        if ($node instanceof PhpParser\Node\Stmt\Class_) { $kind = 'class'; $name = node_name($node->name) ?: 'anonymous'; }
+        elseif ($node instanceof PhpParser\Node\Stmt\Interface_) { $kind = 'interface'; $name = node_name($node->name); }
+        elseif ($node instanceof PhpParser\Node\Stmt\Trait_) { $kind = 'trait'; $name = node_name($node->name); }
+        elseif ($node instanceof PhpParser\Node\Stmt\Function_) { $kind = str_starts_with(strtolower(node_name($node->name)), 'test') ? 'test' : 'function'; $name = node_name($node->name); }
+        elseif ($node instanceof PhpParser\Node\Stmt\ClassMethod) { $kind = str_starts_with(strtolower(node_name($node->name)), 'test') ? 'test' : 'method'; $name = node_name($node->name); }
+        elseif ($node instanceof PhpParser\Node\Expr\Closure || $node instanceof PhpParser\Node\Expr\ArrowFunction) { $kind = 'function'; $name = 'anonymous'; }
+        if ($kind !== null) {
+            $current = (string)$next++;
+            $params = property_exists($node, 'params') ? array_map(fn($p) => node_name($p->var), $node->params) : [];
+            $visibility = method_exists($node, 'isPrivate') && $node->isPrivate() ? 'private' : (method_exists($node, 'isProtected') && $node->isProtected() ? 'protected' : (method_exists($node, 'isPublic') && $node->isPublic() ? 'public' : ''));
+            $declarations[] = ['key'=>$current,'parent'=>$owner,'kind'=>$kind,'name'=>$name,'line_start'=>max(1,$node->getStartLine()),'line_end'=>max(1,$node->getEndLine()),'signature'=>$name.'('.implode(', ',$params).')','visibility'=>$visibility,'native_kind'=>$node->getType()];
+            if ($node instanceof PhpParser\Node\Stmt\Class_) {
+                if ($node->extends) $relations[] = ['owner'=>$current,'type'=>'extends','target'=>'type:'.node_name($node->extends),'line'=>$node->extends->getStartLine(),'confidence'=>'inferred','metadata'=>['resolution'=>'syntax_name']];
+                foreach ($node->implements as $type) $relations[] = ['owner'=>$current,'type'=>'implements','target'=>'type:'.node_name($type),'line'=>$type->getStartLine(),'confidence'=>'inferred','metadata'=>['resolution'=>'syntax_name']];
+            }
+        }
+        if ($node instanceof PhpParser\Node\Stmt\Use_ || $node instanceof PhpParser\Node\Stmt\GroupUse) {
+            foreach ($node->uses as $use) $relations[] = ['owner'=>$owner,'type'=>'imports','target'=>'import:'.node_name($use->name),'line'=>$use->getStartLine(),'confidence'=>'exact','metadata'=>['resolution'=>'use_tree']];
+        } elseif ($node instanceof PhpParser\Node\Expr\FuncCall) {
+            $target = node_name($node->name); if ($target) $relations[] = ['owner'=>$owner,'type'=>'calls','target'=>'call:'.$target,'line'=>$node->getStartLine(),'confidence'=>'inferred','metadata'=>['resolution'=>'syntax_name']];
+        } elseif ($node instanceof PhpParser\Node\Expr\MethodCall || $node instanceof PhpParser\Node\Expr\NullsafeMethodCall) {
+            $target = node_name($node->name); if ($target) $relations[] = ['owner'=>$owner,'type'=>'calls','target'=>'call:'.$target,'line'=>$node->getStartLine(),'confidence'=>'heuristic','metadata'=>['resolution'=>'receiver_unresolved']];
+        } elseif ($node instanceof PhpParser\Node\Expr\StaticCall) {
+            $target = node_name($node->class).'::'.node_name($node->name); if ($target !== '::') $relations[] = ['owner'=>$owner,'type'=>'calls','target'=>'call:'.$target,'line'=>$node->getStartLine(),'confidence'=>'heuristic','metadata'=>['resolution'=>'static_receiver_unresolved']];
+        } elseif ($node instanceof PhpParser\Node\Expr\New_) {
+            $target = node_name($node->class); if ($target) $relations[] = ['owner'=>$owner,'type'=>'calls','target'=>'call:'.$target,'line'=>$node->getStartLine(),'confidence'=>'inferred','metadata'=>['resolution'=>'constructor_syntax']];
+        }
+        foreach ($node->getSubNodeNames() as $field) {
+            $value = $node->$field;
+            if ($value instanceof PhpParser\Node) $walk($value, $current);
+            elseif (is_array($value)) foreach ($value as $child) if ($child instanceof PhpParser\Node) $walk($child, $current);
+        }
+    };
+    foreach ($nodes as $node) $walk($node, '');
+    return ['ok'=>true,'declarations'=>$declarations,'relations'=>$relations,'diagnostics'=>$diagnostics];
+}
+
+while (($line = fgets(STDIN)) !== false) {
+    try {
+        $request = json_decode($line, true, 512, JSON_THROW_ON_ERROR);
+        echo json_encode(parse_source((string)($request['source'] ?? '')), JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) . "\n";
+    } catch (Throwable $error) {
+        echo json_encode(['ok'=>false,'error'=>$error->getMessage()], JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) . "\n";
+    }
+    flush();
+}

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;
+}

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/helpers/typescript_ast_helper.cjs

@@ -0,0 +1,123 @@
+const readline = require("readline");
+
+let ts;
+try {
+  ts = require("typescript");
+} catch (error) {
+  process.stdout.write(JSON.stringify({ ok: false, error: `typescript compiler API unavailable: ${error.message}` }) + "\n");
+  process.exit(2);
+}
+
+function scriptKind(path) {
+  if (path.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (path.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  if (path.endsWith(".js") || path.endsWith(".mjs") || path.endsWith(".cjs")) return ts.ScriptKind.JS;
+  return ts.ScriptKind.TS;
+}
+
+function parse(input) {
+  const source = ts.createSourceFile(input.path, input.source, ts.ScriptTarget.Latest, true, scriptKind(input.path));
+  const declarations = [];
+  const relations = [];
+  let nextKey = 1;
+
+  function line(node) {
+    return source.getLineAndCharacterOfPosition(node.getStart(source, false)).line + 1;
+  }
+  function endLine(node) {
+    return source.getLineAndCharacterOfPosition(node.end).line + 1;
+  }
+  function nodeName(node) {
+    if (node.name && ts.isIdentifier(node.name)) return node.name.text;
+    if (node.name && ts.isStringLiteralLike(node.name)) return node.name.text;
+    return "anonymous";
+  }
+  function signature(node, name) {
+    if (node.parameters) {
+      const parameters = node.parameters.map((p) => p.name.getText(source));
+      return `${name}(${parameters.join(", ")})`;
+    }
+    return `${name}()`;
+  }
+  function visibility(node) {
+    const modifiers = node.modifiers || [];
+    if (modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword)) return "private";
+    if (modifiers.some((m) => m.kind === ts.SyntaxKind.ProtectedKeyword)) return "protected";
+    if (modifiers.some((m) => m.kind === ts.SyntaxKind.PublicKeyword)) return "public";
+    return "";
+  }
+  function declarationKind(node) {
+    if (ts.isClassDeclaration(node) || ts.isEnumDeclaration(node)) return "class";
+    if (ts.isInterfaceDeclaration(node)) return "interface";
+    if (ts.isModuleDeclaration(node)) return "module";
+    if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isConstructorDeclaration(node)) return "method";
+    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) return "function";
+    return null;
+  }
+  function callTarget(expression) {
+    if (ts.isIdentifier(expression)) return { target: expression.text, confidence: "inferred", resolution: "lexical_name" };
+    if (ts.isPropertyAccessExpression(expression)) return { target: expression.getText(source), confidence: "heuristic", resolution: "receiver_unresolved" };
+    if (ts.isElementAccessExpression(expression)) return { target: expression.getText(source), confidence: "heuristic", resolution: "dynamic_element" };
+    return null;
+  }
+  function addRelation(owner, type, target, at, confidence, metadata = {}) {
+    relations.push({ owner: owner || "", type, target, line: at, confidence, metadata });
+  }
+  function visit(node, owner = "") {
+    let current = owner;
+    let kind = declarationKind(node);
+    let name = nodeName(node);
+    if (ts.isVariableDeclaration(node) && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+      kind = "function";
+      name = node.name.getText(source);
+    }
+    if (kind) {
+      const key = String(nextKey++);
+      declarations.push({
+        key,
+        parent: owner,
+        kind: name.toLowerCase().startsWith("test") && kind === "function" ? "test" : kind,
+        name,
+        line_start: line(node),
+        line_end: endLine(node),
+        signature: signature(node, name),
+        visibility: visibility(node),
+        native_kind: ts.SyntaxKind[node.kind],
+      });
+      current = key;
+      const heritage = node.heritageClauses || [];
+      for (const clause of heritage) {
+        const type = clause.token === ts.SyntaxKind.ImplementsKeyword ? "implements" : "extends";
+        for (const inherited of clause.types) {
+          addRelation(current, type, `type:${inherited.expression.getText(source)}`, line(inherited), "inferred", { resolution: "syntax_name" });
+        }
+      }
+    }
+    if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
+      addRelation(owner, "imports", `import:${node.moduleSpecifier.text}`, line(node), "exact", { resolution: "module_specifier" });
+    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
+      addRelation(owner, "imports", `import:${node.moduleSpecifier.text}`, line(node), "exact", { resolution: "export_module_specifier" });
+    } else if (ts.isCallExpression(node)) {
+      const target = callTarget(node.expression);
+      if (target) addRelation(owner, "calls", `call:${target.target}`, line(node), target.confidence, { resolution: target.resolution });
+    }
+    ts.forEachChild(node, (child) => visit(child, current));
+  }
+  visit(source, "");
+  const diagnostics = source.parseDiagnostics.map((diagnostic) => ({
+    line: diagnostic.start == null ? 1 : source.getLineAndCharacterOfPosition(diagnostic.start).line + 1,
+    severity: "warning",
+    kind: "parse_failed",
+    message: ts.flattenDiagnosticMessageText(diagnostic.messageText, " "),
+  }));
+  return { ok: true, declarations, relations, diagnostics };
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+rl.on("line", (line) => {
+  try {
+    process.stdout.write(JSON.stringify(parse(JSON.parse(line))) + "\n");
+  } catch (error) {
+    process.stdout.write(JSON.stringify({ ok: false, error: error.stack || error.message || String(error) }) + "\n");
+  }
+});