@hegemonart/get-design-done 1.28.6 → 1.28.8

package/scripts/lib/install/converters/cursor-marketplace.cjs

@@ -0,0 +1,309 @@
+'use strict';
+
+/**
+ * scripts/lib/install/converters/cursor-marketplace.cjs — Phase 28.8 (Plan B1).
+ *
+ * Cursor Marketplace Tier-2 distribution-channel converter. SEPARATE from
+ * Phase 28.7's `cursor.cjs` SKILL.md file-drop converter — that one rewrites
+ * per-skill content for the runtime install path. THIS one builds the
+ * `.cursor-plugin/plugin.json` manifest and emits the marketplace bundle
+ * layout consumed by `build-distribution-bundles.cjs` (Plan 28-8-X1).
+ *
+ * Architecture note: per CONTEXT D-05 (additive), Tier-1 file-drop and
+ * Tier-2 marketplace coexist — `cursor.cjs` is UNCHANGED. Per CONTEXT D-06,
+ * `skills/` is the SHARED source; this converter passes skill content
+ * through verbatim (Cursor accepts Claude-compatible SKILL.md per Wave A
+ * research, so no per-skill content transform is required at the Tier-2
+ * bundle layer).
+ *
+ * Source mapping: see `.planning/research/cursor-marketplace-2026-05-19.md`
+ * § Schema Mapping (lines 234-256) for the authoritative field-by-field spec.
+ *
+ * GDD-original pattern (no gsd-build/get-shit-done counterpart): Tier-2
+ * distribution channels do not exist in the upstream multi-runtime install
+ * reference (CONTEXT line 34). No port attribution required.
+ *
+ * Exports:
+ *   - `buildManifest(sources, opts)` — pure function, returns the manifest
+ *     object ready to `JSON.stringify(obj, null, 2)`.
+ *   - `convert({ skillsDir, outDir, manifest }, opts)` — file-emission
+ *     function for `build-distribution-bundles.cjs`. The only side-effect
+ *     surface; touches only paths under `outDir`.
+ *   - `CURATED_KEYWORDS` — frozen 8-tag default keyword subset.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Curated keyword subset for Cursor's marketplace card display.
+// Per Wave A research § Schema Mapping `keywords` row: marketplace card
+// surfaces ~5-8 tags — picking the most Cursor-user-relevant subset out
+// of the 60+ tags in package.json.keywords.
+const CURATED_KEYWORDS = Object.freeze([
+  'design',
+  'ui',
+  'ux',
+  'frontend',
+  'design-system',
+  'accessibility',
+  'figma',
+  'skill',
+]);
+
+/**
+ * Build the .cursor-plugin/plugin.json manifest object from GDD source
+ * artifacts. Pure function — no fs, env, or path access.
+ *
+ * Field-by-field source mapping per Wave A research § Schema Mapping:
+ *
+ *   name        ← claudePluginJson.name (canonical, kebab-case)
+ *   description ← packageJson.description (verbatim)
+ *   version     ← packageJson.version (verbatim, lockstep per D-08)
+ *   author      ← {name: claudePluginJson.author.name} (transform)
+ *   homepage    ← packageJson.homepage (verbatim, omit if absent)
+ *   repository  ← packageJson.repository.url with trailing .git stripped
+ *   license     ← packageJson.license (verbatim, omit if absent)
+ *   keywords    ← opts.keywords || CURATED_KEYWORDS
+ *
+ * OMITTED (per research § Schema Mapping rationale):
+ *   logo, rules, agents, skills, commands, hooks, mcpServers
+ *
+ * @param {Object} sources                            Source metadata.
+ * @param {Object} sources.packageJson                Parsed package.json.
+ * @param {Object} [sources.claudePluginJson]         Parsed .claude-plugin/plugin.json.
+ * @param {Object} [opts]
+ * @param {string[]} [opts.keywords]                  Override keyword subset
+ *   (defaults to CURATED_KEYWORDS).
+ * @returns {Object}                                  Manifest object,
+ *   keys in documented order, ready to JSON.stringify with 2-space indent.
+ */
+function buildManifest(sources, opts) {
+  const opts2 = opts || {};
+  const pkg = sources && sources.packageJson;
+  const claudePlugin = sources && sources.claudePluginJson;
+
+  if (!pkg || typeof pkg !== 'object') {
+    throw new Error('cursor-marketplace: sources.packageJson is required');
+  }
+
+  // name — prefer .claude-plugin/plugin.json.name (canonical, already
+  // kebab-case as "get-design-done"); fall back to stripping npm scope
+  // prefix from package.json.name.
+  let name;
+  if (claudePlugin && typeof claudePlugin.name === 'string') {
+    name = claudePlugin.name;
+  } else if (typeof pkg.name === 'string') {
+    name = pkg.name.replace(/^@[^/]+\//, '');
+  } else {
+    throw new Error('cursor-marketplace: name is required (no source)');
+  }
+
+  // description — required (we want predictable failure if package.json
+  // is malformed).
+  if (typeof pkg.description !== 'string' || pkg.description.length === 0) {
+    throw new Error('cursor-marketplace: packageJson.description is required');
+  }
+  const description = pkg.description;
+
+  // version — required, semver-shaped.
+  if (typeof pkg.version !== 'string' || !/^\d+\.\d+\.\d+/.test(pkg.version)) {
+    throw new Error(
+      'cursor-marketplace: packageJson.version is required and must be semver-shaped'
+    );
+  }
+  const version = pkg.version;
+
+  // author — resolve in order: claudePluginJson.author.name → pkg.author
+  // (string form) → pkg.author.name. Email only if claudePluginJson source
+  // carries one (GDD does not today).
+  let authorName;
+  let authorEmail;
+  if (
+    claudePlugin
+    && claudePlugin.author
+    && typeof claudePlugin.author === 'object'
+    && typeof claudePlugin.author.name === 'string'
+  ) {
+    authorName = claudePlugin.author.name;
+    if (typeof claudePlugin.author.email === 'string') {
+      authorEmail = claudePlugin.author.email;
+    }
+  } else if (typeof pkg.author === 'string' && pkg.author.length > 0) {
+    authorName = pkg.author;
+  } else if (
+    pkg.author
+    && typeof pkg.author === 'object'
+    && typeof pkg.author.name === 'string'
+  ) {
+    authorName = pkg.author.name;
+    if (typeof pkg.author.email === 'string') {
+      authorEmail = pkg.author.email;
+    }
+  } else {
+    throw new Error('cursor-marketplace: author.name is required (no source)');
+  }
+  const author = authorEmail
+    ? { name: authorName, email: authorEmail }
+    : { name: authorName };
+
+  // homepage — verbatim, omit if absent.
+  const homepage =
+    typeof pkg.homepage === 'string' && pkg.homepage.length > 0
+      ? pkg.homepage
+      : undefined;
+
+  // repository — package.json may store as object {type, url} or string.
+  // Strip trailing .git for cleaner display.
+  let repository;
+  if (pkg.repository) {
+    let rawUrl;
+    if (typeof pkg.repository === 'string') {
+      rawUrl = pkg.repository;
+    } else if (typeof pkg.repository === 'object'
+      && typeof pkg.repository.url === 'string') {
+      rawUrl = pkg.repository.url;
+    }
+    if (rawUrl) {
+      repository = rawUrl.replace(/\.git$/, '');
+    }
+  }
+
+  // license — verbatim, omit if absent.
+  const license =
+    typeof pkg.license === 'string' && pkg.license.length > 0
+      ? pkg.license
+      : undefined;
+
+  // keywords — opts override → CURATED_KEYWORDS default. Always materialize
+  // a fresh array (don't expose the frozen module-level constant directly
+  // in user-mutable output).
+  const keywords =
+    Array.isArray(opts2.keywords) && opts2.keywords.length > 0
+      ? opts2.keywords.slice()
+      : CURATED_KEYWORDS.slice();
+
+  // Assemble in documented order: name, description, version, author,
+  // homepage, repository, license, keywords. Omit undefined fields so
+  // JSON.stringify produces a clean diff.
+  const manifest = {};
+  manifest.name = name;
+  manifest.description = description;
+  manifest.version = version;
+  manifest.author = author;
+  if (homepage !== undefined) manifest.homepage = homepage;
+  if (repository !== undefined) manifest.repository = repository;
+  if (license !== undefined) manifest.license = license;
+  manifest.keywords = keywords;
+
+  return manifest;
+}
+
+/**
+ * Copy a directory tree recursively. Vanilla fs only — no deps.
+ * Returns the list of relative paths written (relative to `dest`).
+ */
+function copyDirRecursive(src, dest, relPrefix) {
+  const written = [];
+  const stack = [{ s: src, d: dest, rel: relPrefix || '' }];
+  while (stack.length > 0) {
+    const { s, d, rel } = stack.pop();
+    fs.mkdirSync(d, { recursive: true });
+    const entries = fs.readdirSync(s);
+    for (const entry of entries) {
+      const sp = path.join(s, entry);
+      const dp = path.join(d, entry);
+      const relPath = rel ? `${rel}/${entry}` : entry;
+      const stat = fs.statSync(sp);
+      if (stat.isDirectory()) {
+        stack.push({ s: sp, d: dp, rel: relPath });
+      } else if (stat.isFile()) {
+        fs.copyFileSync(sp, dp);
+        written.push(relPath);
+      }
+      // symlinks + other: ignored (skills tree is regular files only)
+    }
+  }
+  return written;
+}
+
+/**
+ * Convert/emit the cursor-marketplace bundle into a destination directory.
+ * Called by build-distribution-bundles.cjs (Plan 28-8-X1).
+ *
+ * Per CONTEXT D-06, `skills/` is the shared source — this converter emits
+ * the marketplace bundle as:
+ *
+ *   <outDir>/
+ *     .cursor-plugin/
+ *       plugin.json          ← the manifest object, JSON.stringified
+ *     skills/
+ *       <each skill copied verbatim from input.skillsDir>
+ *
+ * Cursor accepts Claude-compatible SKILL.md so no per-skill content
+ * transform is required at this layer. The Tier-1 cursor.cjs converter
+ * remains responsible for the per-runtime SKILL.md rewrites needed by the
+ * file-drop install path; those rewrites are irrelevant to a marketplace
+ * bundle (Cursor's marketplace reads the SKILL.md content directly).
+ *
+ * Idempotent: rerunning with the same inputs produces identical files
+ * (no partial-state corruption, no append-only emissions).
+ *
+ * Touches only paths under `outDir`. The source `skillsDir` is read-only.
+ *
+ * @param {Object} input
+ * @param {string} input.skillsDir                    Path to source skills/ tree.
+ * @param {string} input.outDir                       Path to destination bundle directory.
+ * @param {Object} input.manifest                     Manifest object from buildManifest().
+ * @param {Object} [opts]
+ * @returns {{ filesWritten: string[] }}              Sorted relative paths under outDir.
+ */
+function convert(input, opts) {
+  if (!input || typeof input !== 'object') {
+    throw new Error('cursor-marketplace.convert: input is required');
+  }
+  const { skillsDir, outDir, manifest } = input;
+  if (typeof skillsDir !== 'string' || skillsDir.length === 0) {
+    throw new Error('cursor-marketplace.convert: input.skillsDir is required');
+  }
+  if (typeof outDir !== 'string' || outDir.length === 0) {
+    throw new Error('cursor-marketplace.convert: input.outDir is required');
+  }
+  if (!manifest || typeof manifest !== 'object') {
+    throw new Error('cursor-marketplace.convert: input.manifest is required');
+  }
+
+  const skillsStat = fs.statSync(skillsDir);
+  if (!skillsStat.isDirectory()) {
+    throw new Error(
+      `cursor-marketplace.convert: skillsDir is not a directory: ${skillsDir}`
+    );
+  }
+
+  const written = [];
+
+  // Create outDir if absent.
+  fs.mkdirSync(outDir, { recursive: true });
+
+  // Write manifest at <outDir>/.cursor-plugin/plugin.json.
+  const manifestDir = path.join(outDir, '.cursor-plugin');
+  fs.mkdirSync(manifestDir, { recursive: true });
+  const manifestPath = path.join(manifestDir, 'plugin.json');
+  fs.writeFileSync(
+    manifestPath,
+    JSON.stringify(manifest, null, 2) + '\n',
+    'utf8'
+  );
+  written.push('.cursor-plugin/plugin.json');
+
+  // Copy skills/ tree verbatim under <outDir>/skills.
+  const skillsDest = path.join(outDir, 'skills');
+  const copied = copyDirRecursive(skillsDir, skillsDest, 'skills');
+  for (const rel of copied) {
+    written.push(rel);
+  }
+
+  written.sort();
+  return { filesWritten: written };
+}
+
+module.exports = { buildManifest, convert, CURATED_KEYWORDS };

package/scripts/lib/install/converters/cursor.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+/**
+ * scripts/lib/install/converters/cursor.cjs — Phase 28.7 (Plan 28.7-04).
+ *
+ * Cursor SKILL.md converter. Translates Claude-shape source into
+ * Cursor's expected shape:
+ *
+ *   - Frontmatter `name:` normalized to `gdd-<skill>` (no double-prefix).
+ *   - Slash references in prose pass through unchanged — Cursor consumes
+ *     the same `/gdd-<name>` shape Claude does (see runtime-slash.cjs).
+ *     Mixed-shape inputs (`gdd-x`, `/gdd:x`) are normalized to `/gdd-x`
+ *     so the installed skill is consistent.
+ *   - Tool names in code fences pass through unchanged — Cursor accepts
+ *     the Claude vocabulary (Read/Write/Bash/Edit/Grep/Glob).
+ *   - A 1-line HTML adapter header is injected at the top of the body
+ *     to record that this file was auto-generated from Claude source.
+ *
+ * Architecture ported from gsd-build/get-shit-done (MIT) — per Phase
+ * 28.7 D-02 (port architecture, not source). See NOTICE for upstream
+ * attribution. gsd-build's equivalent function is
+ * `convertClaudeCommandToCursorSkill` in bin/install.js; our modular
+ * factor delegates the actual rewrites to ./shared.cjs.
+ *
+ * Pure / side-effect-free: no fs, no env, no path. `convert` is a
+ * deterministic string → string transform.
+ */
+
+const shared = require('./shared.cjs');
+
+/**
+ * Convert Claude-source SKILL.md content for the Cursor runtime.
+ *
+ * @param {string} content        Full source SKILL.md content (frontmatter + body).
+ * @param {string} skillName      The bare skill name (e.g. `'help'`, `'explore'`).
+ * @param {{ runtime?: string }} [opts]  Optional context — `runtime` defaults
+ *   to `'cursor'`. Currently informational only; future per-tier branching
+ *   may consume it.
+ * @returns {string}
+ */
+function convert(content, skillName, opts) {
+  const { frontmatter, body } = shared.extractFrontmatterAndBody(content);
+  const fm = shared.buildFrontmatter(frontmatter, skillName, 'gdd-');
+  let out = shared.rewriteSlashRefs(body, 'cursor');
+  out = shared.ensureAdapterHeader(out, 'Cursor');
+  return fm + out;
+}
+
+module.exports = { convert };

package/scripts/lib/install/converters/gemini.cjs

@@ -0,0 +1,116 @@
+'use strict';
+
+/**
+ * scripts/lib/install/converters/gemini.cjs — Phase 28.7 (Plan 28.7-07).
+ *
+ * Gemini CLI command-file converter. Translates Claude-shape SKILL.md
+ * source into the command-format output Gemini expects under
+ * `<config>/commands/gdd/<name>.md` (see Phase 28.7 D-05 +
+ * `runtime-artifact-layout.cjs#gemini`, which stages this converter via
+ * `commandsKind('commands/gdd', 'gdd-', ...)`).
+ *
+ * Translation rules:
+ *
+ *   - Frontmatter `name:` normalized to `gdd-<skill>` (no double-prefix).
+ *   - Slash references in prose pass through as `/gdd-<name>` — Gemini
+ *     accepts the Claude-canonical slash shape via `runtime-slash.cjs`
+ *     (rt: 'gemini' → `/gdd-`). Legacy colon and shell-variable forms
+ *     are normalized to `/gdd-`.
+ *   - Tool names in code fences are rewritten per `GEMINI_TOOL_MAP`
+ *     (Phase 28.7 D-06 — reuse Phase 21 `reference/gemini-tools.md`
+ *     authoritative table). Source of truth for the map is the Phase 21
+ *     reference doc, NOT this file; the constant below is a frozen
+ *     snapshot of that table as of `Last verified: 2026-04-24`. If
+ *     Gemini ships a tool-vocabulary change, update
+ *     `reference/gemini-tools.md` FIRST and then re-sync the constant.
+ *     Currently mapped:
+ *       Read       → read_file
+ *       Write      → write_file
+ *       Edit       → replace
+ *       Bash       → run_shell_command
+ *       Grep       → search_file_content
+ *       Glob       → glob
+ *       WebSearch  → google_web_search
+ *       WebFetch   → web_fetch
+ *     `Task` is intentionally absent — per Phase 21 gemini-tools.md
+ *     "Known gaps", Gemini handles Task via a nested-CLI invocation, not
+ *     a tool call; skills that rely on Task fall back to documentation
+ *     prose ("on Gemini this becomes a nested gemini CLI run") that the
+ *     converter leaves untouched.
+ *   - Prose mentions of tool names (e.g. "use the Bash tool") are NOT
+ *     rewritten — only the parenthesized invocation form inside fenced
+ *     blocks gets rewritten. This matches the codex + augment converter
+ *     policies (Phase 28.7 D-06 invocation-only convention).
+ *   - A 1-line HTML adapter header is injected at the top of the body
+ *     to record that this file was auto-generated from Claude source.
+ *
+ * Wave 4 layout note: Gemini uses `commands/gdd/<name>.md` (nested
+ * `gdd/` subdirectory under `commands/`), distinct from OpenCode + Kilo
+ * which use the XDG singular `command/<name>.md` layout. Both shapes
+ * are command-format runtimes — they differ only in destSubpath, which
+ * is encoded in `runtime-artifact-layout.cjs#commandsKind`.
+ *
+ * Architecture ported from gsd-build/get-shit-done (MIT) — per Phase
+ * 28.7 D-02 (port architecture, not source). See NOTICE for upstream
+ * attribution. gsd-build's equivalent function is
+ * `convertClaudeCommandToGeminiCommand` in bin/install.js; our modular
+ * factor delegates the actual rewrites to ./shared.cjs and follows the
+ * same `tool-map + slash-rewrite + adapter-header` pattern as the codex
+ * (CODEX_TOOL_MAP) and augment (AUGMENT_TOOL_MAP) converters.
+ *
+ * Phase 21 reference cite (D-06): reference/gemini-tools.md is the
+ * canonical, version-pinned source for the tool-name mapping. Do not
+ * edit GEMINI_TOOL_MAP without first updating that file.
+ *
+ * Pure / side-effect-free: no fs, no env, no path. `convert` is a
+ * deterministic string → string transform.
+ */
+
+const shared = require('./shared.cjs');
+
+/**
+ * Claude tool name → Gemini tool name. Locked by Phase 21
+ * `reference/gemini-tools.md` (per Phase 28.7 D-06). Skills referenced
+ * as `Read(...)`, `Write(...)`, etc. in Claude-source code fences are
+ * rewritten to Gemini's vocabulary at install time.
+ *
+ * Note: `Task` is intentionally absent. Per Phase 21 gemini-tools.md
+ * "Known gaps", Gemini handles Task via nested-CLI invocation (not a
+ * tool call); the converter leaves `Task(...)` references untouched so
+ * fallback prose ("on Gemini this becomes a nested gemini CLI run")
+ * is still readable.
+ *
+ * Frozen to prevent accidental mutation. The same Object.freeze pattern
+ * is used by CODEX_TOOL_MAP (shared.cjs) and AUGMENT_TOOL_MAP
+ * (augment.cjs).
+ */
+const GEMINI_TOOL_MAP = Object.freeze({
+  Read: 'read_file',
+  Write: 'write_file',
+  Edit: 'replace',
+  Bash: 'run_shell_command',
+  Grep: 'search_file_content',
+  Glob: 'glob',
+  WebSearch: 'google_web_search',
+  WebFetch: 'web_fetch',
+});
+
+/**
+ * Convert Claude-source SKILL.md content for the Gemini runtime.
+ *
+ * @param {string} content        Full source SKILL.md content (frontmatter + body).
+ * @param {string} skillName      The bare skill name (e.g. `'help'`, `'explore'`).
+ * @param {{ runtime?: string }} [opts]  Optional context — `runtime` defaults
+ *   to `'gemini'`. Currently informational only.
+ * @returns {string}
+ */
+function convert(content, skillName, opts) {
+  const { frontmatter, body } = shared.extractFrontmatterAndBody(content);
+  const fm = shared.buildFrontmatter(frontmatter, skillName, 'gdd-');
+  let out = shared.rewriteSlashRefs(body, 'gemini');
+  out = shared.rewriteCodeFenceTools(out, GEMINI_TOOL_MAP);
+  out = shared.ensureAdapterHeader(out, 'Gemini');
+  return fm + out;
+}
+
+module.exports = { convert, GEMINI_TOOL_MAP };

package/scripts/lib/install/converters/kilo.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * scripts/lib/install/converters/kilo.cjs — Phase 28.7 (Plan 28.7-07).
+ *
+ * Kilo command-file converter. Translates Claude-shape SKILL.md source
+ * into the command-format output Kilo expects under its XDG
+ * `command/<name>.md` slash-command directory (see Phase 28.7 D-05 +
+ * `runtime-artifact-layout.cjs#kilo`, which stages this converter via
+ * `commandsKind('command', 'gdd-', ...)`).
+ *
+ * Translation rules:
+ *
+ *   - Frontmatter `name:` normalized to `gdd-<skill>` (no double-prefix).
+ *   - Slash references in prose pass through as `/gdd-<name>` — Kilo
+ *     accepts the Claude-canonical slash shape via the
+ *     `runtime-slash.cjs` map (rt: 'kilo' → `/gdd-`). Legacy colon and
+ *     shell-variable forms are normalized to `/gdd-`.
+ *   - Tool names in code fences pass through unchanged — per Phase 21
+ *     verification, Kilo accepts the Claude vocabulary
+ *     (Read/Write/Bash/Edit/Grep/Glob) natively. No tool-map rewrite.
+ *   - A 1-line HTML adapter header is injected at the top of the body
+ *     to record that this file was auto-generated from Claude source.
+ *
+ * Wave 4 layout note: Kilo uses the same `command/<name>.md` flat
+ * layout as OpenCode (its sibling Wave 4 runtime). The converter is
+ * structurally identical to opencode.cjs — only the runtime string
+ * and adapter-display label differ. Both runtimes share the XDG
+ * `command/` directory convention (singular `command`, not the
+ * Gemini-style `commands/gdd/` nested path).
+ *
+ * Architecture ported from gsd-build/get-shit-done (MIT) — per Phase
+ * 28.7 D-02 (port architecture, not source). See NOTICE for upstream
+ * attribution. gsd-build's equivalent function is
+ * `convertClaudeCommandToKiloCommand` in bin/install.js; our modular
+ * factor delegates the actual rewrites to ./shared.cjs and follows
+ * the same uniform pattern as opencode / cursor / qwen.
+ *
+ * Pure / side-effect-free: no fs, no env, no path. `convert` is a
+ * deterministic string → string transform.
+ */
+
+const shared = require('./shared.cjs');
+
+/**
+ * Convert Claude-source SKILL.md content for the Kilo runtime.
+ *
+ * @param {string} content        Full source SKILL.md content (frontmatter + body).
+ * @param {string} skillName      The bare skill name (e.g. `'help'`, `'explore'`).
+ * @param {{ runtime?: string }} [opts]  Optional context — `runtime` defaults
+ *   to `'kilo'`. Currently informational only.
+ * @returns {string}
+ */
+function convert(content, skillName, opts) {
+  const { frontmatter, body } = shared.extractFrontmatterAndBody(content);
+  const fm = shared.buildFrontmatter(frontmatter, skillName, 'gdd-');
+  let out = shared.rewriteSlashRefs(body, 'kilo');
+  out = shared.ensureAdapterHeader(out, 'Kilo');
+  return fm + out;
+}
+
+module.exports = { convert };

package/scripts/lib/install/converters/opencode.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+/**
+ * scripts/lib/install/converters/opencode.cjs — Phase 28.7 (Plan 28.7-07).
+ *
+ * OpenCode command-file converter. Translates Claude-shape SKILL.md
+ * source into the command-format output OpenCode expects under its
+ * XDG `command/<name>.md` slash-command directory (see Phase 28.7
+ * D-05 + `runtime-artifact-layout.cjs#opencode`, which stages this
+ * converter via `commandsKind('command', 'gdd-', ...)`).
+ *
+ * Translation rules:
+ *
+ *   - Frontmatter `name:` normalized to `gdd-<skill>` (no double-prefix).
+ *   - Slash references in prose pass through as `/gdd-<name>` —
+ *     OpenCode accepts the Claude-canonical slash shape via the
+ *     `runtime-slash.cjs` map (rt: 'opencode' → `/gdd-`). Legacy
+ *     colon and shell-variable forms are normalized to `/gdd-`.
+ *   - Tool names in code fences pass through unchanged — per Phase 21
+ *     verification, OpenCode accepts the Claude vocabulary
+ *     (Read/Write/Bash/Edit/Grep/Glob) natively. No tool-map rewrite.
+ *   - A 1-line HTML adapter header is injected at the top of the body
+ *     to record that this file was auto-generated from Claude source.
+ *
+ * Command-format vs skills-format note: OpenCode is one of three Wave 4
+ * runtimes (alongside kilo + gemini) whose layout is a flat
+ * `command/<name>.md` file rather than the per-skill folder structure
+ * (`skills/<name>/SKILL.md`) used by Wave 1/2/3 runtimes. The converter
+ * itself does NOT know its destination directory — the destSubpath is
+ * encoded in `runtime-artifact-layout.cjs#commandsKind`. From the
+ * converter's perspective, the output is still a single markdown +
+ * YAML-frontmatter string; the installer routes it to the right path.
+ *
+ * Architecture ported from gsd-build/get-shit-done (MIT) — per Phase
+ * 28.7 D-02 (port architecture, not source). See NOTICE for upstream
+ * attribution. gsd-build's equivalent function is
+ * `convertClaudeCommandToOpenCodeCommand` in bin/install.js; our
+ * modular factor delegates the actual rewrites to ./shared.cjs and
+ * follows the same uniform pattern as cursor / qwen / copilot.
+ *
+ * Pure / side-effect-free: no fs, no env, no path. `convert` is a
+ * deterministic string → string transform.
+ */
+
+const shared = require('./shared.cjs');
+
+/**
+ * Convert Claude-source SKILL.md content for the OpenCode runtime.
+ *
+ * @param {string} content        Full source SKILL.md content (frontmatter + body).
+ * @param {string} skillName      The bare skill name (e.g. `'help'`, `'explore'`).
+ * @param {{ runtime?: string }} [opts]  Optional context — `runtime` defaults
+ *   to `'opencode'`. Currently informational only.
+ * @returns {string}
+ */
+function convert(content, skillName, opts) {
+  const { frontmatter, body } = shared.extractFrontmatterAndBody(content);
+  const fm = shared.buildFrontmatter(frontmatter, skillName, 'gdd-');
+  let out = shared.rewriteSlashRefs(body, 'opencode');
+  out = shared.ensureAdapterHeader(out, 'OpenCode');
+  return fm + out;
+}
+
+module.exports = { convert };

package/scripts/lib/install/converters/qwen.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * scripts/lib/install/converters/qwen.cjs — Phase 28.7 (Plan 28.7-05).
+ *
+ * Qwen Code SKILL.md converter. Translates Claude-shape source into
+ * Qwen's expected shape:
+ *
+ *   - Frontmatter `name:` normalized to `gdd-<skill>` (no double-prefix).
+ *   - Slash references in prose pass through as `/gdd-<name>` —
+ *     Qwen accepts the Claude shape. Mixed-shape inputs are normalized
+ *     via the runtime-slash module.
+ *   - Tool names in code fences pass through unchanged — per Phase 21
+ *     verification, Qwen Code is Claude-compatible and accepts the
+ *     Claude vocabulary (Read/Write/Bash/Edit/Grep/Glob) natively.
+ *     gsd-build reuses `convertClaudeCommandToClaudeSkill` for Qwen on
+ *     the same grounds; our modular equivalent simply omits the tool-map
+ *     rewrite step (cf. cursor.cjs / windsurf.cjs / trae.cjs).
+ *   - A 1-line HTML adapter header is injected at the top of the body
+ *     to record that this file was auto-generated from Claude source.
+ *
+ * Architecture ported from gsd-build/get-shit-done (MIT) — per Phase
+ * 28.7 D-02 (port architecture, not source). See NOTICE for upstream
+ * attribution. gsd-build's qwen runtime reuses Claude-shape conversion
+ * (see runtime-artifact-layout.cjs case 'qwen'); our modular factor
+ * delegates the actual rewrites to ./shared.cjs.
+ *
+ * Pure / side-effect-free: no fs, no env, no path. `convert` is a
+ * deterministic string → string transform.
+ */
+
+const shared = require('./shared.cjs');
+
+/**
+ * Convert Claude-source SKILL.md content for the Qwen runtime.
+ *
+ * @param {string} content        Full source SKILL.md content (frontmatter + body).
+ * @param {string} skillName      The bare skill name (e.g. `'help'`, `'explore'`).
+ * @param {{ runtime?: string }} [opts]  Optional context — `runtime` defaults
+ *   to `'qwen'`. Currently informational only.
+ * @returns {string}
+ */
+function convert(content, skillName, opts) {
+  const { frontmatter, body } = shared.extractFrontmatterAndBody(content);
+  const fm = shared.buildFrontmatter(frontmatter, skillName, 'gdd-');
+  let out = shared.rewriteSlashRefs(body, 'qwen');
+  out = shared.ensureAdapterHeader(out, 'Qwen');
+  return fm + out;
+}
+
+module.exports = { convert };