codetrellis 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,103 @@
+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 java_exports = {};
+__export(java_exports, {
+  javaPlugin: () => javaPlugin
+});
+module.exports = __toCommonJS(java_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 modifiersOf = (node) => (node.children.find((c) => c.type === "modifiers")?.children ?? []).filter((c) => !/annotation/.test(c.type)).map((c) => c.text);
+const sig = (node, skip = []) => {
+  const signature = (0, import_base.headerSignature)(node, skip);
+  return signature ? { signature } : {};
+};
+function extractMembers(body, owner) {
+  if (!body) return [];
+  const out = [];
+  for (const child of body.children) {
+    if (child.type === "method_declaration" || child.type === "constructor_declaration") {
+      out.push({
+        name: `${owner}.${nameOf(child)}`,
+        kind: "method",
+        ...lineOf(child),
+        children: [],
+        modifiers: [...modifiersOf(child), ...child.type === "constructor_declaration" ? ["constructor"] : []],
+        ...sig(child)
+      });
+    }
+  }
+  return out;
+}
+function nodeToSymbol(node) {
+  const name = nameOf(node);
+  switch (node.type) {
+    case "class_declaration":
+      return { name, kind: "class", ...lineOf(node), children: extractMembers(node.childForFieldName("body"), name), modifiers: modifiersOf(node) };
+    case "interface_declaration":
+      return { name, kind: "interface", ...lineOf(node), children: extractMembers(node.childForFieldName("body"), name), modifiers: modifiersOf(node) };
+    case "enum_declaration":
+      return { name: nameOf(node), kind: "enum", ...lineOf(node), children: [], modifiers: modifiersOf(node) };
+    case "record_declaration":
+      return { name: nameOf(node), kind: "class", ...lineOf(node), children: [], modifiers: ["record", ...modifiersOf(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 (0, import_base.flattenSymbols)(symbols);
+}
+function extractImports(node) {
+  const imports = [];
+  for (const child of node.children) {
+    if (child.type !== "import_declaration") continue;
+    const text = (child.text || "").replace(/^import\s+(static\s+)?/, "").replace(/;\s*$/, "").trim();
+    if (!text) continue;
+    const cleanPath = text.replace(/\.\*$/, "");
+    const isWildcard = text.endsWith(".*");
+    imports.push({
+      source: cleanPath,
+      specifiers: isWildcard ? ["*"] : [cleanPath.split(".").pop() || cleanPath],
+      isDefault: false,
+      isNamespace: isWildcard
+    });
+  }
+  return imports;
+}
+const javaPlugin = {
+  language: "java",
+  extensions: [".java"],
+  grammarFile: "tree-sitter-java.wasm",
+  grammarKey: "java",
+  extractSymbols,
+  extractImports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  javaPlugin
+});

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

@@ -0,0 +1,252 @@
+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 kotlin_exports = {};
+__export(kotlin_exports, {
+  kotlinPlugin: () => kotlinPlugin
+});
+module.exports = __toCommonJS(kotlin_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 hasKeyword(node, keyword) {
+  return node.children.some((c) => !c.isNamed && c.type === keyword);
+}
+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 identifierOf(node) {
+  return node.children.find((c) => c.type === "identifier")?.text ?? null;
+}
+function bodyOf(node) {
+  return node.children.find(
+    (c) => c.type === "class_body" || c.type === "enum_class_body"
+  ) ?? null;
+}
+function receiverOf(node) {
+  for (const child of node.children) {
+    if (child.type === "identifier") return null;
+    if (child.type === "user_type") return child.text;
+  }
+  return null;
+}
+function functionSymbol(node, owner) {
+  const bare = identifierOf(node);
+  if (!bare) return null;
+  const receiver = receiverOf(node);
+  const qualifier = receiver ?? owner;
+  return {
+    name: qualifier ? `${qualifier}.${bare}` : bare,
+    kind: owner ? "method" : "function",
+    ...lineOf(node),
+    children: [],
+    modifiers: modifiersOf(node, ...receiver ? ["extension"] : []),
+    ...sig(node)
+  };
+}
+function propertySymbols(node, owner) {
+  const mods = modifiersOf(node, owner ? "property" : "top_level");
+  const out = [];
+  for (const child of node.children) {
+    if (child.type !== "variable_declaration" && child.type !== "multi_variable_declaration") continue;
+    const targets = child.type === "multi_variable_declaration" ? child.namedChildren.filter((c) => c.type === "variable_declaration") : [child];
+    for (const target of targets) {
+      const name = identifierOf(target) ?? target.text;
+      if (!name) continue;
+      out.push({
+        name: owner ? `${owner}.${name}` : name,
+        kind: "variable",
+        ...lineOf(node),
+        children: [],
+        modifiers: mods
+      });
+    }
+  }
+  return out;
+}
+function primaryConstructorProperties(node, owner) {
+  const ctor = node.children.find((c) => c.type === "primary_constructor");
+  if (!ctor) return [];
+  const params = ctor.children.find((c) => c.type === "class_parameters");
+  if (!params) return [];
+  const out = [];
+  for (const param of params.namedChildren) {
+    if (param.type !== "class_parameter") continue;
+    if (!hasKeyword(param, "val") && !hasKeyword(param, "var")) continue;
+    const name = identifierOf(param);
+    if (!name) continue;
+    out.push({
+      name: `${owner}.${name}`,
+      kind: "variable",
+      ...lineOf(param),
+      children: [],
+      modifiers: ["property", "constructor_param"]
+    });
+  }
+  return out;
+}
+function memberSymbols(body, owner) {
+  if (!body) return [];
+  const out = [];
+  for (const child of body.namedChildren) {
+    switch (child.type) {
+      case "function_declaration": {
+        const sym = functionSymbol(child, owner);
+        if (sym) out.push(sym);
+        break;
+      }
+      case "property_declaration":
+        out.push(...propertySymbols(child, owner));
+        break;
+      case "enum_entry": {
+        const name = identifierOf(child);
+        if (name) {
+          out.push({
+            name: `${owner}.${name}`,
+            kind: "variable",
+            ...lineOf(child),
+            children: [],
+            modifiers: ["enum_member"]
+          });
+        }
+        break;
+      }
+      case "companion_object": {
+        const name = identifierOf(child) ?? "Companion";
+        const qualified = `${owner}.${name}`;
+        out.push({
+          name: qualified,
+          kind: "class",
+          ...lineOf(child),
+          children: memberSymbols(bodyOf(child), qualified),
+          modifiers: ["companion"]
+        });
+        break;
+      }
+      default: {
+        const nested = declarationSymbol(child, owner);
+        if (nested) out.push(nested);
+      }
+    }
+  }
+  return out;
+}
+function declarationSymbol(node, prefix) {
+  if (node.type === "class_declaration") {
+    const bare = identifierOf(node);
+    if (!bare) return null;
+    const name = prefix ? `${prefix}.${bare}` : bare;
+    const mods = modifiersOf(node);
+    const kind = hasKeyword(node, "interface") ? "interface" : mods.includes("enum") ? "enum" : "class";
+    return {
+      name,
+      kind,
+      ...lineOf(node),
+      children: [
+        ...primaryConstructorProperties(node, name),
+        ...memberSymbols(bodyOf(node), name)
+      ],
+      modifiers: mods
+    };
+  }
+  if (node.type === "object_declaration") {
+    const bare = identifierOf(node);
+    if (!bare) return null;
+    const name = prefix ? `${prefix}.${bare}` : bare;
+    return {
+      name,
+      kind: "class",
+      ...lineOf(node),
+      children: memberSymbols(bodyOf(node), name),
+      modifiers: modifiersOf(node, "object")
+    };
+  }
+  if (node.type === "type_alias") {
+    const bare = identifierOf(node);
+    if (!bare) return null;
+    return {
+      name: prefix ? `${prefix}.${bare}` : bare,
+      kind: "type",
+      ...lineOf(node),
+      children: [],
+      modifiers: modifiersOf(node)
+    };
+  }
+  return null;
+}
+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 sym2 = functionSymbol(child, null);
+      if (sym2) out.push(sym2);
+      continue;
+    }
+    if (child.type === "property_declaration") {
+      out.push(...propertySymbols(child, null));
+      continue;
+    }
+    const sym = declarationSymbol(child, null);
+    if (sym) out.push(sym);
+  }
+  return out;
+}
+function extractImports(root) {
+  const imports = [];
+  for (const child of root.namedChildren) {
+    if (child.type !== "import" && child.type !== "import_header") continue;
+    const qualified = child.children.find(
+      (c) => c.type === "qualified_identifier" || c.type === "identifier"
+    );
+    const source = qualified?.text;
+    if (!source) continue;
+    const isWildcard = /\*\s*$/.test(child.text || "");
+    const alias = child.children.filter((c) => c.type === "identifier").map((c) => c.text).find((text) => text !== source);
+    imports.push({
+      source,
+      specifiers: isWildcard ? ["*"] : [alias ?? (source.split(".").pop() ?? source)],
+      isDefault: false,
+      isNamespace: isWildcard
+    });
+  }
+  return imports;
+}
+const kotlinPlugin = {
+  language: "kotlin",
+  // `.kts` is Kotlin script — Gradle build files, mostly. Same grammar,
+  // and a build file is part of the architecture whether or not anyone
+  // enjoys reading it.
+  extensions: [".kt", ".kts"],
+  grammarFile: "tree-sitter-kotlin.wasm",
+  grammarKey: "kotlin",
+  extractSymbols,
+  extractImports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  kotlinPlugin
+});

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

@@ -0,0 +1,113 @@
+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 php_exports = {};
+__export(php_exports, {
+  phpPlugin: () => phpPlugin
+});
+module.exports = __toCommonJS(php_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 visibility = (node) => node.children.filter((c) => c.type === "visibility_modifier" || c.type === "static_modifier").map((c) => c.text);
+const sig = (node, skip = []) => {
+  const signature = (0, import_base.headerSignature)(node, skip);
+  return signature ? { signature } : {};
+};
+function nodeToSymbol(node) {
+  switch (node.type) {
+    case "function_definition":
+      return { name: nameOf(node), kind: "function", ...lineOf(node), children: [], modifiers: [], ...sig(node) };
+    case "class_declaration": {
+      const body = node.childForFieldName("body");
+      const children = body ? extractClassMembers(body) : [];
+      return { name: nameOf(node), kind: "class", ...lineOf(node), children, modifiers: [] };
+    }
+    case "interface_declaration":
+      return { name: nameOf(node), kind: "interface", ...lineOf(node), children: [], modifiers: [] };
+    case "trait_declaration":
+      return { name: nameOf(node), kind: "class", ...lineOf(node), children: [], modifiers: ["trait"] };
+    case "enum_declaration":
+      return { name: nameOf(node), kind: "enum", ...lineOf(node), children: [], modifiers: [] };
+    default:
+      return null;
+  }
+}
+function extractClassMembers(body) {
+  const out = [];
+  for (const child of body.children) {
+    if (child.type === "method_declaration") {
+      out.push({ name: nameOf(child), kind: "method", ...lineOf(child), children: [], modifiers: visibility(child), ...sig(child) });
+    }
+  }
+  return out;
+}
+function extractSymbols(node) {
+  const symbols = [];
+  for (const child of node.children) {
+    if (child.type === "namespace_definition") {
+      const body = child.childForFieldName("body");
+      if (body) symbols.push(...extractSymbols(body));
+      continue;
+    }
+    const sym = nodeToSymbol(child);
+    if (sym) symbols.push(sym);
+  }
+  return symbols;
+}
+function extractImports(node) {
+  const imports = [];
+  const collect = (n) => {
+    for (const child of n.children) {
+      if (child.type === "namespace_use_declaration") {
+        const clauses = child.children.filter((c) => c.type === "namespace_use_clause" || c.type === "namespace_use_group_clause");
+        for (const clause of clauses) {
+          const text = clause.text.trim();
+          const [pathPart, ...rest] = text.split(/\s+as\s+/i);
+          const alias = rest.join(" as ").trim();
+          imports.push({
+            source: pathPart.trim().replace(/^\\/, ""),
+            specifiers: alias ? [alias] : [pathPart.trim().split("\\").pop() || pathPart.trim()],
+            isDefault: false,
+            isNamespace: false
+          });
+        }
+      } else if (child.type === "namespace_definition") {
+        const body = child.childForFieldName("body");
+        if (body) collect(body);
+      }
+    }
+  };
+  collect(node);
+  return imports;
+}
+const phpPlugin = {
+  language: "php",
+  extensions: [".php"],
+  grammarFile: "tree-sitter-php.wasm",
+  grammarKey: "php",
+  extractSymbols,
+  extractImports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  phpPlugin
+});

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

@@ -0,0 +1,189 @@
+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 python_exports = {};
+__export(python_exports, {
+  pythonPlugin: () => pythonPlugin
+});
+module.exports = __toCommonJS(python_exports);
+var import_base = require("./base");
+function extractSymbols(node) {
+  const symbols = [];
+  for (const child of node.children) {
+    const sym = nodeToSymbol(child);
+    if (sym) symbols.push(sym);
+  }
+  return symbols;
+}
+function nodeToSymbol(node) {
+  switch (node.type) {
+    case "function_definition":
+    case "async_function_definition": {
+      const name = node.childForFieldName("name")?.text || "anonymous";
+      const modifiers = node.type === "async_function_definition" ? ["async"] : [];
+      const ret = (0, import_base.shapeOf)(node.childForFieldName("return_type"));
+      const signature = (0, import_base.signatureOf)(
+        (0, import_base.shapeOf)(node.childForFieldName("type_parameters")),
+        (0, import_base.shapeOf)(node.childForFieldName("parameters")),
+        ret ? ` -> ${ret}` : null
+      );
+      return {
+        name,
+        kind: "function",
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        children: [],
+        modifiers,
+        ...signature ? { signature } : {}
+      };
+    }
+    case "class_definition": {
+      const name = node.childForFieldName("name")?.text || "anonymous";
+      const body = node.childForFieldName("body");
+      const children = body ? extractClassMembers(body) : [];
+      return {
+        name,
+        kind: "class",
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        children,
+        modifiers: []
+      };
+    }
+    case "decorated_definition": {
+      const inner = node.children.find(
+        (c) => c.type === "function_definition" || c.type === "async_function_definition" || c.type === "class_definition"
+      );
+      if (!inner) return null;
+      const sym = nodeToSymbol(inner);
+      if (!sym) return null;
+      const decorators = node.children.filter((c) => c.type === "decorator").map((d) => `@${d.text.replace(/^@/, "").trim().split(/\s|\(/)[0]}`);
+      sym.modifiers = [...sym.modifiers, ...decorators];
+      sym.startLine = node.startPosition.row + 1;
+      return sym;
+    }
+    case "expression_statement": {
+      const child = node.children[0];
+      if (child?.type !== "assignment") return null;
+      const left = child.childForFieldName("left");
+      if (!left || left.type !== "identifier") return null;
+      const name = left.text;
+      if (!/^[A-Z][A-Z0-9_]*$/.test(name)) return null;
+      return {
+        name,
+        kind: "variable",
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        children: [],
+        modifiers: ["const"]
+      };
+    }
+    default:
+      return null;
+  }
+}
+function extractClassMembers(body) {
+  const members = [];
+  for (const child of body.children) {
+    const sym = nodeToSymbol(child);
+    if (!sym) continue;
+    if (sym.kind === "function") sym.kind = "method";
+    members.push(sym);
+  }
+  return members;
+}
+function extractImports(node) {
+  const imports = [];
+  for (const child of node.children) {
+    if (child.type === "import_statement") {
+      for (const spec of child.children) {
+        const moduleName = readImportTarget(spec);
+        if (!moduleName) continue;
+        imports.push({
+          source: moduleName.module,
+          specifiers: moduleName.alias ? [moduleName.alias] : [moduleName.module.split(".").pop() || moduleName.module],
+          isDefault: false,
+          isNamespace: true
+          // `import x` brings x in as a namespace
+        });
+      }
+    } else if (child.type === "import_from_statement") {
+      const moduleNode = child.childForFieldName("module_name");
+      const module2 = readModuleSource(moduleNode);
+      const names = [];
+      let sawImport = false;
+      for (const c of child.children) {
+        if (c.type === "import") {
+          sawImport = true;
+          continue;
+        }
+        if (!sawImport) continue;
+        const target = readImportTarget(c);
+        if (target) names.push(target.module);
+        else if (c.type === "wildcard_import" || (c.type === "*" || c.text === "*")) names.push("*");
+      }
+      imports.push({
+        source: module2 || "",
+        specifiers: names,
+        isDefault: false,
+        isNamespace: names.includes("*")
+      });
+    }
+  }
+  return imports;
+}
+function readImportTarget(node) {
+  if (!node) return null;
+  if (node.type === "aliased_import") {
+    const inner = node.childForFieldName("name");
+    const aliasNode = node.childForFieldName("alias");
+    const module2 = readModuleSource(inner) || "";
+    if (!module2) return null;
+    return { module: module2, alias: aliasNode?.text };
+  }
+  if (node.type === "dotted_name" || node.type === "identifier") {
+    const module2 = readModuleSource(node);
+    if (!module2) return null;
+    return { module: module2 };
+  }
+  return null;
+}
+function readModuleSource(node) {
+  if (!node) return "";
+  if (node.type === "identifier") return node.text;
+  if (node.type === "dotted_name") {
+    return node.children.filter((c) => c.type === "identifier").map((c) => c.text).join(".");
+  }
+  if (node.type === "relative_import") {
+    const dots = node.children.filter((c) => c.type === "import_prefix" || c.text === "." || c.text === "..").map((c) => c.text).join("");
+    const inner = node.children.find((c) => c.type === "dotted_name");
+    return dots + (inner ? readModuleSource(inner) : "");
+  }
+  return node.text || "";
+}
+const pythonPlugin = {
+  language: "python",
+  extensions: [".py"],
+  grammarFile: "tree-sitter-python.wasm",
+  grammarKey: "python",
+  extractSymbols,
+  extractImports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pythonPlugin
+});