orion-super-agent-dev 0.1.13 → 0.1.15

package/out/indexProcessWorker.cjs

@@ -4533,6 +4533,164 @@ var JAVA_QUERY = `
 
 (method_invocation name: (identifier) @edge.call.target)
 `;
+var C_QUERY = `
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @symbol.function.name)) @symbol.function.def
+
+(struct_specifier
+  name: (type_identifier) @symbol.class.name
+  body: (field_declaration_list)) @symbol.class.def
+
+(enum_specifier
+  name: (type_identifier) @symbol.enum.name
+  body: (enumerator_list)) @symbol.enum.def
+
+(type_definition
+  declarator: (type_identifier) @symbol.type.name) @symbol.type.def
+
+(preproc_include path: (string_literal) @edge.import.source)
+
+(call_expression
+  function: (identifier) @edge.call.target)
+`;
+var CPP_QUERY = `
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @symbol.function.name)) @symbol.function.def
+
+(function_definition
+  declarator: (function_declarator
+    declarator: (field_identifier) @symbol.method.name)) @symbol.method.def
+
+(class_specifier
+  name: (type_identifier) @symbol.class.name
+  body: (field_declaration_list)) @symbol.class.def
+
+(struct_specifier
+  name: (type_identifier) @symbol.class.name
+  body: (field_declaration_list)) @symbol.class.def
+
+(enum_specifier
+  name: (type_identifier) @symbol.enum.name
+  body: (enumerator_list)) @symbol.enum.def
+
+(type_definition
+  declarator: (type_identifier) @symbol.type.name) @symbol.type.def
+
+(preproc_include path: (string_literal) @edge.import.source)
+
+(base_class_clause (type_identifier) @edge.extends.parent)
+
+(call_expression
+  function: (identifier) @edge.call.target)
+
+(call_expression
+  function: (field_expression field: (field_identifier) @edge.call.target))
+`;
+var CSHARP_QUERY = `
+(class_declaration
+  name: (identifier) @symbol.class.name) @symbol.class.def
+
+(struct_declaration
+  name: (identifier) @symbol.class.name) @symbol.class.def
+
+(interface_declaration
+  name: (identifier) @symbol.interface.name) @symbol.interface.def
+
+(enum_declaration
+  name: (identifier) @symbol.enum.name) @symbol.enum.def
+
+(method_declaration
+  name: (identifier) @symbol.method.name) @symbol.method.def
+
+(base_list (identifier) @edge.extends.parent)
+
+(using_directive (identifier) @edge.import.target)
+
+(using_directive (qualified_name) @edge.import.target)
+
+(invocation_expression
+  function: (identifier) @edge.call.target)
+
+(invocation_expression
+  function: (member_access_expression name: (identifier) @edge.call.target))
+`;
+var PHP_QUERY = `
+(function_definition
+  name: (name) @symbol.function.name) @symbol.function.def
+
+(method_declaration
+  name: (name) @symbol.method.name) @symbol.method.def
+
+(class_declaration
+  name: (name) @symbol.class.name) @symbol.class.def
+
+(trait_declaration
+  name: (name) @symbol.class.name) @symbol.class.def
+
+(interface_declaration
+  name: (name) @symbol.interface.name) @symbol.interface.def
+
+(base_clause (name) @edge.extends.parent)
+
+(class_interface_clause (name) @edge.implements.parent)
+
+(namespace_use_clause (qualified_name (name) @edge.import.target))
+
+(function_call_expression
+  function: (name) @edge.call.target)
+
+(member_call_expression
+  name: (name) @edge.call.target)
+`;
+var KOTLIN_QUERY = `
+(function_declaration
+  (simple_identifier) @symbol.function.name) @symbol.function.def
+
+(class_declaration
+  (type_identifier) @symbol.class.name) @symbol.class.def
+
+(object_declaration
+  (type_identifier) @symbol.class.name) @symbol.class.def
+
+(delegation_specifier
+  (constructor_invocation (user_type (type_identifier) @edge.extends.parent)))
+
+(delegation_specifier
+  (user_type (type_identifier) @edge.implements.parent))
+
+(import_header (identifier) @edge.import.target)
+
+(call_expression (simple_identifier) @edge.call.target)
+`;
+var SCALA_QUERY = `
+(function_definition
+  name: (identifier) @symbol.function.name) @symbol.function.def
+
+(function_declaration
+  name: (identifier) @symbol.function.name) @symbol.function.def
+
+(class_definition
+  name: (identifier) @symbol.class.name) @symbol.class.def
+
+(object_definition
+  name: (identifier) @symbol.class.name) @symbol.class.def
+
+(trait_definition
+  name: (identifier) @symbol.interface.name) @symbol.interface.def
+
+(extends_clause type: (type_identifier) @edge.extends.parent)
+
+(extends_clause type: (compound_type base: (type_identifier) @edge.extends.parent))
+
+(extends_clause type: (compound_type extra: (type_identifier) @edge.implements.parent))
+
+(import_declaration path: (stable_identifier) @edge.import.target)
+
+(call_expression
+  function: (identifier) @edge.call.target)
+`;
 
 // ../packages/orion-client-core/src/treesitter/extractor.ts
 function queryFor(lang) {
@@ -4550,6 +4708,18 @@ function queryFor(lang) {
       return RUST_QUERY;
     case "java":
       return JAVA_QUERY;
+    case "c":
+      return C_QUERY;
+    case "cpp":
+      return CPP_QUERY;
+    case "csharp":
+      return CSHARP_QUERY;
+    case "php":
+      return PHP_QUERY;
+    case "kotlin":
+      return KOTLIN_QUERY;
+    case "scala":
+      return SCALA_QUERY;
     // Ruby intentionally falls back to regex: tree-sitter `(call method: …)`
     // can't distinguish `require "x"` (an import) from any other method
     // call without a `#match?` predicate, and a tree-sitter pass that
@@ -4568,21 +4738,64 @@ function signatureOf(node, allLines) {
   const line = (allLines[row] ?? "").trim();
   return line.length > 160 ? line.slice(0, 160) + "\u2026" : line;
 }
+var DEFINITION_NODE_TYPES = /* @__PURE__ */ new Set([
+  // Python
+  "function_definition",
+  "class_definition",
+  // JS/TS
+  "method_definition",
+  "function_declaration",
+  "class_declaration",
+  // Go / Java / C#
+  "method_declaration",
+  "interface_declaration",
+  "enum_declaration",
+  "struct_declaration",
+  // Rust
+  "function_item",
+  // C / C++
+  "class_specifier",
+  "struct_specifier",
+  "enum_specifier",
+  "type_definition",
+  // PHP
+  "trait_declaration",
+  // Kotlin
+  "object_declaration",
+  // Scala
+  "class_definition",
+  "object_definition",
+  "trait_definition"
+]);
+var NAME_NODE_TYPES = /* @__PURE__ */ new Set([
+  "identifier",
+  "type_identifier",
+  "simple_identifier",
+  "field_identifier",
+  "name"
+]);
+function definitionName(node) {
+  const named = node.childForFieldName("name");
+  if (named) return named.text;
+  let decl = node.childForFieldName("declarator");
+  for (let depth = 0; decl && depth < 8; depth += 1) {
+    if (NAME_NODE_TYPES.has(decl.type)) return decl.text;
+    decl = decl.childForFieldName("declarator");
+  }
+  for (const child of node.namedChildren) {
+    if (NAME_NODE_TYPES.has(child.type)) return child.text;
+  }
+  return "";
+}
 function enclosingSymbolName(node) {
   let cur = node.parent;
   while (cur) {
     if (cur.type === "impl_item") {
       const t = cur.childForFieldName("type");
       if (t) return t.text;
-    } else if (
-      // Python
-      cur.type === "function_definition" || cur.type === "class_definition" || // JS/TS
-      cur.type === "method_definition" || cur.type === "function_declaration" || cur.type === "class_declaration" || // Go / Java
-      cur.type === "method_declaration" || cur.type === "interface_declaration" || cur.type === "enum_declaration" || // Rust
-      cur.type === "function_item"
-    ) {
-      const nameNode = cur.childForFieldName("name");
-      if (nameNode) return nameNode.text;
+    } else if (DEFINITION_NODE_TYPES.has(cur.type)) {
+      const name2 = definitionName(cur);
+      if (name2) return name2;
     }
     cur = cur.parent;
   }
@@ -4904,6 +5117,7 @@ var TreeSitterWorkerPool = class {
 
 // ../packages/orion-client-core/src/treesitter/loader.ts
 var fs3 = __toESM(require("fs"));
+var zlib = __toESM(require("zlib"));
 var GRAMMAR_FILE = {
   python: "tree-sitter-python.wasm",
   typescript: "tree-sitter-typescript.wasm",
@@ -4912,7 +5126,13 @@ var GRAMMAR_FILE = {
   go: "tree-sitter-go.wasm",
   rust: "tree-sitter-rust.wasm",
   java: "tree-sitter-java.wasm",
-  ruby: "tree-sitter-ruby.wasm"
+  ruby: "tree-sitter-ruby.wasm",
+  c: "tree-sitter-c.wasm",
+  cpp: "tree-sitter-cpp.wasm",
+  csharp: "tree-sitter-csharp.wasm",
+  php: "tree-sitter-php.wasm",
+  kotlin: "tree-sitter-kotlin.wasm",
+  scala: "tree-sitter-scala.wasm"
 };
 var handle2 = null;
 var initAttempted = false;
@@ -4937,6 +5157,21 @@ function langFromExt(ext) {
       return "java";
     case ".rb":
       return "ruby";
+    case ".c":
+      return "c";
+    case ".cpp":
+    case ".cc":
+    case ".h":
+    case ".hpp":
+      return "cpp";
+    case ".cs":
+      return "csharp";
+    case ".php":
+      return "php";
+    case ".kt":
+      return "kotlin";
+    case ".scala":
+      return "scala";
     default:
       return null;
   }
@@ -4977,12 +5212,16 @@ async function tryLoad(grammarDir) {
     const next = grammarQueue.then(async () => {
       if (grammarCache.has(lang)) return grammarCache.get(lang) ?? null;
       const wasmPath = `${grammarDir}/${GRAMMAR_FILE[lang]}`;
-      if (!fs3.existsSync(wasmPath)) {
+      const gzPath = `${wasmPath}.gz`;
+      const plainExists = fs3.existsSync(wasmPath);
+      if (!plainExists && !fs3.existsSync(gzPath)) {
         grammarCache.set(lang, null);
         return null;
       }
       try {
-        const langObj = await Parser2.Language.load(wasmPath);
+        const langObj = plainExists ? await Parser2.Language.load(wasmPath) : await Parser2.Language.load(
+          new Uint8Array(zlib.gunzipSync(fs3.readFileSync(gzPath)))
+        );
         grammarCache.set(lang, langObj);
         return langObj;
       } catch {
@@ -5312,6 +5551,24 @@ var import_fs2 = require("fs");
 var import_fs = require("fs");
 var import_path = require("path");
 var tmpSeq = 0;
+var RENAME_CONTENTION = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
+function retriesRenameContention(code, platform = process.platform) {
+  return platform === "win32" && code !== void 0 && RENAME_CONTENTION.has(code);
+}
+async function renameWhenUnlocked(tmp, target) {
+  const ATTEMPTS = 20;
+  const DELAY_MS = 5;
+  for (let attempt = 1; ; attempt++) {
+    try {
+      await import_fs.promises.rename(tmp, target);
+      return;
+    } catch (err2) {
+      const code = err2.code;
+      if (attempt >= ATTEMPTS || !retriesRenameContention(code)) throw err2;
+      await new Promise((resolve5) => setTimeout(resolve5, DELAY_MS));
+    }
+  }
+}
 async function atomicWriteFile(targetPath, content, options = {}) {
   const encoding = options.encoding ?? "utf8";
   let target = targetPath;
@@ -5337,7 +5594,7 @@ async function atomicWriteFile(targetPath, content, options = {}) {
       await handle4.close();
     }
     if (targetExists && targetMode !== void 0) await import_fs.promises.chmod(tmp, targetMode);
-    await import_fs.promises.rename(tmp, target);
+    await renameWhenUnlocked(tmp, target);
   } catch {
     await import_fs.promises.unlink(tmp).catch(() => {
     });
@@ -5895,6 +6152,46 @@ var RUBY_RULES = [
   { match: /^\s*class\s+(\w+)/, kind: "class", nameGroup: 1 },
   { match: /^\s*module\s+(\w+)/, kind: "type", nameGroup: 1 }
 ];
+var C_FAMILY_RULES = [
+  { match: /^\s*(?:template\s*<[^>]*>\s*)?class\s+(\w+)/, kind: "class", nameGroup: 1 },
+  { match: /^\s*(?:typedef\s+)?struct\s+(\w+)/, kind: "struct", nameGroup: 1 },
+  { match: /^\s*enum(?:\s+class)?\s+(\w+)/, kind: "enum", nameGroup: 1 },
+  { match: /^\s*namespace\s+(\w+)/, kind: "type", nameGroup: 1 },
+  // A definition, not a declaration: the line must open a body, so `void go();` is correctly
+  // skipped. Leading indentation IS allowed, because a class's methods are indented and they are
+  // most of the content of the large C++ files this fallback exists to serve — anchoring at column
+  // 0 found the class and none of its methods.
+  //
+  // Allowing indentation is what makes the negative lookahead load-bearing: without it, `if (x) {`,
+  // `while (y) {` and `for (i) {` all parse as functions named after the keyword. `\b` in the
+  // lookahead keeps a real function called `news()` or `deleter()` matchable.
+  {
+    match: /^\s*(?!(?:if|for|while|switch|catch|return|else|do|new|delete|sizeof|throw|co_return|co_await)\b)[\w~][\w\s:*&<>,~]*?\b(\w+)\s*\([^)]*\)\s*(?:(?:const|noexcept|override|final|mutable)\s+)*\{/,
+    kind: "function",
+    nameGroup: 1
+  }
+];
+var CSHARP_RULES = [
+  { match: /^\s*(?:public|private|protected|internal|static|sealed|abstract|partial|\s)*class\s+(\w+)/, kind: "class", nameGroup: 1 },
+  { match: /^\s*(?:public|private|protected|internal|partial|\s)*interface\s+(\w+)/, kind: "interface", nameGroup: 1 },
+  { match: /^\s*(?:public|private|protected|internal|readonly|record|partial|\s)*struct\s+(\w+)/, kind: "struct", nameGroup: 1 },
+  { match: /^\s*(?:public|private|protected|internal|\s)*enum\s+(\w+)/, kind: "enum", nameGroup: 1 },
+  { match: /^\s*(?:public|private|protected|internal|static|virtual|override|async|sealed|abstract|extern|unsafe|new|\s)+[\w<>[\],.?]+\s+(\w+)\s*\([^)]*\)\s*[{=;]/, kind: "method", nameGroup: 1 }
+];
+var PHP_RULES = [
+  { match: /^\s*(?:abstract\s+|final\s+)*class\s+(\w+)/, kind: "class", nameGroup: 1 },
+  { match: /^\s*interface\s+(\w+)/, kind: "interface", nameGroup: 1 },
+  { match: /^\s*trait\s+(\w+)/, kind: "class", nameGroup: 1 },
+  { match: /^\s*(?:(?:public|private|protected|static|abstract|final)\s+)*function\s+&?(\w+)\s*\(/, kind: "function", nameGroup: 1 }
+];
+var SWIFT_RULES = [
+  { match: /^\s*(?:(?:public|private|internal|fileprivate|open|final)\s+)*class\s+(\w+)/, kind: "class", nameGroup: 1 },
+  { match: /^\s*(?:(?:public|private|internal|fileprivate|open)\s+)*struct\s+(\w+)/, kind: "struct", nameGroup: 1 },
+  { match: /^\s*(?:(?:public|private|internal|fileprivate|open|indirect)\s+)*enum\s+(\w+)/, kind: "enum", nameGroup: 1 },
+  { match: /^\s*(?:(?:public|private|internal|fileprivate|open)\s+)*protocol\s+(\w+)/, kind: "interface", nameGroup: 1 },
+  { match: /^\s*extension\s+(\w+)/, kind: "type", nameGroup: 1 },
+  { match: /^\s*(?:(?:public|private|internal|fileprivate|open|static|class|final|override|mutating)\s+)*func\s+(\w+)/, kind: "function", nameGroup: 1 }
+];
 function languageFor(path5) {
   const dot = path5.lastIndexOf(".");
   const ext = dot >= 0 ? path5.slice(dot).toLowerCase() : "";
@@ -5921,6 +6218,20 @@ function languageFor(path5) {
       return { family: "java", rules: JAVA_KOTLIN_RULES };
     case ".rb":
       return { family: "ruby", rules: RUBY_RULES };
+    // `.h` follows the same C++-over-C choice the tree-sitter mapping makes (loader.ts
+    // `langFromExt`) — the extension is ambiguous and C++ is the more forgiving superset.
+    case ".c":
+    case ".cpp":
+    case ".cc":
+    case ".h":
+    case ".hpp":
+      return { family: "cfamily", rules: C_FAMILY_RULES };
+    case ".cs":
+      return { family: "csharp", rules: CSHARP_RULES };
+    case ".php":
+      return { family: "php", rules: PHP_RULES };
+    case ".swift":
+      return { family: "swift", rules: SWIFT_RULES };
     default:
       return { family: "other", rules: [] };
   }
@@ -6052,6 +6363,13 @@ function lastWord(s) {
   const m = s.match(/(\w+)\s*$/);
   return m ? m[1] : s;
 }
+function pathBasename(s) {
+  const parts2 = s.trim().split(/[\\/]/);
+  return parts2[parts2.length - 1] || s;
+}
+function jsModuleTarget(spec) {
+  return pathBasename(spec).replace(/\.(d\.)?ts$/, "").replace(/\.js$/, "");
+}
 function extractEdgesPython(path5, lines) {
   const edges = [];
   const scope = [];
@@ -6161,7 +6479,7 @@ function extractEdgesJsTs(path5, lines) {
     if (importMatch) {
       const moduleSpec = importMatch[5];
       if (moduleSpec) {
-        const tgt = lastWord(moduleSpec.replace(/[./]+/g, "."));
+        const tgt = jsModuleTarget(moduleSpec);
         if (tgt) {
           edges.push({
             kind: "imports",
@@ -6386,7 +6704,7 @@ function extractEdgesRuby(path5, lines) {
     const line = lines[i2];
     const requireMatch = /^\s*require(?:_relative)?\s+['"]([^'"]+)['"]/.exec(line);
     if (requireMatch) {
-      const tgt = lastWord(requireMatch[1].replace(/\//g, "."));
+      const tgt = pathBasename(requireMatch[1]).replace(/\.rb$/, "");
       edges.push({
         kind: "imports",
         source_path: path5,
@@ -6408,6 +6726,122 @@ function extractEdgesRuby(path5, lines) {
   }
   return edges;
 }
+function stripBracketGroups(s) {
+  let out2 = s;
+  for (let i2 = 0; i2 < 8; i2++) {
+    const next = out2.replace(/<[^<>]*>/g, " ").replace(/\([^()]*\)/g, " ");
+    if (next === out2) break;
+    out2 = next;
+  }
+  return out2;
+}
+var declRegexCache = /* @__PURE__ */ new Map();
+function declRegexFor(keywords) {
+  const key = keywords.join("|");
+  let re = declRegexCache.get(key);
+  if (!re) {
+    re = new RegExp(`^\\s*(?:[\\w[\\]]+\\s+)*?(?:${key})\\s+(\\w+)\\s*:\\s*([^{;/]+)`);
+    declRegexCache.set(key, re);
+  }
+  return re;
+}
+function extractEdgesColonInherit(path5, lines, opts) {
+  const edges = [];
+  const declRe = declRegexFor(opts.declKeywords);
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    const imp = opts.importRe.exec(line);
+    if (imp && imp[1]) {
+      const target = opts.importTarget(imp[1]);
+      if (target) {
+        edges.push({
+          kind: "imports",
+          source_path: path5,
+          source_name: "",
+          target: target.toLowerCase(),
+          line: i2 + 1
+        });
+      }
+    }
+    const decl = declRe.exec(line);
+    if (decl) {
+      const child = decl[1];
+      let list = decl[2];
+      const whereAt = list.search(/\bwhere\b/);
+      if (whereAt >= 0) list = list.slice(0, whereAt);
+      for (const raw of stripBracketGroups(list).split(",")) {
+        let base = raw;
+        if (opts.baseNoise) base = base.replace(opts.baseNoise, " ");
+        const first = base.trim().split(/\s+/)[0] ?? "";
+        const name2 = first.includes(".") ? first.split(".").pop() ?? "" : first;
+        if (/^\w+$/.test(name2) && name2 !== child) {
+          edges.push({
+            kind: "extends",
+            source_path: path5,
+            source_name: child,
+            target: name2.toLowerCase(),
+            line: i2 + 1
+          });
+        }
+      }
+    }
+  }
+  return edges;
+}
+function extractEdgesPhp(path5, lines) {
+  const edges = [];
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    const use = /^\s*use\s+([\w\\]+)\s*(?:as\s+\w+\s*)?;/.exec(line);
+    if (use) {
+      edges.push({
+        kind: "imports",
+        source_path: path5,
+        source_name: "",
+        target: lastWord(use[1].replace(/\\/g, ".")).toLowerCase(),
+        line: i2 + 1
+      });
+    }
+    const req = /^\s*(?:require|include)(?:_once)?\s*\(?\s*['"]([^'"]+)['"]/.exec(line);
+    if (req) {
+      edges.push({
+        kind: "imports",
+        source_path: path5,
+        source_name: "",
+        target: pathBasename(req[1]).toLowerCase(),
+        line: i2 + 1
+      });
+    }
+    const decl = /^\s*(?:abstract\s+|final\s+)*class\s+(\w+)(?:\s+extends\s+([\w\\]+))?(?:\s+implements\s+([\w\\,\s]+))?/.exec(line);
+    if (decl) {
+      const child = decl[1];
+      if (decl[2]) {
+        edges.push({
+          kind: "extends",
+          source_path: path5,
+          source_name: child,
+          target: lastWord(decl[2].replace(/\\/g, ".")).toLowerCase(),
+          line: i2 + 1
+        });
+      }
+      if (decl[3]) {
+        for (const raw of decl[3].split(",")) {
+          const name2 = lastWord(raw.trim().replace(/\\/g, "."));
+          if (name2) {
+            edges.push({
+              kind: "implements",
+              source_path: path5,
+              source_name: child,
+              target: name2.toLowerCase(),
+              line: i2 + 1
+            });
+          }
+        }
+      }
+    }
+  }
+  return edges;
+}
 function extractEdges(path5, content) {
   const { family } = languageFor(path5);
   const lines = content.split("\n");
@@ -6424,6 +6858,30 @@ function extractEdges(path5, content) {
       return extractEdgesJava(path5, lines);
     case "ruby":
       return extractEdgesRuby(path5, lines);
+    case "cfamily":
+      return extractEdgesColonInherit(path5, lines, {
+        importRe: /^\s*#\s*include\s+"([^"]+)"/,
+        importTarget: pathBasename,
+        // C++ `enum class Foo : int` names a storage type, not a base — excluded (see declKeywords).
+        declKeywords: ["class", "struct"],
+        baseNoise: /\b(?:public|private|protected|virtual)\b/g
+      });
+    case "csharp":
+      return extractEdgesColonInherit(path5, lines, {
+        importRe: /^\s*(?:global\s+)?using\s+(?:static\s+)?([\w.]+)\s*;/,
+        importTarget: lastWord,
+        // `enum Color : byte` is a storage type, not a base — excluded (see declKeywords).
+        declKeywords: ["class", "struct", "interface"]
+      });
+    case "swift":
+      return extractEdgesColonInherit(path5, lines, {
+        importRe: /^\s*import\s+([\w.]+)/,
+        importTarget: lastWord,
+        // Swift DOES carry real conformance on an enum, and its query emits those edges.
+        declKeywords: ["class", "struct", "enum", "protocol"]
+      });
+    case "php":
+      return extractEdgesPhp(path5, lines);
     default:
       return [];
   }