@mcptoolshop/claude-synergy 0.0.0 → 1.0.0

package/dist/fetch-playwright-HQ6OTMSQ.js

@@ -0,0 +1,80 @@
+// src/fetch-playwright.ts
+async function fetchWindsurfWithPlaywright(sinceIso, opts = {}) {
+  let chromium;
+  try {
+    ({ chromium } = await import("playwright"));
+  } catch (e) {
+    throw new Error(
+      `[fetch-playwright] playwright is not installed. To enable Windsurf coverage, run: pnpm add -D playwright && npx playwright install chromium`
+    );
+  }
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  const url = "https://windsurf.com/changelog";
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const context = await browser.newContext({
+      userAgent: "claude-synergy/0.1.0 (+https://github.com/mcp-tool-shop-org/claude-synergy)"
+    });
+    const page = await context.newPage();
+    await page.goto(url, { waitUntil: "networkidle", timeout: timeoutMs });
+    await page.waitForSelector("h1[id], h2[id], h3[id]", { timeout: timeoutMs });
+    const rawEntries = await page.evaluate(() => {
+      const entries = [];
+      const headings = Array.from(document.querySelectorAll("h1[id]"));
+      for (let i = 0; i < headings.length; i++) {
+        const head = headings[i];
+        const id = head.id;
+        const title = head.textContent?.trim() ?? "";
+        if (!title || !id) continue;
+        let date = null;
+        let wrapper = head;
+        for (let depth = 0; depth < 6 && wrapper; depth++) {
+          const sample = (wrapper.textContent ?? "").slice(0, 200);
+          const m = sample.match(/(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{1,2},?\s+\d{4}/i);
+          if (m) {
+            const d = new Date(m[0]);
+            if (!Number.isNaN(d.getTime())) {
+              date = d.toISOString();
+              break;
+            }
+          }
+          wrapper = wrapper.parentElement;
+        }
+        const bodyParts = [];
+        let next = head.nextElementSibling;
+        const nextHead = headings[i + 1];
+        while (next && next !== nextHead) {
+          if (next instanceof HTMLElement && next.matches("h1[id]")) break;
+          bodyParts.push(next.outerHTML);
+          next = next.nextElementSibling;
+        }
+        entries.push({
+          title,
+          id,
+          date,
+          body: bodyParts.join("\n").trim()
+        });
+      }
+      return entries;
+    });
+    const items = [];
+    for (const e of rawEntries) {
+      const pubDate = e.date ?? null;
+      if (!pubDate) continue;
+      if (pubDate <= sinceIso) continue;
+      items.push({
+        slug: `${pubDate.split("T")[0]}-${e.id}`,
+        title: e.title,
+        pubDate,
+        link: `${url}#${e.id}`,
+        body: e.body
+      });
+    }
+    return items;
+  } finally {
+    await browser.close();
+  }
+}
+export {
+  fetchWindsurfWithPlaywright
+};

package/dist/ingest-3LJNQWS7.js

@@ -0,0 +1,6 @@
+import {
+  ingestAll
+} from "./chunk-HCIZPSW4.js";
+export {
+  ingestAll
+};

package/dist/mcp-server.js

@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+import {
+  entityFrequency,
+  hybridSearch,
+  listProducts,
+  lookupEntity,
+  openDb,
+  recentReleases,
+  searchChanges
+} from "./chunk-YFGUTT22.js";
+
+// src/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ErrorCode,
+  McpError
+} from "@modelcontextprotocol/sdk/types.js";
+import { readdirSync, readFileSync, existsSync } from "fs";
+import { join, dirname, basename } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import matter from "gray-matter";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var _require = createRequire(import.meta.url);
+var { version: PKG_VERSION } = _require("../package.json");
+var SYNERGY_NAME_RE = /^[a-z0-9_-]+$/i;
+var DB_PATH = process.env.CLAUDE_SYNERGY_DB ?? process.argv[2] ?? join(process.cwd(), "data", "claude-synergy.db");
+var SYNERGIES_DIR = process.env.CLAUDE_SYNERGY_SYNERGIES_DIR ?? resolveSynergiesDir();
+function resolveSynergiesDir() {
+  const dbDir = dirname(DB_PATH);
+  const candidates = [
+    join(dbDir, "..", "synergies"),
+    join(process.cwd(), "synergies"),
+    join(__dirname, "..", "synergies")
+  ];
+  for (const c of candidates) if (existsSync(c)) return c;
+  return candidates[0];
+}
+if (!existsSync(DB_PATH)) {
+  console.error(
+    `claude-synergy-mcp: DB not found at ${DB_PATH}. Run 'hk init && hk ingest && hk embed' first, or set CLAUDE_SYNERGY_DB.`
+  );
+  process.exit(1);
+}
+var db = openDb(DB_PATH);
+var hasChunks = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='chunks'`).get() !== void 0;
+var server = new Server(
+  { name: "claude-synergy", version: PKG_VERSION },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "search",
+      description: "Search the Anthropic product changelog corpus. Use mode=hybrid (default, requires embeddings) for semantic/conceptual queries; mode=fts for exact keyword/phrase matching. Returns ranked changelog bullets with product+version+date metadata.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query. Natural language works for hybrid; FTS5 syntax for fts mode." },
+          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" },
+          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 }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "lookup_entity",
+      description: "Find every release that mentions a specific entity: env var, slash command, CLI option, model ID, beta header, hook event, CVE, GHSA. Returns chronological history of mentions across products.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["env_var", "slash_command", "cli_option", "model_id", "beta_header", "hook_event", "setting_key", "cve", "ghsa"],
+            description: "Entity type"
+          },
+          value: { type: "string", description: "Exact entity value (e.g. CLAUDE_CODE_WORKFLOWS, /code-review, claude-opus-4-7, CVE-2025-66414)" }
+        },
+        required: ["type", "value"]
+      }
+    },
+    {
+      name: "latest_releases",
+      description: "Get recent releases across all products (or one). Use this to orient on what shipped recently before recommending features.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          product: { type: "string", description: "Limit to one product" },
+          limit: { type: "number", description: "Max releases", default: 20 }
+        }
+      }
+    },
+    {
+      name: "get_release",
+      description: "Full content of one specific release (all change bullets + metadata).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          product: { type: "string" },
+          version: { type: "string" }
+        },
+        required: ["product", "version"]
+      }
+    },
+    {
+      name: "list_products",
+      description: "Enumerate products in the database with release counts and date of latest release. Use this for orientation.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "top_entities",
+      description: 'Most-mentioned entities of a given type (e.g. top env vars, top slash commands). Useful for "what env vars exist in Claude Code".',
+      inputSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["env_var", "slash_command", "cli_option", "model_id", "beta_header", "hook_event", "setting_key", "cve", "ghsa"]
+          },
+          limit: { type: "number", default: 30 }
+        },
+        required: ["type"]
+      }
+    },
+    {
+      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: {} }
+    },
+    {
+      name: "read_synergy",
+      description: "Read one synergy file in full. Use after list_synergies to drill into a specific pattern.",
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string", description: "Synergy name from list_synergies (e.g. skill-portability)" } },
+        required: ["name"]
+      }
+    }
+  ]
+}));
+var SEARCH_MODES = /* @__PURE__ */ new Set(["hybrid", "fts"]);
+var RERANK_MODES = /* @__PURE__ */ new Set(["none", "ollama-judge"]);
+var ENTITY_TYPES = /* @__PURE__ */ new Set([
+  "env_var",
+  "slash_command",
+  "cli_option",
+  "model_id",
+  "beta_header",
+  "hook_event",
+  "setting_key",
+  "cve",
+  "ghsa"
+]);
+function asRecord(args, tool) {
+  if (args === null || typeof args !== "object" || Array.isArray(args)) {
+    throw new McpError(ErrorCode.InvalidParams, `${tool}: arguments must be an object`);
+  }
+  return args;
+}
+function requireString(rec, field, tool) {
+  const v = rec[field];
+  if (typeof v !== "string" || v.length === 0) {
+    throw new McpError(ErrorCode.InvalidParams, `${tool}: ${field} must be a non-empty string`);
+  }
+  return v;
+}
+function optString(rec, field, tool) {
+  const v = rec[field];
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v !== "string") {
+    throw new McpError(ErrorCode.InvalidParams, `${tool}: ${field} must be a string`);
+  }
+  return v;
+}
+function optInt(rec, field, tool, min = 1, max = 1e4) {
+  const v = rec[field];
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v) || v < min || v > max) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `${tool}: ${field} must be an integer in [${min}, ${max}]`
+    );
+  }
+  return v;
+}
+function optEnum(rec, field, allowed, tool) {
+  const v = rec[field];
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v !== "string" || !allowed.has(v)) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `${tool}: ${field} must be one of ${[...allowed].join(", ")}`
+    );
+  }
+  return v;
+}
+var SEARCH_TIMEOUT_MS = 3e4;
+function withTimeout(promise, ms, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new McpError(ErrorCode.InternalError, message)), ms);
+    promise.then(
+      (val) => {
+        clearTimeout(timer);
+        resolve(val);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "search": {
+        const r = asRecord(args, "search");
+        const searchResult = await withTimeout(
+          handleSearch({
+            query: requireString(r, "query", "search"),
+            mode: optEnum(r, "mode", SEARCH_MODES, "search"),
+            product: optString(r, "product", "search"),
+            since: optString(r, "since", "search"),
+            kind: optString(r, "kind", "search"),
+            rerank: optEnum(r, "rerank", RERANK_MODES, "search"),
+            limit: optInt(r, "limit", "search")
+          }),
+          SEARCH_TIMEOUT_MS,
+          "search timed out (30s) \u2014 is the embedding provider (Ollama) running?"
+        );
+        return {
+          content: [{ type: "text", text: searchResult }]
+        };
+      }
+      case "lookup_entity": {
+        const r = asRecord(args, "lookup_entity");
+        const type = requireString(r, "type", "lookup_entity");
+        if (!ENTITY_TYPES.has(type)) {
+          throw new McpError(
+            ErrorCode.InvalidParams,
+            `lookup_entity: type must be one of ${[...ENTITY_TYPES].join(", ")}`
+          );
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: handleLookupEntity({ type, value: requireString(r, "value", "lookup_entity") })
+            }
+          ]
+        };
+      }
+      case "latest_releases": {
+        const r = asRecord(args ?? {}, "latest_releases");
+        return {
+          content: [
+            {
+              type: "text",
+              text: handleLatestReleases({
+                product: optString(r, "product", "latest_releases"),
+                limit: optInt(r, "limit", "latest_releases")
+              })
+            }
+          ]
+        };
+      }
+      case "get_release": {
+        const r = asRecord(args, "get_release");
+        return {
+          content: [
+            {
+              type: "text",
+              text: handleGetRelease({
+                product: requireString(r, "product", "get_release"),
+                version: requireString(r, "version", "get_release")
+              })
+            }
+          ]
+        };
+      }
+      case "list_products":
+        return { content: [{ type: "text", text: handleListProducts() }] };
+      case "top_entities": {
+        const r = asRecord(args, "top_entities");
+        const type = requireString(r, "type", "top_entities");
+        if (!ENTITY_TYPES.has(type)) {
+          throw new McpError(
+            ErrorCode.InvalidParams,
+            `top_entities: type must be one of ${[...ENTITY_TYPES].join(", ")}`
+          );
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: handleTopEntities({ type, limit: optInt(r, "limit", "top_entities") })
+            }
+          ]
+        };
+      }
+      case "list_synergies":
+        return { content: [{ type: "text", text: handleListSynergies() }] };
+      case "read_synergy": {
+        const r = asRecord(args, "read_synergy");
+        const synName = requireString(r, "name", "read_synergy");
+        if (!SYNERGY_NAME_RE.test(synName)) {
+          throw new McpError(
+            ErrorCode.InvalidParams,
+            "read_synergy: name must match /^[a-z0-9_-]+$/i"
+          );
+        }
+        return { content: [{ type: "text", text: handleReadSynergy({ name: synName }) }] };
+      }
+      default:
+        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+    }
+  } catch (e) {
+    if (e instanceof McpError) throw e;
+    throw new McpError(ErrorCode.InternalError, e.message);
+  }
+});
+async function handleSearch(args) {
+  const mode = args.mode ?? "hybrid";
+  const limit = args.limit ?? 10;
+  if (mode === "fts") {
+    const results2 = searchChanges(db, args.query, {
+      product: args.product,
+      since: args.since,
+      kind: args.kind,
+      limit
+    });
+    return formatSearchResults(results2.map((r) => ({
+      product: r.product,
+      version: r.version,
+      released_at: r.released_at,
+      kind: r.kind,
+      text: r.text,
+      mode: "fts"
+    })));
+  }
+  if (!hasChunks) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      'hybrid mode requires embeddings \u2014 run `hk embed` first, or pass mode="fts"'
+    );
+  }
+  const results = await hybridSearch(db, args.query, {
+    product: args.product,
+    since: args.since,
+    kind: args.kind,
+    rerankProviderName: args.rerank ?? "none",
+    limit
+  });
+  return formatSearchResults(results.map((r) => ({
+    product: r.product,
+    version: r.version,
+    released_at: r.released_at,
+    kind: r.kind,
+    text: r.text,
+    mode: "hybrid",
+    rrf_score: r.rrf_score,
+    rerank_score: r.rerank_score
+  })));
+}
+function formatSearchResults(results) {
+  if (results.length === 0) return "(no results)";
+  const lines = [];
+  for (const r of results) {
+    const scoreInfo = r.rerank_score != null ? ` rerank=${r.rerank_score.toFixed(2)}` : r.rrf_score != null ? ` rrf=${r.rrf_score.toFixed(4)}` : "";
+    lines.push(`${r.released_at ?? "????-??-??"}  ${r.product}@${r.version}  [${r.kind}]${scoreInfo}`);
+    lines.push(`  ${r.text}`);
+    lines.push("");
+  }
+  lines.push(`${results.length} result${results.length === 1 ? "" : "s"}`);
+  return lines.join("\n");
+}
+function handleLookupEntity(args) {
+  const results = lookupEntity(db, args.type, args.value);
+  if (results.length === 0) return `(no mentions of ${args.type}: ${args.value})`;
+  const lines = [`${args.type} ${args.value} \u2014 ${results.length} mention${results.length === 1 ? "" : "s"}:
+`];
+  for (const r of results) {
+    lines.push(`${r.released_at ?? "????-??-??"}  ${r.product}@${r.version}  [${r.kind}]`);
+    lines.push(`  ${r.text}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function handleLatestReleases(args) {
+  const limit = args.limit ?? 20;
+  const releases = recentReleases(db, args.product, limit);
+  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");
+}
+function handleGetRelease(args) {
+  const release = db.prepare(`SELECT product, version, released_at, source_url, notes_path FROM releases WHERE product = ? AND version = ?`).get(args.product, args.version);
+  if (!release) return `(no such release: ${args.product}@${args.version})`;
+  const changes = db.prepare(`SELECT ordinal, kind, text FROM changes WHERE product = ? AND version = ? ORDER BY ordinal`).all(args.product, args.version);
+  const lines = [
+    `# ${release.product} ${release.version}`,
+    `Released: ${release.released_at}`,
+    `Source: ${release.source_url}`,
+    `Notes file: ${release.notes_path}`,
+    ``,
+    `## Changes (${changes.length})`,
+    ``
+  ];
+  for (const c of changes) {
+    lines.push(`- [${c.kind}] ${c.text}`);
+  }
+  return lines.join("\n");
+}
+function handleListProducts() {
+  const products = listProducts(db);
+  if (products.length === 0) return "(no products)";
+  const lines = [
+    "Product                              Releases  Latest",
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+  ];
+  for (const p of products) {
+    const latest = p.latest_version ? `${p.latest_version} (${p.latest_date})` : "\u2014";
+    lines.push(`${p.name.padEnd(36)} ${String(p.release_count).padStart(8)}  ${latest}`);
+  }
+  return lines.join("\n");
+}
+function handleTopEntities(args) {
+  const results = entityFrequency(db, args.type, args.limit ?? 30);
+  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() {
+  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}):
+`];
+  for (const f of files) {
+    try {
+      const raw = readFileSync(join(SYNERGIES_DIR, f), "utf-8");
+      const { data } = matter(raw);
+      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}`);
+      if (trigger) lines.push(`    trigger:  ${trigger}`);
+      lines.push("");
+    } catch {
+    }
+  }
+  return 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})`;
+  }
+  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;
+  }
+  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;
+      }
+    } catch {
+    }
+  }
+  return `(synergy not found: ${args.name})`;
+}
+function shutdownMcp() {
+  try {
+    db.close();
+  } catch {
+  }
+  process.exit(0);
+}
+server.onclose = shutdownMcp;
+process.on("SIGINT", shutdownMcp);
+process.on("SIGTERM", shutdownMcp);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(`claude-synergy-mcp ready (db: ${DB_PATH}, vec: ${hasChunks ? "on" : "off"})`);

package/package.json

@@ -1,14 +1,88 @@
 {
   "name": "@mcptoolshop/claude-synergy",
-  "version": "0.0.0",
-  "description": "Placeholder — real release v0.1.0+ coming soon. See https://github.com/mcp-tool-shop-org/claude-synergy",
+  "version": "1.0.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": {
+    ".": "./dist/cli.js",
+    "./mcp": "./dist/mcp-server.js"
+  },
+  "bin": {
+    "hk": "./dist/cli.js",
+    "claude-synergy-mcp": "./dist/mcp-server.js"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts src/mcp-server.ts --format esm --target node22 --shims --clean --external playwright",
+    "dev": "tsx src/cli.ts",
+    "mcp": "tsx src/mcp-server.ts",
+    "init": "tsx src/cli.ts init",
+    "ingest": "tsx src/cli.ts ingest",
+    "query": "tsx src/cli.ts query",
+    "latest": "tsx src/cli.ts latest",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:smoke": "cross-env RUN_SMOKE=1 vitest run test/smoke",
+    "prepublishOnly": "tsup src/cli.ts src/mcp-server.ts --format esm --target node22 --shims --clean --external playwright"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "better-sqlite3": "^11.5.0",
+    "cheerio": "^1.0.0",
+    "commander": "^12.1.0",
+    "fast-xml-parser": "^4.5.0",
+    "gray-matter": "^4.0.3",
+    "sqlite-vec": "^0.1.9",
+    "turndown": "^7.2.0",
+    "yaml": "^2.6.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/node": "^22.10.0",
+    "@types/turndown": "^5.0.5",
+    "@vitest/coverage-v8": "^2.1.0",
+    "cross-env": "^7.0.3",
+    "playwright": "^1.60.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3",
+      "esbuild"
+    ]
+  },
+  "files": [
+    "dist",
+    "schema.sql",
+    "schema-vec.sql",
+    "synergies",
+    "products.yaml",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "changelog",
+    "synergy",
+    "mcp",
+    "agent-sdk"
+  ],
   "license": "MIT",
   "author": "mcp-tool-shop <64996768+mcp-tool-shop@users.noreply.github.com>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mcp-tool-shop-org/claude-synergy.git"
-  },
-  "files": [
-    "README.md"
-  ]
+    "url": "https://github.com/mcp-tool-shop-org/claude-synergy"
+  }
 }