@mcptoolshop/claude-synergy 1.0.0 → 1.1.0

package/dist/ingest-Z45YH7OX.js

@@ -0,0 +1,8 @@
+import {
+  ingestAll,
+  ingestSynergies
+} from "./chunk-HZEQG3WT.js";
+export {
+  ingestAll,
+  ingestSynergies
+};

package/dist/mcp-server.js

@@ -1,13 +1,18 @@
 #!/usr/bin/env node
 import {
+  browseChanges,
+  compareVersions,
   entityFrequency,
+  getChangesSince,
+  getSynergy,
   hybridSearch,
   listProducts,
+  listSynergies,
   lookupEntity,
   openDb,
   recentReleases,
   searchChanges
-} from "./chunk-YFGUTT22.js";
+} from "./chunk-H3466JDH.js";
 
 // src/mcp-server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -63,6 +68,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
           mode: { type: "string", enum: ["hybrid", "fts"], description: "hybrid = FTS5+vec via RRF (best for concepts); fts = BM25 only (best for exact terms)", default: "hybrid" },
           product: { type: "string", description: "Limit to one product (e.g. claude-code, claude-agent-sdk-python, anthropic-cli)" },
           since: { type: "string", description: "YYYY-MM-DD lower bound on release date" },
+          until: { type: "string", description: "YYYY-MM-DD upper bound on release date" },
           kind: { type: "string", description: "Filter by change kind: added | fixed | breaking | deprecated | renamed | removed | improved | changed" },
           rerank: { type: "string", enum: ["none", "ollama-judge"], description: "Rerank top-K candidates (hybrid mode only). Defaults to none for speed.", default: "none" },
           limit: { type: "number", description: "Max results (default 10)", default: 10 }
@@ -93,6 +99,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         type: "object",
         properties: {
           product: { type: "string", description: "Limit to one product" },
+          since: { type: "string", description: "YYYY-MM-DD lower bound on release date" },
           limit: { type: "number", description: "Max releases", default: 20 }
         }
       }
@@ -132,7 +139,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     {
       name: "list_synergies",
       description: "List curated cross-product workflows (Claude Design \u2194 Code bundle, MCP server portability, etc). Each synergy describes a composition pattern with evidence.",
-      inputSchema: { type: "object", properties: {} }
+      inputSchema: {
+        type: "object",
+        properties: {
+          product: { type: "string", description: "Filter to synergies that mention this product (e.g. claude-code)" }
+        }
+      }
     },
     {
       name: "read_synergy",
@@ -142,6 +154,47 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         properties: { name: { type: "string", description: "Synergy name from list_synergies (e.g. skill-portability)" } },
         required: ["name"]
       }
+    },
+    {
+      name: "get_changes_since",
+      description: 'Get all changes in a date window, grouped by product+version. The LLM-orientation tool: "what shipped in the last 7 days" without needing a search term. Use this before recommending features to know the current ground truth.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          since: { type: "string", description: "Lower bound \u2014 YYYY-MM-DD, full ISO, or relative (e.g. 7d, 2w, 1m, 1y)" },
+          until: { type: "string", description: "Upper bound \u2014 YYYY-MM-DD, full ISO, or relative; defaults to now" },
+          product: { type: "string", description: "Limit to one product" },
+          kind: { type: "string", description: "Filter by change kind: added | fixed | breaking | deprecated | renamed | removed | improved | changed" },
+          limit: { type: "number", description: "Max change rows returned (default 200)", default: 200 }
+        },
+        required: ["since"]
+      }
+    },
+    {
+      name: "search_breaking_changes",
+      description: "Browse breaking changes in a date window. No search term required \u2014 returns all changes with kind=breaking, most recent first. Use this for upgrade-planning and migration workflows.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          product: { type: "string", description: "Limit to one product" },
+          since: { type: "string", description: "Lower bound \u2014 YYYY-MM-DD, full ISO, or relative (e.g. 7d)" },
+          until: { type: "string", description: "Upper bound \u2014 YYYY-MM-DD, full ISO, or relative; defaults to now" },
+          limit: { type: "number", description: "Max results (default 50)", default: 50 }
+        }
+      }
+    },
+    {
+      name: "compare_versions",
+      description: 'Cumulative diff between two versions of a product, grouped by intermediate release. Use for upgrade planning ("I am on python 0.88.0, what changed through 0.94.0?"). Single call replaces N+1 get_release lookups.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          product: { type: "string", description: "Product slug (e.g. anthropic-sdk-python)" },
+          from_version: { type: "string", description: "Starting version, exclusive (you are already on this)" },
+          to_version: { type: "string", description: "Target version, inclusive" }
+        },
+        required: ["product", "from_version", "to_version"]
+      }
     }
   ]
 }));
@@ -229,6 +282,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             mode: optEnum(r, "mode", SEARCH_MODES, "search"),
             product: optString(r, "product", "search"),
             since: optString(r, "since", "search"),
+            until: optString(r, "until", "search"),
             kind: optString(r, "kind", "search"),
             rerank: optEnum(r, "rerank", RERANK_MODES, "search"),
             limit: optInt(r, "limit", "search")
@@ -266,6 +320,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               type: "text",
               text: handleLatestReleases({
                 product: optString(r, "product", "latest_releases"),
+                since: optString(r, "since", "latest_releases"),
                 limit: optInt(r, "limit", "latest_releases")
               })
             }
@@ -306,8 +361,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           ]
         };
       }
-      case "list_synergies":
-        return { content: [{ type: "text", text: handleListSynergies() }] };
+      case "list_synergies": {
+        const r = asRecord(args ?? {}, "list_synergies");
+        return {
+          content: [
+            {
+              type: "text",
+              text: handleListSynergies({ product: optString(r, "product", "list_synergies") })
+            }
+          ]
+        };
+      }
       case "read_synergy": {
         const r = asRecord(args, "read_synergy");
         const synName = requireString(r, "name", "read_synergy");
@@ -319,6 +383,54 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         return { content: [{ type: "text", text: handleReadSynergy({ name: synName }) }] };
       }
+      case "get_changes_since": {
+        const r = asRecord(args, "get_changes_since");
+        return {
+          content: [
+            {
+              type: "text",
+              text: handleGetChangesSince({
+                since: requireString(r, "since", "get_changes_since"),
+                until: optString(r, "until", "get_changes_since"),
+                product: optString(r, "product", "get_changes_since"),
+                kind: optString(r, "kind", "get_changes_since"),
+                limit: optInt(r, "limit", "get_changes_since")
+              })
+            }
+          ]
+        };
+      }
+      case "search_breaking_changes": {
+        const r = asRecord(args ?? {}, "search_breaking_changes");
+        return {
+          content: [
+            {
+              type: "text",
+              text: handleSearchBreakingChanges({
+                product: optString(r, "product", "search_breaking_changes"),
+                since: optString(r, "since", "search_breaking_changes"),
+                until: optString(r, "until", "search_breaking_changes"),
+                limit: optInt(r, "limit", "search_breaking_changes")
+              })
+            }
+          ]
+        };
+      }
+      case "compare_versions": {
+        const r = asRecord(args, "compare_versions");
+        return {
+          content: [
+            {
+              type: "text",
+              text: handleCompareVersions({
+                product: requireString(r, "product", "compare_versions"),
+                from_version: requireString(r, "from_version", "compare_versions"),
+                to_version: requireString(r, "to_version", "compare_versions")
+              })
+            }
+          ]
+        };
+      }
       default:
         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
     }
@@ -334,6 +446,7 @@ async function handleSearch(args) {
     const results2 = searchChanges(db, args.query, {
       product: args.product,
       since: args.since,
+      until: args.until,
       kind: args.kind,
       limit
     });
@@ -355,6 +468,7 @@ async function handleSearch(args) {
   const results = await hybridSearch(db, args.query, {
     product: args.product,
     since: args.since,
+    until: args.until,
     kind: args.kind,
     rerankProviderName: args.rerank ?? "none",
     limit
@@ -396,7 +510,7 @@ function handleLookupEntity(args) {
 }
 function handleLatestReleases(args) {
   const limit = args.limit ?? 20;
-  const releases = recentReleases(db, args.product, limit);
+  const releases = recentReleases(db, args.product, limit, args.since);
   if (releases.length === 0) return "(no releases)";
   return releases.map((r) => `${r.released_at}  ${r.product}@${r.version}  (${r.change_count} change${r.change_count === 1 ? "" : "s"})`).join("\n");
 }
@@ -436,52 +550,173 @@ function handleTopEntities(args) {
   if (results.length === 0) return `(no entities of type ${args.type})`;
   return results.map((r) => `${String(r.count).padStart(4)}  ${r.first_seen ?? "????-??-??"}  ${r.value}`).join("\n");
 }
-function handleListSynergies() {
+function dbSynergiesEmpty() {
+  try {
+    const row = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='synergies'`).get();
+    if (!row) return true;
+    const count = db.prepare(`SELECT COUNT(*) AS n FROM synergies`).get();
+    return !count || count.n === 0;
+  } catch {
+    return true;
+  }
+}
+function handleListSynergies(args = {}) {
+  if (!dbSynergiesEmpty()) {
+    try {
+      const rows = listSynergies(db, args.product ? { product: args.product } : void 0);
+      if (rows.length === 0) {
+        return args.product ? `(no synergies mention product "${args.product}")` : "(no synergies)";
+      }
+      const lines = [`Synergies (${rows.length}):
+`];
+      for (const s of rows) {
+        const name = s.name ?? "";
+        const title = s.title ?? name;
+        const products = Array.isArray(s.products) ? s.products.join(", ") : s.products ?? "unknown";
+        const trigger = s.trigger ?? "";
+        lines.push(`- ${name}: ${title}`);
+        lines.push(`    products: ${products}`);
+        if (trigger) lines.push(`    trigger:  ${trigger}`);
+        lines.push("");
+      }
+      return lines.join("\n");
+    } catch {
+    }
+  }
+  return listSynergiesFromDisk(args.product);
+}
+function listSynergiesFromDisk(productFilter) {
   if (!existsSync(SYNERGIES_DIR)) return "(synergies dir not found)";
   const files = readdirSync(SYNERGIES_DIR).filter((f) => f.endsWith(".md") && f !== "INDEX.md");
   if (files.length === 0) return "(no synergies)";
-  const lines = [`Synergies (${files.length}):
-`];
+  const lines = [];
+  let count = 0;
   for (const f of files) {
     try {
       const raw = readFileSync(join(SYNERGIES_DIR, f), "utf-8");
       const { data } = matter(raw);
+      const products = Array.isArray(data.products) ? data.products : [];
+      if (productFilter && !products.includes(productFilter)) continue;
       const name = data.name ?? f.replace(/\.md$/, "");
       const title = data.title ?? name;
-      const products = Array.isArray(data.products) ? data.products.join(", ") : "unknown";
       const trigger = data.trigger ?? "";
       lines.push(`- ${name}: ${title}`);
-      lines.push(`    products: ${products}`);
+      lines.push(`    products: ${products.length > 0 ? products.join(", ") : "unknown"}`);
       if (trigger) lines.push(`    trigger:  ${trigger}`);
       lines.push("");
+      count += 1;
     } catch {
     }
   }
-  return lines.join("\n");
+  if (count === 0) {
+    return productFilter ? `(no synergies mention product "${productFilter}")` : "(no synergies)";
+  }
+  return [`Synergies (${count}):
+`, ...lines].join("\n");
 }
 function handleReadSynergy(args) {
-  if (!existsSync(SYNERGIES_DIR)) return "(synergies dir not found)";
   if (!SYNERGY_NAME_RE.test(args.name)) {
     return `(synergy not found: ${args.name})`;
   }
+  if (!dbSynergiesEmpty()) {
+    try {
+      const synergy = getSynergy(db, args.name);
+      if (synergy && synergy.body) {
+        return synergy.body;
+      }
+    } catch {
+    }
+  }
+  if (!existsSync(SYNERGIES_DIR)) return `(synergy not found: ${args.name})`;
   const files = readdirSync(SYNERGIES_DIR).filter((f) => f.endsWith(".md"));
   const targetFile = files.find((f) => basename(f, ".md") === args.name);
   if (targetFile) {
-    const raw = readFileSync(join(SYNERGIES_DIR, targetFile), "utf-8");
-    return raw;
+    return readFileSync(join(SYNERGIES_DIR, targetFile), "utf-8");
   }
   for (const f of files) {
     try {
       const raw = readFileSync(join(SYNERGIES_DIR, f), "utf-8");
       const { data } = matter(raw);
-      if (data.name === args.name) {
-        return raw;
-      }
+      if (data.name === args.name) return raw;
     } catch {
     }
   }
   return `(synergy not found: ${args.name})`;
 }
+function formatChangesSinceResults(results) {
+  if (results.length === 0) {
+    return "(no changes in window \u2014 try widening --since)";
+  }
+  const lines = [];
+  let total = 0;
+  for (const rel of results) {
+    const date = rel.released_at ?? "????-??-??";
+    lines.push(`${date}  ${rel.product}@${rel.version}  (${rel.changes.length} change${rel.changes.length === 1 ? "" : "s"})`);
+    for (const c of rel.changes) {
+      lines.push(`  - [${c.kind}] ${c.text}`);
+    }
+    lines.push("");
+    total += rel.changes.length;
+  }
+  lines.push(`${total} change${total === 1 ? "" : "s"} across ${results.length} release${results.length === 1 ? "" : "s"}`);
+  return lines.join("\n");
+}
+function handleGetChangesSince(args) {
+  let results;
+  try {
+    results = getChangesSince(db, {
+      since: args.since,
+      until: args.until,
+      product: args.product,
+      kind: args.kind,
+      limit: args.limit ?? 200
+    });
+  } catch (e) {
+    throw new McpError(ErrorCode.InvalidParams, `get_changes_since: ${e.message}`);
+  }
+  return formatChangesSinceResults(results);
+}
+function handleSearchBreakingChanges(args) {
+  let results;
+  try {
+    results = browseChanges(db, {
+      product: args.product,
+      since: args.since,
+      until: args.until,
+      kind: "breaking",
+      limit: args.limit ?? 50
+    });
+  } catch (e) {
+    throw new McpError(ErrorCode.InvalidParams, `search_breaking_changes: ${e.message}`);
+  }
+  if (results.length === 0) {
+    return "(no breaking changes \u2014 note: ingest may not have classified any changes as breaking yet)";
+  }
+  const lines = [];
+  for (const r of results) {
+    lines.push(`${r.released_at ?? "????-??-??"}  ${r.product}@${r.version}  [${r.kind}]`);
+    lines.push(`  ${r.text}`);
+    lines.push("");
+  }
+  lines.push(`${results.length} breaking change${results.length === 1 ? "" : "s"}`);
+  return lines.join("\n");
+}
+function handleCompareVersions(args) {
+  let results;
+  try {
+    results = compareVersions(db, {
+      product: args.product,
+      fromVersion: args.from_version,
+      toVersion: args.to_version
+    });
+  } catch (e) {
+    throw new McpError(ErrorCode.InvalidParams, `compare_versions: ${e.message}`);
+  }
+  if (results.length === 0) {
+    return `(no intermediate releases between ${args.product}@${args.from_version} and ${args.product}@${args.to_version})`;
+  }
+  return formatChangesSinceResults(results);
+}
 function shutdownMcp() {
   try {
     db.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcptoolshop/claude-synergy",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Local mirror of Anthropic product changelogs + curated cross-product synergies. So the LLM agent inside the harness knows what the harness can do.",
   "type": "module",
   "exports": {

package/products.yaml

@@ -62,14 +62,20 @@
 
 products:
 
-  # ── Tier 2 / Anthropic CHANGELOG.md ───────────────────────────────────────
+  # ── Tier 1 / Anthropic flagship product ──────────────────────────────────
+  # FE-1 (2026-05-22): wired up automated sync via GH Releases. The repo
+  # publishes a per-version GitHub Release whose body mirrors CHANGELOG.md,
+  # so gh-releases yields strictly richer data than parsing the raw file
+  # (released_at, html_url, tag_name are all structured). Bumped to tier 1
+  # from tier 2 to reflect that this is now a Structured-API source.
   - name: claude-code
     display_name: Claude Code
-    tier: 2
-    source_url: https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md
-    fetch_strategy: git-changelog
-    # No fetch: block — corpus seeded by initial study-swarm; CHANGELOG.md
-    # incremental sync deferred to a future phase.
+    tier: 1
+    source_url: https://github.com/anthropics/claude-code
+    fetch_strategy: gh-releases
+    fetch:
+      type: gh-releases
+      repo: anthropics/claude-code
 
   # ── Tier 3 / HTML feeds ──────────────────────────────────────────────────
   - name: claude-api

package/schema-vec.sql

@@ -2,7 +2,12 @@
 -- Run after schema.sql. Tables here are independent of Tier 2a's changes_fts,
 -- so naive FTS still works on the raw bullets while hybrid uses the contextualized layer.
 --
--- Dimension: 768 (nomic-embed-text native; Voyage 3 truncatable via Matryoshka)
+-- Dimension: configurable, stored in `schema_meta` under the key
+-- `embedding_dim` (see src/db.ts). The `chunks_vec` virtual table is created
+-- in code by initVecSchema() in src/embed.ts using the negotiated dim so that
+-- switching providers (Ollama 768d, Voyage 768d-truncated, OpenAI 1536d, etc.)
+-- works without manual schema edits. Default is 768 (nomic-embed-text native;
+-- Voyage 3 truncatable via Matryoshka).
 -- One row per change. Reranking deferred.
 
 CREATE TABLE IF NOT EXISTS chunks (
@@ -22,10 +27,9 @@ CREATE TABLE IF NOT EXISTS chunks (
 CREATE INDEX IF NOT EXISTS idx_chunks_product ON chunks(product, released_at);
 CREATE INDEX IF NOT EXISTS idx_chunks_change ON chunks(change_id);
 
--- Vector storage (sqlite-vec extension required)
-CREATE VIRTUAL TABLE IF NOT EXISTS chunks_vec USING vec0(
-  embedding FLOAT[768]
-);
+-- NOTE: `chunks_vec` is created dynamically by src/embed.ts initVecSchema()
+-- so its dimension can match the configured embedding provider. The legacy
+-- 768-dim definition is preserved in db migration code for backward compat.
 
 -- FTS5 over the contextualized text (separate from changes_fts which indexes raw bullets)
 CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(