orion-super-agent-dev 0.1.13 → 0.1.14

package/out/worker.js

@@ -1581,6 +1581,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) {
@@ -1598,6 +1756,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
@@ -1616,21 +1786,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;
   }
@@ -1823,6 +2036,7 @@ function extractWithTreeSitter(handle4, lang, path, content) {
 
 // ../packages/orion-client-core/src/treesitter/loader.ts
 import * as fs2 from "fs";
+import * as zlib from "zlib";
 var GRAMMAR_FILE = {
   python: "tree-sitter-python.wasm",
   typescript: "tree-sitter-typescript.wasm",
@@ -1831,7 +2045,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;
@@ -1866,12 +2086,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 (!fs2.existsSync(wasmPath)) {
+      const gzPath = `${wasmPath}.gz`;
+      const plainExists = fs2.existsSync(wasmPath);
+      if (!plainExists && !fs2.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(fs2.readFileSync(gzPath)))
+        );
         grammarCache.set(lang, langObj);
         return langObj;
       } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orion-super-agent-dev",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "[dev] Orion \u2014 a terminal AI super-agent, strongest at coding. Local brain, local disk: the agent loop runs on your machine; only the metered model call leaves it.",
   "license": "MIT",
   "type": "module",