codetrellis 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,124 @@
+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 base_exports = {};
+__export(base_exports, {
+  flattenSymbols: () => flattenSymbols,
+  headerSignature: () => headerSignature,
+  shapeOf: () => shapeOf,
+  shapeOfNodes: () => shapeOfNodes,
+  signatureOf: () => signatureOf
+});
+module.exports = __toCommonJS(base_exports);
+function flattenSymbols(symbols) {
+  const out = [];
+  const visit = (list) => {
+    for (const sym of list) {
+      out.push({ ...sym, children: [] });
+      if (sym.children.length > 0) visit(sym.children);
+    }
+  };
+  visit(symbols);
+  return out;
+}
+const ATOMIC = /* @__PURE__ */ new Set(["string", "template_string", "number", "integer", "float", "regex", "true", "false", "none", "null", "undefined"]);
+const STRING_LITERAL = /(^|_)string(_literal)?$|^encapsed_string$|^character_literal$/;
+const TIGHT = /* @__PURE__ */ new Set(["variable_name", "optional_type", "splat_parameter", "hash_splat_parameter", "block_parameter", "pointer_type", "reference_type", "self_parameter"]);
+function shapeOf(node) {
+  if (!node) return null;
+  return shapeOfNodes([node]);
+}
+function shapeOfNodes(nodes) {
+  if (!nodes.length) return null;
+  const tokens = [];
+  const walk = (n) => {
+    if (n.type === "comment" || /_comment$/.test(n.type) || n.type === ";") return;
+    if (n.childCount === 0 || ATOMIC.has(n.type) || STRING_LITERAL.test(n.type)) {
+      if (n.text) tokens.push(n.text);
+      return;
+    }
+    if (TIGHT.has(n.type)) {
+      tokens.push(n.text.replace(/\s+/g, " ").replace(/([&*]) (?=[\w'])/g, "$1"));
+      return;
+    }
+    for (const c of n.children) walk(c);
+  };
+  for (const node of nodes) walk(node);
+  return tokens.join(" ").replace(/,(\s*[)\]}>])/g, "$1").replace(/\s+([,;:)\]>?])/g, "$1").replace(/([([<])\s+/g, "$1").replace(/([\w>\])])\s+([<[])/g, "$1$2").replace(/([>\]]) \(/g, "$1(").replace(/ \.$/, ".").replace(/ \. /g, ".").replace(/\.\.\. /g, "...").replace(/(^|[(,] ?)(\*{1,2}) /g, "$1$2");
+}
+function signatureOf(...parts) {
+  const present = parts.filter((p) => !!p);
+  return present.length ? present.join("").replace(/\s{2,}/g, " ").trim() : void 0;
+}
+const NOT_HEADER = /* @__PURE__ */ new Set([
+  // bodies
+  "block",
+  "function_body",
+  "body_statement",
+  "compound_statement",
+  "constructor_body",
+  "arrow_expression_clause",
+  // modifiers, visibility, annotations and attributes
+  "modifiers",
+  "modifier",
+  "visibility_modifier",
+  "static_modifier",
+  "abstract_modifier",
+  "final_modifier",
+  "readonly_modifier",
+  "function_modifiers",
+  "attribute_list",
+  "annotation",
+  "marker_annotation",
+  "attribute",
+  // declaring keywords, and what ends a declaration
+  "fn",
+  "fun",
+  "func",
+  "def",
+  "function",
+  "end",
+  ";"
+]);
+function headerSignature(node, skipFields = []) {
+  const name = node.childForFieldName("name");
+  const before = [];
+  const after = [];
+  let seenName = false;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (name && child.startIndex === name.startIndex && child.endIndex === name.endIndex) {
+      seenName = true;
+      continue;
+    }
+    if (NOT_HEADER.has(child.type)) continue;
+    const field = node.fieldNameForChild(i);
+    if (field === "body" || field && skipFields.includes(field)) continue;
+    (seenName ? after : before).push(child);
+  }
+  const text = [shapeOfNodes(before), shapeOfNodes(after)].filter(Boolean).join(" ");
+  return signatureOf(text);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flattenSymbols,
+  headerSignature,
+  shapeOf,
+  shapeOfNodes,
+  signatureOf
+});

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

@@ -0,0 +1,224 @@
+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 csharp_exports = {};
+__export(csharp_exports, {
+  csharpPlugin: () => csharpPlugin
+});
+module.exports = __toCommonJS(csharp_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 nameOf(node) {
+  return node.childForFieldName("name")?.text ?? null;
+}
+function modifiersOf(node, ...extra) {
+  const mods = [];
+  for (const child of node.children) {
+    if (child.type === "modifier") mods.push(child.text);
+  }
+  return [...mods, ...extra];
+}
+function declarationList(node) {
+  return node.children.find((c) => c.type === "declaration_list") ?? null;
+}
+function positionalMembers(node, owner) {
+  const params = node.children.find((c) => c.type === "parameter_list");
+  if (!params) return [];
+  const out = [];
+  for (const param of params.namedChildren) {
+    if (param.type !== "parameter") continue;
+    const name = nameOf(param) ?? param.children.find((c) => c.type === "identifier")?.text;
+    if (!name) continue;
+    out.push({
+      name: `${owner}.${name}`,
+      kind: "variable",
+      ...lineOf(param),
+      children: [],
+      modifiers: ["positional"]
+    });
+  }
+  return out;
+}
+function memberSymbol(node, owner) {
+  switch (node.type) {
+    case "method_declaration":
+    case "local_function_statement": {
+      const name = nameOf(node);
+      if (!name) return null;
+      return { name: `${owner}.${name}`, kind: "method", ...lineOf(node), children: [], modifiers: modifiersOf(node), ...sig(node) };
+    }
+    case "constructor_declaration": {
+      const name = nameOf(node) ?? owner;
+      return { name: `${owner}.${name}`, kind: "method", ...lineOf(node), children: [], modifiers: modifiersOf(node, "constructor"), ...sig(node) };
+    }
+    case "destructor_declaration":
+      return { name: `${owner}.~${owner}`, kind: "method", ...lineOf(node), children: [], modifiers: modifiersOf(node, "destructor") };
+    case "operator_declaration":
+      return { name: `${owner}.operator`, kind: "method", ...lineOf(node), children: [], modifiers: modifiersOf(node, "operator"), ...sig(node) };
+    case "property_declaration":
+    case "indexer_declaration": {
+      const name = nameOf(node) ?? (node.type === "indexer_declaration" ? "this[]" : null);
+      if (!name) return null;
+      return { name: `${owner}.${name}`, kind: "variable", ...lineOf(node), children: [], modifiers: modifiersOf(node, "property") };
+    }
+    case "event_declaration": {
+      const name = nameOf(node);
+      if (!name) return null;
+      return { name: `${owner}.${name}`, kind: "variable", ...lineOf(node), children: [], modifiers: modifiersOf(node, "event") };
+    }
+    default:
+      return null;
+  }
+}
+function fieldSymbols(node, owner) {
+  const decl = node.children.find((c) => c.type === "variable_declaration");
+  if (!decl) return [];
+  const mods = modifiersOf(node, "field");
+  const out = [];
+  for (const child of decl.namedChildren) {
+    if (child.type !== "variable_declarator") continue;
+    const name = child.children.find((c) => c.type === "identifier")?.text;
+    if (!name) continue;
+    out.push({ name: `${owner}.${name}`, kind: "variable", ...lineOf(child), children: [], modifiers: mods });
+  }
+  return out;
+}
+function extractMembers(body, owner) {
+  if (!body) return [];
+  const out = [];
+  for (const child of body.namedChildren) {
+    if (child.type === "field_declaration") {
+      out.push(...fieldSymbols(child, owner));
+      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 TYPE_KINDS = {
+  class_declaration: "class",
+  struct_declaration: "class",
+  record_declaration: "class",
+  interface_declaration: "interface",
+  enum_declaration: "enum",
+  delegate_declaration: "type"
+};
+function typeSymbol(node, prefix) {
+  const kind = TYPE_KINDS[node.type];
+  if (!kind) return null;
+  const bare = nameOf(node);
+  if (!bare) return null;
+  const name = prefix ? `${prefix}.${bare}` : bare;
+  const extra = [];
+  if (node.type === "struct_declaration") extra.push("struct");
+  if (node.type === "record_declaration") extra.push("record");
+  if (node.type === "delegate_declaration") extra.push("delegate");
+  if (node.type === "enum_declaration") {
+    const list = node.children.find((c) => c.type === "enum_member_declaration_list");
+    const members = [];
+    for (const member of list?.namedChildren ?? []) {
+      if (member.type !== "enum_member_declaration") continue;
+      const memberName = nameOf(member) ?? member.children.find((c) => c.type === "identifier")?.text;
+      if (!memberName) continue;
+      members.push({
+        name: `${name}.${memberName}`,
+        kind: "variable",
+        ...lineOf(member),
+        children: [],
+        modifiers: ["enum_member"]
+      });
+    }
+    return { name, kind, ...lineOf(node), children: members, modifiers: modifiersOf(node, ...extra) };
+  }
+  const children = [
+    ...positionalMembers(node, name),
+    ...extractMembers(declarationList(node), name)
+  ];
+  return { name, kind, ...lineOf(node), children, modifiers: modifiersOf(node, ...extra) };
+}
+function isNamespace(node) {
+  return node.type === "namespace_declaration" || node.type === "file_scoped_namespace_declaration";
+}
+function collectTypes(container, out) {
+  for (const child of container.namedChildren) {
+    if (isNamespace(child)) {
+      const body = declarationList(child);
+      collectTypes(body ?? child, out);
+      continue;
+    }
+    if (child.type === "declaration_list") {
+      collectTypes(child, out);
+      continue;
+    }
+    const sym = typeSymbol(child, null);
+    if (sym) out.push(sym);
+  }
+}
+function extractSymbols(root) {
+  const out = [];
+  collectTypes(root, out);
+  return (0, import_base.flattenSymbols)(out);
+}
+function extractImports(root) {
+  const imports = [];
+  for (const child of root.namedChildren) {
+    if (child.type !== "using_directive") continue;
+    const qualified = child.children.find((c) => c.type === "qualified_name");
+    const identifiers = child.children.filter((c) => c.type === "identifier");
+    const alias = child.childForFieldName("alias")?.text ?? (qualified && identifiers.length > 0 ? identifiers[0].text : null);
+    let source = qualified?.text ?? null;
+    if (!source) {
+      source = identifiers.length > 1 ? identifiers[identifiers.length - 1].text : identifiers[0]?.text ?? null;
+    }
+    if (!source) continue;
+    const isAliased = Boolean(alias) && alias !== source;
+    imports.push({
+      source,
+      specifiers: isAliased ? [alias] : [source.split(".").pop() ?? source],
+      isDefault: false,
+      // A plain `using` brings a whole namespace into scope — that is a
+      // namespace import in every sense the graph cares about. An alias
+      // binds one name, so it is not.
+      isNamespace: !isAliased
+    });
+  }
+  return imports;
+}
+const csharpPlugin = {
+  language: "csharp",
+  extensions: [".cs"],
+  grammarFile: "tree-sitter-c-sharp.wasm",
+  grammarKey: "csharp",
+  extractSymbols,
+  extractImports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  csharpPlugin
+});

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

@@ -0,0 +1,180 @@
+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 go_exports = {};
+__export(go_exports, {
+  goPlugin: () => goPlugin
+});
+module.exports = __toCommonJS(go_exports);
+var import_base = require("./base");
+function lineOf(node) {
+  return { startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1 };
+}
+function isExported(name) {
+  const first = name.charAt(0);
+  return first !== "" && first === first.toUpperCase() && first !== first.toLowerCase();
+}
+function modifiersFor(name, ...extra) {
+  return isExported(name) ? ["exported", ...extra] : [...extra];
+}
+function receiverTypeName(receiver) {
+  if (!receiver) return null;
+  const raw = (receiver.text || "").trim().replace(/^\(/, "").replace(/\)$/, "").trim();
+  if (!raw) return null;
+  const parts = raw.split(/\s+/);
+  const typePart = parts.length > 1 ? parts[parts.length - 1] : parts[0];
+  return typePart.replace(/^\*/, "").replace(/\[.*\]$/, "") || null;
+}
+function specNames(spec) {
+  const names = [];
+  for (const child of spec.children) {
+    if (child.type === "identifier") names.push(child.text);
+  }
+  if (names.length === 0) {
+    const named = spec.childForFieldName("name")?.text;
+    if (named) names.push(named);
+  }
+  return names.filter((n) => n && n !== "_");
+}
+function typeSpecToSymbol(spec) {
+  const name = spec.childForFieldName("name")?.text;
+  if (!name) return null;
+  const typeNode = spec.childForFieldName("type");
+  const lines = lineOf(spec);
+  switch (typeNode?.type) {
+    case "struct_type":
+      return { name, kind: "class", ...lines, children: [], modifiers: modifiersFor(name, "struct") };
+    case "interface_type":
+      return { name, kind: "interface", ...lines, children: [], modifiers: modifiersFor(name, "interface") };
+    default:
+      return { name, kind: "type", ...lines, children: [], modifiers: modifiersFor(name) };
+  }
+}
+const sig = (node, skip = []) => {
+  const signature = (0, import_base.headerSignature)(node, skip);
+  return signature ? { signature } : {};
+};
+function nodeToSymbols(node) {
+  switch (node.type) {
+    case "function_declaration": {
+      const name = node.childForFieldName("name")?.text;
+      if (!name) return [];
+      return [{ name, kind: "function", ...lineOf(node), children: [], modifiers: modifiersFor(name), ...sig(node) }];
+    }
+    case "method_declaration": {
+      const name = node.childForFieldName("name")?.text;
+      if (!name) return [];
+      const recv = receiverTypeName(node.childForFieldName("receiver"));
+      const qualified = recv ? `(${recv}).${name}` : name;
+      return [{
+        name: qualified,
+        kind: "function",
+        ...lineOf(node),
+        children: [],
+        // Exportedness is a property of the method name, not the
+        // qualified form.
+        modifiers: modifiersFor(name, "method"),
+        // The receiver is in the name; its variable is not shape.
+        ...sig(node, ["receiver"])
+      }];
+    }
+    case "type_declaration": {
+      const out = [];
+      for (const spec of node.children) {
+        if (spec.type !== "type_spec" && spec.type !== "type_alias") continue;
+        const sym = typeSpecToSymbol(spec);
+        if (sym) out.push(sym);
+      }
+      return out;
+    }
+    case "const_declaration":
+    case "var_declaration": {
+      const out = [];
+      const extra = node.type === "const_declaration" ? "const" : "var";
+      const specs = node.children.flatMap(
+        (c) => c.type.endsWith("_spec_list") ? c.children : [c]
+      );
+      for (const spec of specs) {
+        if (!spec.type.endsWith("_spec")) continue;
+        for (const name of specNames(spec)) {
+          out.push({
+            name,
+            kind: "variable",
+            ...lineOf(spec),
+            children: [],
+            modifiers: modifiersFor(name, extra)
+          });
+        }
+      }
+      return out;
+    }
+    default:
+      return [];
+  }
+}
+function extractSymbols(root) {
+  const symbols = [];
+  for (const child of root.children) {
+    symbols.push(...nodeToSymbols(child));
+  }
+  return symbols;
+}
+function unquote(text) {
+  if (!text) return "";
+  return text.replace(/^[`"]/, "").replace(/[`"]$/, "");
+}
+function importSpecToDeclaration(spec) {
+  const source = unquote(spec.childForFieldName("path")?.text);
+  if (!source) return null;
+  const alias = spec.childForFieldName("name")?.text;
+  const lastSegment = source.split("/").pop() || source;
+  return {
+    source,
+    // A blank import is kept deliberately. It is a *side-effect*
+    // dependency — driver registration, codec registration — and it
+    // is invisible in the call graph, which makes it more worth
+    // surfacing than an ordinary import, not less.
+    specifiers: [alias || lastSegment],
+    isDefault: false,
+    isNamespace: alias === "."
+  };
+}
+function extractImports(root) {
+  const imports = [];
+  for (const child of root.children) {
+    if (child.type !== "import_declaration") continue;
+    const list = child.children.find((c) => c.type === "import_spec_list");
+    const specs = (list ? list.children : child.children).filter((c) => c.type === "import_spec");
+    for (const spec of specs) {
+      const decl = importSpecToDeclaration(spec);
+      if (decl) imports.push(decl);
+    }
+  }
+  return imports;
+}
+const goPlugin = {
+  language: "go",
+  extensions: [".go"],
+  grammarFile: "tree-sitter-go.wasm",
+  grammarKey: "go",
+  extractSymbols,
+  extractImports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  goPlugin
+});

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

@@ -0,0 +1,101 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parsers_exports = {};
+__export(parsers_exports, {
+  PARSER_PLUGINS: () => PARSER_PLUGINS,
+  findUnparsedLanguages: () => findUnparsedLanguages,
+  findUnscannedExtensions: () => findUnscannedExtensions,
+  getPluginForFile: () => getPluginForFile,
+  listPluginExtensions: () => listPluginExtensions
+});
+module.exports = __toCommonJS(parsers_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_typescript = require("./typescript");
+var import_python = require("./python");
+var import_rust = require("./rust");
+var import_php = require("./php");
+var import_java = require("./java");
+var import_go = require("./go");
+var import_ruby = require("./ruby");
+var import_csharp = require("./csharp");
+var import_kotlin = require("./kotlin");
+var import_swift = require("./swift");
+const PARSER_PLUGINS = [
+  import_typescript.typescriptPlugin,
+  import_typescript.tsxPlugin,
+  import_typescript.javascriptPlugin,
+  import_python.pythonPlugin,
+  import_rust.rustPlugin,
+  import_php.phpPlugin,
+  import_java.javaPlugin,
+  import_go.goPlugin,
+  import_ruby.rubyPlugin,
+  import_csharp.csharpPlugin,
+  import_kotlin.kotlinPlugin,
+  import_swift.swiftPlugin
+];
+const EXTENSION_INDEX = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const plugin of PARSER_PLUGINS) {
+    for (const ext of plugin.extensions) {
+      map.set(ext.toLowerCase(), plugin);
+    }
+  }
+  return map;
+})();
+function getPluginForFile(filePath) {
+  return EXTENSION_INDEX.get(import_node_path.default.extname(filePath).toLowerCase()) ?? null;
+}
+function listPluginExtensions() {
+  return [...EXTENSION_INDEX.keys()];
+}
+function findUnparsedLanguages(taggedLanguages) {
+  const parsed = new Set(PARSER_PLUGINS.map((p) => p.language));
+  const intentionallyUnparsed = /* @__PURE__ */ new Set([
+    "sql",
+    "json",
+    "css",
+    "html",
+    "markdown",
+    "yaml",
+    "toml"
+  ]);
+  return [...new Set(taggedLanguages)].filter((lang) => !parsed.has(lang) && !intentionallyUnparsed.has(lang)).sort();
+}
+function findUnscannedExtensions(taggedExtensions) {
+  const tagged = new Set(taggedExtensions.map((e) => e.toLowerCase()));
+  return [...EXTENSION_INDEX.keys()].filter((ext) => !tagged.has(ext)).sort();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PARSER_PLUGINS,
+  findUnparsedLanguages,
+  findUnscannedExtensions,
+  getPluginForFile,
+  listPluginExtensions
+});