@vheins/local-memory-mcp 0.1.0

package/dist/tools/memory.store.js

@@ -0,0 +1,41 @@
+import { randomUUID } from "crypto";
+import { MemoryStoreSchema } from "./schemas.js";
+import { logger } from "../utils/logger.js";
+import { createMcpResponse } from "../utils/mcp-response.js";
+export async function handleMemoryStore(params, db, vectors) {
+    // Validate input
+    const validated = MemoryStoreSchema.parse(params);
+    // Create memory entry
+    const now = new Date().toISOString();
+    // Compute expires_at if ttlDays is provided
+    const expires_at = validated.ttlDays != null
+        ? new Date(Date.now() + validated.ttlDays * 86400000).toISOString()
+        : null;
+    const entry = {
+        id: randomUUID(),
+        type: validated.type,
+        content: validated.content,
+        importance: validated.importance,
+        scope: validated.scope,
+        created_at: now,
+        updated_at: now,
+        hit_count: 0,
+        recall_count: 0,
+        last_used_at: null,
+        expires_at,
+    };
+    // Store in SQLite
+    db.insert(entry);
+    // Automatically generate and store vector embedding
+    try {
+        await vectors.upsert(entry.id, entry.content);
+    }
+    catch (error) {
+        logger.warn("Failed to generate vector embedding", { error: String(error) });
+        // Continue anyway - vectors are optional for search fallback
+    }
+    // Log the write action
+    db.logAction('write', validated.scope.repo, { memoryId: entry.id, resultCount: 1 });
+    return createMcpResponse({ success: true, id: entry.id }, `Stored memory ${entry.id.slice(0, 8)}...`);
+}
+//# sourceMappingURL=memory.store.js.map

package/dist/tools/memory.store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.store.js","sourceRoot":"","sources":["../../src/tools/memory.store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGjD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAe,MAAM,0BAA0B,CAAC;AAE1E,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,MAAW,EACX,EAAe,EACf,OAAoB;IAEpB,iBAAiB;IACjB,MAAM,SAAS,GAAG,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAElD,sBAAsB;IACtB,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAErC,4CAA4C;IAC5C,MAAM,UAAU,GAAG,SAAS,CAAC,OAAO,IAAI,IAAI;QAC1C,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,OAAO,GAAG,QAAQ,CAAC,CAAC,WAAW,EAAE;QACnE,CAAC,CAAC,IAAI,CAAC;IAET,MAAM,KAAK,GAAgB;QACzB,EAAE,EAAE,UAAU,EAAE;QAChB,IAAI,EAAE,SAAS,CAAC,IAAI;QACpB,OAAO,EAAE,SAAS,CAAC,OAAO;QAC1B,UAAU,EAAE,SAAS,CAAC,UAAU;QAChC,KAAK,EAAE,SAAS,CAAC,KAAK;QACtB,UAAU,EAAE,GAAG;QACf,UAAU,EAAE,GAAG;QACf,SAAS,EAAE,CAAC;QACZ,YAAY,EAAE,CAAC;QACf,YAAY,EAAE,IAAI;QAClB,UAAU;KACX,CAAC;IAEF,kBAAkB;IAClB,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAEjB,oDAAoD;IACpD,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,IAAI,CAAC,qCAAqC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC7E,6DAA6D;IAC/D,CAAC;IAED,uBAAuB;IACvB,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;IAEpF,OAAO,iBAAiB,CACtB,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAC/B,iBAAiB,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAC3C,CAAC;AACJ,CAAC"}

package/dist/tools/memory.summarize.d.ts

@@ -0,0 +1,4 @@
+import { SQLiteStore } from "../storage/sqlite.js";
+import { McpResponse } from "../utils/mcp-response.js";
+export declare function handleMemorySummarize(params: any, db: SQLiteStore): Promise<McpResponse>;
+//# sourceMappingURL=memory.summarize.d.ts.map

package/dist/tools/memory.summarize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.summarize.d.ts","sourceRoot":"","sources":["../../src/tools/memory.summarize.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAqB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE1E,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,GAAG,EACX,EAAE,EAAE,WAAW,GACd,OAAO,CAAC,WAAW,CAAC,CAetB"}

package/dist/tools/memory.summarize.js

@@ -0,0 +1,13 @@
+import { MemorySummarizeSchema } from "./schemas.js";
+import { createMcpResponse } from "../utils/mcp-response.js";
+export async function handleMemorySummarize(params, db) {
+    // Validate input
+    const validated = MemorySummarizeSchema.parse(params);
+    // Create summary from signals
+    const summary = validated.signals.join("\n- ");
+    const fullSummary = `Project summary:\n- ${summary}`;
+    // Store summary
+    db.upsertSummary(validated.repo, fullSummary);
+    return createMcpResponse({ success: true }, `Updated summary for repo "${validated.repo}"`);
+}
+//# sourceMappingURL=memory.summarize.js.map

package/dist/tools/memory.summarize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.summarize.js","sourceRoot":"","sources":["../../src/tools/memory.summarize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAe,MAAM,0BAA0B,CAAC;AAE1E,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAW,EACX,EAAe;IAEf,iBAAiB;IACjB,MAAM,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAEtD,8BAA8B;IAC9B,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/C,MAAM,WAAW,GAAG,uBAAuB,OAAO,EAAE,CAAC;IAErD,gBAAgB;IAChB,EAAE,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAE9C,OAAO,iBAAiB,CACtB,EAAE,OAAO,EAAE,IAAI,EAAE,EACjB,6BAA6B,SAAS,CAAC,IAAI,GAAG,CAC/C,CAAC;AACJ,CAAC"}

package/dist/tools/memory.update.d.ts

@@ -0,0 +1,5 @@
+import { SQLiteStore } from "../storage/sqlite.js";
+import { VectorStore } from "../types.js";
+import { McpResponse } from "../utils/mcp-response.js";
+export declare function handleMemoryUpdate(params: any, db: SQLiteStore, vectors: VectorStore): Promise<McpResponse>;
+//# sourceMappingURL=memory.update.d.ts.map

package/dist/tools/memory.update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.update.d.ts","sourceRoot":"","sources":["../../src/tools/memory.update.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAqB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE1E,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,GAAG,EACX,EAAE,EAAE,WAAW,EACf,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,WAAW,CAAC,CAoCtB"}

package/dist/tools/memory.update.js

@@ -0,0 +1,31 @@
+import { MemoryUpdateSchema } from "./schemas.js";
+import { createMcpResponse } from "../utils/mcp-response.js";
+export async function handleMemoryUpdate(params, db, vectors) {
+    // Validate input
+    const validated = MemoryUpdateSchema.parse(params);
+    // Check if memory exists
+    const existing = db.getById(validated.id);
+    if (!existing) {
+        throw new Error(`Memory not found: ${validated.id}`);
+    }
+    // Update in SQLite
+    const updates = {};
+    if (validated.title !== undefined) {
+        updates.title = validated.title;
+    }
+    if (validated.content !== undefined) {
+        updates.content = validated.content;
+    }
+    if (validated.importance !== undefined) {
+        updates.importance = validated.importance;
+    }
+    db.update(validated.id, updates);
+    // Update vector if content changed
+    if (validated.content !== undefined) {
+        await vectors.upsert(validated.id, validated.content);
+    }
+    // Log the update action
+    db.logAction('update', existing.scope.repo, { memoryId: validated.id, resultCount: 1 });
+    return createMcpResponse({ success: true }, `Updated memory ${validated.id.slice(0, 8)}...`);
+}
+//# sourceMappingURL=memory.update.js.map

package/dist/tools/memory.update.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.update.js","sourceRoot":"","sources":["../../src/tools/memory.update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGlD,OAAO,EAAE,iBAAiB,EAAe,MAAM,0BAA0B,CAAC;AAE1E,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,MAAW,EACX,EAAe,EACf,OAAoB;IAEpB,iBAAiB;IACjB,MAAM,SAAS,GAAG,kBAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAEnD,yBAAyB;IACzB,MAAM,QAAQ,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IAC1C,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,qBAAqB,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC;IACvD,CAAC;IAED,mBAAmB;IACnB,MAAM,OAAO,GAA8D,EAAE,CAAC;IAC9E,IAAI,SAAS,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAClC,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,SAAS,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACpC,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;IACtC,CAAC;IACD,IAAI,SAAS,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACvC,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC;IAC5C,CAAC;IAED,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAEjC,mCAAmC;IACnC,IAAI,SAAS,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACpC,MAAM,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;IAED,wBAAwB;IACxB,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;IAExF,OAAO,iBAAiB,CACtB,EAAE,OAAO,EAAE,IAAI,EAAE,EACjB,kBAAkB,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAChD,CAAC;AACJ,CAAC"}

package/dist/tools/schemas.d.ts

@@ -0,0 +1,334 @@
+import { z } from "zod";
+export declare const MemoryScopeSchema: z.ZodObject<{
+    repo: z.ZodString;
+    branch: z.ZodOptional<z.ZodString>;
+    folder: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const MemoryTypeSchema: z.ZodEnum<{
+    code_fact: "code_fact";
+    decision: "decision";
+    mistake: "mistake";
+    pattern: "pattern";
+}>;
+export declare const MemoryStoreSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        code_fact: "code_fact";
+        decision: "decision";
+        mistake: "mistake";
+        pattern: "pattern";
+    }>;
+    title: z.ZodString;
+    content: z.ZodString;
+    importance: z.ZodNumber;
+    scope: z.ZodObject<{
+        repo: z.ZodString;
+        branch: z.ZodOptional<z.ZodString>;
+        folder: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    ttlDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const MemoryUpdateSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    importance: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const MemorySearchSchema: z.ZodObject<{
+    query: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+    repo: z.ZodString;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        code_fact: "code_fact";
+        decision: "decision";
+        mistake: "mistake";
+        pattern: "pattern";
+    }>>>;
+    minImportance: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    includeRecap: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const MemoryRecapSchema: z.ZodObject<{
+    repo: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const MemorySummarizeSchema: z.ZodObject<{
+    repo: z.ZodString;
+    signals: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const TOOL_DEFINITIONS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            title: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+                description: string;
+            };
+            content: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            importance: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            scope: {
+                type: string;
+                properties: {
+                    repo: {
+                        type: string;
+                        description: string;
+                    };
+                    branch: {
+                        type: string;
+                        description: string;
+                    };
+                    folder: {
+                        type: string;
+                        description: string;
+                    };
+                    language: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+            };
+            ttlDays: {
+                type: string;
+                minimum: number;
+                description: string;
+            };
+            id?: undefined;
+            query?: undefined;
+            prompt?: undefined;
+            repo?: undefined;
+            types?: undefined;
+            minImportance?: undefined;
+            limit?: undefined;
+            includeRecap?: undefined;
+            signals?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+                description: string;
+            };
+            content: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            importance: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            type?: undefined;
+            scope?: undefined;
+            ttlDays?: undefined;
+            query?: undefined;
+            prompt?: undefined;
+            repo?: undefined;
+            types?: undefined;
+            minImportance?: undefined;
+            limit?: undefined;
+            includeRecap?: undefined;
+            signals?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            prompt: {
+                type: string;
+                description: string;
+            };
+            repo: {
+                type: string;
+                description: string;
+            };
+            types: {
+                type: string;
+                items: {
+                    type: string;
+                    enum: string[];
+                };
+                description: string;
+            };
+            minImportance: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            limit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+                description: string;
+            };
+            includeRecap: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+            type?: undefined;
+            title?: undefined;
+            content?: undefined;
+            importance?: undefined;
+            scope?: undefined;
+            ttlDays?: undefined;
+            id?: undefined;
+            signals?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            repo: {
+                type: string;
+                description: string;
+            };
+            signals: {
+                type: string;
+                items: {
+                    type: string;
+                    maxLength: number;
+                };
+                minItems: number;
+                description: string;
+            };
+            type?: undefined;
+            title?: undefined;
+            content?: undefined;
+            importance?: undefined;
+            scope?: undefined;
+            ttlDays?: undefined;
+            id?: undefined;
+            query?: undefined;
+            prompt?: undefined;
+            types?: undefined;
+            minImportance?: undefined;
+            limit?: undefined;
+            includeRecap?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            type?: undefined;
+            title?: undefined;
+            content?: undefined;
+            importance?: undefined;
+            scope?: undefined;
+            ttlDays?: undefined;
+            query?: undefined;
+            prompt?: undefined;
+            repo?: undefined;
+            types?: undefined;
+            minImportance?: undefined;
+            limit?: undefined;
+            includeRecap?: undefined;
+            signals?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            repo: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+                description: string;
+            };
+            offset: {
+                type: string;
+                minimum: number;
+                default: number;
+                description: string;
+            };
+            type?: undefined;
+            title?: undefined;
+            content?: undefined;
+            importance?: undefined;
+            scope?: undefined;
+            ttlDays?: undefined;
+            id?: undefined;
+            query?: undefined;
+            prompt?: undefined;
+            types?: undefined;
+            minImportance?: undefined;
+            includeRecap?: undefined;
+            signals?: undefined;
+        };
+        required: string[];
+    };
+})[];
+//# sourceMappingURL=schemas.d.ts.map

package/dist/tools/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;EAA0D,CAAC;AAGxF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;iBAO5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;iBAQ9B,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;iBAQ7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;iBAGhC,CAAC;AAGH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8M5B,CAAC"}