@cognistore/mcp-server 2.0.2 → 2.1.0

package/dist/index.js

@@ -94,7 +94,8 @@ var searchOptionsSchema = z.object({
   scope: scopeSchema.optional(),
   limit: z.number().int().min(1).max(100).optional().default(DEFAULT_SEARCH_LIMIT),
   threshold: z.number().min(0).max(1).optional().default(DEFAULT_SIMILARITY_THRESHOLD),
-  includePlanContext: z.boolean().optional().default(false)
+  includePlanContext: z.boolean().optional().default(false),
+  queryText: z.string().optional()
 });
 var createPlanSchema = z.object({
   title: z.string().min(1, "Title is required"),
@@ -140,6 +141,7 @@ __export(schema_exports, {
   createEmbeddingsTable: () => createEmbeddingsTable,
   deleteEmbedding: () => deleteEmbedding,
   deletePlanEmbedding: () => deletePlanEmbedding,
+  getEmbeddingById: () => getEmbeddingById,
   insertEmbedding: () => insertEmbedding,
   insertPlanEmbedding: () => insertPlanEmbedding,
   knowledgeEntries: () => knowledgeEntries,
@@ -195,6 +197,14 @@ function deleteEmbedding(sqlite, id) {
   const stmt = sqlite.prepare(`DELETE FROM ${VIRTUAL_TABLE_NAME} WHERE id = ?`);
   stmt.run(id);
 }
+function getEmbeddingById(sqlite, id) {
+  const row = sqlite.prepare(`SELECT embedding FROM ${VIRTUAL_TABLE_NAME} WHERE id = ?`).get(id);
+  if (!row || row.embedding == null)
+    return null;
+  const buf = row.embedding;
+  const f32 = new Float32Array(buf.buffer, buf.byteOffset, Math.floor(buf.byteLength / 4));
+  return Array.from(f32);
+}
 function searchKnn(sqlite, queryEmbedding, k) {
   const stmt = sqlite.prepare(`
     SELECT id, distance
@@ -224,6 +234,49 @@ function searchPlansKnn(sqlite, queryEmbedding, k) {
   return stmt.all(Buffer.from(new Float32Array(queryEmbedding).buffer), k);
 }
 
+// ../../packages/core/dist/db/schema/fts.js
+var FTS_TABLE_NAME = "knowledge_fts";
+function createKnowledgeFtsTable(sqlite) {
+  sqlite.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS ${FTS_TABLE_NAME} USING fts5(
+      id UNINDEXED,
+      title,
+      content,
+      tags
+    )
+  `);
+}
+function insertFts(sqlite, row) {
+  sqlite.prepare(`INSERT INTO ${FTS_TABLE_NAME}(id, title, content, tags) VALUES (?, ?, ?, ?)`).run(row.id, row.title ?? "", row.content ?? "", row.tags ?? "");
+}
+function updateFts(sqlite, row) {
+  deleteFts(sqlite, row.id);
+  insertFts(sqlite, row);
+}
+function deleteFts(sqlite, id) {
+  sqlite.prepare(`DELETE FROM ${FTS_TABLE_NAME} WHERE id = ?`).run(id);
+}
+function ftsCount(sqlite) {
+  const row = sqlite.prepare(`SELECT count(*) AS c FROM ${FTS_TABLE_NAME}`).get();
+  return row?.c ?? 0;
+}
+function sanitizeFtsQuery(query) {
+  return query.split(/\s+/).filter(Boolean).map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
+}
+function searchFts(sqlite, query, k) {
+  const match = sanitizeFtsQuery(query);
+  if (!match)
+    return [];
+  const stmt = sqlite.prepare(`
+    SELECT id, bm25(${FTS_TABLE_NAME}) AS bm25
+    FROM ${FTS_TABLE_NAME}
+    WHERE ${FTS_TABLE_NAME} MATCH ?
+    ORDER BY bm25
+    LIMIT ?
+  `);
+  return stmt.all(match, k);
+}
+
 // ../../packages/core/dist/db/migrate.js
 import { readdirSync, readFileSync, existsSync } from "fs";
 import { resolve } from "path";
@@ -357,6 +410,9 @@ CREATE TABLE IF NOT EXISTS scan_state (
 );
 
 ALTER TABLE plans ADD COLUMN plan_file_path TEXT;
+`,
+  "2.1.0": `
+CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_fts USING fts5(id UNINDEXED, title, content, tags);
 `
 };
 function runMigrations(sqlite, migrationsDir) {
@@ -459,9 +515,34 @@ function createDbClient(dbPath) {
   const dims = Number(process.env.EMBEDDING_DIMENSIONS) || DEFAULT_EMBEDDING_DIMENSIONS;
   createEmbeddingsTable(sqlite, dims);
   createPlansEmbeddingsTable(sqlite, dims);
+  try {
+    createKnowledgeFtsTable(sqlite);
+    backfillFtsIfEmpty(sqlite);
+    sqlite.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_created_at ON knowledge_entries(created_at)");
+    sqlite.exec("CREATE INDEX IF NOT EXISTS idx_plans_created_at ON plans(created_at)");
+  } catch {
+  }
   const db = drizzle(sqlite, { schema: schema_exports });
   return { db, sqlite };
 }
+function backfillFtsIfEmpty(sqlite) {
+  if (ftsCount(sqlite) > 0)
+    return;
+  const rows = sqlite.prepare("SELECT id, title, content, tags FROM knowledge_entries WHERE type != 'system'").all();
+  for (const r of rows) {
+    let tags = "";
+    try {
+      const parsed = JSON.parse(r.tags ?? "[]");
+      tags = Array.isArray(parsed) ? parsed.filter(Boolean).join(" ") : "";
+    } catch {
+      tags = "";
+    }
+    try {
+      insertFts(sqlite, { id: r.id, title: r.title ?? "", content: r.content ?? "", tags });
+    } catch {
+    }
+  }
+}
 function createPlansEmbeddingsTable(sqlite, dimensions = DEFAULT_EMBEDDING_DIMENSIONS) {
   try {
     sqlite.exec(`
@@ -503,6 +584,10 @@ var KnowledgeRepository = class {
       updatedAt: now
     }).returning();
     insertEmbedding(this.sqlite, id, input.embedding);
+    try {
+      insertFts(this.sqlite, { id, title: input.title, content: input.content, tags: ftsTags(input.tags) });
+    } catch {
+    }
     return entry;
   }
   async findById(id) {
@@ -522,6 +607,17 @@ var KnowledgeRepository = class {
       ...values,
       version: sql`${knowledgeEntries.version} + 1`
     }).where(eq(knowledgeEntries.id, id)).returning();
+    if (entry) {
+      try {
+        updateFts(this.sqlite, {
+          id,
+          title: entry.title ?? "",
+          content: entry.content ?? "",
+          tags: ftsTags(entry.tags)
+        });
+      } catch {
+      }
+    }
     if (embedding) {
       updateEmbedding(this.sqlite, id, embedding);
     }
@@ -531,6 +627,10 @@ var KnowledgeRepository = class {
     const [entry] = await this.db.delete(knowledgeEntries).where(eq(knowledgeEntries.id, id)).returning();
     if (entry) {
       deleteEmbedding(this.sqlite, id);
+      try {
+        deleteFts(this.sqlite, id);
+      } catch {
+      }
     }
     return entry ?? null;
   }
@@ -544,11 +644,20 @@ var KnowledgeRepository = class {
     const threshold = options?.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
     const candidateLimit = limit * 5;
     const knnResults = searchKnn(this.sqlite, queryEmbedding, candidateLimit);
-    if (knnResults.length === 0) {
+    const distanceMap = new Map(knnResults.map((r) => [r.id, r.distance]));
+    let ftsResults = [];
+    if (options?.queryText) {
+      try {
+        ftsResults = searchFts(this.sqlite, options.queryText, candidateLimit);
+      } catch {
+        ftsResults = [];
+      }
+    }
+    const bm25Map = new Map(ftsResults.map((r) => [r.id, r.bm25]));
+    if (knnResults.length === 0 && ftsResults.length === 0) {
       return [];
     }
-    const candidateIds = knnResults.map((r) => r.id);
-    const distanceMap = new Map(knnResults.map((r) => [r.id, r.distance]));
+    const candidateIds = [.../* @__PURE__ */ new Set([...knnResults.map((r) => r.id), ...ftsResults.map((r) => r.id)])];
     const conditions = [];
     conditions.push(sql`${knowledgeEntries.id} IN (${sql.join(candidateIds.map((id) => sql`${id}`), sql`, `)})`);
     if (options?.scope) {
@@ -565,18 +674,25 @@ var KnowledgeRepository = class {
     conditions.push(or(isNull(knowledgeEntries.expiresAt), sql`${knowledgeEntries.expiresAt} > ${(/* @__PURE__ */ new Date()).toISOString()}`));
     const whereClause = and(...conditions);
     const entries = await this.db.select().from(knowledgeEntries).where(whereClause);
-    return entries.map((entry) => ({
-      entry,
-      similarity: 1 - (distanceMap.get(entry.id) ?? 1)
-    })).filter((r) => r.similarity >= threshold).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
-  }
-  async listRecent(limit = 20, filters) {
+    return entries.map((entry) => {
+      const semantic = 1 - (distanceMap.get(entry.id) ?? 1);
+      const hasFts = bm25Map.has(entry.id);
+      const bm25Norm = hasFts ? 1 / (1 + Math.exp(bm25Map.get(entry.id))) : 0;
+      const combined = 0.7 * semantic + 0.3 * bm25Norm;
+      return { entry, similarity: combined, semantic, hasFts };
+    }).filter((r) => r.semantic >= threshold || r.hasFts).sort((a, b) => b.similarity - a.similarity).slice(0, limit).map(({ entry, similarity }) => ({ entry, similarity }));
+  }
+  async listRecent(limit = 20, filters, offset = 0) {
     const conditions = [ne(knowledgeEntries.type, "system")];
     if (filters?.type)
       conditions.push(sql`${knowledgeEntries.type} = ${filters.type}`);
     if (filters?.scope)
       conditions.push(sql`${knowledgeEntries.scope} = ${filters.scope}`);
-    return this.db.select().from(knowledgeEntries).where(and(...conditions)).orderBy(sql`${knowledgeEntries.createdAt} DESC`).limit(limit);
+    if (filters?.tags && filters.tags.length > 0) {
+      const tagConditions = filters.tags.map((tag) => sql`EXISTS (SELECT 1 FROM json_each(${knowledgeEntries.tags}) WHERE value = ${tag})`);
+      conditions.push(or(...tagConditions));
+    }
+    return this.db.select().from(knowledgeEntries).where(and(...conditions)).orderBy(sql`${knowledgeEntries.createdAt} DESC`).limit(limit).offset(offset);
   }
   async listTags(opts = {}) {
     const { from, to } = opts;
@@ -603,6 +719,110 @@ var KnowledgeRepository = class {
     const result = await this.db.all(sql`SELECT value as tag, COUNT(*) as count FROM knowledge_entries, json_each(knowledge_entries.tags) WHERE knowledge_entries.type != 'system' GROUP BY value ORDER BY count DESC LIMIT ${limit}`);
     return result;
   }
+  /**
+   * Rename/merge a tag across all entries. Per-row correlated rebuild of the JSON
+   * tags array: replace `from`→`to`, and `json_group_array(DISTINCT ...)` collapses
+   * a pre-existing `to`. The `WHERE EXISTS` guard limits both the updated_at bump
+   * and the affected-id list to rows that actually contain `from`. Returns the IDs
+   * of the rows that changed (callers re-embed + resync FTS for these).
+   */
+  renameTag(from, to) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const affected = this.sqlite.prepare(`SELECT id FROM knowledge_entries WHERE EXISTS (SELECT 1 FROM json_each(knowledge_entries.tags) WHERE value = ?)`).all(from);
+    if (affected.length === 0)
+      return [];
+    this.sqlite.prepare(`UPDATE knowledge_entries
+         SET tags = (
+           SELECT json_group_array(DISTINCT CASE WHEN value = @from THEN @to ELSE value END)
+           FROM json_each(knowledge_entries.tags)
+         ),
+         updated_at = @now
+       WHERE EXISTS (SELECT 1 FROM json_each(knowledge_entries.tags) WHERE value = @from)`).run({ from, to, now });
+    return affected.map((r) => r.id);
+  }
+  /**
+   * Flag stale knowledge: not updated since `cutoff` (days), OR already expired,
+   * OR confidence below `minConfidence`. Lightweight metadata-only query (no new
+   * column / no per-entry access tracking).
+   */
+  async findStaleEntries(opts = {}) {
+    const days = opts.days ?? 90;
+    const minConfidence = opts.minConfidence ?? 0.5;
+    const limit = opts.limit ?? 100;
+    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const rows = this.sqlite.prepare(`SELECT id, title, type, scope, confidence_score AS confidenceScore, updated_at AS updatedAt, expires_at AS expiresAt
+         FROM knowledge_entries
+        WHERE type != 'system'
+          AND (updated_at < @cutoff OR (expires_at IS NOT NULL AND expires_at < @now) OR confidence_score < @minConfidence)
+        ORDER BY updated_at ASC
+        LIMIT @limit`).all({ cutoff, now, minConfidence, limit });
+    return rows;
+  }
+  /**
+   * Find near-duplicate entry pairs via per-entry KNN (avoids an O(n²) full scan).
+   * The embedding MUST be read from the vec table (listAll() blanks it). Canonical
+   * `id < neighborId` filter dedups pairs and drops the self-match. Returns [] when
+   * there are no embeddings yet.
+   */
+  async findDuplicatePairs(opts = {}) {
+    const threshold = opts.threshold ?? 0.9;
+    const limit = opts.limit ?? 100;
+    const entries = await this.listAll();
+    const meta = new Map(entries.map((e) => [e.id, e]));
+    const pairs = [];
+    for (const entry of entries) {
+      const emb = getEmbeddingById(this.sqlite, entry.id);
+      if (!emb)
+        continue;
+      const neighbors = searchKnn(this.sqlite, emb, 5);
+      for (const n of neighbors) {
+        if (entry.id >= n.id)
+          continue;
+        if (!meta.has(n.id))
+          continue;
+        const similarity = 1 - n.distance;
+        if (similarity >= threshold) {
+          const other = meta.get(n.id);
+          pairs.push({
+            a: { id: entry.id, title: entry.title },
+            b: { id: other.id, title: other.title },
+            similarity
+          });
+        }
+      }
+      if (pairs.length >= limit)
+        break;
+    }
+    return pairs.sort((x, y) => y.similarity - x.similarity).slice(0, limit);
+  }
+  /**
+   * (Re)populate the FTS5 index from knowledge_entries. Used at startup when the
+   * index is empty but entries exist (e.g. after the FTS migration on an existing
+   * DB). Best-effort and idempotent (clears then re-inserts).
+   */
+  backfillFts() {
+    const rows = this.sqlite.prepare(`SELECT id, title, content, tags FROM knowledge_entries WHERE type != 'system'`).all();
+    let count = 0;
+    for (const r of rows) {
+      try {
+        insertFts(this.sqlite, { id: r.id, title: r.title ?? "", content: r.content ?? "", tags: ftsTags(r.tags) });
+        count++;
+      } catch {
+      }
+    }
+    return count;
+  }
+  /** Backfill the FTS index only when it's empty but entries exist (startup path). */
+  backfillFtsIfNeeded() {
+    try {
+      if (ftsCount(this.sqlite) > 0)
+        return 0;
+      return this.backfillFts();
+    } catch {
+      return 0;
+    }
+  }
   async count() {
     const [result] = await this.db.select({ count: sql`count(*)` }).from(knowledgeEntries).where(ne(knowledgeEntries.type, "system"));
     return Number(result.count);
@@ -690,7 +910,7 @@ var KnowledgeRepository = class {
   listAllPlans() {
     return this.sqlite.prepare("SELECT * FROM plans ORDER BY created_at DESC").all();
   }
-  listPlans(limit = 20, status, scope) {
+  listPlans(limit = 20, status, scope, offset = 0) {
     const conditions = [];
     const params = [];
     if (status) {
@@ -702,8 +922,8 @@ var KnowledgeRepository = class {
       params.push(scope);
     }
     const where = conditions.length ? "WHERE " + conditions.join(" AND ") : "";
-    params.push(limit);
-    return this.sqlite.prepare(`SELECT * FROM plans ${where} ORDER BY created_at DESC LIMIT ?`).all(...params);
+    params.push(limit, offset);
+    return this.sqlite.prepare(`SELECT * FROM plans ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params);
   }
   findSimilarActivePlans(embedding, scope, threshold = 0.5) {
     try {
@@ -945,6 +1165,17 @@ var KnowledgeRepository = class {
     return removed;
   }
 };
+function ftsTags(tags) {
+  let arr = tags;
+  if (typeof tags === "string") {
+    try {
+      arr = JSON.parse(tags);
+    } catch {
+      return tags;
+    }
+  }
+  return Array.isArray(arr) ? arr.filter(Boolean).join(" ") : "";
+}
 function cosineSimilarity(a, b) {
   let dot = 0, magA = 0, magB = 0;
   for (let i = 0; i < a.length; i++) {
@@ -957,6 +1188,25 @@ function cosineSimilarity(a, b) {
 }
 
 // ../../packages/core/dist/services/knowledge.service.js
+function levenshtein(a, b) {
+  if (a === b)
+    return 0;
+  if (!a.length)
+    return b.length;
+  if (!b.length)
+    return a.length;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  let curr = new Array(b.length + 1);
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[b.length];
+}
 var KnowledgeService = class {
   repository;
   embeddingProvider;
@@ -977,8 +1227,26 @@ var KnowledgeService = class {
   buildEmbeddingText(title, content, tags) {
     return `${title} ${content} ${tags.join(" ")}`;
   }
+  /**
+   * Conservative tag normalization: trim + lowercase + dedup (order-preserving).
+   * Deliberately does NOT rewrite tokens (e.g. nest.js→nestjs) — that's left to
+   * the explicit merge flow so meaning is never silently changed.
+   */
+  normalizeTags(tags = []) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const raw of tags) {
+      const t = (raw ?? "").trim().toLowerCase();
+      if (t && !seen.has(t)) {
+        seen.add(t);
+        out.push(t);
+      }
+    }
+    return out;
+  }
   async add(input) {
     const { skipDedup, ...rest } = input;
+    rest.tags = this.normalizeTags(rest.tags);
     const embeddingText = this.buildEmbeddingText(rest.title, rest.content, rest.tags);
     const embedding = await this.embeddingProvider.embed(embeddingText);
     if (!skipDedup) {
@@ -1004,7 +1272,7 @@ var KnowledgeService = class {
   }
   async search(query, options) {
     const queryEmbedding = await this.embeddingProvider.embed(query);
-    const results = await this.repository.searchBySimilarity(queryEmbedding, options);
+    const results = await this.repository.searchBySimilarity(queryEmbedding, { ...options, queryText: query });
     this.logOp("read", results.length);
     const direct = results.map((r) => ({
       entry: this.toKnowledgeEntry(r.entry),
@@ -1073,6 +1341,8 @@ var KnowledgeService = class {
     return entry ? this.toKnowledgeEntry(entry) : null;
   }
   async update(id, updates) {
+    if (updates.tags)
+      updates.tags = this.normalizeTags(updates.tags);
     let embedding;
     if (updates.content || updates.title || updates.tags) {
       const current = await this.repository.findById(id);
@@ -1195,8 +1465,8 @@ var KnowledgeService = class {
     }
     return hash.toString(36);
   }
-  async listRecent(limit = 20, filters) {
-    const entries = await this.repository.listRecent(limit, filters);
+  async listRecent(limit = 20, filters, offset = 0) {
+    const entries = await this.repository.listRecent(limit, filters, offset);
     return entries.map((e) => this.toKnowledgeEntry(e));
   }
   async topTags(limit = 10, opts = {}) {
@@ -1205,6 +1475,74 @@ var KnowledgeService = class {
   async listTags(opts = {}) {
     return this.repository.listTags(opts);
   }
+  /**
+   * Suggest near-duplicate tag pairs to merge (e.g. nest.js ↔ nestjs, redis ↔ Redis).
+   * Compares lowercased forms via max(normalized Levenshtein, token-set Jaccard).
+   * O(n²) over the small DISTINCT tag set.
+   */
+  async suggestTagMerges(threshold = 0.82) {
+    const tags = await this.repository.listTags();
+    const out = [];
+    for (let i = 0; i < tags.length; i++) {
+      for (let j = i + 1; j < tags.length; j++) {
+        const sim = this.tagSimilarity(tags[i], tags[j]);
+        if (sim >= threshold)
+          out.push({ a: tags[i], b: tags[j], similarity: Math.round(sim * 100) / 100 });
+      }
+    }
+    return out.sort((x, y) => y.similarity - x.similarity);
+  }
+  tagSimilarity(a, b) {
+    const la = a.trim().toLowerCase();
+    const lb = b.trim().toLowerCase();
+    if (!la || !lb)
+      return 0;
+    if (la === lb)
+      return 1;
+    const lev = 1 - levenshtein(la, lb) / Math.max(la.length, lb.length);
+    const ta = new Set(la.split(/[^a-z0-9]+/).filter(Boolean));
+    const tb = new Set(lb.split(/[^a-z0-9]+/).filter(Boolean));
+    let inter = 0;
+    for (const t of ta)
+      if (tb.has(t))
+        inter++;
+    const union = (/* @__PURE__ */ new Set([...ta, ...tb])).size;
+    const jaccard = union ? inter / union : 0;
+    return Math.max(lev, jaccard);
+  }
+  /**
+   * Merge tag `from` into `to` across all entries, then re-embed + resync FTS for
+   * affected rows. Re-embeds via repository.update (the UPDATE path), NOT the
+   * insert path — and update() also resyncs the FTS row.
+   */
+  async mergeTag(from, to) {
+    const f = (from ?? "").trim();
+    const t = (to ?? "").trim();
+    if (!f || !t || f === t)
+      return { merged: 0 };
+    const affected = this.repository.renameTag(f, t);
+    for (const id of affected) {
+      const entry = await this.repository.findById(id);
+      if (!entry)
+        continue;
+      const tags = Array.isArray(entry.tags) ? entry.tags : JSON.parse(entry.tags ?? "[]");
+      const embedding = await this.embeddingProvider.embed(this.buildEmbeddingText(entry.title, entry.content, tags));
+      await this.repository.update(id, { embedding });
+    }
+    if (affected.length)
+      this.logOp("write", affected.length);
+    return { merged: affected.length };
+  }
+  async findStaleEntries(opts = {}) {
+    return this.repository.findStaleEntries(opts);
+  }
+  async findDuplicatePairs(opts = {}) {
+    return this.repository.findDuplicatePairs(opts);
+  }
+  /** (Re)populate the FTS5 index if it's empty but entries exist. Returns rows indexed. */
+  backfillFtsIfNeeded() {
+    return this.repository.backfillFtsIfNeeded();
+  }
   async getStats() {
     const [count, byType, byScope, lastUpdatedAt] = await Promise.all([
       this.repository.count(),
@@ -1323,8 +1661,8 @@ var KnowledgeService = class {
     const rows = this.repository.listAllPlans();
     return rows.map((r) => this.toPlan(r));
   }
-  listPlans(limit = 20, status, scope) {
-    const rows = this.repository.listPlans(limit, status, scope);
+  listPlans(limit = 20, status, scope, offset = 0) {
+    const rows = this.repository.listPlans(limit, status, scope, offset);
     return rows.map((r) => this.toPlan(r));
   }
   archiveStaleDrafts(maxAgeHours = 24) {
@@ -2932,10 +3270,10 @@ var KnowledgeSDK = class {
       throw this.wrapError(error, "Failed to delete knowledge");
     }
   }
-  async listRecent(limit = 20, filters) {
+  async listRecent(limit = 20, filters, offset = 0) {
     this.ensureInitialized();
     try {
-      return await this.service.listRecent(limit, filters);
+      return await this.service.listRecent(limit, filters, offset);
     } catch (error) {
       throw this.wrapError(error, "Failed to list recent knowledge");
     }
@@ -2956,6 +3294,38 @@ var KnowledgeSDK = class {
       throw this.wrapError(error, "Failed to list tags");
     }
   }
+  async suggestTagMerges(threshold = 0.82) {
+    this.ensureInitialized();
+    try {
+      return await this.service.suggestTagMerges(threshold);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to suggest tag merges");
+    }
+  }
+  async mergeTags(from, to) {
+    this.ensureInitialized();
+    try {
+      return await this.service.mergeTag(from, to);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to merge tags");
+    }
+  }
+  async findStaleEntries(opts = {}) {
+    this.ensureInitialized();
+    try {
+      return await this.service.findStaleEntries(opts);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to find stale entries");
+    }
+  }
+  async findDuplicatePairs(opts = {}) {
+    this.ensureInitialized();
+    try {
+      return await this.service.findDuplicatePairs(opts);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to find duplicate pairs");
+    }
+  }
   async countByType(opts = {}) {
     this.ensureInitialized();
     try {
@@ -3059,9 +3429,9 @@ var KnowledgeSDK = class {
     this.ensureInitialized();
     return this.service.deletePlan(id);
   }
-  listPlans(limit = 20, status, scope) {
+  listPlans(limit = 20, status, scope, offset = 0) {
     this.ensureInitialized();
-    return this.service.listPlans(limit, status, scope);
+    return this.service.listPlans(limit, status, scope, offset);
   }
   async addPlanRelation(planId, knowledgeId, relationType) {
     this.ensureInitialized();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognistore/mcp-server",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "private": false,
   "type": "module",
   "description": "MCP server for CogniStore — integrates with Claude Code and GitHub Copilot",
@@ -12,7 +12,7 @@
   },
   "main": "./dist/index.js",
   "bin": {
-    "cognistore-mcp": "./dist/index.js"
+    "cognistore-mcp": "dist/index.js"
   },
   "files": [
     "dist"