@prih/mcp-graph-memory 1.0.3

package/dist/lib/multi-config.js

@@ -0,0 +1,254 @@
+"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(),
+});
+const embeddingConfigSchema = zod_1.z.object({
+    model: 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(),
+    batchSize: zod_1.z.number().int().positive().optional(),
+});
+const graphEmbeddingOverridesSchema = zod_1.z.object({
+    docs: embeddingConfigSchema.partial().optional(),
+    code: embeddingConfigSchema.partial().optional(),
+    knowledge: embeddingConfigSchema.partial().optional(),
+    tasks: embeddingConfigSchema.partial().optional(),
+    files: embeddingConfigSchema.partial().optional(),
+    skills: embeddingConfigSchema.partial().optional(),
+});
+const projectSchema = zod_1.z.object({
+    projectDir: zod_1.z.string(),
+    graphMemory: zod_1.z.string().optional(),
+    docsPattern: zod_1.z.string().optional(),
+    codePattern: zod_1.z.string().optional(),
+    excludePattern: zod_1.z.string().optional(),
+    tsconfig: zod_1.z.string().optional(),
+    chunkDepth: zod_1.z.number().int().positive().optional(),
+    maxTokensDefault: zod_1.z.number().int().positive().optional(),
+    embedMaxChars: zod_1.z.number().int().positive().optional(),
+    embedding: embeddingConfigSchema.optional(),
+    graphs: graphEmbeddingOverridesSchema.optional(),
+    author: authorSchema.optional(),
+});
+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(),
+    embedding: embeddingConfigSchema.optional(),
+});
+const wsGraphOverridesSchema = zod_1.z.object({
+    knowledge: embeddingConfigSchema.partial().optional(),
+    tasks: embeddingConfigSchema.partial().optional(),
+    skills: embeddingConfigSchema.partial().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(),
+    embedding: embeddingConfigSchema.optional(),
+    graphs: wsGraphOverridesSchema.optional(),
+    author: authorSchema.optional(),
+});
+const configFileSchema = zod_1.z.object({
+    author: authorSchema.optional(),
+    server: serverSchema.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 embedding config fields that affect stored vectors.
+ * Used to detect config changes that require re-indexing.
+ *
+ * queryPrefix is intentionally excluded: it only affects query-time embeddings,
+ * not the stored document vectors — so changing it does not require re-indexing.
+ */
+function embeddingFingerprint(config) {
+    return `${config.model}|${config.pooling}|${config.normalize}|${config.dtype ?? ''}|${config.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 EMBEDDING_DEFAULTS = {
+    model: 'Xenova/bge-m3',
+    pooling: 'cls',
+    normalize: true,
+    queryPrefix: '',
+    documentPrefix: '',
+    batchSize: 1,
+};
+const SERVER_DEFAULTS = {
+    host: '127.0.0.1',
+    port: 3000,
+    sessionTimeout: 1800,
+    modelsDir: path_1.default.join(HOME, '.graph-memory/models'),
+    embedding: EMBEDDING_DEFAULTS,
+};
+const PROJECT_DEFAULTS = {
+    docsPattern: '**/*.md',
+    codePattern: '**/*.{js,ts,jsx,tsx}',
+    excludePattern: 'node_modules/**',
+    chunkDepth: 4,
+    maxTokensDefault: 4000,
+    embedMaxChars: 2000,
+};
+// ---------------------------------------------------------------------------
+// Resolution
+// ---------------------------------------------------------------------------
+/**
+ * Merge embedding configs with inheritance:
+ *   override fields → base fields → defaults.
+ */
+function mergeEmbeddingConfig(base, override) {
+    if (!override)
+        return base;
+    return {
+        model: override.model ?? base.model,
+        pooling: override.pooling ?? base.pooling,
+        normalize: override.normalize ?? base.normalize,
+        dtype: override.dtype ?? base.dtype,
+        queryPrefix: override.queryPrefix ?? base.queryPrefix,
+        documentPrefix: override.documentPrefix ?? base.documentPrefix,
+        batchSize: override.batchSize ?? base.batchSize,
+    };
+}
+/**
+ * Resolve a full EmbeddingConfig from the Zod-parsed raw embedding object,
+ * falling back to defaults for missing fields.
+ */
+function resolveEmbeddingConfig(raw, fallback) {
+    if (!raw)
+        return fallback;
+    return {
+        model: raw.model,
+        pooling: raw.pooling ?? fallback.pooling,
+        normalize: raw.normalize ?? fallback.normalize,
+        dtype: raw.dtype ?? fallback.dtype,
+        queryPrefix: raw.queryPrefix ?? fallback.queryPrefix,
+        documentPrefix: raw.documentPrefix ?? fallback.documentPrefix,
+        batchSize: raw.batchSize ?? fallback.batchSize,
+    };
+}
+// ---------------------------------------------------------------------------
+// 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;
+    const globalEmbedding = resolveEmbeddingConfig(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),
+        embedding: globalEmbedding,
+    };
+    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');
+        // Project-level embedding (inherits from server)
+        const projectEmbedding = resolveEmbeddingConfig(raw.embedding, globalEmbedding);
+        // Per-graph embeddings (inherit from project)
+        const graphOverrides = raw.graphs ?? {};
+        const graphEmbeddings = {};
+        for (const gn of exports.GRAPH_NAMES) {
+            graphEmbeddings[gn] = mergeEmbeddingConfig(projectEmbedding, graphOverrides[gn]);
+        }
+        projects.set(id, {
+            projectDir,
+            graphMemory,
+            docsPattern: raw.docsPattern ?? PROJECT_DEFAULTS.docsPattern,
+            codePattern: raw.codePattern ?? PROJECT_DEFAULTS.codePattern,
+            excludePattern: raw.excludePattern ?? PROJECT_DEFAULTS.excludePattern,
+            tsconfig: raw.tsconfig,
+            chunkDepth: raw.chunkDepth ?? PROJECT_DEFAULTS.chunkDepth,
+            maxTokensDefault: raw.maxTokensDefault ?? PROJECT_DEFAULTS.maxTokensDefault,
+            embedMaxChars: raw.embedMaxChars ?? PROJECT_DEFAULTS.embedMaxChars,
+            embedding: projectEmbedding,
+            graphEmbeddings,
+            author: raw.author ?? globalAuthor,
+        });
+    }
+    // --- Workspaces ---
+    const workspaces = new Map();
+    if (validated.workspaces) {
+        for (const [wsId, raw] of Object.entries(validated.workspaces)) {
+            // Validate that all referenced projects exist
+            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;
+            // Workspace-level embedding (inherits from server)
+            const wsEmbedding = resolveEmbeddingConfig(raw.embedding, globalEmbedding);
+            // Per-graph embeddings for workspace's shared graphs (knowledge, tasks, skills)
+            const graphOverrides = raw.graphs ?? {};
+            const graphEmbeddings = {
+                knowledge: mergeEmbeddingConfig(wsEmbedding, graphOverrides.knowledge),
+                tasks: mergeEmbeddingConfig(wsEmbedding, graphOverrides.tasks),
+                skills: mergeEmbeddingConfig(wsEmbedding, graphOverrides.skills),
+            };
+            workspaces.set(wsId, {
+                projects: raw.projects,
+                graphMemory,
+                mirrorDir,
+                embedding: wsEmbedding,
+                graphEmbeddings,
+                author: raw.author ?? globalAuthor,
+            });
+        }
+    }
+    return { author: globalAuthor, server, projects, workspaces };
+}

package/dist/lib/parsers/code.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProject = getProject;
+exports.resetProject = resetProject;
+exports.parseCodeFile = parseCodeFile;
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+// Keyed cache: one ts-morph Project per codeDir — avoids re-parsing tsconfig
+const _projects = new Map();
+function getProject(codeDir, tsconfig) {
+    const existing = _projects.get(codeDir);
+    if (existing)
+        return existing;
+    const tsconfigPath = tsconfig ?? path_1.default.join(codeDir, 'tsconfig.json');
+    let project;
+    try {
+        project = new ts_morph_1.Project({
+            tsConfigFilePath: tsconfigPath,
+            skipAddingFilesFromTsConfig: true, // we add files manually
+            skipFileDependencyResolution: false,
+        });
+    }
+    catch {
+        // No tsconfig — use minimal compiler options
+        project = new ts_morph_1.Project({
+            compilerOptions: { allowJs: true, strict: false },
+            skipFileDependencyResolution: true,
+        });
+    }
+    _projects.set(codeDir, project);
+    return project;
+}
+/** Reset cached project for a specific codeDir, or all if omitted. */
+function resetProject(codeDir) {
+    if (codeDir) {
+        _projects.delete(codeDir);
+    }
+    else {
+        _projects.clear();
+    }
+}
+function parseCodeFile(absolutePath, codeDir, mtime, project) {
+    const fileId = path_1.default.relative(codeDir, absolutePath);
+    // Add or refresh the source file in the project
+    let sourceFile = project.getSourceFile(absolutePath);
+    if (sourceFile) {
+        sourceFile.refreshFromFileSystemSync();
+    }
+    else {
+        sourceFile = project.addSourceFileAtPath(absolutePath);
+    }
+    const nodes = [];
+    const edges = [];
+    const fileNodeId = fileId;
+    // --- File root node ---
+    const fileDocComment = extractFileDocComment(sourceFile);
+    const importSummary = buildImportSummary(sourceFile);
+    nodes.push({
+        id: fileNodeId,
+        attrs: {
+            kind: 'file',
+            fileId,
+            name: path_1.default.basename(fileId),
+            signature: fileId,
+            docComment: fileDocComment,
+            body: importSummary,
+            startLine: 1,
+            endLine: sourceFile.getEndLineNumber(),
+            isExported: false,
+            embedding: [],
+            fileEmbedding: [],
+            mtime,
+        },
+    });
+    // --- Top-level declarations ---
+    for (const decl of sourceFile.getStatements()) {
+        processStatement(decl, fileId, fileNodeId, mtime, nodes, edges);
+    }
+    // --- Import edges: file → imported file ---
+    for (const imp of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = imp.getModuleSpecifierValue();
+        if (!isRelative(moduleSpecifier))
+            continue;
+        const resolved = imp.getModuleSpecifierSourceFile();
+        if (!resolved)
+            continue;
+        const targetAbsolute = resolved.getFilePath();
+        if (!targetAbsolute.startsWith(codeDir))
+            continue;
+        const targetFileId = path_1.default.relative(codeDir, targetAbsolute);
+        const targetNodeId = targetFileId;
+        if (targetNodeId !== fileNodeId) {
+            edges.push({
+                from: fileNodeId,
+                to: targetNodeId,
+                attrs: { kind: 'imports' },
+            });
+        }
+    }
+    return { fileId, mtime, nodes, edges };
+}
+// ---------------------------------------------------------------------------
+// Statement processing
+// ---------------------------------------------------------------------------
+function processStatement(node, fileId, parentId, mtime, nodes, edges) {
+    // Function declarations
+    if (ts_morph_1.Node.isFunctionDeclaration(node)) {
+        const name = node.getName();
+        if (!name)
+            return;
+        const id = makeId(fileId, name);
+        nodes.push({ id, attrs: buildAttrs('function', fileId, name, node, mtime) });
+        edges.push({ from: parentId, to: id, attrs: { kind: 'contains' } });
+        return;
+    }
+    // Class declarations
+    if (ts_morph_1.Node.isClassDeclaration(node)) {
+        const name = node.getName();
+        if (!name)
+            return;
+        const id = makeId(fileId, name);
+        nodes.push({ id, attrs: buildAttrs('class', fileId, name, node, mtime) });
+        edges.push({ from: parentId, to: id, attrs: { kind: 'contains' } });
+        // extends
+        const base = node.getBaseClass();
+        if (base) {
+            const baseName = base.getName?.() ?? base.getSymbol()?.getName();
+            if (baseName) {
+                edges.push({ from: id, to: makeId(fileId, baseName), attrs: { kind: 'extends' } });
+            }
+        }
+        // implements
+        for (const impl of node.getImplements()) {
+            const implName = impl.getExpression().getText();
+            edges.push({ from: id, to: makeId(fileId, implName), attrs: { kind: 'implements' } });
+        }
+        // Methods
+        for (const method of node.getMethods()) {
+            const methodName = method.getName();
+            const methodId = makeId(fileId, name, methodName);
+            nodes.push({ id: methodId, attrs: buildAttrs('method', fileId, methodName, method, mtime) });
+            edges.push({ from: id, to: methodId, attrs: { kind: 'contains' } });
+        }
+        return;
+    }
+    // Interface declarations
+    if (ts_morph_1.Node.isInterfaceDeclaration(node)) {
+        const name = node.getName();
+        const id = makeId(fileId, name);
+        nodes.push({ id, attrs: buildAttrs('interface', fileId, name, node, mtime) });
+        edges.push({ from: parentId, to: id, attrs: { kind: 'contains' } });
+        return;
+    }
+    // Type alias declarations
+    if (ts_morph_1.Node.isTypeAliasDeclaration(node)) {
+        const name = node.getName();
+        const id = makeId(fileId, name);
+        nodes.push({ id, attrs: buildAttrs('type', fileId, name, node, mtime) });
+        edges.push({ from: parentId, to: id, attrs: { kind: 'contains' } });
+        return;
+    }
+    // Enum declarations
+    if (ts_morph_1.Node.isEnumDeclaration(node)) {
+        const name = node.getName();
+        const id = makeId(fileId, name);
+        nodes.push({ id, attrs: buildAttrs('enum', fileId, name, node, mtime) });
+        edges.push({ from: parentId, to: id, attrs: { kind: 'contains' } });
+        return;
+    }
+    // Variable statements: export const foo = ..., export const bar = () => ...
+    if (ts_morph_1.Node.isVariableStatement(node)) {
+        for (const decl of node.getDeclarations()) {
+            const name = decl.getName();
+            if (typeof name !== 'string')
+                continue;
+            const initializer = decl.getInitializer();
+            const isArrow = initializer?.getKind() === ts_morph_1.SyntaxKind.ArrowFunction ||
+                initializer?.getKind() === ts_morph_1.SyntaxKind.FunctionExpression;
+            const kind = isArrow ? 'function' : 'variable';
+            const id = makeId(fileId, name);
+            nodes.push({ id, attrs: buildAttrs(kind, fileId, name, node, mtime) });
+            edges.push({ from: parentId, to: id, attrs: { kind: 'contains' } });
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeId(fileId, ...parts) {
+    return [fileId, ...parts].join('::');
+}
+function buildAttrs(kind, fileId, name, node, mtime) {
+    const start = node.getStartLineNumber();
+    const end = node.getEndLineNumber();
+    const fullText = node.getFullText().trim();
+    // Signature = first line (up to opening brace or end of line)
+    const firstLine = fullText.split('\n')[0].trim();
+    const signature = firstLine.length > 200 ? firstLine.slice(0, 200) + '…' : firstLine;
+    // JSDoc = leading comment of the node
+    const jsDocs = 'getJsDocs' in node
+        ? node.getJsDocs()
+        : [];
+    const docComment = jsDocs.map(d => d.getFullText().trim()).join('\n').trim();
+    // isExported
+    const isExported = 'isExported' in node
+        ? node.isExported()
+        : false;
+    return {
+        kind,
+        fileId,
+        name,
+        signature,
+        docComment,
+        body: fullText,
+        startLine: start,
+        endLine: end,
+        isExported,
+        embedding: [],
+        fileEmbedding: [],
+        mtime,
+    };
+}
+function extractFileDocComment(sourceFile) {
+    // First statement's leading trivia that looks like a file-level JSDoc
+    const firstStatement = sourceFile.getStatements()[0];
+    if (!firstStatement)
+        return '';
+    const leadingComments = firstStatement.getLeadingCommentRanges();
+    return leadingComments
+        .map(r => r.getText())
+        .filter(t => t.startsWith('/**') || t.startsWith('//'))
+        .join('\n')
+        .trim();
+}
+function buildImportSummary(sourceFile) {
+    const imports = sourceFile.getImportDeclarations();
+    if (imports.length === 0)
+        return '';
+    return imports.map(i => i.getText().trim()).join('\n');
+}
+function isRelative(moduleSpecifier) {
+    return moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../');
+}

package/dist/lib/parsers/codeblock.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSymbols = extractSymbols;
+const ts_morph_1 = require("ts-morph");
+const TS_LANGUAGES = new Set([
+    'ts', 'typescript',
+    'js', 'javascript',
+    'tsx', 'jsx',
+]);
+/**
+ * Extract top-level symbol names from a code block using ts-morph.
+ * Returns [] for non-TS/JS languages or on parse failure.
+ */
+function extractSymbols(code, language) {
+    if (!TS_LANGUAGES.has(language.toLowerCase()))
+        return [];
+    try {
+        const project = new ts_morph_1.Project({
+            useInMemoryFileSystem: true,
+            compilerOptions: { allowJs: true, strict: false },
+        });
+        const ext = language.toLowerCase().startsWith('ts') || language.toLowerCase() === 'tsx'
+            ? '.tsx'
+            : '.jsx';
+        const sourceFile = project.createSourceFile(`__snippet${ext}`, code);
+        const symbols = [];
+        for (const stmt of sourceFile.getStatements()) {
+            if (ts_morph_1.Node.isFunctionDeclaration(stmt)) {
+                const name = stmt.getName();
+                if (name)
+                    symbols.push(name);
+            }
+            else if (ts_morph_1.Node.isClassDeclaration(stmt)) {
+                const name = stmt.getName();
+                if (name)
+                    symbols.push(name);
+            }
+            else if (ts_morph_1.Node.isInterfaceDeclaration(stmt)) {
+                symbols.push(stmt.getName());
+            }
+            else if (ts_morph_1.Node.isTypeAliasDeclaration(stmt)) {
+                symbols.push(stmt.getName());
+            }
+            else if (ts_morph_1.Node.isEnumDeclaration(stmt)) {
+                symbols.push(stmt.getName());
+            }
+            else if (ts_morph_1.Node.isVariableStatement(stmt)) {
+                for (const decl of stmt.getDeclarations()) {
+                    const name = decl.getName();
+                    if (typeof name === 'string')
+                        symbols.push(name);
+                }
+            }
+            else if (ts_morph_1.Node.isExportAssignment(stmt)) {
+                // export default ... — skip, no named symbol
+            }
+            else if (ts_morph_1.Node.isExpressionStatement(stmt)) {
+                // e.g. `app.use(...)` — skip
+            }
+        }
+        return symbols;
+    }
+    catch {
+        return [];
+    }
+}