@monoes/monograph 1.0.0

package/src/export/svg.ts

@@ -0,0 +1,55 @@
+import type { MonographNode, MonographEdge } from '../types.js';
+
+const W = 1200;
+const H = 800;
+
+export function toSvg(nodes: MonographNode[], edges: MonographEdge[]): string {
+  const positions = forceLayout(nodes.slice(0, 200));
+
+  const edgeSvg = edges
+    .filter(e => positions.has(e.sourceId) && positions.has(e.targetId))
+    .map(e => {
+      const s = positions.get(e.sourceId)!;
+      const t = positions.get(e.targetId)!;
+      return `<line x1="${s.x}" y1="${s.y}" x2="${t.x}" y2="${t.y}" stroke="#94a3b8" stroke-width="1" opacity="0.5"/>`;
+    })
+    .join('\n');
+
+  const nodeSvg = [...positions.entries()]
+    .map(([id, pos]) => {
+      const node = nodes.find(n => n.id === id);
+      const label = node?.name ?? id;
+      return (
+        `<circle cx="${pos.x}" cy="${pos.y}" r="6" fill="#3b82f6" stroke="#1e293b" stroke-width="0.5"/>` +
+        `<text x="${pos.x + 8}" y="${pos.y + 4}" font-size="10" fill="#1e293b">${sanitizeLabel(label)}</text>`
+      );
+    })
+    .join('\n');
+
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}">
+<defs>
+<style>
+  text { font-family: system-ui, -apple-system, sans-serif; user-select: none; }
+</style>
+</defs>
+<rect width="${W}" height="${H}" fill="#f8fafc"/>
+${edgeSvg}
+${nodeSvg}
+</svg>`;
+}
+
+function forceLayout(nodes: MonographNode[]): Map<string, { x: number; y: number }> {
+  const positions = new Map<string, { x: number; y: number }>();
+  nodes.forEach((n, i) => {
+    const angle = (i / Math.max(nodes.length, 1)) * 2 * Math.PI;
+    positions.set(n.id, {
+      x: W / 2 + Math.cos(angle) * (W * 0.35),
+      y: H / 2 + Math.sin(angle) * (H * 0.35),
+    });
+  });
+  return positions;
+}
+
+function sanitizeLabel(s: string): string {
+  return s.substring(0, 20).replace(/[&<>"']/g, '_');
+}

package/src/graph/analyzer.ts

@@ -0,0 +1,29 @@
+import { bidirectional } from 'graphology-shortest-path';
+import type Graph from 'graphology';
+import type { MonographDb } from '../storage/db.js';
+import { loadGraphFromDb } from './loader.js';
+
+export function getShortestPath(
+  db: MonographDb,
+  sourceId: string,
+  targetId: string,
+  maxDepth = 6,
+): string[] | null {
+  const graph = loadGraphFromDb(db);
+  if (!graph.hasNode(sourceId) || !graph.hasNode(targetId)) return null;
+  try {
+    const path = bidirectional(graph, sourceId, targetId);
+    if (path && path.length <= maxDepth + 1) return path;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function getNodeDegrees(graph: Graph, nodeId: string): { in: number; out: number } {
+  if (!graph.hasNode(nodeId)) return { in: 0, out: 0 };
+  return {
+    in: graph.inDegree ? graph.inDegree(nodeId) : 0,
+    out: graph.outDegree ? graph.outDegree(nodeId) : 0,
+  };
+}

package/src/graph/diff.ts

@@ -0,0 +1,65 @@
+import type { MonographNode, MonographEdge } from '../types.js';
+
+export interface GraphSnapshot {
+  nodes: MonographNode[];
+  edges: MonographEdge[];
+  capturedAt: string;
+}
+
+export interface GraphDiff {
+  newNodes: MonographNode[];
+  removedNodes: MonographNode[];
+  newEdges: MonographEdge[];
+  removedEdges: MonographEdge[];
+  modifiedNodes: Array<{ before: MonographNode; after: MonographNode }>;
+}
+
+export function diffSnapshots(before: GraphSnapshot, after: GraphSnapshot): GraphDiff {
+  const beforeNodeIds = new Map(before.nodes.map(n => [n.id, n]));
+  const afterNodeIds = new Map(after.nodes.map(n => [n.id, n]));
+  const beforeEdgeIds = new Set(before.edges.map(e => e.id));
+  const afterEdgeIds = new Set(after.edges.map(e => e.id));
+
+  return {
+    newNodes: after.nodes.filter(n => !beforeNodeIds.has(n.id)),
+    removedNodes: before.nodes.filter(n => !afterNodeIds.has(n.id)),
+    newEdges: after.edges.filter(e => !beforeEdgeIds.has(e.id)),
+    removedEdges: before.edges.filter(e => !afterEdgeIds.has(e.id)),
+    modifiedNodes: after.nodes
+      .filter(n => beforeNodeIds.has(n.id))
+      .filter(n => JSON.stringify(n) !== JSON.stringify(beforeNodeIds.get(n.id)))
+      .map(n => ({ before: beforeNodeIds.get(n.id)!, after: n })),
+  };
+}
+
+export function snapshotFromDb(db: import('../storage/db.js').MonographDb): GraphSnapshot {
+  const rawNodes = db.prepare(`
+    SELECT id, label, name,
+      norm_label AS normLabel,
+      file_path AS filePath,
+      start_line AS startLine,
+      end_line AS endLine,
+      community_id AS communityId,
+      is_exported AS isExported,
+      language, properties
+    FROM nodes
+  `).all() as Array<Record<string, unknown>>;
+
+  const rawEdges = db.prepare(`
+    SELECT id,
+      source_id AS sourceId,
+      target_id AS targetId,
+      relation, confidence,
+      confidence_score AS confidenceScore
+    FROM edges
+  `).all() as Array<Record<string, unknown>>;
+
+  const nodes: MonographNode[] = rawNodes.map(r => ({
+    ...r,
+    isExported: Boolean(r['isExported']),
+  } as MonographNode));
+
+  const edges = rawEdges as unknown as MonographEdge[];
+
+  return { nodes, edges, capturedAt: new Date().toISOString() };
+}

package/src/graph/loader.ts

@@ -0,0 +1,41 @@
+import Graph from 'graphology';
+import type { MonographEdge } from '../types.js';
+
+export function loadGraphFromEdges(edges: MonographEdge[]): Graph {
+  const graph = new Graph({ multi: true, type: 'directed' });
+  for (const edge of edges) {
+    if (!graph.hasNode(edge.sourceId)) graph.addNode(edge.sourceId);
+    if (!graph.hasNode(edge.targetId)) graph.addNode(edge.targetId);
+    try {
+      graph.addEdge(edge.sourceId, edge.targetId, {
+        id: edge.id, relation: edge.relation,
+        confidence: edge.confidence, confidenceScore: edge.confidenceScore,
+      });
+    } catch { /* duplicate edge */ }
+  }
+  return graph;
+}
+
+export function loadGraphFromDb(db: import('../storage/db.js').MonographDb): Graph {
+  const nodes = db.prepare('SELECT id FROM nodes').all() as { id: string }[];
+  const edges = db.prepare('SELECT * FROM edges').all() as {
+    id: string; source_id: string; target_id: string; relation: string;
+    confidence: string; confidence_score: number;
+  }[];
+
+  const graph = new Graph({ multi: true, type: 'directed' });
+  for (const n of nodes) {
+    if (!graph.hasNode(n.id)) graph.addNode(n.id);
+  }
+  for (const e of edges) {
+    if (!graph.hasNode(e.source_id)) graph.addNode(e.source_id);
+    if (!graph.hasNode(e.target_id)) graph.addNode(e.target_id);
+    try {
+      graph.addEdge(e.source_id, e.target_id, {
+        id: e.id, relation: e.relation,
+        confidence: e.confidence, confidenceScore: e.confidence_score,
+      });
+    } catch { /* skip */ }
+  }
+  return graph;
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from './types.js';
+export * from './storage/db.js';
+export * from './storage/node-store.js';
+export * from './storage/edge-store.js';
+export * from './storage/fts-store.js';
+export * from './pipeline/runner.js';
+export * from './pipeline/types.js';
+export * from './pipeline/orchestrator.js';
+export * from './graph/loader.js';
+export * from './graph/analyzer.js';
+export * from './graph/diff.js';
+export * from './watch/watcher.js';
+export * from './export/json.js';
+export * from './export/html.js';
+export * from './export/cypher.js';
+export * from './export/graphml.js';
+export * from './export/svg.js';

package/src/mcp/resources.ts

@@ -0,0 +1,69 @@
+export interface MCPResource {
+  uri: string;
+  name: string;
+  description: string;
+  mimeType: string;
+  handler: (uri: string) => Promise<{ content: string }>;
+}
+
+import { openDb, closeDb } from '../storage/db.js';
+import { countNodes } from '../storage/node-store.js';
+import { countEdges } from '../storage/edge-store.js';
+import { join } from 'path';
+
+function getDbPath(): string {
+  const base = process.env.MONOMIND_CWD ?? process.cwd();
+  return join(base, '.monomind', 'monograph.db');
+}
+
+export const monographResources: MCPResource[] = [
+  {
+    uri: 'monograph://repo/{name}/context',
+    name: 'Monograph Repo Context',
+    description: 'Full graph context summary for the indexed repository',
+    mimeType: 'application/json',
+    handler: async (_uri) => {
+      const db = openDb(getDbPath());
+      try {
+        const nodes = countNodes(db);
+        const edges = countEdges(db);
+        const meta = db.prepare('SELECT key, value FROM index_meta').all() as { key: string; value: string }[];
+        return { content: JSON.stringify({ nodes, edges, meta }, null, 2) };
+      } finally { closeDb(db); }
+    },
+  },
+  {
+    uri: 'monograph://repo/{name}/clusters',
+    name: 'Monograph Community Clusters',
+    description: 'Community cluster summary with sizes and labels',
+    mimeType: 'application/json',
+    handler: async (_uri) => {
+      const db = openDb(getDbPath());
+      try {
+        const communities = db.prepare('SELECT * FROM communities ORDER BY size DESC').all();
+        return { content: JSON.stringify(communities, null, 2) };
+      } finally { closeDb(db); }
+    },
+  },
+  {
+    uri: 'monograph://repo/{name}/processes',
+    name: 'Monograph Process Map',
+    description: 'Process detection results (populated in Sub-project 3)',
+    mimeType: 'application/json',
+    handler: async (_uri) => ({ content: JSON.stringify({ note: 'Process detection available in Sub-project 3' }) }),
+  },
+  {
+    uri: 'monograph://repo/{name}/schema',
+    name: 'Monograph Schema',
+    description: 'Node label and edge relation types present in this repo',
+    mimeType: 'application/json',
+    handler: async (_uri) => {
+      const db = openDb(getDbPath());
+      try {
+        const labels = db.prepare('SELECT DISTINCT label, COUNT(*) as count FROM nodes GROUP BY label ORDER BY count DESC').all();
+        const relations = db.prepare('SELECT DISTINCT relation, COUNT(*) as count FROM edges GROUP BY relation ORDER BY count DESC').all();
+        return { content: JSON.stringify({ nodeLabels: labels, edgeRelations: relations }, null, 2) };
+      } finally { closeDb(db); }
+    },
+  },
+];

package/src/parsers/extractor.ts

@@ -0,0 +1,180 @@
+import type Parser from 'tree-sitter';
+import type { LanguageConfig } from './language-config.js';
+import type { MonographNode, MonographEdge } from '../types.js';
+import { makeId, toNormLabel, CONFIDENCE_SCORE } from '../types.js';
+import type { ParseResult } from './loader.js';
+
+export function extractSymbols(
+  tree: Parser.Tree,
+  source: string,
+  repoPath: string,
+  config: LanguageConfig,
+  ext: string,
+): ParseResult {
+  const nodes: MonographNode[] = [];
+  const edges: MonographEdge[] = [];
+  const parseErrors: string[] = [];
+  const language = config.name;
+
+  function nodeId(name: string, filePath: string, extra?: string): string {
+    return makeId(filePath.replace(/\//g, '_'), name, extra ?? '');
+  }
+
+  const fileNodeId = makeId(repoPath.replace(/\//g, '_'), 'file');
+  nodes.push({
+    id: fileNodeId,
+    label: 'File',
+    name: repoPath.split('/').pop() ?? repoPath,
+    normLabel: toNormLabel(repoPath.split('/').pop() ?? repoPath),
+    filePath: repoPath,
+    isExported: false,
+    language,
+  });
+
+  function walk(node: Parser.SyntaxNode, parentId?: string): void {
+    const { type } = node;
+
+    if (config.importNodeTypes.has(type)) {
+      handleImport(node, fileNodeId, source, config, edges, repoPath);
+      return;
+    }
+
+    const isClass = config.classNodeTypes.has(type);
+    const isStruct = config.structNodeTypes.has(type);
+    const isEnum = config.enumNodeTypes.has(type);
+    const isFunction = config.functionNodeTypes.has(type);
+    const isMethod = config.methodNodeTypes.has(type);
+    const isInterface = config.interfaceNodeTypes.has(type);
+    const isConstructor = config.constructorNodeTypes.has(type);
+
+    if (isClass || isStruct || isEnum || isFunction || isMethod || isInterface || isConstructor) {
+      const nameNode = node.childForFieldName(config.nameField);
+      const name = nameNode?.text ?? node.text.split('\n')[0].slice(0, 40);
+      // When a node type is in BOTH functionNodeTypes and methodNodeTypes (e.g. Python
+      // `function_definition`), check parent chain to disambiguate: a function_definition
+      // whose grandparent is a class_definition is a method, otherwise it's a function.
+      const isBothFunctionAndMethod = isFunction && isMethod;
+      const isActuallyMethod = isBothFunctionAndMethod
+        ? config.classNodeTypes.has(node.parent?.parent?.type ?? '')
+        : isMethod;
+      const label = isClass ? 'Class' : isStruct ? 'Struct' : isEnum ? 'Enum' :
+                    isInterface ? 'Interface' : isActuallyMethod ? 'Method' :
+                    isConstructor ? 'Constructor' : 'Function';
+      const id = nodeId(name, repoPath, label.toLowerCase());
+      const isExported = config.exportDetector
+        ? config.exportDetector(node, source)
+        : isNodeExported(node, source);
+
+      nodes.push({
+        id, label, name,
+        normLabel: toNormLabel(name),
+        filePath: repoPath,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        isExported, language,
+      });
+
+      const containerId = parentId ?? fileNodeId;
+      edges.push({
+        id: makeId(containerId, id, 'contains'),
+        sourceId: containerId, targetId: id,
+        relation: 'CONTAINS',
+        confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
+      });
+
+      handleInheritance(node, id, edges, repoPath, config, source);
+
+      for (let i = 0; i < node.childCount; i++) {
+        walk(node.child(i)!, id);
+      }
+      return;
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+      walk(node.child(i)!, parentId);
+    }
+  }
+
+  walk(tree.rootNode);
+  return { nodes, edges, parseErrors };
+}
+
+function isNodeExported(node: Parser.SyntaxNode, _source: string): boolean {
+  const parent = node.parent;
+  if (!parent) return false;
+  return parent.type === 'export_statement' ||
+    parent.type === 'export_default_declaration';
+}
+
+function handleImport(
+  node: Parser.SyntaxNode,
+  fileNodeId: string,
+  source: string,
+  config: LanguageConfig,
+  edges: MonographEdge[],
+  repoPath: string,
+): void {
+  const targetPath = config.importExtractor ? config.importExtractor(source, node) : null;
+  const targetId = makeId('import', targetPath ?? node.text.slice(0, 60));
+  edges.push({
+    id: makeId(fileNodeId, targetId, 'imports'),
+    sourceId: fileNodeId, targetId,
+    relation: 'IMPORTS',
+    confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
+  });
+}
+
+function handleInheritance(
+  node: Parser.SyntaxNode,
+  nodeId: string,
+  edges: MonographEdge[],
+  _repoPath: string,
+  _config: LanguageConfig,
+  _source: string,
+): void {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i)!;
+    if (child.type === 'extends_clause') {
+      const targetId = makeId('import', child.text.replace(/extends?\s+/, '').trim());
+      edges.push({
+        id: makeId(nodeId, targetId, 'extends'),
+        sourceId: nodeId, targetId,
+        relation: 'EXTENDS',
+        confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
+      });
+    }
+    if (child.type === 'implements_clause') {
+      const targetId = makeId('import', child.text.replace(/implements\s+/, '').trim());
+      edges.push({
+        id: makeId(nodeId, targetId, 'implements'),
+        sourceId: nodeId, targetId,
+        relation: 'IMPLEMENTS',
+        confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
+      });
+    }
+    // class_heritage is the direct child; implements_clause is nested inside it
+    if (child.type === 'class_heritage') {
+      for (let j = 0; j < child.childCount; j++) {
+        const grandChild = child.child(j)!;
+        if (grandChild.type === 'extends_clause') {
+          const targetId = makeId('import', grandChild.text.replace(/extends?\s+/, '').trim());
+          edges.push({
+            id: makeId(nodeId, targetId, 'extends'),
+            sourceId: nodeId, targetId,
+            relation: 'EXTENDS',
+            confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
+          });
+        }
+        if (grandChild.type === 'implements_clause') {
+          const targetId = makeId('import', grandChild.text.replace(/implements\s+/, '').trim());
+          edges.push({
+            id: makeId(nodeId, targetId, 'implements'),
+            sourceId: nodeId, targetId,
+            relation: 'IMPLEMENTS',
+            confidence: 'EXTRACTED', confidenceScore: CONFIDENCE_SCORE.EXTRACTED,
+          });
+        }
+      }
+    }
+  }
+}

package/src/parsers/go.ts

@@ -0,0 +1,27 @@
+import { createRequire } from 'module';
+import type { LanguageConfig } from './language-config.js';
+
+const require = createRequire(import.meta.url);
+
+export const goConfig: LanguageConfig = {
+  name: 'go',
+  extensions: ['.go'],
+  treeSitterModule: 'tree-sitter-go',
+  getLanguage: () => require('tree-sitter-go'),
+  classNodeTypes: new Set([]),
+  structNodeTypes: new Set(['type_spec']),
+  enumNodeTypes: new Set([]),
+  functionNodeTypes: new Set(['function_declaration']),
+  methodNodeTypes: new Set(['method_declaration']),
+  constructorNodeTypes: new Set([]),
+  interfaceNodeTypes: new Set(['interface_type']),
+  importNodeTypes: new Set(['import_declaration', 'import_spec']),
+  callNodeTypes: new Set(['call_expression']),
+  decoratorNodeTypes: new Set([]),
+  nameField: 'name',
+  packageScopeType: 'package_clause',
+  importExtractor: (_source, node) => {
+    const pathNode = node.childForFieldName('path') ?? node.child(1);
+    return pathNode?.text.replace(/['"]/g, '') ?? null;
+  },
+};

package/src/parsers/java.ts

@@ -0,0 +1,27 @@
+import { createRequire } from 'module';
+import type { LanguageConfig } from './language-config.js';
+
+const require = createRequire(import.meta.url);
+
+export const javaConfig: LanguageConfig = {
+  name: 'java',
+  extensions: ['.java'],
+  treeSitterModule: 'tree-sitter-java',
+  getLanguage: () => require('tree-sitter-java'),
+  classNodeTypes: new Set(['class_declaration']),
+  structNodeTypes: new Set(['record_declaration']),
+  enumNodeTypes: new Set(['enum_declaration']),
+  functionNodeTypes: new Set([]),
+  methodNodeTypes: new Set(['method_declaration']),
+  constructorNodeTypes: new Set(['constructor_declaration']),
+  interfaceNodeTypes: new Set(['interface_declaration', 'annotation_type_declaration']),
+  importNodeTypes: new Set(['import_declaration']),
+  callNodeTypes: new Set(['method_invocation', 'object_creation_expression']),
+  decoratorNodeTypes: new Set(['annotation']),
+  nameField: 'name',
+  importExtractor: (_source, node) => {
+    const path = node.text.replace(/^import\s+(static\s+)?/, '').replace(/;$/, '').trim();
+    return path || null;
+  },
+  exportDetector: (_node, _source) => true,
+};

package/src/parsers/language-config.ts

@@ -0,0 +1,28 @@
+export interface ImportExtractor {
+  (sourceText: string, importNode: import('tree-sitter').SyntaxNode): string | null;
+}
+
+export interface ExportDetector {
+  (node: import('tree-sitter').SyntaxNode, sourceText: string): boolean;
+}
+
+export interface LanguageConfig {
+  name: string;
+  extensions: string[];
+  treeSitterModule: string;
+  getLanguage: () => import('tree-sitter').Language;
+  classNodeTypes: Set<string>;
+  structNodeTypes: Set<string>;
+  enumNodeTypes: Set<string>;
+  functionNodeTypes: Set<string>;
+  methodNodeTypes: Set<string>;
+  constructorNodeTypes: Set<string>;
+  interfaceNodeTypes: Set<string>;
+  importNodeTypes: Set<string>;
+  callNodeTypes: Set<string>;
+  decoratorNodeTypes: Set<string>;
+  nameField: string;
+  packageScopeType?: string;
+  importExtractor?: ImportExtractor;
+  exportDetector?: ExportDetector;
+}

package/src/parsers/loader.ts

@@ -0,0 +1,85 @@
+import Parser from 'tree-sitter';
+import type { LanguageConfig } from './language-config.js';
+
+const parserCache = new Map<string, Parser>();
+const configCache = new Map<string, LanguageConfig>();
+
+async function loadConfig(ext: string): Promise<LanguageConfig | null> {
+  if (configCache.has(ext)) return configCache.get(ext)!;
+
+  let config: LanguageConfig | null = null;
+  if (ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs') {
+    const { typescriptConfig } = await import('./typescript.js');
+    config = typescriptConfig;
+  } else if (ext === '.py') {
+    const { pythonConfig } = await import('./python.js');
+    config = pythonConfig;
+  } else if (ext === '.go') {
+    const { goConfig } = await import('./go.js');
+    config = goConfig;
+  } else if (ext === '.rs') {
+    const { rustConfig } = await import('./rust.js');
+    config = rustConfig;
+  } else if (ext === '.java') {
+    const { javaConfig } = await import('./java.js');
+    config = javaConfig;
+  }
+
+  if (config) {
+    for (const e of config.extensions) configCache.set(e, config);
+  }
+  return config;
+}
+
+export async function getParser(ext: string): Promise<{ parser: Parser; config: LanguageConfig } | null> {
+  const config = await loadConfig(ext);
+  if (!config) return null;
+
+  if (parserCache.has(ext)) {
+    return { parser: parserCache.get(ext)!, config };
+  }
+
+  const parser = new Parser();
+  parser.setLanguage(config.getLanguage());
+  parserCache.set(ext, parser);
+  return { parser, config };
+}
+
+export function isSupportedExtension(ext: string): boolean {
+  const supported = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs', '.java'];
+  return supported.includes(ext);
+}
+
+export function getLanguageForExt(ext: string): string {
+  const map: Record<string, string> = {
+    '.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript',
+    '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
+    '.py': 'python', '.go': 'go', '.rs': 'rust', '.java': 'java',
+  };
+  return map[ext] ?? 'unknown';
+}
+
+export interface ParseResult {
+  nodes: import('../types.js').MonographNode[];
+  edges: import('../types.js').MonographEdge[];
+  parseErrors: string[];
+}
+
+export async function parseFile(
+  absolutePath: string,
+  sourceText: string,
+  repoRelativePath: string,
+): Promise<ParseResult> {
+  const ext = absolutePath.slice(absolutePath.lastIndexOf('.'));
+  const entry = await getParser(ext);
+  if (!entry) return { nodes: [], edges: [], parseErrors: [] };
+
+  const { parser, config } = entry;
+  try {
+    const tree = parser.parse(sourceText);
+    const { extractSymbols } = await import('./extractor.js');
+    return extractSymbols(tree, sourceText, repoRelativePath, config, ext);
+  } catch (err) {
+    return { nodes: [], edges: [], parseErrors: [`${repoRelativePath}: ${err}`] };
+  }
+}

package/src/parsers/python.ts

@@ -0,0 +1,26 @@
+import { createRequire } from 'module';
+import type { LanguageConfig } from './language-config.js';
+
+const require = createRequire(import.meta.url);
+
+export const pythonConfig: LanguageConfig = {
+  name: 'python',
+  extensions: ['.py'],
+  treeSitterModule: 'tree-sitter-python',
+  getLanguage: () => require('tree-sitter-python'),
+  classNodeTypes: new Set(['class_definition']),
+  structNodeTypes: new Set([]),
+  enumNodeTypes: new Set([]),
+  functionNodeTypes: new Set(['function_definition']),
+  methodNodeTypes: new Set(['function_definition']),
+  constructorNodeTypes: new Set([]),
+  interfaceNodeTypes: new Set([]),
+  importNodeTypes: new Set(['import_statement', 'import_from_statement']),
+  callNodeTypes: new Set(['call']),
+  decoratorNodeTypes: new Set(['decorator']),
+  nameField: 'name',
+  importExtractor: (_source, node) => {
+    const moduleNode = node.childForFieldName('module_name') ?? node.child(1);
+    return moduleNode?.text ?? null;
+  },
+};