@mcptoolshop/claude-synergy 0.0.0 → 1.0.0

package/dist/chunk-HCIZPSW4.js

@@ -0,0 +1,469 @@
+// src/ingest.ts
+import { readdirSync, readFileSync as readFileSync2, statSync, existsSync as existsSync2 } from "fs";
+import { join as join2, relative, basename } from "path";
+import { createHash } from "crypto";
+import matter from "gray-matter";
+import TurndownService from "turndown";
+
+// src/extract.ts
+var PATTERNS = [
+  // env vars — uppercase with underscores, prefixed by known prefixes
+  {
+    type: "env_var",
+    pattern: /\b((?:CLAUDE_CODE|ANTHROPIC|MCP|GH|GITHUB|AWS|GOOGLE|VOYAGE|OLLAMA|NPM|NODE)_[A-Z][A-Z0-9_]+)\b/g
+  },
+  // slash commands — lowercase with hyphens, must start with /
+  {
+    type: "slash_command",
+    pattern: /(?<![A-Za-z0-9_/])(\/[a-z][a-z0-9-]+)(?![A-Za-z0-9-])/g
+  },
+  // CLI options — --long-form or -s shorthand
+  {
+    type: "cli_option",
+    pattern: /(?<![A-Za-z0-9])(--[a-z][a-z0-9-]+)(?![A-Za-z0-9-])/g
+  },
+  // Beta headers — kebab-case with date suffix YYYY-MM-DD
+  {
+    type: "beta_header",
+    pattern: /\b([a-z][a-z0-9-]*-20\d{2}-\d{2}-\d{2})\b/g
+  },
+  // Model IDs — claude-{opus,sonnet,haiku}-N(-N)?(-YYYYMMDD)?
+  {
+    type: "model_id",
+    pattern: /\b(claude-(?:opus|sonnet|haiku)-\d+(?:-\d+)?(?:-\d{8})?)\b/g
+  },
+  // Hook event names — defined set
+  {
+    type: "hook_event",
+    pattern: /\b(PreToolUse|PostToolUse|SessionStart|SessionEnd|SubagentStart|SubagentStop|Stop|UserPromptSubmit|Setup|Notification|PreCompact|ConfigChange|WorktreeCreate)\b/g
+  },
+  // Setting keys — camelCase under settings.json (heuristic)
+  {
+    type: "setting_key",
+    pattern: /\b((?:permissions|hooks|worktree|mcpServers|spinnerVerbs|allowed_non_write_users)\.[a-zA-Z]+)\b/g
+  },
+  // CVE identifiers
+  {
+    type: "cve",
+    pattern: /\b(CVE-20\d{2}-\d{4,7})\b/g
+  },
+  // GHSA identifiers
+  {
+    type: "ghsa",
+    pattern: /\b(GHSA-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4})\b/g
+  }
+];
+function extractEntities(text) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { type, pattern } of PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const value = match[1];
+      const key = `${type}:${value}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        found.push([type, value]);
+      }
+    }
+  }
+  return found;
+}
+
+// src/products-config.ts
+import { readFileSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var PRODUCT_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+var GH_REPO_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+var warnedAboutMissingYaml = false;
+function loadProductsConfig(yamlPath) {
+  const resolved = yamlPath ?? resolveYamlPath();
+  if (!resolved || !existsSync(resolved)) {
+    if (!warnedAboutMissingYaml) {
+      console.error(`[claude-synergy] products.yaml not found at ${resolved}; using hardcoded defaults`);
+      warnedAboutMissingYaml = true;
+    }
+    return null;
+  }
+  let raw;
+  try {
+    raw = readFileSync(resolved, "utf-8");
+  } catch (e) {
+    console.error(`[claude-synergy] could not read ${resolved}: ${e.message}; using hardcoded defaults`);
+    return null;
+  }
+  if (raw.charCodeAt(0) === 65279) raw = raw.slice(1);
+  let parsed;
+  try {
+    parsed = parseYaml(raw);
+  } catch (e) {
+    throw new Error(`[claude-synergy] products.yaml parse error: ${e.message}`);
+  }
+  if (!parsed || !Array.isArray(parsed.products)) {
+    throw new Error(`[claude-synergy] products.yaml missing required 'products' array`);
+  }
+  const productMeta = {};
+  const fetchTargets = [];
+  for (const p of parsed.products) {
+    if (!p.name || !p.display_name) {
+      throw new Error(`[claude-synergy] products.yaml entry missing name/display_name: ${JSON.stringify(p)}`);
+    }
+    if (!PRODUCT_NAME_RE.test(p.name)) {
+      throw new Error(
+        `[claude-synergy] products.yaml: invalid product name '${p.name}' \u2014 must match /^[a-z0-9][a-z0-9-]*$/ (lowercase alphanumeric + hyphens, no leading hyphen)`
+      );
+    }
+    productMeta[p.name] = {
+      name: p.name,
+      display_name: p.display_name,
+      source_tier: p.tier ?? 1,
+      source_url: p.source_url ?? "",
+      fetch_strategy: p.fetch_strategy ?? "gh-releases",
+      notes: p.notes ?? null
+    };
+    if (p.fetch) {
+      const target = buildFetchTarget(p.name, p.fetch);
+      if (target) {
+        if (target.strategy === "gh-releases" && target.repo && !GH_REPO_RE.test(target.repo)) {
+          throw new Error(
+            `[claude-synergy] products.yaml: ${p.name}: invalid repo '${target.repo}' \u2014 must match 'owner/repo' (alphanumeric + dot/underscore/hyphen)`
+          );
+        }
+        fetchTargets.push(target);
+      }
+    }
+  }
+  return { productMeta, fetchTargets };
+}
+function buildFetchTarget(name, fetch) {
+  if (!fetch) return null;
+  const target = { product: name, strategy: fetch.type };
+  switch (fetch.type) {
+    case "gh-releases":
+      if (!fetch.repo) throw new Error(`[claude-synergy] ${name}: gh-releases requires 'repo'`);
+      target.repo = fetch.repo;
+      if (fetch.multi_package) target.multiPackage = true;
+      break;
+    case "rss":
+      if (!fetch.url) throw new Error(`[claude-synergy] ${name}: rss requires 'url'`);
+      target.rssUrl = fetch.url;
+      if (fetch.title_filter) {
+        try {
+          target.rssTitleFilter = new RegExp(fetch.title_filter, "i");
+        } catch (e) {
+          throw new Error(`[claude-synergy] ${name}: invalid rss title_filter regex: ${e.message}`);
+        }
+      }
+      break;
+    case "raw-changelog":
+      if (!fetch.url) throw new Error(`[claude-synergy] ${name}: raw-changelog requires 'url'`);
+      if (!fetch.parser) throw new Error(`[claude-synergy] ${name}: raw-changelog requires 'parser'`);
+      target.rawChangelogUrl = fetch.url;
+      target.rawChangelogParser = fetch.parser;
+      break;
+    case "html-scrape":
+      if (!fetch.parser) throw new Error(`[claude-synergy] ${name}: html-scrape requires 'parser'`);
+      target.htmlParser = fetch.parser;
+      break;
+    case "catalog":
+      if (!fetch.catalog_type) throw new Error(`[claude-synergy] ${name}: catalog requires 'catalog_type'`);
+      target.catalogType = fetch.catalog_type;
+      if (fetch.max_entries) target.catalogMaxEntries = fetch.max_entries;
+      break;
+    case "playwright":
+      break;
+    default:
+      throw new Error(`[claude-synergy] ${name}: unknown fetch type ${fetch.type}`);
+  }
+  return target;
+}
+function resolveYamlPath() {
+  const candidates = [
+    join(__dirname2, "..", "products.yaml"),
+    join(process.cwd(), "products.yaml")
+  ];
+  for (const p of candidates) {
+    try {
+      readFileSync(p);
+      return p;
+    } catch {
+    }
+  }
+  return candidates[0];
+}
+
+// src/ingest.ts
+var turndown = new TurndownService({
+  headingStyle: "atx",
+  bulletListMarker: "-",
+  codeBlockStyle: "fenced",
+  emDelimiter: "_"
+});
+turndown.addRule("plainLinks", {
+  filter: "a",
+  replacement: (content, node) => {
+    const href = node.getAttribute?.("href");
+    return href ? `${content} (${href})` : content;
+  }
+});
+function maybeConvertHtmlToMarkdown(content) {
+  const tagCount = (content.match(/<\/?[a-z][^>]*>/gi) || []).length;
+  if (tagCount < 5) return content;
+  try {
+    return turndown.turndown(content);
+  } catch {
+    return content;
+  }
+}
+function compactCommitDumpBody(bullets) {
+  if (bullets.length < 10) return bullets;
+  const SHA_PREFIX = /^\s*[0-9a-f]{7,40}\b/i;
+  const commitLines = bullets.filter((b) => SHA_PREFIX.test(b)).length;
+  const ratio = commitLines / bullets.length;
+  if (commitLines >= 10 && ratio >= 0.5) {
+    const nonCommitLines = bullets.length - commitLines;
+    const noteParts = [`Auto-generated release notes: ${commitLines} commits from previous release. See source_url for full commit list.`];
+    if (nonCommitLines > 0) {
+      const preserved = bullets.filter((b) => !SHA_PREFIX.test(b));
+      noteParts.push(...preserved);
+    }
+    return noteParts;
+  }
+  return bullets;
+}
+function contentHash(raw) {
+  return createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+var HARDCODED_PRODUCT_META = {
+  "claude-code": { tier: 2, strategy: "git-changelog", url: "https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md", display: "Claude Code" },
+  "claude-api": { tier: 3, strategy: "webfetch", url: "https://platform.claude.com/docs/en/release-notes/overview", display: "Claude API / Platform" },
+  "anthropic-apps": { tier: 3, strategy: "webfetch", url: "https://support.claude.com/en/articles/12138966-release-notes", display: "Anthropic Apps (Design / Cowork / Chat / Mobile)" },
+  "claude-agent-sdk-python": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/claude-agent-sdk-python", display: "Claude Agent SDK (Python)" },
+  "claude-agent-sdk-typescript": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/claude-agent-sdk-typescript", display: "Claude Agent SDK (TypeScript)" },
+  "anthropic-cli": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/anthropic-cli", display: "Anthropic CLI (ant)" },
+  "anthropic-sdk-python": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/anthropic-sdk-python", display: "Anthropic SDK (Python)" },
+  "anthropic-sdk-typescript": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/anthropic-sdk-typescript", display: "Anthropic SDK (TypeScript)" },
+  "anthropic-sdk-go": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/anthropic-sdk-go", display: "Anthropic SDK (Go)" },
+  "anthropic-sdk-java": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/anthropic-sdk-java", display: "Anthropic SDK (Java)" },
+  "anthropic-sdk-ruby": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/anthropic-sdk-ruby", display: "Anthropic SDK (Ruby)" },
+  "anthropic-sdk-csharp": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/anthropic-sdk-csharp", display: "Anthropic SDK (C#)" },
+  "anthropic-sdk-php": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/anthropic-sdk-php", display: "Anthropic SDK (PHP)" },
+  "claude-code-action": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/claude-code-action", display: "Claude Code Action (GitHub Action)" },
+  "claude-code-security-review": { tier: 1, strategy: "gh-releases", url: "https://github.com/anthropics/claude-code-security-review", display: "Claude Code Security Review (GitHub Action)" },
+  "skills": { tier: 4, strategy: "git-snapshot", url: "https://github.com/anthropics/skills", display: "Anthropic Skills Catalog" },
+  "plugins-official": { tier: 4, strategy: "git-snapshot", url: "https://github.com/anthropics/claude-plugins-official", display: "Claude Plugins (Official)" },
+  "plugins-community": { tier: 4, strategy: "git-snapshot", url: "https://github.com/anthropics/claude-plugins-community", display: "Claude Plugins (Community)" },
+  "plugins-knowledge-work": { tier: 4, strategy: "git-snapshot", url: "https://github.com/anthropics/knowledge-work-plugins", display: "Knowledge Work Plugins (Cowork)" },
+  // Tier 4a additions — MCP ecosystem
+  "mcp-python-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/python-sdk", display: "MCP Python SDK" },
+  "mcp-typescript-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/typescript-sdk", display: "MCP TypeScript SDK" },
+  "mcp-go-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/go-sdk", display: "MCP Go SDK" },
+  "mcp-java-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/java-sdk", display: "MCP Java SDK" },
+  "mcp-csharp-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/csharp-sdk", display: "MCP C# SDK" },
+  "mcp-kotlin-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/kotlin-sdk", display: "MCP Kotlin SDK" },
+  "mcp-ruby-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/ruby-sdk", display: "MCP Ruby SDK" },
+  "mcp-swift-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/swift-sdk", display: "MCP Swift SDK" },
+  "mcp-rust-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/rust-sdk", display: "MCP Rust SDK" },
+  "mcp-php-sdk": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/php-sdk", display: "MCP PHP SDK" },
+  "mcp-spec": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/modelcontextprotocol", display: "MCP Specification" },
+  "mcp-inspector": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/inspector", display: "MCP Inspector" },
+  "mcp-registry": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/registry", display: "MCP Registry" },
+  "mcp-mcpb": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/mcpb", display: "MCP Bundle (mcpb)" },
+  "mcp-conformance": { tier: 1, strategy: "gh-releases", url: "https://github.com/modelcontextprotocol/conformance", display: "MCP Conformance" },
+  // Tier 4a additions — non-Anthropic AI dev tools
+  "continue-dev": { tier: 1, strategy: "gh-releases", url: "https://github.com/continuedev/continue", display: "Continue.dev" },
+  "continue-cli": { tier: 1, strategy: "gh-releases", url: "https://github.com/continuedev/continue-cli", display: "Continue.dev CLI" },
+  "cursor": { tier: 3, strategy: "rss", url: "https://cursor.com/changelog/rss.xml", display: "Cursor" },
+  "cody-enterprise": { tier: 3, strategy: "rss", url: "https://sourcegraph.com/changelog/featured.rss", display: "Sourcegraph Cody Enterprise" },
+  "aider": { tier: 2, strategy: "raw-changelog", url: "https://raw.githubusercontent.com/Aider-AI/aider/main/HISTORY.md", display: "Aider" },
+  // Tier 4b additions — HTML-scraped sources
+  "github-copilot": { tier: 3, strategy: "html-scrape", url: "https://github.blog/changelog/label/copilot/", display: "GitHub Copilot" },
+  "vscode-copilot-chat": { tier: 3, strategy: "html-scrape", url: "https://code.visualstudio.com/updates/", display: "VS Code Copilot Chat (editor)" },
+  "windsurf": { tier: 3, strategy: "html-scrape", url: "https://windsurf.com/changelog", display: "Windsurf (Cognition)" }
+};
+var PRODUCT_META = (() => {
+  const cfg = loadProductsConfig();
+  if (!cfg) return HARDCODED_PRODUCT_META;
+  const out = {};
+  for (const [name, meta] of Object.entries(cfg.productMeta)) {
+    out[name] = {
+      tier: meta.source_tier,
+      strategy: meta.fetch_strategy,
+      url: meta.source_url,
+      display: meta.display_name
+    };
+  }
+  return out;
+})();
+function ingestAll(db, productsRoot) {
+  const stats = {
+    productsCount: 0,
+    releasesAdded: 0,
+    changesAdded: 0,
+    entitiesAdded: 0,
+    skipped: 0,
+    total: 0,
+    errors: []
+  };
+  const productDirs = readdirSync(productsRoot).filter((name) => {
+    try {
+      return statSync(join2(productsRoot, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  const insertProduct = db.prepare(`
+    INSERT OR REPLACE INTO products (name, display_name, source_tier, source_url, fetch_strategy, notes)
+    VALUES (@name, @display_name, @source_tier, @source_url, @fetch_strategy, @notes)
+  `);
+  const insertRelease = db.prepare(`
+    INSERT OR REPLACE INTO releases (product, version, released_at, notes_path, fetched_at, source_url, bundle_size_kb, notes_hash)
+    VALUES (@product, @version, @released_at, @notes_path, @fetched_at, @source_url, @bundle_size_kb, @notes_hash)
+  `);
+  const insertChange = db.prepare(`
+    INSERT INTO changes (product, version, ordinal, kind, text)
+    VALUES (@product, @version, @ordinal, @kind, @text)
+  `);
+  const deleteChanges = db.prepare(`DELETE FROM changes WHERE product = ? AND version = ?`);
+  const selectExistingHash = db.prepare(
+    `SELECT notes_hash FROM releases WHERE product = ? AND version = ?`
+  );
+  const insertEntity = db.prepare(`
+    INSERT INTO entities (change_id, entity_type, entity_value)
+    VALUES (?, ?, ?)
+  `);
+  for (const product of productDirs) {
+    const releasesDir = join2(productsRoot, product, "releases");
+    if (!existsSync2(releasesDir)) {
+      continue;
+    }
+    let releaseFiles;
+    try {
+      releaseFiles = readdirSync(releasesDir).filter((f) => f.endsWith(".md"));
+    } catch {
+      continue;
+    }
+    if (releaseFiles.length === 0) {
+      continue;
+    }
+    stats.productsCount++;
+    const meta = PRODUCT_META[product] ?? {
+      tier: 1,
+      strategy: "gh-releases",
+      url: "",
+      display: product
+    };
+    insertProduct.run({
+      name: product,
+      display_name: meta.display,
+      source_tier: meta.tier,
+      source_url: meta.url,
+      fetch_strategy: meta.strategy,
+      notes: null
+    });
+    const ingestTransaction = db.transaction(() => {
+      for (const file of releaseFiles) {
+        try {
+          stats.total++;
+          const path = join2(releasesDir, file);
+          const raw = readFileSync2(path, "utf-8");
+          const { data: fm, content } = matter(raw);
+          const fmTyped = fm;
+          const baseVersion = fmTyped.version ?? basename(file, ".md");
+          const version = fmTyped.sub_product ? `${baseVersion}-${fmTyped.sub_product}` : baseVersion;
+          const hash = contentHash(raw);
+          const existingRow = selectExistingHash.get(product, version);
+          if (existingRow?.notes_hash === hash) {
+            stats.skipped++;
+            continue;
+          }
+          const released_at = fmTyped.released_at ?? null;
+          const source_url = fmTyped.source_url ?? "";
+          const fetched_at = fmTyped.fetched_at ?? (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+          const bundle_size_kb = fmTyped.bundle_size_kb_delta ?? null;
+          deleteChanges.run(product, version);
+          insertRelease.run({
+            product,
+            version,
+            released_at,
+            notes_path: relative(productsRoot, path).replace(/\\/g, "/"),
+            fetched_at,
+            source_url,
+            bundle_size_kb,
+            notes_hash: hash
+          });
+          stats.releasesAdded++;
+          const bullets = compactCommitDumpBody(parseBullets(maybeConvertHtmlToMarkdown(content)));
+          bullets.forEach((bullet, i) => {
+            const kind = classifyKind(bullet);
+            const result = insertChange.run({
+              product,
+              version,
+              ordinal: i + 1,
+              kind,
+              text: bullet
+            });
+            stats.changesAdded++;
+            const changeId = result.lastInsertRowid;
+            const entities = extractEntities(bullet);
+            for (const [type, value] of entities) {
+              insertEntity.run(changeId, type, value);
+              stats.entitiesAdded++;
+            }
+          });
+        } catch (e) {
+          stats.errors.push({ file, error: e.message });
+        }
+      }
+    });
+    ingestTransaction();
+  }
+  return stats;
+}
+function parseBullets(content) {
+  const lines = content.split("\n");
+  const bullets = [];
+  let current = "";
+  let inFencedBlock = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("```")) {
+      inFencedBlock = !inFencedBlock;
+      continue;
+    }
+    if (inFencedBlock) continue;
+    const bulletMatch = line.match(/^[-*] (.+)$/);
+    if (bulletMatch) {
+      if (current) bullets.push(current.trim());
+      current = bulletMatch[1];
+    } else if (line.match(/^\s{2,}\S/) && current) {
+      current += " " + line.trim();
+    } else if (line.trim() === "" || line.match(/^#/) || line.match(/^\|/)) {
+      if (current) {
+        bullets.push(current.trim());
+        current = "";
+      }
+    }
+  }
+  if (current) bullets.push(current.trim());
+  return bullets;
+}
+function classifyKind(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("breaking")) return "breaking";
+  if (lower.startsWith("added") || lower.match(/^new /)) return "added";
+  if (lower.startsWith("fixed") || lower.startsWith("fix ")) return "fixed";
+  if (lower.startsWith("removed") || lower.startsWith("retired")) return "removed";
+  if (lower.includes("deprecat")) return "deprecated";
+  if (lower.startsWith("renamed")) return "renamed";
+  if (lower.startsWith("improved")) return "improved";
+  return "changed";
+}
+
+export {
+  loadProductsConfig,
+  ingestAll
+};