@hegemonart/get-design-done 1.23.0 → 1.24.0

package/scripts/lib/install/merge.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+// Pure merge / mutation helpers for the multi-runtime installer.
+//
+// mergeClaudeSettings — extracted from the v1.23.5 entrypoint. Adds a
+//   marketplace registration + flips enabledPlugins[<plugin>@<marketplace>].
+//
+// removeClaudeSettings — inverse: removes the marketplace + the
+//   enabledPlugins entry. Leaves untouched anything we did not write.
+//
+// agentsFileFingerprint — first-line marker we drop into every AGENTS.md /
+//   GEMINI.md write so uninstall can confirm the file is plugin-owned.
+
+const PLUGIN_FINGERPRINT = 'get-design-done plugin instructions';
+
+function mergeClaudeSettings(existing, marketplaceEntry) {
+  const next = { ...(existing || {}) };
+
+  const marketplaces = { ...(next.extraKnownMarketplaces || {}) };
+  const desired = {
+    source: { source: 'github', repo: marketplaceEntry.repo },
+  };
+  const marketplaceChanged =
+    JSON.stringify(marketplaces[marketplaceEntry.name]) !==
+    JSON.stringify(desired);
+  marketplaces[marketplaceEntry.name] = desired;
+  next.extraKnownMarketplaces = marketplaces;
+
+  const enabled = { ...(next.enabledPlugins || {}) };
+  const enabledKey = `${marketplaceEntry.pluginName}@${marketplaceEntry.name}`;
+  const enabledChanged = enabled[enabledKey] !== true;
+  enabled[enabledKey] = true;
+  next.enabledPlugins = enabled;
+
+  return { next, changed: marketplaceChanged || enabledChanged };
+}
+
+function removeClaudeSettings(existing, marketplaceEntry) {
+  const next = { ...(existing || {}) };
+
+  const marketplaces = { ...(next.extraKnownMarketplaces || {}) };
+  const marketplaceChanged = Object.prototype.hasOwnProperty.call(
+    marketplaces,
+    marketplaceEntry.name,
+  );
+  delete marketplaces[marketplaceEntry.name];
+  if (Object.keys(marketplaces).length > 0) {
+    next.extraKnownMarketplaces = marketplaces;
+  } else if ('extraKnownMarketplaces' in next) {
+    delete next.extraKnownMarketplaces;
+  }
+
+  const enabled = { ...(next.enabledPlugins || {}) };
+  const enabledKey = `${marketplaceEntry.pluginName}@${marketplaceEntry.name}`;
+  const enabledChanged = Object.prototype.hasOwnProperty.call(
+    enabled,
+    enabledKey,
+  );
+  delete enabled[enabledKey];
+  if (Object.keys(enabled).length > 0) {
+    next.enabledPlugins = enabled;
+  } else if ('enabledPlugins' in next) {
+    delete next.enabledPlugins;
+  }
+
+  return { next, changed: marketplaceChanged || enabledChanged };
+}
+
+function agentsFileFingerprint() {
+  return PLUGIN_FINGERPRINT;
+}
+
+function buildAgentsFileContent(runtime, payloadHeader) {
+  const lines = [
+    `<!-- ${PLUGIN_FINGERPRINT} -->`,
+    '',
+    `# ${runtime.displayName} — get-design-done plugin`,
+    '',
+    'This file was written by `npx @hegemonart/get-design-done`. It loads',
+    'the GDD plugin instructions for this runtime. Re-run the installer to',
+    'refresh; run `npx @hegemonart/get-design-done --uninstall` to remove.',
+    '',
+    payloadHeader || '',
+    '',
+    `Plugin repository: https://github.com/hegemonart/get-design-done`,
+    '',
+  ];
+  return lines.join('\n');
+}
+
+function isPluginOwned(content) {
+  if (!content || typeof content !== 'string') return false;
+  return content.includes(PLUGIN_FINGERPRINT);
+}
+
+module.exports = {
+  mergeClaudeSettings,
+  removeClaudeSettings,
+  agentsFileFingerprint,
+  buildAgentsFileContent,
+  isPluginOwned,
+  PLUGIN_FINGERPRINT,
+};

package/scripts/lib/install/runtimes.cjs

@@ -0,0 +1,172 @@
+'use strict';
+
+// Per-runtime install matrix for the get-design-done plugin.
+//
+// Each entry is pure data describing how to install / uninstall the plugin
+// into one runtime. The 14 runtimes listed below are roadmap-locked
+// (Phase 24 D-02). Two `kind`s exist:
+//
+//   - `claude-marketplace` — register a marketplace entry + flip
+//     `enabledPlugins[<name>@<marketplace>]` in settings.json. Today only
+//     Claude Code uses this.
+//
+//   - `agents-md` — drop a runtime-specific instructions file (AGENTS.md /
+//     GEMINI.md) into the runtime's config directory. Most modern AI coding
+//     CLIs follow this convention.
+//
+// Adding a new runtime: append to RUNTIMES below, append the same id to the
+// alphabetised baseline at test-fixture/baselines/phase-24/runtimes.txt.
+
+const REPO = 'hegemonart/get-design-done';
+const MARKETPLACE_NAME = 'get-design-done';
+const PLUGIN_NAME = 'get-design-done';
+
+const RUNTIMES = Object.freeze([
+  {
+    id: 'claude',
+    displayName: 'Claude Code',
+    configDirEnv: 'CLAUDE_CONFIG_DIR',
+    configDirFallback: '.claude',
+    kind: 'claude-marketplace',
+    files: [],
+    marketplaceEntry: {
+      name: MARKETPLACE_NAME,
+      pluginName: PLUGIN_NAME,
+      repo: REPO,
+    },
+  },
+  {
+    id: 'opencode',
+    displayName: 'OpenCode',
+    configDirEnv: 'OPENCODE_CONFIG_DIR',
+    configDirFallback: '.config/opencode',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'gemini',
+    displayName: 'Gemini CLI',
+    configDirEnv: 'GEMINI_CONFIG_DIR',
+    configDirFallback: '.gemini',
+    kind: 'agents-md',
+    files: ['GEMINI.md'],
+  },
+  {
+    id: 'kilo',
+    displayName: 'Kilo Code',
+    configDirEnv: 'KILO_CONFIG_DIR',
+    configDirFallback: '.kilo',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'codex',
+    displayName: 'OpenAI Codex CLI',
+    configDirEnv: 'CODEX_HOME',
+    configDirFallback: '.codex',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'copilot',
+    displayName: 'GitHub Copilot CLI',
+    configDirEnv: 'COPILOT_CONFIG_DIR',
+    configDirFallback: '.copilot',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'cursor',
+    displayName: 'Cursor',
+    configDirEnv: 'CURSOR_CONFIG_DIR',
+    configDirFallback: '.cursor',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'windsurf',
+    displayName: 'Windsurf',
+    configDirEnv: 'WINDSURF_CONFIG_DIR',
+    configDirFallback: '.windsurf',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'antigravity',
+    displayName: 'Antigravity',
+    configDirEnv: 'ANTIGRAVITY_CONFIG_DIR',
+    configDirFallback: '.antigravity',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'augment',
+    displayName: 'Augment',
+    configDirEnv: 'AUGMENT_CONFIG_DIR',
+    configDirFallback: '.augment',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'trae',
+    displayName: 'Trae',
+    configDirEnv: 'TRAE_CONFIG_DIR',
+    configDirFallback: '.trae',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'qwen',
+    displayName: 'Qwen Code',
+    configDirEnv: 'QWEN_CONFIG_DIR',
+    configDirFallback: '.qwen',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'codebuddy',
+    displayName: 'CodeBuddy',
+    configDirEnv: 'CODEBUDDY_CONFIG_DIR',
+    configDirFallback: '.codebuddy',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+  {
+    id: 'cline',
+    displayName: 'Cline',
+    configDirEnv: 'CLINE_CONFIG_DIR',
+    configDirFallback: '.cline',
+    kind: 'agents-md',
+    files: ['AGENTS.md'],
+  },
+]);
+
+const BY_ID = new Map(RUNTIMES.map((r) => [r.id, r]));
+
+function getRuntime(id) {
+  const r = BY_ID.get(id);
+  if (!r) {
+    throw new RangeError(
+      `Unknown runtime "${id}". Known: ${[...BY_ID.keys()].join(', ')}`,
+    );
+  }
+  return r;
+}
+
+function listRuntimes() {
+  return RUNTIMES;
+}
+
+function listRuntimeIds() {
+  return RUNTIMES.map((r) => r.id);
+}
+
+module.exports = {
+  RUNTIMES,
+  REPO,
+  MARKETPLACE_NAME,
+  PLUGIN_NAME,
+  getRuntime,
+  listRuntimes,
+  listRuntimeIds,
+};

package/scripts/lib/mmr-rerank.cjs

@@ -0,0 +1,154 @@
+/**
+ * mmr-rerank.cjs — Maximal Marginal Relevance post-pass on top-K
+ * (Plan 23.5-03).
+ *
+ * Solves the "all 5 surfaced learnings are about the same thing"
+ * failure mode in the Phase 14.5 decision-injector. Greedy selection
+ * with the standard MMR criterion:
+ *
+ *   nextItem = argmax_{i ∉ selected}  λ * relevance(i) − (1 − λ) * max_sim(i, selected)
+ *
+ * Similarity is token-overlap (Jaccard on case-folded word n-grams,
+ * default n=2). No external deps, no embedding API.
+ *
+ * Pure helper — caller supplies the candidates and a relevance score
+ * already computed by upstream (e.g. grep hit count, BM25, or the
+ * decision-injector's existing rank function). MMR re-ranks ONLY.
+ */
+
+'use strict';
+
+const DEFAULT_LAMBDA = 0.7;
+const DEFAULT_NGRAM = 2;
+const TOKEN_RE = /[\p{L}\p{N}_-]+/gu;
+
+/**
+ * Tokenize a string into case-folded alphanumeric+underscore+dash runs.
+ *
+ * @param {string} text
+ * @returns {string[]}
+ */
+function tokenize(text) {
+  if (typeof text !== 'string' || text.length === 0) return [];
+  const matches = text.toLowerCase().match(TOKEN_RE);
+  return matches ? matches : [];
+}
+
+/**
+ * Build a Set of word n-grams from a string.
+ *
+ * @param {string} text
+ * @param {number} n
+ * @returns {Set<string>}
+ */
+function ngrams(text, n) {
+  const toks = tokenize(text);
+  if (toks.length < n) return new Set(toks);
+  const out = new Set();
+  for (let i = 0; i <= toks.length - n; i++) {
+    out.add(toks.slice(i, i + n).join(' '));
+  }
+  return out;
+}
+
+/**
+ * Jaccard similarity between two strings on word n-grams.
+ *
+ * @param {string} a
+ * @param {string} b
+ * @param {number} [n]
+ * @returns {number} 0..1
+ */
+function similarity(a, b, n = DEFAULT_NGRAM) {
+  const A = ngrams(a, n);
+  const B = ngrams(b, n);
+  if (A.size === 0 || B.size === 0) return 0;
+  let inter = 0;
+  for (const g of A) if (B.has(g)) inter += 1;
+  const union = A.size + B.size - inter;
+  return union > 0 ? inter / union : 0;
+}
+
+/**
+ * Re-rank an array of items using the MMR criterion.
+ *
+ * @param {Array<{text: string, relevance?: number}>} items
+ * @param {{lambda?: number, k?: number, ngram?: number, textOf?: (item: object) => string, relevanceOf?: (item: object) => number}} [opts]
+ * @returns {Array<object>} subset of input in MMR-selected order
+ */
+function rerank(items, opts = {}) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('mmr-rerank.rerank: items must be an array');
+  }
+  if (items.length === 0) return [];
+  const lambda = typeof opts.lambda === 'number' ? opts.lambda : DEFAULT_LAMBDA;
+  const ngram = typeof opts.ngram === 'number' ? opts.ngram : DEFAULT_NGRAM;
+  const k = typeof opts.k === 'number' && opts.k > 0 ? Math.min(opts.k, items.length) : items.length;
+  const textOf =
+    typeof opts.textOf === 'function'
+      ? opts.textOf
+      : (it) => (typeof it === 'string' ? it : (it && typeof it.text === 'string' ? it.text : ''));
+  const relOf =
+    typeof opts.relevanceOf === 'function'
+      ? opts.relevanceOf
+      : (it) => {
+          if (it && typeof it.relevance === 'number') return it.relevance;
+          if (it && typeof it.score === 'number') return it.score;
+          return 1;
+        };
+
+  // Pre-tokenize candidates.
+  const grams = items.map((it) => ngrams(textOf(it), ngram));
+  const relevance = items.map((it) => relOf(it));
+  const remaining = items.map((_, i) => i);
+  /** @type {number[]} */
+  const selected = [];
+
+  while (selected.length < k && remaining.length > 0) {
+    let bestIdx = -1;
+    let bestScore = -Infinity;
+    for (const i of remaining) {
+      let maxSim = 0;
+      for (const j of selected) {
+        const sim = jaccard(grams[i], grams[j]);
+        if (sim > maxSim) maxSim = sim;
+      }
+      const score = lambda * relevance[i] - (1 - lambda) * maxSim;
+      if (score > bestScore) {
+        bestScore = score;
+        bestIdx = i;
+      }
+    }
+    if (bestIdx === -1) break;
+    selected.push(bestIdx);
+    const pos = remaining.indexOf(bestIdx);
+    if (pos !== -1) remaining.splice(pos, 1);
+  }
+  return selected.map((i) => items[i]);
+}
+
+/**
+ * Jaccard between two pre-built ngram sets. Faster than calling
+ * `similarity()` from the rerank loop.
+ *
+ * @param {Set<string>} A
+ * @param {Set<string>} B
+ * @returns {number}
+ */
+function jaccard(A, B) {
+  if (A.size === 0 || B.size === 0) return 0;
+  let inter = 0;
+  for (const g of A) if (B.has(g)) inter += 1;
+  const union = A.size + B.size - inter;
+  return union > 0 ? inter / union : 0;
+}
+
+module.exports = {
+  rerank,
+  similarity,
+  tokenize,
+  ngrams,
+  jaccard,
+  DEFAULT_LAMBDA,
+  DEFAULT_NGRAM,
+};