@graphmemory/server 1.1.0

package/dist/lib/multi-config.js

@@ -0,0 +1,393 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPH_NAMES = void 0;
+exports.embeddingFingerprint = embeddingFingerprint;
+exports.formatAuthor = formatAuthor;
+exports.loadMultiConfig = loadMultiConfig;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = require("yaml");
+const zod_1 = require("zod");
+const HOME = os_1.default.homedir();
+// ---------------------------------------------------------------------------
+// Zod schemas
+// ---------------------------------------------------------------------------
+const authorSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    email: zod_1.z.string(),
+});
+// Model config: taken as a whole from the first level that defines it (no field merge)
+const modelConfigSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    pooling: zod_1.z.enum(['mean', 'cls']).optional(),
+    normalize: zod_1.z.boolean().optional(),
+    dtype: zod_1.z.string().optional(),
+    queryPrefix: zod_1.z.string().optional(),
+    documentPrefix: zod_1.z.string().optional(),
+});
+// Embedding config: each field individually inherits up the chain
+const embeddingConfigSchema = zod_1.z.object({
+    batchSize: zod_1.z.number().int().positive().optional(),
+    maxChars: zod_1.z.number().int().positive().optional(),
+    cacheSize: zod_1.z.number().int().min(0).optional(),
+    remote: zod_1.z.string().optional(), // Remote embedding API URL
+    remoteApiKey: zod_1.z.string().optional(), // API key for remote embedding
+});
+const accessLevelSchema = zod_1.z.enum(['deny', 'r', 'rw']);
+const accessMapSchema = zod_1.z.record(zod_1.z.string(), accessLevelSchema).optional();
+// Exclude accepts string ("a,b") or array (["a", "b"]) in YAML
+const excludeSchema = zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional();
+const userSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    email: zod_1.z.string(),
+    apiKey: zod_1.z.string(),
+    passwordHash: zod_1.z.string().optional(),
+});
+const graphConfigSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().optional(),
+    include: zod_1.z.string().optional(),
+    exclude: excludeSchema,
+    model: modelConfigSchema.optional(),
+    embedding: embeddingConfigSchema.optional(),
+    access: accessMapSchema,
+});
+const graphsConfigSchema = zod_1.z.object({
+    docs: graphConfigSchema.optional(),
+    code: graphConfigSchema.optional(),
+    knowledge: graphConfigSchema.optional(),
+    tasks: graphConfigSchema.optional(),
+    files: graphConfigSchema.optional(),
+    skills: graphConfigSchema.optional(),
+});
+const projectSchema = zod_1.z.object({
+    projectDir: zod_1.z.string(),
+    graphMemory: zod_1.z.string().optional(),
+    exclude: excludeSchema,
+    chunkDepth: zod_1.z.number().int().positive().optional(),
+    maxFileSize: zod_1.z.number().int().positive().optional(),
+    model: modelConfigSchema.optional(),
+    embedding: embeddingConfigSchema.optional(),
+    graphs: graphsConfigSchema.optional(),
+    author: authorSchema.optional(),
+    access: accessMapSchema,
+});
+const embeddingApiSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().optional(),
+    apiKey: zod_1.z.string().optional(),
+    maxTexts: zod_1.z.number().int().positive().optional(), // max texts per request
+    maxTextChars: zod_1.z.number().int().positive().optional(), // max chars per text
+});
+const rateLimitSchema = zod_1.z.object({
+    global: zod_1.z.number().int().min(0).optional(), // req/min per IP (0 = disabled)
+    search: zod_1.z.number().int().min(0).optional(), // req/min per IP for search/embed
+    auth: zod_1.z.number().int().min(0).optional(), // req/min per IP for login
+});
+const serverSchema = zod_1.z.object({
+    host: zod_1.z.string().optional(),
+    port: zod_1.z.number().int().positive().optional(),
+    sessionTimeout: zod_1.z.number().int().positive().optional(),
+    modelsDir: zod_1.z.string().optional(),
+    corsOrigins: zod_1.z.array(zod_1.z.string()).optional(),
+    model: modelConfigSchema.optional(),
+    embedding: embeddingConfigSchema.optional(),
+    embeddingApi: embeddingApiSchema.optional(),
+    defaultAccess: accessLevelSchema.optional(),
+    access: accessMapSchema,
+    jwtSecret: zod_1.z.string().optional(),
+    accessTokenTtl: zod_1.z.string().optional(),
+    refreshTokenTtl: zod_1.z.string().optional(),
+    rateLimit: rateLimitSchema.optional(),
+    maxFileSize: zod_1.z.number().int().positive().optional(),
+    exclude: excludeSchema,
+});
+const wsGraphConfigSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().optional(),
+    exclude: excludeSchema,
+    model: modelConfigSchema.optional(),
+    embedding: embeddingConfigSchema.optional(),
+    access: accessMapSchema,
+});
+const wsGraphsConfigSchema = zod_1.z.object({
+    knowledge: wsGraphConfigSchema.optional(),
+    tasks: wsGraphConfigSchema.optional(),
+    skills: wsGraphConfigSchema.optional(),
+});
+const workspaceSchema = zod_1.z.object({
+    projects: zod_1.z.array(zod_1.z.string()),
+    graphMemory: zod_1.z.string().optional(),
+    mirrorDir: zod_1.z.string().optional(),
+    model: modelConfigSchema.optional(),
+    embedding: embeddingConfigSchema.optional(),
+    graphs: wsGraphsConfigSchema.optional(),
+    author: authorSchema.optional(),
+    access: accessMapSchema,
+    maxFileSize: zod_1.z.number().int().positive().optional(),
+    exclude: excludeSchema,
+});
+const configFileSchema = zod_1.z.object({
+    author: authorSchema.optional(),
+    server: serverSchema.optional(),
+    users: zod_1.z.record(zod_1.z.string(), userSchema).optional(),
+    projects: zod_1.z.record(zod_1.z.string(), projectSchema),
+    workspaces: zod_1.z.record(zod_1.z.string(), workspaceSchema).optional(),
+});
+exports.GRAPH_NAMES = ['docs', 'code', 'knowledge', 'tasks', 'files', 'skills'];
+/**
+ * Build a stable fingerprint string from model config fields that affect stored vectors.
+ * queryPrefix excluded: only affects query-time, not stored document vectors.
+ */
+function embeddingFingerprint(model) {
+    return `${model.name}|${model.pooling}|${model.normalize}|${model.dtype ?? ''}|${model.documentPrefix}`;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const AUTHOR_DEFAULT = { name: '', email: '' };
+/**
+ * Format an author as a git-style string: "Name <email>".
+ * Returns empty string if name is not set.
+ */
+function formatAuthor(author) {
+    if (!author.name)
+        return '';
+    return `${author.name} <${author.email}>`;
+}
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+const MODEL_DEFAULTS = {
+    name: 'Xenova/bge-m3',
+    pooling: 'cls',
+    normalize: true,
+    queryPrefix: '',
+    documentPrefix: '',
+};
+const EMBEDDING_DEFAULTS = {
+    batchSize: 1,
+    maxChars: 8000,
+    cacheSize: 10_000,
+};
+const RATE_LIMIT_DEFAULTS = {
+    global: 600,
+    search: 120,
+    auth: 10,
+};
+const SERVER_DEFAULTS = {
+    host: '127.0.0.1',
+    port: 3000,
+    sessionTimeout: 1800,
+    modelsDir: path_1.default.join(HOME, '.graph-memory/models'),
+    model: MODEL_DEFAULTS,
+    embedding: EMBEDDING_DEFAULTS,
+    defaultAccess: 'rw',
+    accessTokenTtl: '15m',
+    refreshTokenTtl: '7d',
+    rateLimit: RATE_LIMIT_DEFAULTS,
+    maxFileSize: 1 * 1024 * 1024, // 1 MB
+    exclude: ['**/node_modules/**', '**/dist/**'],
+};
+const PROJECT_DEFAULTS = {
+    docsInclude: '**/*.md',
+    codeInclude: '**/*.{js,ts,jsx,tsx}',
+    chunkDepth: 4,
+};
+/** Parse comma-separated exclude string into array of patterns. */
+function parseExclude(raw) {
+    if (!raw)
+        return [];
+    if (Array.isArray(raw))
+        return raw.map(p => p.trim()).filter(Boolean);
+    return raw.split(',').map(p => p.trim()).filter(Boolean);
+}
+// ---------------------------------------------------------------------------
+// Resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve ModelConfig: take the whole object from the first level that defines it.
+ * If undefined, returns parent (next level up the chain).
+ */
+function resolveModel(raw, parent) {
+    if (!raw)
+        return parent;
+    return {
+        name: raw.name,
+        pooling: raw.pooling ?? MODEL_DEFAULTS.pooling,
+        normalize: raw.normalize ?? MODEL_DEFAULTS.normalize,
+        dtype: raw.dtype,
+        queryPrefix: raw.queryPrefix ?? MODEL_DEFAULTS.queryPrefix,
+        documentPrefix: raw.documentPrefix ?? MODEL_DEFAULTS.documentPrefix,
+    };
+}
+/**
+ * Resolve EmbeddingConfig: each field individually inherits up the chain.
+ */
+function resolveEmbedding(raw, parent) {
+    if (!raw)
+        return parent;
+    return {
+        batchSize: raw.batchSize ?? parent.batchSize,
+        maxChars: raw.maxChars ?? parent.maxChars,
+        cacheSize: raw.cacheSize ?? parent.cacheSize,
+        remote: raw.remote ?? parent.remote,
+        remoteApiKey: raw.remoteApiKey ?? parent.remoteApiKey,
+    };
+}
+// ---------------------------------------------------------------------------
+// Load
+// ---------------------------------------------------------------------------
+/**
+ * Load and validate a `graph-memory.yaml` config file.
+ * Resolves all paths to absolute, applies defaults.
+ */
+function loadMultiConfig(yamlPath) {
+    const raw = fs_1.default.readFileSync(yamlPath, 'utf-8');
+    const parsed = (0, yaml_1.parse)(raw);
+    const validated = configFileSchema.parse(parsed);
+    const srv = validated.server ?? {};
+    const globalAuthor = validated.author ?? AUTHOR_DEFAULT;
+    // Server-level: model + embedding
+    const serverModel = resolveModel(srv.model, MODEL_DEFAULTS);
+    const serverEmbedding = resolveEmbedding(srv.embedding, EMBEDDING_DEFAULTS);
+    const server = {
+        host: srv.host ?? SERVER_DEFAULTS.host,
+        port: srv.port ?? SERVER_DEFAULTS.port,
+        sessionTimeout: srv.sessionTimeout ?? SERVER_DEFAULTS.sessionTimeout,
+        modelsDir: path_1.default.resolve(srv.modelsDir ?? SERVER_DEFAULTS.modelsDir),
+        corsOrigins: srv.corsOrigins,
+        model: serverModel,
+        embedding: serverEmbedding,
+        embeddingApi: srv.embeddingApi ? { enabled: !!srv.embeddingApi.enabled, apiKey: srv.embeddingApi.apiKey, maxTexts: srv.embeddingApi.maxTexts ?? 100, maxTextChars: srv.embeddingApi.maxTextChars ?? 10_000 } : undefined,
+        defaultAccess: srv.defaultAccess ?? SERVER_DEFAULTS.defaultAccess,
+        access: srv.access ?? undefined,
+        jwtSecret: srv.jwtSecret,
+        accessTokenTtl: srv.accessTokenTtl ?? SERVER_DEFAULTS.accessTokenTtl,
+        refreshTokenTtl: srv.refreshTokenTtl ?? SERVER_DEFAULTS.refreshTokenTtl,
+        rateLimit: {
+            global: srv.rateLimit?.global ?? RATE_LIMIT_DEFAULTS.global,
+            search: srv.rateLimit?.search ?? RATE_LIMIT_DEFAULTS.search,
+            auth: srv.rateLimit?.auth ?? RATE_LIMIT_DEFAULTS.auth,
+        },
+        maxFileSize: srv.maxFileSize ?? SERVER_DEFAULTS.maxFileSize,
+        exclude: [...SERVER_DEFAULTS.exclude, ...parseExclude(srv.exclude)],
+    };
+    // Users
+    const users = {};
+    if (validated.users) {
+        for (const [id, raw] of Object.entries(validated.users)) {
+            users[id] = { name: raw.name, email: raw.email, apiKey: raw.apiKey, passwordHash: raw.passwordHash };
+        }
+    }
+    const projects = new Map();
+    for (const [id, raw] of Object.entries(validated.projects)) {
+        const projectDir = path_1.default.resolve(raw.projectDir);
+        const graphMemory = raw.graphMemory
+            ? path_1.default.resolve(projectDir, raw.graphMemory)
+            : path_1.default.join(projectDir, '.graph-memory');
+        const projectModel = resolveModel(raw.model, serverModel);
+        const projectEmbedding = resolveEmbedding(raw.embedding, serverEmbedding);
+        // Exclude accumulates: server + project
+        const projectExclude = [...server.exclude, ...parseExclude(raw.exclude)];
+        const rawGraphs = raw.graphs ?? {};
+        const graphConfigs = {};
+        for (const gn of exports.GRAPH_NAMES) {
+            const gc = rawGraphs[gn];
+            // Exclude accumulates: server + project + graph
+            const graphExclude = [...projectExclude, ...parseExclude(gc?.exclude)];
+            graphConfigs[gn] = {
+                enabled: gc?.enabled ?? true,
+                include: gc?.include ?? (gn === 'docs' ? PROJECT_DEFAULTS.docsInclude : gn === 'code' ? PROJECT_DEFAULTS.codeInclude : undefined),
+                exclude: graphExclude,
+                model: resolveModel(gc?.model, projectModel),
+                embedding: resolveEmbedding(gc?.embedding, projectEmbedding),
+                access: gc?.access ?? undefined,
+            };
+        }
+        projects.set(id, {
+            projectDir,
+            graphMemory,
+            exclude: projectExclude,
+            chunkDepth: raw.chunkDepth ?? PROJECT_DEFAULTS.chunkDepth,
+            maxFileSize: raw.maxFileSize ?? -1,
+            model: projectModel,
+            embedding: projectEmbedding,
+            graphConfigs,
+            author: raw.author ?? globalAuthor,
+            access: raw.access ?? undefined,
+        });
+    }
+    // --- Workspaces ---
+    const workspaces = new Map();
+    if (validated.workspaces) {
+        for (const [wsId, raw] of Object.entries(validated.workspaces)) {
+            for (const projId of raw.projects) {
+                if (!projects.has(projId)) {
+                    throw new Error(`Workspace "${wsId}" references unknown project "${projId}"`);
+                }
+            }
+            const firstProject = projects.get(raw.projects[0]);
+            const graphMemory = raw.graphMemory
+                ? path_1.default.resolve(raw.graphMemory)
+                : path_1.default.join(firstProject.projectDir, '.graph-memory', 'workspace');
+            const mirrorDir = raw.mirrorDir
+                ? path_1.default.resolve(raw.mirrorDir)
+                : graphMemory;
+            const wsModel = resolveModel(raw.model, serverModel);
+            const wsEmbedding = resolveEmbedding(raw.embedding, serverEmbedding);
+            // Exclude accumulates: server + workspace
+            const wsExclude = [...server.exclude, ...parseExclude(raw.exclude)];
+            const rawGraphs = raw.graphs ?? {};
+            const WS_GRAPH_NAMES = ['knowledge', 'tasks', 'skills'];
+            const graphConfigs = {};
+            for (const gn of WS_GRAPH_NAMES) {
+                const gc = rawGraphs[gn];
+                graphConfigs[gn] = {
+                    enabled: gc?.enabled ?? true,
+                    exclude: [...wsExclude, ...parseExclude(gc?.exclude)],
+                    model: resolveModel(gc?.model, wsModel),
+                    embedding: resolveEmbedding(gc?.embedding, wsEmbedding),
+                    access: gc?.access ?? undefined,
+                };
+            }
+            workspaces.set(wsId, {
+                projects: raw.projects,
+                graphMemory,
+                mirrorDir,
+                model: wsModel,
+                embedding: wsEmbedding,
+                graphConfigs,
+                author: raw.author ?? globalAuthor,
+                access: raw.access ?? undefined,
+                maxFileSize: raw.maxFileSize,
+                exclude: wsExclude,
+            });
+        }
+    }
+    // --- Post-parse: inject workspace-level settings into member projects ---
+    const wsForProject = new Map();
+    for (const ws of workspaces.values()) {
+        for (const pid of ws.projects)
+            wsForProject.set(pid, ws);
+    }
+    for (const [pid, proj] of projects) {
+        const ws = wsForProject.get(pid);
+        // maxFileSize: project → workspace → server
+        if (proj.maxFileSize === -1) {
+            proj.maxFileSize = ws?.maxFileSize ?? server.maxFileSize;
+        }
+        // Inject workspace excludes into project + graph excludes
+        if (ws) {
+            const wsExtra = ws.exclude.filter(e => !server.exclude.includes(e)); // ws-only patterns
+            if (wsExtra.length > 0) {
+                proj.exclude = [...proj.exclude, ...wsExtra];
+                for (const gn of exports.GRAPH_NAMES) {
+                    proj.graphConfigs[gn].exclude = [...proj.graphConfigs[gn].exclude, ...wsExtra];
+                }
+            }
+        }
+    }
+    return { author: globalAuthor, server, users, projects, workspaces };
+}

package/dist/lib/parsers/code.js

@@ -0,0 +1,214 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCodeFile = parseCodeFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const languages_1 = require("../../lib/parsers/languages");
+const file_lang_1 = require("../../graphs/file-lang");
+// ---------------------------------------------------------------------------
+// Import resolution — replaces ts-morph's getModuleSpecifierSourceFile()
+// ---------------------------------------------------------------------------
+const RESOLVE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs'];
+/** Resolve a relative import specifier to an absolute file path, or null. */
+function resolveRelativeImport(fromFile, specifier) {
+    const dir = path_1.default.dirname(fromFile);
+    const base = path_1.default.resolve(dir, specifier);
+    // Exact match (e.g. './foo.ts')
+    if (hasFile(base))
+        return base;
+    // Try adding extensions (e.g. './foo' → './foo.ts')
+    for (const ext of RESOLVE_EXTENSIONS) {
+        const candidate = base + ext;
+        if (hasFile(candidate))
+            return candidate;
+    }
+    // Try index files (e.g. './foo' → './foo/index.ts')
+    for (const ext of RESOLVE_EXTENSIONS) {
+        const candidate = path_1.default.join(base, 'index' + ext);
+        if (hasFile(candidate))
+            return candidate;
+    }
+    return null;
+}
+function hasFile(p) {
+    try {
+        return fs_1.default.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Main parser
+// ---------------------------------------------------------------------------
+async function parseCodeFile(absolutePath, codeDir, mtime) {
+    const fileId = path_1.default.relative(codeDir, absolutePath);
+    // Determine language from file extension
+    const ext = path_1.default.extname(absolutePath);
+    const language = (0, file_lang_1.getLanguage)(ext);
+    if (!language || !(0, languages_1.isLanguageSupported)(language)) {
+        // Unsupported language — return file-only node, no symbols
+        return {
+            fileId,
+            mtime,
+            nodes: [{
+                    id: fileId,
+                    attrs: makeFileAttrs(fileId, '', '', 1, mtime),
+                }],
+            edges: [],
+        };
+    }
+    const source = fs_1.default.readFileSync(absolutePath, 'utf-8');
+    const rootNode = await (0, languages_1.parseSource)(source, language);
+    if (!rootNode) {
+        return {
+            fileId,
+            mtime,
+            nodes: [{
+                    id: fileId,
+                    attrs: makeFileAttrs(fileId, '', '', 1, mtime),
+                }],
+            edges: [],
+        };
+    }
+    const mapper = (0, languages_1.getMapper)(language);
+    const symbols = mapper.extractSymbols(rootNode);
+    const edgeInfos = mapper.extractEdges(rootNode);
+    const imports = mapper.extractImports(rootNode);
+    const nodes = [];
+    const edges = [];
+    const fileNodeId = fileId;
+    // --- File root node ---
+    const fileDocComment = extractFileDocComment(rootNode);
+    const importSummary = buildImportSummary(rootNode);
+    const lastLine = (rootNode.endPosition?.row ?? 0) + 1;
+    nodes.push({
+        id: fileNodeId,
+        attrs: makeFileAttrs(fileId, fileDocComment, importSummary, lastLine, mtime),
+    });
+    // --- Symbols ---
+    for (const sym of symbols) {
+        if (!sym.name)
+            continue;
+        const symbolId = makeId(fileId, sym.name);
+        nodes.push({
+            id: symbolId,
+            attrs: {
+                kind: sym.kind,
+                fileId,
+                name: sym.name,
+                signature: sym.signature,
+                docComment: sym.docComment,
+                body: sym.body,
+                startLine: sym.startLine,
+                endLine: sym.endLine,
+                isExported: sym.isExported,
+                embedding: [],
+                fileEmbedding: [],
+                mtime,
+            },
+        });
+        edges.push({ from: fileNodeId, to: symbolId, attrs: { kind: 'contains' } });
+        // Child symbols (e.g. methods)
+        if (sym.children) {
+            for (const child of sym.children) {
+                if (!child.name)
+                    continue;
+                const childId = makeId(fileId, sym.name, child.name);
+                nodes.push({
+                    id: childId,
+                    attrs: {
+                        kind: child.kind,
+                        fileId,
+                        name: child.name,
+                        signature: child.signature,
+                        docComment: child.docComment,
+                        body: child.body,
+                        startLine: child.startLine,
+                        endLine: child.endLine,
+                        isExported: child.isExported,
+                        embedding: [],
+                        fileEmbedding: [],
+                        mtime,
+                    },
+                });
+                edges.push({ from: symbolId, to: childId, attrs: { kind: 'contains' } });
+            }
+        }
+    }
+    // --- Extends / implements edges ---
+    for (const edge of edgeInfos) {
+        const fromId = makeId(fileId, edge.fromName);
+        const toId = makeId(fileId, edge.toName);
+        edges.push({ from: fromId, to: toId, attrs: { kind: edge.kind } });
+    }
+    // --- Import edges: file → imported file ---
+    for (const imp of imports) {
+        const targetAbsolute = resolveRelativeImport(absolutePath, imp.specifier);
+        if (!targetAbsolute)
+            continue;
+        const targetRel = path_1.default.relative(codeDir, targetAbsolute);
+        if (targetRel.startsWith('..') || path_1.default.isAbsolute(targetRel))
+            continue;
+        const targetFileId = path_1.default.relative(codeDir, targetAbsolute);
+        if (targetFileId !== fileNodeId) {
+            edges.push({
+                from: fileNodeId,
+                to: targetFileId,
+                attrs: { kind: 'imports' },
+            });
+        }
+    }
+    return { fileId, mtime, nodes, edges };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeId(fileId, ...parts) {
+    return [fileId, ...parts].join('::');
+}
+function makeFileAttrs(fileId, docComment, importSummary, lastLine, mtime) {
+    return {
+        kind: 'file',
+        fileId,
+        name: path_1.default.basename(fileId),
+        signature: fileId,
+        docComment,
+        body: importSummary,
+        startLine: 1,
+        endLine: lastLine,
+        isExported: false,
+        embedding: [],
+        fileEmbedding: [],
+        mtime,
+    };
+}
+/**
+ * Extract the file-level doc comment (first JSDoc comment before any declaration).
+ */
+function extractFileDocComment(rootNode) {
+    for (const child of rootNode.children) {
+        if (child.type === 'comment' && child.text.startsWith('/**')) {
+            return child.text.trim();
+        }
+        // Stop at first non-comment node
+        if (child.type !== 'comment')
+            break;
+    }
+    return '';
+}
+/**
+ * Build a summary of import statements.
+ */
+function buildImportSummary(rootNode) {
+    const imports = [];
+    for (const child of rootNode.children) {
+        if (child.type === 'import_statement') {
+            imports.push(child.text.trim());
+        }
+    }
+    return imports.join('\n');
+}

package/dist/lib/parsers/codeblock.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSymbols = extractSymbols;
+const languages_1 = require("../../lib/parsers/languages");
+/** Map of common code fence language tags to language names used by the registry. */
+const TAG_TO_LANGUAGE = {
+    ts: 'typescript',
+    typescript: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    javascript: 'javascript',
+    jsx: 'javascript',
+};
+/**
+ * Extract top-level symbol names from a code block using tree-sitter.
+ * Returns [] for unsupported languages or on parse failure.
+ */
+async function extractSymbols(code, language) {
+    const lang = TAG_TO_LANGUAGE[language.toLowerCase()];
+    if (!lang || !(0, languages_1.isLanguageSupported)(lang))
+        return [];
+    try {
+        const rootNode = await (0, languages_1.parseSource)(code, lang);
+        if (!rootNode)
+            return [];
+        const mapper = (0, languages_1.getMapper)(lang);
+        const symbols = mapper.extractSymbols(rootNode);
+        return symbols.map(s => s.name).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}