@mr-jones123/toji 0.1.1

package/packages/toji-mem/src/indexer/index-project.ts

@@ -0,0 +1,277 @@
+import type { TojiDatabase } from "../db/connection";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { basename, dirname, join, normalize, parse, resolve } from "node:path";
+
+import { walkProjectFiles } from "./file-walker";
+import { getParserForPath, getSupportedExtensions } from "./parsers/registry";
+
+export interface IndexProjectResult {
+  projectId: number;
+  rootPath: string;
+  indexedFiles: number;
+  symbols: number;
+  imports: number;
+  calls: number;
+}
+
+export async function indexProject(database: TojiDatabase, rootPath: string): Promise<IndexProjectResult> {
+  const normalizedRoot = resolve(rootPath);
+  const project = database
+    .query<{ id: number }, [string, string]>(
+      `INSERT INTO projects (root_path, name, indexed_at)
+       VALUES (?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(root_path) DO UPDATE SET indexed_at = CURRENT_TIMESTAMP
+       RETURNING id`,
+    )
+    .get(normalizedRoot, basename(normalizedRoot));
+
+  if (!project) throw new Error("Failed to create or update project");
+
+  const files = await walkProjectFiles(normalizedRoot, getSupportedExtensions());
+  const freshHashes = await hashFiles(normalizedRoot, files);
+  const previousHashes = new Map(
+    database
+      .query<{ path: string; hash: string }, [number]>(`SELECT path, hash FROM files WHERE project_id = ?`)
+      .all(project.id)
+      .map((row) => [row.path, row.hash]),
+  );
+
+  if (hashesMatch(freshHashes, previousHashes)) {
+    const counts = database
+      .query<{ symbols: number; imports: number; calls: number }, [number, number, number]>(
+        `SELECT
+           (SELECT COUNT(*) FROM symbols WHERE project_id = ?) AS symbols,
+           (SELECT COUNT(*) FROM imports WHERE project_id = ?) AS imports,
+           (SELECT COUNT(*) FROM calls WHERE project_id = ?) AS calls`,
+      )
+      .get(project.id, project.id, project.id);
+    return {
+      projectId: project.id,
+      rootPath: normalizedRoot,
+      indexedFiles: files.length,
+      symbols: counts?.symbols ?? 0,
+      imports: counts?.imports ?? 0,
+      calls: counts?.calls ?? 0,
+    };
+  }
+
+  database.query("DELETE FROM files WHERE project_id = ?").run(project.id);
+  database.query("DELETE FROM edges WHERE project_id = ?").run(project.id);
+  database.query("DELETE FROM symbol_fts WHERE project_id = ?").run(project.id);
+  database.query("DELETE FROM file_fts WHERE project_id = ?").run(project.id);
+
+  let symbolCount = 0;
+  let importCount = 0;
+  let callCount = 0;
+
+  const insertFile = database.query<{ id: number }, [number, string, string, string, string]>(
+    `INSERT INTO files (project_id, path, name, language, hash)
+     VALUES (?, ?, ?, ?, ?)
+     RETURNING id`,
+  );
+  const insertSymbol = database.query<{ id: number }, [number, number, string, string, string, string, number, number, string | null, number]>(
+    `INSERT INTO symbols (project_id, file_id, name, canon_name, kind, language, start_line, end_line, signature, exported)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     RETURNING id`,
+  );
+  const insertImport = database.query<unknown, [number, number, string | null, string, number]>(
+    `INSERT INTO imports (project_id, file_id, imported_name, source, start_line)
+     VALUES (?, ?, ?, ?, ?)`,
+  );
+  const insertCall = database.query<unknown, [number, number, string | null, string, number]>(
+    `INSERT INTO calls (project_id, file_id, caller_name, callee_name, start_line)
+     VALUES (?, ?, ?, ?, ?)`,
+  );
+  const insertSymbolFts = database.query<unknown, [number, number, number, string, string, string, string, string, string, string]>(
+    `INSERT INTO symbol_fts (symbol_id, project_id, file_id, name, canon_name, kind, language, path, signature, docstring)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+  const insertFileFts = database.query<unknown, [number, number, string, string, string, string]>(
+    `INSERT INTO file_fts (file_id, project_id, name, path, language, docstring) VALUES (?, ?, ?, ?, ?, ?)`,
+  );
+
+  const fileIds = new Map<string, number>();
+  const symbolsByFile = new Map<number, Array<{ id: number; name: string; startLine: number; endLine: number; exported: boolean }>>();
+  const importsByFile = new Map<number, Array<{ source: string; startLine: number }>>();
+  const callsByFile = new Map<number, Array<{ callerId?: number; calleeName: string; startLine: number }>>();
+  const relationsByFile = new Map<number, Array<{ fromName: string; toName: string; edgeType: "symbol_extends_symbol" | "symbol_implements_symbol" }>>();
+
+  for (const relativePath of files) {
+    const parser = getParserForPath(relativePath);
+    if (!parser) continue;
+
+    const absolutePath = join(normalizedRoot, relativePath);
+    const content = await readFile(absolutePath, "utf8");
+    const hash = freshHashes.get(relativePath) ?? createHash("sha256").update(content).digest("hex");
+    const fileName = basename(relativePath);
+    const file = insertFile.get(project.id, relativePath, fileName, parser.language, hash);
+    if (!file) continue;
+
+    insertFileFts.run(file.id, project.id, fileName, relativePath, parser.language, "");
+    fileIds.set(relativePath, file.id);
+
+    const parsed = await parser.parseFile({ projectId: project.id, filePath: relativePath, content });
+    const fileSymbols: Array<{ id: number; name: string; startLine: number; endLine: number; exported: boolean }> = [];
+
+    for (const symbol of parsed.symbols) {
+      const canon_name = symbolQname(relativePath, symbol.name);
+      const insertedSymbol = insertSymbol.get(
+        project.id,
+        file.id,
+        symbol.name,
+        canon_name,
+        symbol.kind,
+        parser.language,
+        symbol.startLine,
+        symbol.endLine,
+        symbol.signature ?? null,
+        symbol.exported ? 1 : 0,
+      );
+      if (!insertedSymbol) continue;
+
+      fileSymbols.push({
+        id: insertedSymbol.id,
+        name: symbol.name,
+        startLine: symbol.startLine,
+        endLine: symbol.endLine,
+        exported: symbol.exported,
+      });
+      insertSymbolFts.run(insertedSymbol.id, project.id, file.id, symbol.name, canon_name, symbol.kind, parser.language, relativePath, symbol.signature ?? "", "");
+      symbolCount += 1;
+    }
+
+    symbolsByFile.set(file.id, fileSymbols);
+
+    const fileImports: Array<{ source: string; startLine: number }> = [];
+    for (const parsedImport of parsed.imports) {
+      insertImport.run(project.id, file.id, parsedImport.importedName ?? null, parsedImport.source, parsedImport.startLine);
+      fileImports.push({ source: parsedImport.source, startLine: parsedImport.startLine });
+      importCount += 1;
+    }
+    importsByFile.set(file.id, fileImports);
+
+    const fileCalls: Array<{ callerId?: number; calleeName: string; startLine: number }> = [];
+    for (const call of parsed.calls) {
+      const caller = findContainingSymbol(fileSymbols, call.startLine);
+      insertCall.run(project.id, file.id, caller?.name ?? call.callerName ?? null, call.calleeName, call.startLine);
+      fileCalls.push({ callerId: caller?.id, calleeName: call.calleeName, startLine: call.startLine });
+      callCount += 1;
+    }
+    callsByFile.set(file.id, fileCalls);
+    relationsByFile.set(file.id, parsed.relations.map((relation) => ({
+      fromName: relation.fromName,
+      toName: relation.toName,
+      edgeType: relation.edgeType,
+    })));
+  }
+
+  createGraphEdges(database, project.id, files, fileIds, symbolsByFile, importsByFile, callsByFile, relationsByFile);
+
+  return { projectId: project.id, rootPath: normalizedRoot, indexedFiles: files.length, symbols: symbolCount, imports: importCount, calls: callCount };
+}
+
+async function hashFiles(rootPath: string, files: string[]): Promise<Map<string, string>> {
+  const hashes = new Map<string, string>();
+  for (const relativePath of files) {
+    const content = await readFile(join(rootPath, relativePath), "utf8");
+    hashes.set(relativePath, createHash("sha256").update(content).digest("hex"));
+  }
+  return hashes;
+}
+
+function hashesMatch(fresh: Map<string, string>, previous: Map<string, string>): boolean {
+  if (fresh.size === 0 || fresh.size !== previous.size) return false;
+  for (const [path, hash] of fresh) {
+    if (previous.get(path) !== hash) return false;
+  }
+  return true;
+}
+
+function symbolQname(filePath: string, symbolName: string): string {
+  const parsed = parse(filePath);
+  const moduleName = join(parsed.dir, parsed.name).replaceAll("/", ".").replaceAll("\\\\", ".");
+  return moduleName ? `${moduleName}.${symbolName}` : symbolName;
+}
+
+function findContainingSymbol(
+  symbols: Array<{ id: number; name: string; startLine: number; endLine: number }>,
+  line: number,
+): { id: number; name: string; startLine: number; endLine: number } | undefined {
+  return symbols
+    .filter((symbol) => symbol.startLine <= line && symbol.endLine >= line)
+    .sort((left, right) => left.endLine - left.startLine - (right.endLine - right.startLine))[0];
+}
+
+function createGraphEdges(
+  database: TojiDatabase,
+  projectId: number,
+  files: string[],
+  fileIds: Map<string, number>,
+  symbolsByFile: Map<number, Array<{ id: number; name: string; startLine: number; endLine: number; exported: boolean }>>,
+  importsByFile: Map<number, Array<{ source: string; startLine: number }>>,
+  callsByFile: Map<number, Array<{ callerId?: number; calleeName: string; startLine: number }>>,
+  relationsByFile: Map<number, Array<{ fromName: string; toName: string; edgeType: "symbol_extends_symbol" | "symbol_implements_symbol" }>>,
+): void {
+  const insertEdge = database.query<unknown, [number, string, number, string, number | null, string | null, string, number]>(
+    `INSERT INTO edges (project_id, from_type, from_id, to_type, to_id, to_name, edge_type, confidence)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+
+  const symbolsByName = new Map<string, Array<{ id: number; fileId: number; exported: boolean }>>();
+  for (const [fileId, symbols] of symbolsByFile) {
+    for (const symbol of symbols) {
+      insertEdge.run(projectId, "file", fileId, "symbol", symbol.id, symbol.name, "file_contains_symbol", 1);
+      if (symbol.exported) insertEdge.run(projectId, "file", fileId, "symbol", symbol.id, symbol.name, "file_exports_symbol", 1);
+
+      const namedSymbols = symbolsByName.get(symbol.name) ?? [];
+      namedSymbols.push({ id: symbol.id, fileId, exported: symbol.exported });
+      symbolsByName.set(symbol.name, namedSymbols);
+    }
+  }
+
+  for (const [relativePath, fileId] of fileIds) {
+    for (const parsedImport of importsByFile.get(fileId) ?? []) {
+      const importedFile = resolveImportPath(relativePath, parsedImport.source, files);
+      if (importedFile) {
+        insertEdge.run(projectId, "file", fileId, "file", fileIds.get(importedFile) ?? null, importedFile, "file_imports_file", 0.9);
+      } else {
+        insertEdge.run(projectId, "file", fileId, "package", null, parsedImport.source, "file_imports_package", 0.8);
+      }
+    }
+
+    for (const relation of relationsByFile.get(fileId) ?? []) {
+      const fromSymbol = (symbolsByFile.get(fileId) ?? []).find((symbol) => symbol.name === relation.fromName);
+      if (!fromSymbol) continue;
+
+      const target = symbolsByName.get(relation.toName)?.find((symbol) => symbol.exported) ?? symbolsByName.get(relation.toName)?.[0];
+      insertEdge.run(projectId, "symbol", fromSymbol.id, "symbol", target?.id ?? null, relation.toName, relation.edgeType, target ? 0.8 : 0.4);
+    }
+
+    for (const call of callsByFile.get(fileId) ?? []) {
+      if (!call.callerId) continue;
+      const sameFileTarget = (symbolsByFile.get(fileId) ?? []).find((symbol) => symbol.name === call.calleeName);
+      const globalTarget = symbolsByName.get(call.calleeName)?.find((symbol) => symbol.exported) ?? symbolsByName.get(call.calleeName)?.[0];
+      const target = sameFileTarget ? { id: sameFileTarget.id, confidence: 0.9 } : globalTarget ? { id: globalTarget.id, confidence: 0.55 } : undefined;
+      insertEdge.run(
+        projectId,
+        "symbol",
+        call.callerId,
+        "symbol",
+        target?.id ?? null,
+        call.calleeName,
+        "symbol_calls_symbol",
+        target?.confidence ?? 0.3,
+      );
+    }
+  }
+}
+
+function resolveImportPath(fromPath: string, source: string, files: string[]): string | undefined {
+  if (!source.startsWith(".")) return undefined;
+
+  const basePath = normalize(join(dirname(fromPath), source));
+  const candidates = [basePath, `${basePath}.ts`, `${basePath}.tsx`, `${basePath}.js`, `${basePath}.jsx`, `${basePath}.py`, join(basePath, "index.ts")];
+  return candidates.find((candidate) => files.includes(candidate));
+}
+

package/packages/toji-mem/src/indexer/parsers/cpp.ts

@@ -0,0 +1,81 @@
+import { Query } from "web-tree-sitter";
+
+import { loadTreeSitterLanguage, parseWithGrammar } from "./tree-sitter-loader";
+import type { LanguageParser, ParsedCall, ParsedFile, ParsedImport, ParsedRelation, ParsedSymbol } from "./types";
+
+const cppQuerySource = `
+(function_definition declarator: (function_declarator declarator: (identifier) @function.name)) @function.definition
+(function_definition declarator: (function_declarator declarator: (field_identifier) @method.name)) @function.definition
+(class_specifier name: (type_identifier) @class.name) @class.definition
+(struct_specifier name: (type_identifier) @class.name) @class.definition
+(preproc_include path: [(string_literal) (system_lib_string)] @import.source) @import.statement
+(call_expression function: (identifier) @call.name) @call.expression
+(call_expression function: (field_expression field: (field_identifier) @call.member_name)) @call.expression
+`;
+
+export const cppParser: LanguageParser = {
+  language: "cpp",
+  extensions: [".cpp", ".cc", ".cxx", ".c++", ".hpp", ".hh", ".hxx", ".h++", ".h"],
+  async parseFile(input): Promise<ParsedFile> {
+    const tree = await parseWithGrammar("tree-sitter-cpp.wasm", input.content);
+    const grammar = await loadTreeSitterLanguage("tree-sitter-cpp.wasm");
+    const query = new Query(grammar, cppQuerySource);
+    const captures = query.captures(tree.rootNode);
+
+    const symbols: ParsedSymbol[] = [];
+    const imports: ParsedImport[] = [];
+    const calls: ParsedCall[] = [];
+    const relations: ParsedRelation[] = [];
+
+    for (const capture of captures) {
+      if (capture.name === "function.name" || capture.name === "method.name") {
+        const definition = nearest(capture.node, "function_definition");
+        symbols.push({
+          name: capture.node.text,
+          kind: capture.name === "method.name" ? "method" : "function",
+          startLine: definition?.startPosition.row !== undefined ? definition.startPosition.row + 1 : capture.node.startPosition.row + 1,
+          endLine: definition?.endPosition.row !== undefined ? definition.endPosition.row + 1 : capture.node.endPosition.row + 1,
+          exported: true,
+          signature: definition?.text.split("\n")[0]?.trim(),
+        });
+        continue;
+      }
+
+      if (capture.name === "class.name") {
+        const definition = capture.node.parent;
+        symbols.push({
+          name: capture.node.text,
+          kind: "class",
+          startLine: definition?.startPosition.row !== undefined ? definition.startPosition.row + 1 : capture.node.startPosition.row + 1,
+          endLine: definition?.endPosition.row !== undefined ? definition.endPosition.row + 1 : capture.node.endPosition.row + 1,
+          exported: true,
+          signature: definition?.text.split("\n")[0]?.trim(),
+        });
+        continue;
+      }
+
+      if (capture.name === "import.source") {
+        imports.push({
+          source: capture.node.text.replace(/[<>"]/g, ""),
+          startLine: capture.node.startPosition.row + 1,
+        });
+        continue;
+      }
+
+      if (capture.name === "call.name" || capture.name === "call.member_name") {
+        calls.push({ calleeName: capture.node.text, startLine: capture.node.startPosition.row + 1 });
+      }
+    }
+
+    return { symbols, imports, calls, relations };
+  },
+};
+
+function nearest(node: { parent: unknown; type: string } | null, type: string): { type: string; text: string; startPosition: { row: number }; endPosition: { row: number } } | undefined {
+  let current = node;
+  while (current) {
+    if (current.type === type) return current as unknown as { type: string; text: string; startPosition: { row: number }; endPosition: { row: number } };
+    current = current.parent as typeof current;
+  }
+  return undefined;
+}

package/packages/toji-mem/src/indexer/parsers/dart.ts

@@ -0,0 +1,91 @@
+import { Query } from "web-tree-sitter";
+
+import { loadTreeSitterLanguage, parseWithGrammar } from "./tree-sitter-loader";
+import type { LanguageParser, ParsedCall, ParsedFile, ParsedImport, ParsedRelation, ParsedSymbol, SymbolKind } from "./types";
+
+const querySource = `
+(class_definition name: (identifier) @class.name) @class.definition
+(class_definition name: (identifier) @heritage.from superclass: (superclass (type_identifier) @extends.to))
+(class_definition name: (identifier) @heritage.from interfaces: (interfaces (type_identifier) @implements.to))
+(function_signature name: (identifier) @function.name) @function.definition
+(method_signature (function_signature name: (identifier) @method.name)) @method.definition
+(library_import (import_specification (configurable_uri (uri (string_literal) @import.source)))) @import.statement
+(expression_statement (identifier) @call.name (selector (argument_part))) @call.expression
+`;
+
+const symbolKinds = new Map<string, SymbolKind>([
+  ["class.name", "class"],
+  ["function.name", "function"],
+  ["method.name", "method"],
+]);
+
+export const dartParser: LanguageParser = {
+  language: "dart",
+  extensions: [".dart"],
+  async parseFile(input): Promise<ParsedFile> {
+    const grammarFile = "tree-sitter-dart.wasm";
+    const tree = await parseWithGrammar(grammarFile, input.content);
+    const grammar = await loadTreeSitterLanguage(grammarFile);
+    const query = new Query(grammar, querySource);
+    const captures = query.captures(tree.rootNode);
+
+    const symbols: ParsedSymbol[] = [];
+    const imports: ParsedImport[] = [];
+    const calls: ParsedCall[] = [];
+    const relations: ParsedRelation[] = [];
+    let heritageFrom: string | undefined;
+
+    for (const capture of captures) {
+      const kind = symbolKinds.get(capture.name);
+      if (kind) {
+        const parent = capture.node.parent;
+        if (kind === "function" && parent?.parent?.type === "method_signature") continue;
+        symbols.push({
+          name: capture.node.text,
+          kind,
+          startLine: capture.node.startPosition.row + 1,
+          endLine: parent ? parent.endPosition.row + 1 : capture.node.endPosition.row + 1,
+          exported: !capture.node.text.startsWith("_"),
+          signature: parent?.text.split("\n")[0]?.trim(),
+        });
+        continue;
+      }
+
+      if (capture.name === "import.source") {
+        imports.push({ source: capture.node.text.replace(/^['\"]|['\"]$/g, ""), startLine: capture.node.startPosition.row + 1 });
+        continue;
+      }
+
+      if (capture.name === "call.name") {
+        calls.push({ calleeName: capture.node.text, startLine: capture.node.startPosition.row + 1 });
+        continue;
+      }
+
+      if (capture.name === "heritage.from") {
+        heritageFrom = capture.node.text;
+        continue;
+      }
+
+      if (capture.name === "extends.to" && heritageFrom) {
+        relations.push({
+          fromName: heritageFrom,
+          toName: capture.node.text,
+          edgeType: "symbol_extends_symbol",
+          startLine: capture.node.startPosition.row + 1,
+        });
+        continue;
+      }
+
+      if (capture.name === "implements.to" && heritageFrom) {
+        relations.push({
+          fromName: heritageFrom,
+          toName: capture.node.text,
+          edgeType: "symbol_implements_symbol",
+          startLine: capture.node.startPosition.row + 1,
+        });
+      }
+    }
+
+    return { symbols, imports, calls, relations };
+  },
+};

package/packages/toji-mem/src/indexer/parsers/java.ts

@@ -0,0 +1,83 @@
+import { Query } from "web-tree-sitter";
+
+import { loadTreeSitterLanguage, parseWithGrammar } from "./tree-sitter-loader";
+import type { LanguageParser, ParsedCall, ParsedFile, ParsedImport, ParsedRelation, ParsedSymbol, SymbolKind } from "./types";
+
+const querySource = `
+(class_declaration name: (identifier) @class.name) @class.definition
+(interface_declaration name: (identifier) @interface.name) @interface.definition
+(method_declaration name: (identifier) @method.name) @method.definition
+(constructor_declaration name: (identifier) @method.name) @method.definition
+(import_declaration (scoped_identifier) @import.source) @import.statement
+(import_declaration (identifier) @import.source) @import.statement
+(method_invocation name: (identifier) @call.name) @call.expression
+(class_declaration name: (identifier) @heritage.from superclass: (superclass (type_identifier) @extends.to))
+(class_declaration name: (identifier) @heritage.from interfaces: (super_interfaces (type_list (type_identifier) @implements.to)))
+(interface_declaration name: (identifier) @heritage.from (extends_interfaces (type_list (type_identifier) @extends.to)))
+`;
+
+const symbolKinds = new Map<string, SymbolKind>([
+  ["class.name", "class"],
+  ["interface.name", "interface"],
+  ["method.name", "method"],
+]);
+
+export const javaParser: LanguageParser = {
+  language: "java",
+  extensions: [".java"],
+  async parseFile(input): Promise<ParsedFile> {
+    const grammarFile = "tree-sitter-java.wasm";
+    const tree = await parseWithGrammar(grammarFile, input.content);
+    const grammar = await loadTreeSitterLanguage(grammarFile);
+    const query = new Query(grammar, querySource);
+    const captures = query.captures(tree.rootNode);
+
+    const symbols: ParsedSymbol[] = [];
+    const imports: ParsedImport[] = [];
+    const calls: ParsedCall[] = [];
+    const relations: ParsedRelation[] = [];
+    let heritageFrom: string | undefined;
+
+    for (const capture of captures) {
+      const kind = symbolKinds.get(capture.name);
+      if (kind) {
+        const parent = capture.node.parent;
+        symbols.push({
+          name: capture.node.text,
+          kind,
+          startLine: capture.node.startPosition.row + 1,
+          endLine: parent ? parent.endPosition.row + 1 : capture.node.endPosition.row + 1,
+          exported: parent?.text.startsWith("public ") ?? false,
+          signature: parent?.text.split("\n")[0]?.trim(),
+        });
+        continue;
+      }
+
+      if (capture.name === "import.source") {
+        imports.push({ source: capture.node.text, startLine: capture.node.startPosition.row + 1 });
+        continue;
+      }
+
+      if (capture.name === "call.name") {
+        calls.push({ calleeName: capture.node.text, startLine: capture.node.startPosition.row + 1 });
+        continue;
+      }
+
+      if (capture.name === "heritage.from") {
+        heritageFrom = capture.node.text;
+        continue;
+      }
+
+      if ((capture.name === "extends.to" || capture.name === "implements.to") && heritageFrom) {
+        relations.push({
+          fromName: heritageFrom,
+          toName: capture.node.text,
+          edgeType: capture.name === "extends.to" ? "symbol_extends_symbol" : "symbol_implements_symbol",
+          startLine: capture.node.startPosition.row + 1,
+        });
+      }
+    }
+
+    return { symbols, imports, calls, relations };
+  },
+};

package/packages/toji-mem/src/indexer/parsers/python.ts

@@ -0,0 +1,84 @@
+import { Query } from "web-tree-sitter";
+
+import { loadTreeSitterLanguage, parseWithGrammar } from "./tree-sitter-loader";
+import type { LanguageParser, ParsedCall, ParsedFile, ParsedImport, ParsedRelation, ParsedSymbol, SymbolKind } from "./types";
+
+const querySource = `
+(function_definition name: (identifier) @function.name) @function.definition
+(class_definition name: (identifier) @class.name) @class.definition
+(class_definition name: (identifier) @heritage.from superclasses: (argument_list (identifier) @extends.to))
+(import_statement) @import.statement
+(import_from_statement module_name: (dotted_name) @import.source) @import.statement
+(call function: (identifier) @call.name) @call.expression
+(call function: (attribute attribute: (identifier) @call.member_name)) @call.expression
+`;
+
+const symbolKinds = new Map<string, SymbolKind>([
+  ["function.name", "function"],
+  ["class.name", "class"],
+]);
+
+export const pythonParser: LanguageParser = {
+  language: "python",
+  extensions: [".py"],
+  async parseFile(input): Promise<ParsedFile> {
+    const grammarFile = "tree-sitter-python.wasm";
+    const tree = await parseWithGrammar(grammarFile, input.content);
+    const grammar = await loadTreeSitterLanguage(grammarFile);
+    const query = new Query(grammar, querySource);
+    const captures = query.captures(tree.rootNode);
+
+    const symbols: ParsedSymbol[] = [];
+    const imports: ParsedImport[] = [];
+    const calls: ParsedCall[] = [];
+    const relations: ParsedRelation[] = [];
+    let heritageFrom: string | undefined;
+
+    for (const capture of captures) {
+      const kind = symbolKinds.get(capture.name);
+      if (kind) {
+        const parent = capture.node.parent;
+        symbols.push({
+          name: capture.node.text,
+          kind,
+          startLine: capture.node.startPosition.row + 1,
+          endLine: parent ? parent.endPosition.row + 1 : capture.node.endPosition.row + 1,
+          exported: !capture.node.text.startsWith("_"),
+          signature: parent?.text.split("\n")[0]?.trim(),
+        });
+        continue;
+      }
+
+      if (capture.name === "import.source") {
+        imports.push({ source: capture.node.text, startLine: capture.node.startPosition.row + 1 });
+        continue;
+      }
+
+      if (capture.name === "import.statement") {
+        imports.push({ source: capture.node.text, startLine: capture.node.startPosition.row + 1 });
+        continue;
+      }
+
+      if (capture.name === "call.name" || capture.name === "call.member_name") {
+        calls.push({ calleeName: capture.node.text, startLine: capture.node.startPosition.row + 1 });
+        continue;
+      }
+
+      if (capture.name === "heritage.from") {
+        heritageFrom = capture.node.text;
+        continue;
+      }
+
+      if (capture.name === "extends.to" && heritageFrom) {
+        relations.push({
+          fromName: heritageFrom,
+          toName: capture.node.text,
+          edgeType: "symbol_extends_symbol",
+          startLine: capture.node.startPosition.row + 1,
+        });
+      }
+    }
+
+    return { symbols, imports, calls, relations };
+  },
+};

package/packages/toji-mem/src/indexer/parsers/registry.ts

@@ -0,0 +1,28 @@
+import { extname } from "node:path";
+
+import { cppParser } from "./cpp";
+import { dartParser } from "./dart";
+import { javaParser } from "./java";
+import { pythonParser } from "./python";
+import { createTypeScriptParser } from "./typescript";
+import type { LanguageParser } from "./types";
+
+const parsers: LanguageParser[] = [
+  createTypeScriptParser("typescript", "tree-sitter-typescript.wasm", [".ts", ".mts", ".cts"]),
+  createTypeScriptParser("tsx", "tree-sitter-tsx.wasm", [".tsx"]),
+  createTypeScriptParser("javascript", "tree-sitter-javascript.wasm", [".js", ".mjs", ".cjs"]),
+  createTypeScriptParser("jsx", "tree-sitter-javascript.wasm", [".jsx"]),
+  cppParser,
+  dartParser,
+  javaParser,
+  pythonParser,
+];
+
+export function getParserForPath(filePath: string): LanguageParser | undefined {
+  const extension = extname(filePath);
+  return parsers.find((parser) => parser.extensions.includes(extension));
+}
+
+export function getSupportedExtensions(): string[] {
+  return parsers.flatMap((parser) => parser.extensions);
+}