@vheins/local-memory-mcp 0.8.48 → 0.9.0

package/dist/{chunk-QCCKQZ5G.js → chunk-XSGHXB35.js}

@@ -3,8 +3,8 @@ import { fileURLToPath } from "url";
 import path from "path";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var pkgVersion = "0.1.0";
-if ("0.8.48") {
-  pkgVersion = "0.8.48";
+if ("0.9.0") {
+  pkgVersion = "0.9.0";
 } else {
   let searchDir = __dirname;
   for (let i = 0; i < 5; i++) {
@@ -309,6 +309,7 @@ var MigrationManager = class {
         id TEXT PRIMARY KEY,
         title TEXT NOT NULL,
         content TEXT NOT NULL,
+        parent_id TEXT,
         context TEXT,
         version TEXT,
         language TEXT,
@@ -319,13 +320,25 @@ var MigrationManager = class {
         metadata TEXT,
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
+        hit_count INTEGER NOT NULL DEFAULT 0,
+        last_used_at TEXT,
         agent TEXT NOT NULL DEFAULT 'unknown',
-        model TEXT NOT NULL DEFAULT 'unknown'
+        model TEXT NOT NULL DEFAULT 'unknown',
+        FOREIGN KEY (parent_id) REFERENCES coding_standards(id) ON DELETE SET NULL
       );
 
       CREATE INDEX IF NOT EXISTS idx_coding_standards_repo ON coding_standards(repo);
       CREATE INDEX IF NOT EXISTS idx_coding_standards_is_global ON coding_standards(is_global);
       CREATE INDEX IF NOT EXISTS idx_coding_standards_language ON coding_standards(language);
+      CREATE INDEX IF NOT EXISTS idx_coding_standards_hit_count ON coding_standards(hit_count);
+
+      CREATE TABLE IF NOT EXISTS standard_vectors (
+        standard_id TEXT PRIMARY KEY,
+        vector TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        vector_version INTEGER NOT NULL DEFAULT 1,
+        FOREIGN KEY (standard_id) REFERENCES coding_standards(id) ON DELETE CASCADE
+      );
 
       CREATE TABLE IF NOT EXISTS memories_archive (
         id TEXT PRIMARY KEY,
@@ -434,6 +447,21 @@ var MigrationManager = class {
         table: "memory_vectors",
         definition: "ALTER TABLE memory_vectors ADD COLUMN vector_version INTEGER NOT NULL DEFAULT 1"
       },
+      {
+        name: "parent_id",
+        table: "coding_standards",
+        definition: "ALTER TABLE coding_standards ADD COLUMN parent_id TEXT"
+      },
+      {
+        name: "hit_count",
+        table: "coding_standards",
+        definition: "ALTER TABLE coding_standards ADD COLUMN hit_count INTEGER NOT NULL DEFAULT 0"
+      },
+      {
+        name: "last_used_at",
+        table: "coding_standards",
+        definition: "ALTER TABLE coding_standards ADD COLUMN last_used_at TEXT"
+      },
       { name: "depends_on", table: "tasks", definition: "ALTER TABLE tasks ADD COLUMN depends_on TEXT" },
       {
         name: "est_tokens",
@@ -2087,13 +2115,14 @@ var StandardEntity = class extends BaseEntity {
   insert(entry) {
     this.run(
       `INSERT INTO coding_standards (
-				id, title, content, context, version, language, stack,
-				is_global, repo, tags, metadata, created_at, updated_at, agent, model
-			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+				id, title, content, parent_id, context, version, language, stack,
+				is_global, repo, tags, metadata, created_at, updated_at, hit_count, last_used_at, agent, model
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         entry.id,
         entry.title,
         entry.content,
+        entry.parent_id,
         entry.context,
         entry.version,
         entry.language ?? null,
@@ -2104,6 +2133,8 @@ var StandardEntity = class extends BaseEntity {
         Object.keys(entry.metadata).length > 0 ? JSON.stringify(entry.metadata) : null,
         entry.created_at,
         entry.updated_at,
+        entry.hit_count,
+        entry.last_used_at,
         entry.agent,
         entry.model
       ]
@@ -2114,7 +2145,7 @@ var StandardEntity = class extends BaseEntity {
     return row ? this.rowToEntry(row) : null;
   }
   search(options) {
-    const { query, context, language, stack, repo, is_global, limit = 20, offset = 0 } = options;
+    const { query, context, version, language, stack, tag, repo, is_global, limit = 20, offset = 0 } = options;
     const where = [];
     const params = [];
     if (query) {
@@ -2125,6 +2156,10 @@ var StandardEntity = class extends BaseEntity {
       where.push("context = ?");
       params.push(context);
     }
+    if (version) {
+      where.push("version = ?");
+      params.push(version);
+    }
     if (language) {
       where.push("language = ?");
       params.push(language);
@@ -2133,6 +2168,10 @@ var StandardEntity = class extends BaseEntity {
       where.push("stack LIKE ?");
       params.push(`%${stack}%`);
     }
+    if (tag) {
+      where.push("tags LIKE ?");
+      params.push(`%${tag}%`);
+    }
     if (repo !== void 0) {
       where.push("(repo = ? OR is_global = 1)");
       params.push(repo);
@@ -2147,6 +2186,43 @@ var StandardEntity = class extends BaseEntity {
     const rows = this.all(sql, params);
     return rows.map((r) => this.rowToEntry(r));
   }
+  searchBySimilarity(query, options) {
+    const candidates = this.search({
+      context: options.context,
+      version: options.version,
+      language: options.language,
+      stack: options.stack?.[0],
+      tag: options.tags?.[0],
+      repo: options.repo,
+      is_global: options.is_global,
+      limit: options.limit ?? 60,
+      offset: options.offset ?? 0
+    });
+    const queryVector = this.computeVector(query);
+    return candidates.map((standard) => {
+      const haystack = [
+        standard.title,
+        standard.content,
+        standard.context,
+        standard.language ?? "",
+        standard.version,
+        ...standard.stack,
+        ...standard.tags,
+        JSON.stringify(standard.metadata)
+      ].filter(Boolean).join(" ");
+      const similarity = this.cosineSimilarity(queryVector, this.computeVector(haystack));
+      return { ...standard, similarity };
+    }).sort((a, b) => b.similarity - a.similarity);
+  }
+  getByIds(ids) {
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this.all(
+      `SELECT * FROM coding_standards WHERE id IN (${placeholders})`,
+      ids
+    );
+    return rows.map((row) => this.rowToEntry(row));
+  }
   update(id, updates) {
     const fields = [];
     const values = [];
@@ -2178,11 +2254,45 @@ var StandardEntity = class extends BaseEntity {
   delete(id) {
     this.run("DELETE FROM coding_standards WHERE id = ?", [id]);
   }
+  incrementHitCounts(ids) {
+    if (ids.length === 0) return;
+    const placeholders = ids.map(() => "?").join(",");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.run(
+      `UPDATE coding_standards
+			 SET hit_count = hit_count + 1,
+			     last_used_at = ?
+			 WHERE id IN (${placeholders})`,
+      [now, ...ids]
+    );
+  }
+  getVectorCandidates(repo, limit = 100) {
+    let sql = `SELECT sv.standard_id, sv.vector
+			FROM standard_vectors sv
+			JOIN coding_standards cs ON cs.id = sv.standard_id`;
+    const params = [];
+    if (repo) {
+      sql += " WHERE (cs.repo = ? OR cs.is_global = 1)";
+      params.push(repo);
+    }
+    sql += " ORDER BY cs.updated_at DESC LIMIT ?";
+    params.push(limit);
+    return this.all(sql, params);
+  }
+  upsertVectorEmbedding(standardId, vector) {
+    this.run(
+      `INSERT INTO standard_vectors (standard_id, vector, updated_at)
+			VALUES (?, ?, ?)
+			ON CONFLICT(standard_id) DO UPDATE SET vector = excluded.vector, updated_at = excluded.updated_at`,
+      [standardId, JSON.stringify(vector), (/* @__PURE__ */ new Date()).toISOString()]
+    );
+  }
   rowToEntry(row) {
     return {
       id: row.id,
       title: row.title,
       content: row.content,
+      parent_id: row.parent_id ?? null,
       context: row.context,
       version: row.version,
       language: row.language ?? null,
@@ -2193,6 +2303,8 @@ var StandardEntity = class extends BaseEntity {
       metadata: this.safeJSONParse(row.metadata, {}),
       created_at: row.created_at,
       updated_at: row.updated_at,
+      hit_count: row.hit_count ?? 0,
+      last_used_at: row.last_used_at ?? null,
       agent: row.agent,
       model: row.model
     };
@@ -2577,6 +2689,82 @@ var SQLiteStore = class _SQLiteStore {
   }
 };
 
+// src/mcp/storage/vectors.ts
+import { pipeline, env } from "@xenova/transformers";
+if (process.env.MCP_SERVER === "true") {
+  env.backends.onnx.logLevel = "error";
+}
+var RealVectorStore = class {
+  db;
+  extractor = null;
+  modelName = "Xenova/all-MiniLM-L6-v2";
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Triggers background loading of the vector model.
+   * Useful for avoiding timeouts on the first search/upsert request.
+   */
+  async initialize() {
+    await this.getExtractor();
+  }
+  async getExtractor() {
+    if (!this.extractor) {
+      this.extractor = await pipeline("feature-extraction", this.modelName);
+    }
+    return this.extractor;
+  }
+  cosineSimilarity(v1, v2) {
+    let dotProduct = 0;
+    let mag1 = 0;
+    let mag2 = 0;
+    for (let i = 0; i < v1.length; i++) {
+      dotProduct += v1[i] * v2[i];
+      mag1 += v1[i] * v1[i];
+      mag2 += v2[i] * v2[i];
+    }
+    const mag = Math.sqrt(mag1) * Math.sqrt(mag2);
+    return mag === 0 ? 0 : dotProduct / mag;
+  }
+  async upsert(id, text, kind = "memory") {
+    try {
+      const extractor = await this.getExtractor();
+      const output = await extractor(text, { pooling: "mean", normalize: true });
+      const vector = Array.from(output.data);
+      if (kind === "standard") {
+        this.db.standards.upsertVectorEmbedding(id, vector);
+      } else {
+        this.db.memories.upsertVectorEmbedding(id, vector);
+      }
+    } catch (error) {
+      logger.error("[Vectors] Error during upsert", { id, kind, error: String(error) });
+      throw error;
+    }
+  }
+  async remove(id, _kind = "memory") {
+    if (!id) return;
+  }
+  async search(query, limit, repo, kind = "memory") {
+    try {
+      const extractor = await this.getExtractor();
+      const output = await extractor(query, { pooling: "mean", normalize: true });
+      const queryVector = Array.from(output.data);
+      const rows = kind === "standard" ? this.db.standards.getVectorCandidates(repo, 100).map((row) => ({ id: row.standard_id, vector: row.vector })) : this.db.memories.getVectorCandidates(repo, 100).map((row) => ({ id: row.memory_id, vector: row.vector }));
+      const results = rows.map((row) => {
+        const memoryVector = JSON.parse(row.vector);
+        return {
+          id: row.id,
+          score: this.cosineSimilarity(queryVector, memoryVector)
+        };
+      });
+      return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    } catch (error) {
+      logger.error("[Vectors] Error during search", { kind, error: String(error) });
+      return [];
+    }
+  }
+};
+
 // src/mcp/session.ts
 import path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -2889,6 +3077,18 @@ var MemoryDetailSchema = z.object({
 }).refine((data) => data.id !== void 0 || data.code !== void 0, {
   message: "Either id or code must be provided"
 });
+var StandardDetailSchema = z.object({
+  id: z.string().uuid(),
+  structured: z.boolean().default(false)
+});
+var StandardDeleteSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo).optional(),
+  id: z.string().uuid().optional(),
+  ids: z.array(z.string().uuid()).min(1).optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.id !== void 0 || data.ids !== void 0, {
+  message: "Either 'id' or 'ids' must be provided for deletion"
+});
 var TaskGetSchema = z.object({
   repo: z.string().min(1).transform(normalizeRepo),
   id: z.string().uuid().optional(),
@@ -2943,24 +3143,53 @@ var TaskClaimSchema = z.object({
 var StandardStoreSchema = z.object({
   name: z.string().min(3).max(255),
   content: z.string().min(10),
+  parent_id: z.string().uuid().optional(),
   context: z.string().optional(),
   version: z.string().optional(),
   language: z.string().optional(),
   stack: z.array(z.string()).optional(),
-  repo: z.string().optional(),
+  repo: z.string().transform(normalizeRepo).optional(),
   is_global: z.boolean().optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
+  tags: z.array(z.string().min(1)).min(1),
+  metadata: z.record(z.string(), z.any()).refine((value) => Object.keys(value).length > 0, {
+    message: "metadata must contain at least one key"
+  }),
   agent: z.string().optional(),
   model: z.string().optional(),
   structured: z.boolean().default(false)
+}).refine((data) => data.is_global !== false || !!data.repo, {
+  message: "repo is required for repo-specific standards"
+});
+var StandardUpdateSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(3).max(255).optional(),
+  content: z.string().min(10).optional(),
+  parent_id: z.string().uuid().nullable().optional(),
+  context: z.string().optional(),
+  version: z.string().optional(),
+  language: z.string().optional(),
+  stack: z.array(z.string().min(1)).min(1).optional(),
+  repo: z.string().transform(normalizeRepo).optional(),
+  is_global: z.boolean().optional(),
+  tags: z.array(z.string().min(1)).min(1).optional(),
+  metadata: z.record(z.string(), z.any()).refine((value) => Object.keys(value).length > 0, { message: "metadata must contain at least one key" }).optional(),
+  agent: z.string().optional(),
+  model: z.string().optional(),
+  structured: z.boolean().default(false)
+}).refine(
+  (data) => data.name !== void 0 || data.content !== void 0 || data.parent_id !== void 0 || data.context !== void 0 || data.version !== void 0 || data.language !== void 0 || data.stack !== void 0 || data.repo !== void 0 || data.is_global !== void 0 || data.tags !== void 0 || data.metadata !== void 0 || data.agent !== void 0 || data.model !== void 0,
+  { message: "At least one field must be provided for update" }
+).refine((data) => data.is_global !== false || !!data.repo, {
+  message: "repo is required for repo-specific standards"
 });
 var StandardSearchSchema = z.object({
   query: z.string().optional(),
   stack: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
   language: z.string().optional(),
+  context: z.string().optional(),
   version: z.string().optional(),
-  repo: z.string().optional(),
+  repo: z.string().transform(normalizeRepo).optional(),
   is_global: z.boolean().optional(),
   limit: z.number().min(1).max(100).default(20),
   offset: z.number().min(0).default(0),
@@ -3070,6 +3299,19 @@ var TOOL_DEFINITIONS = [
       }
     }
   },
+  {
+    name: "standard-detail",
+    title: "Standard Detail",
+    description: "Fetch full details of a specific coding standard by ID. Use after standard-search when a result is relevant and full guidance is needed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", format: "uuid", description: "Coding standard ID." },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
+      },
+      required: ["id"]
+    }
+  },
   {
     name: "task-detail",
     title: "Task Detail",
@@ -3423,6 +3665,42 @@ var TOOL_DEFINITIONS = [
       required: ["success"]
     }
   },
+  {
+    name: "standard-delete",
+    title: "Standard Delete",
+    description: "Delete one or more coding standards. Supports single 'id' or bulk 'ids'.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name (optional for single id)" },
+        id: { type: "string", format: "uuid", description: "Coding standard ID to delete" },
+        ids: {
+          type: "array",
+          items: { type: "string", format: "uuid" },
+          minItems: 1,
+          description: "Array of coding standard IDs to delete"
+        },
+        structured: { type: "boolean", default: false, description: "If true, returns structured JSON result." }
+      }
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        ids: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        deletedCount: { type: "number" }
+      },
+      required: ["success"]
+    }
+  },
   {
     name: "memory-recap",
     title: "Memory Recap",
@@ -3931,6 +4209,7 @@ var TOOL_DEFINITIONS = [
       properties: {
         name: { type: "string", minLength: 3, maxLength: 255, description: "Human-readable standard name" },
         content: { type: "string", minLength: 10, description: "One atomic, actionable standard written as concise Markdown" },
+        parent_id: { type: "string", format: "uuid", description: "Optional parent standard ID when this rule is a child/specialization." },
         context: { type: "string", description: "Context or category (e.g., 'error-handling', 'security')" },
         version: { type: "string", description: "Version of the standard (e.g., '1.0.0')" },
         language: { type: "string", description: "Programming language (e.g., 'typescript', 'python')" },
@@ -3954,7 +4233,7 @@ var TOOL_DEFINITIONS = [
         model: { type: "string", description: "AI model used" },
         structured: { type: "boolean", default: false }
       },
-      required: ["name", "content"]
+      required: ["name", "content", "tags", "metadata"]
     },
     outputSchema: {
       type: "object",
@@ -3966,6 +4245,7 @@ var TOOL_DEFINITIONS = [
             id: { type: "string" },
             title: { type: "string" },
             content: { type: "string" },
+            parent_id: { type: "string", nullable: true },
             context: { type: "string" },
             version: { type: "string" },
             language: { type: "string", nullable: true },
@@ -3983,6 +4263,7 @@ var TOOL_DEFINITIONS = [
             "id",
             "title",
             "content",
+            "parent_id",
             "context",
             "version",
             "stack",
@@ -4000,10 +4281,51 @@ var TOOL_DEFINITIONS = [
       required: ["success", "standard", "message"]
     }
   },
+  {
+    name: "standard-update",
+    title: "Standard Update",
+    description: "Update an existing coding standard. Use this when the rule changes, expands scope, or metadata/tags need correction.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Standard ID to update" },
+        name: { type: "string", minLength: 3, maxLength: 255 },
+        content: { type: "string", minLength: 10 },
+        parent_id: { type: "string", format: "uuid", nullable: true },
+        context: { type: "string" },
+        version: { type: "string" },
+        language: { type: "string" },
+        stack: { type: "array", items: { type: "string" } },
+        repo: { type: "string" },
+        is_global: { type: "boolean" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        agent: { type: "string" },
+        model: { type: "string" },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["id"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        id: { type: "string" },
+        updatedFields: { type: "array", items: { type: "string" } }
+      },
+      required: ["success", "id", "updatedFields"]
+    }
+  },
   {
     name: "standard-search",
     title: "Standard Search",
-    description: "Navigation and lookup layer for coding standards. Query by text, stack, language, version, repo, and global scope before applying or creating standards.",
+    description: "NAVIGATION LAYER: Returns a compact pointer table of matching coding standards. Use `standard-detail` to fetch full content for a selected result.",
     annotations: {
       readOnlyHint: true,
       idempotentHint: true,
@@ -4018,7 +4340,13 @@ var TOOL_DEFINITIONS = [
           items: { type: "string" },
           description: "Technology stack to filter by (e.g., ['react', 'nextjs'])"
         },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tag filter"
+        },
         language: { type: "string", description: "Programming language filter" },
+        context: { type: "string", description: "Context/category filter" },
         version: { type: "string", description: "Version filter" },
         repo: { type: "string", description: "Repository filter (optional)" },
         is_global: { type: "boolean", description: "Filter by global/repo-specific" },
@@ -4031,35 +4359,29 @@ var TOOL_DEFINITIONS = [
     outputSchema: {
       type: "object",
       properties: {
-        success: { type: "boolean" },
-        standards: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              id: { type: "string" },
-              title: { type: "string" },
-              content: { type: "string" },
-              context: { type: "string" },
-              version: { type: "string" },
-              language: { type: "string", nullable: true },
-              stack: { type: "array", items: { type: "string" } },
-              is_global: { type: "boolean" },
-              repo: { type: "string", nullable: true },
-              tags: { type: "array", items: { type: "string" } },
-              metadata: { type: "object" },
-              created_at: { type: "string" },
-              updated_at: { type: "string" },
-              agent: { type: "string" },
-              model: { type: "string" }
+        schema: { type: "string", enum: ["standard-search"] },
+        query: { type: "string" },
+        count: { type: "number", description: "Number of rows returned" },
+        total: { type: "number", description: "Total number of matches before pagination" },
+        offset: { type: "number" },
+        limit: { type: "number" },
+        results: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" }
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row includes standard id and pointer metadata. Fetch full content via standard-detail."
             }
           },
-          description: "Matching coding standards"
-        },
-        count: { type: "number", description: "Number of results returned" },
-        message: { type: "string" }
+          required: ["columns", "rows"]
+        }
       },
-      required: ["success", "standards", "count", "message"]
+      required: ["schema", "query", "count", "total", "offset", "limit", "results"]
     }
   }
 ];
@@ -4630,6 +4952,20 @@ async function completePromptArgument(name, argName, value, contextArguments, da
   return [];
 }
 
+// src/mcp/tools/standard.shared.ts
+function buildStandardVectorText(standard) {
+  return [
+    standard.title,
+    standard.content,
+    standard.context,
+    standard.version,
+    standard.language ?? "",
+    ...standard.stack,
+    ...standard.tags,
+    JSON.stringify(standard.metadata)
+  ].filter(Boolean).join("\n");
+}
+
 export {
   MCP_PROTOCOL_VERSION,
   CAPABILITIES,
@@ -4641,6 +4977,7 @@ export {
   createFileSink,
   normalizeRepo,
   SQLiteStore,
+  RealVectorStore,
   MemoryStoreSchema,
   MemoryUpdateSchema,
   MemorySearchSchema,
@@ -4655,12 +4992,15 @@ export {
   TaskListSchema,
   TaskDeleteSchema,
   MemoryDetailSchema,
+  StandardDetailSchema,
+  StandardDeleteSchema,
   TaskGetSchema,
   HandoffCreateSchema,
   HandoffUpdateSchema,
   HandoffListSchema,
   TaskClaimSchema,
   StandardStoreSchema,
+  StandardUpdateSchema,
   StandardSearchSchema,
   TOOL_DEFINITIONS,
   encodeCursor,
@@ -4680,5 +5020,6 @@ export {
   PROMPTS,
   listPrompts,
   getPrompt,
-  completePromptArgument
+  completePromptArgument,
+  buildStandardVectorText
 };