codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/parsers/ruby.js

@@ -0,0 +1,212 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ruby_exports = {};
+__export(ruby_exports, {
+  rubyPlugin: () => rubyPlugin
+});
+module.exports = __toCommonJS(ruby_exports);
+var import_base = require("./base");
+const sig = (node) => ({ signature: (0, import_base.shapeOf)(node.childForFieldName("parameters"))?.replace(/^(?!\()(.*)$/, "($1)") ?? "()" });
+function lineOf(node) {
+  return { startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1 };
+}
+function nameOf(node) {
+  return node.childForFieldName("name")?.text ?? null;
+}
+function bodyOf(node) {
+  return node.children.find((c) => c.type === "body_statement") ?? null;
+}
+const ATTR_CALLS = /* @__PURE__ */ new Set(["attr_reader", "attr_writer", "attr_accessor"]);
+function attrNames(call) {
+  const args = call.children.find((c) => c.type === "argument_list");
+  if (!args) return [];
+  return args.children.filter((c) => c.type === "simple_symbol").map((c) => c.text.replace(/^:/, "")).filter(Boolean);
+}
+function symbolsInBody(body, qualifier, singleton = false) {
+  if (!body) return [];
+  const out = [];
+  const sep = singleton ? "." : "#";
+  for (const child of body.children) {
+    switch (child.type) {
+      case "method": {
+        const name = nameOf(child);
+        if (!name) break;
+        out.push({
+          name: qualifier ? `${qualifier}${sep}${name}` : name,
+          kind: "function",
+          ...lineOf(child),
+          children: [],
+          modifiers: [singleton ? "class_method" : "instance_method"],
+          ...sig(child)
+        });
+        break;
+      }
+      case "singleton_method": {
+        const name = nameOf(child);
+        if (!name) break;
+        out.push({
+          name: qualifier ? `${qualifier}.${name}` : name,
+          kind: "function",
+          ...lineOf(child),
+          children: [],
+          modifiers: ["class_method"],
+          ...sig(child)
+        });
+        break;
+      }
+      case "call": {
+        const fn = child.children.find((c) => c.type === "identifier")?.text;
+        if (!fn || !ATTR_CALLS.has(fn)) break;
+        for (const attr of attrNames(child)) {
+          out.push({
+            name: qualifier ? `${qualifier}${sep}${attr}` : attr,
+            // attr_* genuinely defines methods in Ruby, so that is what
+            // they are — there is no separate property concept to model.
+            kind: "method",
+            ...lineOf(child),
+            children: [],
+            modifiers: [fn]
+          });
+        }
+        break;
+      }
+      case "class":
+      case "module":
+        out.push(...classOrModule(child, qualifier));
+        break;
+      case "singleton_class": {
+        const reopened = child.children.find(
+          (c) => c.type === "self" || c.type === "constant"
+        );
+        if (reopened?.type !== "self") break;
+        out.push(...symbolsInBody(bodyOf(child), qualifier, true));
+        break;
+      }
+      case "assignment": {
+        const target = child.children[0];
+        if (target?.type !== "constant") break;
+        out.push({
+          name: qualifier ? `${qualifier}::${target.text}` : target.text,
+          kind: "variable",
+          ...lineOf(child),
+          children: [],
+          modifiers: ["constant"]
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return out;
+}
+function classOrModule(node, parentQualifier) {
+  const name = nameOf(node);
+  if (!name) return [];
+  const qualified = parentQualifier ? `${parentQualifier}::${name}` : name;
+  const isClass = node.type === "class";
+  const superclass = node.children.find((c) => c.type === "superclass")?.text.replace(/^<\s*/, "").trim();
+  const modifiers = [isClass ? "class" : "module"];
+  if (superclass) modifiers.push(`extends:${superclass}`);
+  const self = {
+    name: qualified,
+    kind: isClass ? "class" : "interface",
+    ...lineOf(node),
+    children: [],
+    modifiers
+  };
+  return [self, ...symbolsInBody(bodyOf(node), qualified)];
+}
+function extractSymbols(root) {
+  const out = [];
+  for (const child of root.children) {
+    switch (child.type) {
+      case "class":
+      case "module":
+        out.push(...classOrModule(child, null));
+        break;
+      case "method": {
+        const name = nameOf(child);
+        if (name) {
+          out.push({ name, kind: "function", ...lineOf(child), children: [], modifiers: [], ...sig(child) });
+        }
+        break;
+      }
+      case "assignment": {
+        const target = child.children[0];
+        if (target?.type === "constant") {
+          out.push({
+            name: target.text,
+            kind: "variable",
+            ...lineOf(child),
+            children: [],
+            modifiers: ["constant"]
+          });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return out;
+}
+const REQUIRE_CALLS = /* @__PURE__ */ new Set(["require", "require_relative", "load", "autoload"]);
+function* callNodes(node) {
+  if (node.type === "call") yield node;
+  for (const child of node.children) yield* callNodes(child);
+}
+function extractImports(root) {
+  const imports = [];
+  for (const child of callNodes(root)) {
+    const head = child.children[0];
+    const fn = head?.type === "identifier" ? head.text : void 0;
+    if (!fn || !REQUIRE_CALLS.has(fn)) continue;
+    const args = child.children.find((c) => c.type === "argument_list");
+    if (!args) continue;
+    for (const arg of args.children) {
+      if (arg.type !== "string") continue;
+      const source = arg.text.replace(/^['"]/, "").replace(/['"]$/, "");
+      if (!source) continue;
+      imports.push({
+        source,
+        specifiers: [source.split("/").pop() || source],
+        isDefault: false,
+        isNamespace: false,
+        // `require_relative` resolves like a path; `require` is a
+        // load-path lookup. Ruby is the first language here where the
+        // two are syntactically identical in `source`, so the extractor
+        // has to record which was written.
+        isRelative: fn === "require_relative"
+      });
+    }
+  }
+  return imports;
+}
+const rubyPlugin = {
+  language: "ruby",
+  extensions: [".rb", ".rake"],
+  grammarFile: "tree-sitter-ruby.wasm",
+  grammarKey: "ruby",
+  extractSymbols,
+  extractImports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rubyPlugin
+});

package/src/backend/services/parsers/rust.js

@@ -0,0 +1,97 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rust_exports = {};
+__export(rust_exports, {
+  rustPlugin: () => rustPlugin
+});
+module.exports = __toCommonJS(rust_exports);
+var import_base = require("./base");
+function nameOf(node) {
+  return node.childForFieldName("name")?.text || "anonymous";
+}
+function lineOf(node) {
+  return { startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1 };
+}
+const pub = (node) => node.children.some((c) => c.type === "visibility_modifier") ? ["pub"] : [];
+const sig = (node, skip = []) => {
+  const signature = (0, import_base.headerSignature)(node, skip);
+  return signature ? { signature } : {};
+};
+function nodeToSymbol(node) {
+  switch (node.type) {
+    case "function_item":
+      return { name: nameOf(node), kind: "function", ...lineOf(node), children: [], modifiers: pub(node), ...sig(node) };
+    case "struct_item":
+      return { name: nameOf(node), kind: "class", ...lineOf(node), children: [], modifiers: ["struct", ...pub(node)] };
+    case "enum_item":
+      return { name: nameOf(node), kind: "enum", ...lineOf(node), children: [], modifiers: pub(node) };
+    case "trait_item":
+      return { name: nameOf(node), kind: "interface", ...lineOf(node), children: [], modifiers: ["trait", ...pub(node)] };
+    case "impl_item": {
+      const typeNode = node.childForFieldName("type");
+      const name = typeNode ? typeNode.text : "impl";
+      return { name: `impl ${name}`, kind: "class", ...lineOf(node), children: [], modifiers: ["impl"] };
+    }
+    case "mod_item":
+      return { name: nameOf(node), kind: "class", ...lineOf(node), children: [], modifiers: ["mod"] };
+    case "type_item":
+      return { name: nameOf(node), kind: "type", ...lineOf(node), children: [], modifiers: pub(node) };
+    default:
+      return null;
+  }
+}
+function extractSymbols(node) {
+  const symbols = [];
+  for (const child of node.children) {
+    const sym = nodeToSymbol(child);
+    if (sym) symbols.push(sym);
+  }
+  return symbols;
+}
+function readUsePath(node) {
+  const text = (node.text || "").trim().replace(/^use\s+/, "").replace(/;\s*$/, "");
+  const braceIdx = text.indexOf("{");
+  return braceIdx === -1 ? text : text.slice(0, braceIdx).replace(/::$/, "");
+}
+function extractImports(node) {
+  const imports = [];
+  for (const child of node.children) {
+    if (child.type !== "use_declaration") continue;
+    const path = readUsePath(child);
+    if (!path) continue;
+    imports.push({
+      source: path,
+      specifiers: [path.split("::").pop() || path],
+      isDefault: false,
+      isNamespace: false
+    });
+  }
+  return imports;
+}
+const rustPlugin = {
+  language: "rust",
+  extensions: [".rs"],
+  grammarFile: "tree-sitter-rust.wasm",
+  grammarKey: "rust",
+  extractSymbols,
+  extractImports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rustPlugin
+});

package/src/backend/services/parsers/swift.js

@@ -0,0 +1,221 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var swift_exports = {};
+__export(swift_exports, {
+  swiftPlugin: () => swiftPlugin
+});
+module.exports = __toCommonJS(swift_exports);
+var import_base = require("./base");
+const sig = (node, skip = []) => {
+  const signature = (0, import_base.headerSignature)(node, skip);
+  return signature ? { signature } : {};
+};
+function lineOf(node) {
+  return { startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1 };
+}
+function keywordOf(node, keywords) {
+  for (const child of node.children) {
+    if (!child.isNamed && keywords.includes(child.type)) return child.type;
+  }
+  return null;
+}
+function modifiersOf(node, ...extra) {
+  const block = node.children.find((c) => c.type === "modifiers");
+  const mods = block ? block.namedChildren.map((m) => m.text) : [];
+  return [...mods, ...extra];
+}
+function bodyOf(node) {
+  return node.children.find((c) => /(_body|_class_body)$/.test(c.type)) ?? null;
+}
+function firstSimpleIdentifier(node) {
+  if (!node) return null;
+  if (node.type === "simple_identifier") return node.text;
+  for (const child of node.namedChildren) {
+    const found = firstSimpleIdentifier(child);
+    if (found) return found;
+  }
+  return null;
+}
+function propertySymbols(node, owner) {
+  const mods = modifiersOf(node, owner ? "property" : "top_level");
+  const out = [];
+  for (const child of node.children) {
+    if (child.type !== "pattern") continue;
+    const name = firstSimpleIdentifier(child);
+    if (!name) continue;
+    out.push({
+      name: owner ? `${owner}.${name}` : name,
+      kind: "variable",
+      ...lineOf(node),
+      children: [],
+      modifiers: mods
+    });
+  }
+  return out;
+}
+function memberSymbol(node, owner) {
+  switch (node.type) {
+    case "function_declaration":
+    case "protocol_function_declaration": {
+      const name = node.children.find((c) => c.type === "simple_identifier")?.text;
+      if (!name) return null;
+      return { name: `${owner}.${name}`, kind: "method", ...lineOf(node), children: [], modifiers: modifiersOf(node), ...sig(node) };
+    }
+    case "init_declaration":
+      return { name: `${owner}.init`, kind: "method", ...lineOf(node), children: [], modifiers: modifiersOf(node, "initializer"), ...sig(node) };
+    case "deinit_declaration":
+      return { name: `${owner}.deinit`, kind: "method", ...lineOf(node), children: [], modifiers: modifiersOf(node, "deinitializer") };
+    case "subscript_declaration":
+      return { name: `${owner}.subscript`, kind: "method", ...lineOf(node), children: [], modifiers: modifiersOf(node, "subscript"), ...sig(node) };
+    case "typealias_declaration": {
+      const name = node.children.find((c) => c.type === "type_identifier")?.text;
+      if (!name) return null;
+      return { name: `${owner}.${name}`, kind: "type", ...lineOf(node), children: [], modifiers: modifiersOf(node) };
+    }
+    default:
+      return null;
+  }
+}
+function memberSymbols(body, owner) {
+  if (!body) return [];
+  const out = [];
+  for (const child of body.namedChildren) {
+    if (child.type === "property_declaration" || child.type === "protocol_property_declaration") {
+      out.push(...propertySymbols(child, owner));
+      continue;
+    }
+    if (child.type === "enum_entry") {
+      for (const id of child.children) {
+        if (id.type !== "simple_identifier") continue;
+        out.push({
+          name: `${owner}.${id.text}`,
+          kind: "variable",
+          ...lineOf(child),
+          children: [],
+          modifiers: ["enum_member"]
+        });
+      }
+      continue;
+    }
+    const nested = typeSymbol(child, owner);
+    if (nested) {
+      out.push(nested);
+      continue;
+    }
+    const member = memberSymbol(child, owner);
+    if (member) out.push(member);
+  }
+  return out;
+}
+const KEYWORD_KINDS = {
+  class: "class",
+  struct: "class",
+  enum: "enum",
+  actor: "class",
+  extension: "class"
+};
+function typeSymbol(node, prefix) {
+  if (node.type === "protocol_declaration") {
+    const bare2 = node.children.find((c) => c.type === "type_identifier")?.text;
+    if (!bare2) return null;
+    const name2 = prefix ? `${prefix}.${bare2}` : bare2;
+    return {
+      name: name2,
+      kind: "interface",
+      ...lineOf(node),
+      children: memberSymbols(bodyOf(node), name2),
+      modifiers: modifiersOf(node)
+    };
+  }
+  if (node.type !== "class_declaration") return null;
+  const keyword = keywordOf(node, ["class", "struct", "enum", "actor", "extension"]) ?? "class";
+  const kind = KEYWORD_KINDS[keyword] ?? "class";
+  const target = node.children.find(
+    (c) => c.type === "type_identifier" || c.type === "user_type"
+  );
+  if (!target) return null;
+  const bare = keyword === "extension" ? `${target.text} (extension)` : target.text;
+  const name = prefix ? `${prefix}.${bare}` : bare;
+  return {
+    name,
+    kind,
+    ...lineOf(node),
+    children: memberSymbols(bodyOf(node), prefix ? `${prefix}.${target.text}` : target.text),
+    modifiers: modifiersOf(node, keyword)
+  };
+}
+function extractSymbols(root) {
+  return (0, import_base.flattenSymbols)(collectTopLevel(root));
+}
+function collectTopLevel(root) {
+  const out = [];
+  for (const child of root.namedChildren) {
+    if (child.type === "function_declaration") {
+      const name = child.children.find((c) => c.type === "simple_identifier")?.text;
+      if (name) {
+        out.push({ name, kind: "function", ...lineOf(child), children: [], modifiers: modifiersOf(child), ...sig(child) });
+      }
+      continue;
+    }
+    if (child.type === "property_declaration") {
+      out.push(...propertySymbols(child, null));
+      continue;
+    }
+    if (child.type === "typealias_declaration") {
+      const name = child.children.find((c) => c.type === "type_identifier")?.text;
+      if (name) out.push({ name, kind: "type", ...lineOf(child), children: [], modifiers: modifiersOf(child) });
+      continue;
+    }
+    const sym = typeSymbol(child, null);
+    if (sym) out.push(sym);
+  }
+  return out;
+}
+function extractImports(root) {
+  const imports = [];
+  for (const child of root.namedChildren) {
+    if (child.type !== "import_declaration") continue;
+    const target = child.children.find((c) => c.type === "identifier");
+    const full = target?.text?.trim();
+    if (!full) continue;
+    const segments = full.split(".");
+    const moduleName = segments[0];
+    if (!moduleName) continue;
+    imports.push({
+      source: moduleName,
+      specifiers: segments.length > 1 ? [segments[segments.length - 1]] : [moduleName],
+      isDefault: false,
+      // A bare `import Foo` brings the module's whole public surface
+      // into scope; `import struct Foo.Bar` brings one declaration.
+      isNamespace: segments.length === 1
+    });
+  }
+  return imports;
+}
+const swiftPlugin = {
+  language: "swift",
+  extensions: [".swift"],
+  grammarFile: "tree-sitter-swift.wasm",
+  grammarKey: "swift",
+  extractSymbols,
+  extractImports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  swiftPlugin
+});