@ner076/prd-toolkit 0.1.4

package/src/adapters/claude-code.js

@@ -0,0 +1,80 @@
+/**
+ * Claude Code adapter.
+ *
+ * Installs skills to:
+ *   - user scope:    ~/.claude/skills/<skill-name>/SKILL.md
+ *   - project scope: ./.claude/skills/<skill-name>/SKILL.md
+ *
+ * Claude Code expects a SKILL.md file with YAML frontmatter containing
+ * at minimum `name` and `description`. Our source SKILL.md files already
+ * conform, so this adapter mostly copies content and writes a manifest.
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getPackageVersion } from '../version.js';
+
+function resolveBasePath(scope) {
+  if (scope === 'user') return join(homedir(), '.claude', 'skills');
+  return join(process.cwd(), '.claude', 'skills');
+}
+
+function validateFrontmatter(content, skillName) {
+  // Normalize line endings: CRLF → LF (Windows git checkout may produce CRLF)
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    throw new Error(`Skill "${skillName}" is missing YAML frontmatter — required by Claude Code`);
+  }
+  const body = match[1];
+  if (!/^name:\s*\S+/m.test(body)) throw new Error(`Skill "${skillName}" frontmatter missing 'name'`);
+  if (!/^description:\s*\S+/m.test(body)) throw new Error(`Skill "${skillName}" frontmatter missing 'description'`);
+}
+
+export async function installClaudeCode({ skills, opts }) {
+  const basePath = resolveBasePath(opts.scope);
+  const manifest = {
+    tool: '@ner076/prd-toolkit',
+    version: await getPackageVersion(),
+    target: 'claude-code',
+    scope: opts.scope,
+    installedAt: new Date().toISOString(),
+    skills: []
+  };
+
+  if (!opts.dryRun) mkdirSync(basePath, { recursive: true });
+
+  for (const skill of skills) {
+    validateFrontmatter(skill.content, skill.name);
+    const targetDir = join(basePath, skill.name);
+    const targetFile = join(targetDir, 'SKILL.md');
+
+    if (!opts.dryRun) {
+      if (existsSync(targetFile) && !opts.force) {
+        const existing = readFileSync(targetFile, 'utf8');
+        if (existing === skill.content) {
+          manifest.skills.push({ name: skill.name, path: targetFile, status: 'unchanged' });
+          continue;
+        }
+        // Overwrite policy: for non-force, keep existing; log warning
+        console.warn(`     ! ${skill.name} exists at ${targetFile} — skipping (use --force to overwrite)`);
+        manifest.skills.push({ name: skill.name, path: targetFile, status: 'skipped' });
+        continue;
+      }
+      mkdirSync(targetDir, { recursive: true });
+      writeFileSync(targetFile, skill.content, 'utf8');
+    }
+    manifest.skills.push({ name: skill.name, path: targetFile, status: 'installed' });
+  }
+
+  if (!opts.dryRun) {
+    writeFileSync(
+      join(basePath, '.prd-toolkit.manifest.json'),
+      JSON.stringify(manifest, null, 2),
+      'utf8'
+    );
+  }
+
+  return { installPath: basePath, manifest };
+}

package/src/adapters/opencode.js

@@ -0,0 +1,93 @@
+/**
+ * Opencode adapter.
+ *
+ * Installs skills as custom commands to:
+ *   - user scope:    ~/.config/opencode/command/<name>.md
+ *   - project scope: ./.opencode/command/<name>.md
+ *
+ * Opencode custom commands use YAML frontmatter with a `description` field
+ * (and optionally `agent`, `model`). We transform our source SKILL.md by:
+ *   1. Extracting the source frontmatter
+ *   2. Emitting Opencode-flavored frontmatter
+ *   3. Preserving the entire body verbatim
+ *
+ * The result: user can invoke via `/prd-discovery` or `/prd-generator` inside Opencode.
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getPackageVersion } from '../version.js';
+
+function resolveBasePath(scope) {
+  if (scope === 'user') return join(homedir(), '.config', 'opencode', 'command');
+  return join(process.cwd(), '.opencode', 'command');
+}
+
+function parseSourceFrontmatter(content) {
+  // Normalize line endings: CRLF → LF (Windows git checkout may produce CRLF)
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) throw new Error('Source SKILL.md is missing frontmatter');
+  const meta = {};
+  match[1].split('\n').forEach((line) => {
+    const kv = line.match(/^(\w+):\s*(.+)$/);
+    if (kv) meta[kv[1]] = kv[2].trim();
+  });
+  return { meta, body: match[2] };
+}
+
+function toOpencodeFrontmatter(meta) {
+  // Opencode commands accept: description, agent, model, subtask
+  const lines = ['---'];
+  if (meta.description) lines.push(`description: ${meta.description}`);
+  lines.push(`agent: general`);       // reasonable default
+  lines.push(`subtask: true`);        // multi-turn workflows run best as subtask
+  lines.push('---');
+  return lines.join('\n');
+}
+
+export async function installOpencode({ skills, opts }) {
+  const basePath = resolveBasePath(opts.scope);
+  const manifest = {
+    tool: '@ner076/prd-toolkit',
+    version: await getPackageVersion(),
+    target: 'opencode',
+    scope: opts.scope,
+    installedAt: new Date().toISOString(),
+    skills: []
+  };
+
+  if (!opts.dryRun) mkdirSync(basePath, { recursive: true });
+
+  for (const skill of skills) {
+    const { meta, body } = parseSourceFrontmatter(skill.content);
+    const transformed = `${toOpencodeFrontmatter(meta)}\n\n${body}`;
+    const targetFile = join(basePath, `${skill.name}.md`);
+
+    if (!opts.dryRun) {
+      if (existsSync(targetFile) && !opts.force) {
+        const existing = readFileSync(targetFile, 'utf8');
+        if (existing === transformed) {
+          manifest.skills.push({ name: skill.name, path: targetFile, status: 'unchanged' });
+          continue;
+        }
+        console.warn(`     ! ${skill.name} exists at ${targetFile} — skipping (use --force to overwrite)`);
+        manifest.skills.push({ name: skill.name, path: targetFile, status: 'skipped' });
+        continue;
+      }
+      writeFileSync(targetFile, transformed, 'utf8');
+    }
+    manifest.skills.push({ name: skill.name, path: targetFile, status: 'installed' });
+  }
+
+  if (!opts.dryRun) {
+    writeFileSync(
+      join(basePath, '.prd-toolkit.manifest.json'),
+      JSON.stringify(manifest, null, 2),
+      'utf8'
+    );
+  }
+
+  return { installPath: basePath, manifest };
+}

package/src/detect.js

@@ -0,0 +1,86 @@
+/**
+ * Auto-detect which target environment (Claude Code / Opencode) is available.
+ *
+ * Detection signals (any = present):
+ *   Claude Code:
+ *     - ~/.claude/ exists
+ *     - `claude` executable in PATH
+ *     - CLAUDE_CONFIG env var set
+ *   Opencode:
+ *     - ~/.config/opencode/ exists
+ *     - `opencode` executable in PATH
+ *     - .opencode/ in CWD
+ */
+
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+function hasBinary(name) {
+  try {
+    execSync(process.platform === 'win32' ? `where ${name}` : `which ${name}`, {
+      stdio: 'ignore'
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function detectClaudeCode() {
+  const signals = {
+    homeDir: existsSync(join(homedir(), '.claude')),
+    binary: hasBinary('claude'),
+    envVar: !!process.env.CLAUDE_CONFIG
+  };
+  return {
+    detected: Object.values(signals).some(Boolean),
+    signals
+  };
+}
+
+export function detectOpencode() {
+  const signals = {
+    configDir: existsSync(join(homedir(), '.config', 'opencode')),
+    binary: hasBinary('opencode'),
+    projectDir: existsSync(join(process.cwd(), '.opencode'))
+  };
+  return {
+    detected: Object.values(signals).some(Boolean),
+    signals
+  };
+}
+
+export function detectAll() {
+  return {
+    'claude-code': detectClaudeCode(),
+    opencode: detectOpencode()
+  };
+}
+
+/**
+ * Resolve target arg into concrete list of adapters to run.
+ * - 'auto' → whichever is detected (both if both)
+ * - explicit target → just that one
+ * - 'all' → both regardless
+ */
+export function resolveTargets(targetArg) {
+  if (targetArg === 'all') return ['claude-code', 'opencode'];
+  if (targetArg === 'claude-code' || targetArg === 'opencode') return [targetArg];
+
+  // auto
+  const detected = detectAll();
+  const active = Object.entries(detected)
+    .filter(([, v]) => v.detected)
+    .map(([k]) => k);
+
+  if (active.length === 0) {
+    throw new Error(
+      'No supported environment detected.\n' +
+      'Install Claude Code (https://claude.ai/code) or Opencode (https://opencode.ai),\n' +
+      'or pass --target=claude-code|opencode|all explicitly.'
+    );
+  }
+  return active;
+}

package/src/doctor.js

@@ -0,0 +1,33 @@
+/**
+ * Doctor: diagnose environment + install health.
+ */
+
+import { detectAll } from './detect.js';
+import { getPackageVersion } from './version.js';
+
+export async function doctor() {
+  const version = await getPackageVersion();
+  const detected = detectAll();
+
+  console.log('\n🩺 @ner076/prd-toolkit — doctor\n');
+  console.log(`  Toolkit version: ${version}`);
+  console.log(`  Node version:    ${process.version}`);
+  console.log(`  Platform:        ${process.platform}\n`);
+
+  for (const [target, res] of Object.entries(detected)) {
+    const status = res.detected ? '✓ detected' : '✗ not detected';
+    console.log(`  ${target}: ${status}`);
+    for (const [sig, val] of Object.entries(res.signals)) {
+      console.log(`     - ${sig}: ${val}`);
+    }
+    console.log('');
+  }
+
+  const anyDetected = Object.values(detected).some((v) => v.detected);
+  if (!anyDetected) {
+    console.log('  ⚠ No target environment detected.');
+    console.log('    Install Claude Code (https://claude.ai/code) or Opencode (https://opencode.ai) first.\n');
+  } else {
+    console.log('  Ready to install. Run: npx @ner076/prd-toolkit install\n');
+  }
+}

package/src/help.js

@@ -0,0 +1,41 @@
+import { getPackageVersion } from './version.js';
+
+export function printHelp() {
+  console.log(`
+📦 @ner076/prd-toolkit — AI-powered PRD toolkit
+   Guided discovery + auto-dev ready PRD generation for Claude Code & Opencode
+
+Usage:
+  npx @ner076/prd-toolkit <command> [flags]
+
+Commands:
+  install       Install skills to target environment(s)
+  uninstall     Remove installed skills (tracked via manifest)
+  update        Re-install to pick up latest version (implies --force)
+  list          Show installed skills across all targets
+  doctor        Diagnose environment & install health
+  help          Show this help
+
+Flags:
+  --target=<t>  claude-code | opencode | all | auto (default: auto)
+  --scope=<s>   user | project (default: project)
+  -y, --yes     Skip confirmation prompts
+  -f, --force   Overwrite existing files
+  --dryRun      Show what would happen without writing files
+  -v, --version Print version
+  -h, --help    Print this help
+
+Examples:
+  npx @ner076/prd-toolkit install                          # auto-detect, project scope
+  npx @ner076/prd-toolkit install --target=all --scope=user
+  npx @ner076/prd-toolkit install --target=opencode -y
+  npx @ner076/prd-toolkit uninstall --target=claude-code
+  npx @ner076/prd-toolkit doctor
+
+Learn more: https://github.com/ner076/prd-toolkit
+`);
+}
+
+export async function printVersion() {
+  console.log(await getPackageVersion());
+}

package/src/index.js

@@ -0,0 +1,31 @@
+/**
+ * @ner076/prd-toolkit — programmatic API
+ *
+ * Use this when you want to script the toolkit instead of the CLI:
+ *
+ *   import { install, doctor, detectAll } from '@ner076/prd-toolkit';
+ *   await doctor();
+ *   await install({ target: 'claude-code', scope: 'project', yes: true });
+ */
+
+// ── Install / uninstall / list ─────────────────────────────────────
+
+export { install } from './install.js';
+export { uninstall } from './uninstall.js';
+export { list } from './list.js';
+
+// ── Doctor ─────────────────────────────────────────────────────────
+
+export { doctor } from './doctor.js';
+
+// ── Detection helpers ──────────────────────────────────────────────
+
+export { detectClaudeCode, detectOpencode, detectAll, resolveTargets } from './detect.js';
+
+// ── Display helpers ────────────────────────────────────────────────
+
+export { printHelp, printVersion } from './help.js';
+
+// ── Version ────────────────────────────────────────────────────────
+
+export { getPackageVersion } from './version.js';

package/src/install.js

@@ -0,0 +1,82 @@
+/**
+ * Install orchestrator.
+ * Resolves targets, calls appropriate adapters, writes manifests.
+ */
+
+import { readdirSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { resolveTargets } from './detect.js';
+import { installClaudeCode } from './adapters/claude-code.js';
+import { installOpencode } from './adapters/opencode.js';
+import { confirm } from '@inquirer/prompts';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SKILLS_ROOT = join(__dirname, '..', 'skills');
+
+const ADAPTERS = {
+  'claude-code': installClaudeCode,
+  'opencode': installOpencode
+};
+
+function loadSkills() {
+  const names = readdirSync(SKILLS_ROOT, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+
+  return names.map((name) => ({
+    name,
+    sourcePath: join(SKILLS_ROOT, name, 'SKILL.md'),
+    content: readFileSync(join(SKILLS_ROOT, name, 'SKILL.md'), 'utf8')
+  }));
+}
+
+export async function install(opts) {
+  const targets = resolveTargets(opts.target);
+  const skills = loadSkills();
+
+  console.log(`\n📦 @ner076/prd-toolkit — install`);
+  console.log(`   Targets: ${targets.join(', ')}`);
+  console.log(`   Scope:   ${opts.scope}`);
+  console.log(`   Skills:  ${skills.map((s) => s.name).join(', ')}\n`);
+
+  if (opts.dryRun) {
+    console.log('   (dry run — no files will be written)\n');
+  }
+
+  if (!opts.yes && !opts.dryRun) {
+    const ok = await confirm({
+      message: 'Proceed with install?',
+      default: true
+    });
+    if (!ok) {
+      console.log('Cancelled.');
+      return;
+    }
+  }
+
+  const results = [];
+  for (const target of targets) {
+    const adapter = ADAPTERS[target];
+    if (!adapter) {
+      console.warn(`  ⚠ No adapter for target: ${target}`);
+      continue;
+    }
+    try {
+      const result = await adapter({ skills, opts });
+      results.push({ target, ok: true, ...result });
+      console.log(`  ✓ ${target} → ${result.installPath}`);
+    } catch (err) {
+      results.push({ target, ok: false, error: err.message });
+      console.error(`  ✗ ${target} → ${err.message}`);
+    }
+  }
+
+  console.log('\nDone.\n');
+  const successCount = results.filter((r) => r.ok).length;
+  if (successCount === 0) throw new Error('All installs failed.');
+
+  console.log('Try it out:');
+  console.log('  • In Claude Code: run `claude` in your project, then ask "run prd-discovery"');
+  console.log('  • In Opencode:   run `opencode`, then use `/prd-discovery` command\n');
+}

package/src/list.js

@@ -0,0 +1,31 @@
+/**
+ * List installed skills across all known targets & scopes.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const LOCATIONS = [
+  { target: 'claude-code', scope: 'user',    path: join(homedir(), '.claude', 'skills') },
+  { target: 'claude-code', scope: 'project', path: join(process.cwd(), '.claude', 'skills') },
+  { target: 'opencode',    scope: 'user',    path: join(homedir(), '.config', 'opencode', 'command') },
+  { target: 'opencode',    scope: 'project', path: join(process.cwd(), '.opencode', 'command') }
+];
+
+export async function list() {
+  console.log('\n📦 @ner076/prd-toolkit — installed skills\n');
+  let found = 0;
+  for (const loc of LOCATIONS) {
+    const manifestPath = join(loc.path, '.prd-toolkit.manifest.json');
+    if (!existsSync(manifestPath)) continue;
+    const m = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    console.log(`  ${loc.target} · ${loc.scope} · v${m.version} · ${new Date(m.installedAt).toLocaleString()}`);
+    for (const s of m.skills) {
+      console.log(`     - ${s.name} (${s.status})`);
+    }
+    console.log('');
+    found++;
+  }
+  if (found === 0) console.log('  (nothing installed yet — run `install`)\n');
+}

package/src/uninstall.js

@@ -0,0 +1,55 @@
+/**
+ * Uninstall: read manifest per target, remove tracked files, keep everything else.
+ */
+
+import { existsSync, readFileSync, rmSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { confirm } from '@inquirer/prompts';
+import { resolveTargets } from './detect.js';
+
+const PATHS = {
+  'claude-code': (scope) =>
+    scope === 'user' ? join(homedir(), '.claude', 'skills') : join(process.cwd(), '.claude', 'skills'),
+  'opencode': (scope) =>
+    scope === 'user' ? join(homedir(), '.config', 'opencode', 'command') : join(process.cwd(), '.opencode', 'command')
+};
+
+export async function uninstall(opts) {
+  const targets = resolveTargets(opts.target);
+
+  console.log(`\n📦 @ner076/prd-toolkit — uninstall`);
+  console.log(`   Targets: ${targets.join(', ')}`);
+  console.log(`   Scope:   ${opts.scope}\n`);
+
+  if (!opts.yes) {
+    const ok = await confirm({ message: 'Proceed with uninstall?', default: false });
+    if (!ok) return console.log('Cancelled.');
+  }
+
+  for (const target of targets) {
+    const base = PATHS[target](opts.scope);
+    const manifestPath = join(base, '.prd-toolkit.manifest.json');
+
+    if (!existsSync(manifestPath)) {
+      console.warn(`  ⚠ ${target}: no manifest at ${base} — nothing to remove`);
+      continue;
+    }
+
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    for (const skill of manifest.skills) {
+      if (!existsSync(skill.path)) continue;
+      rmSync(skill.path, { force: true });
+
+      // Claude Code puts each skill in its own dir; clean up if empty
+      const parentDir = dirname(skill.path);
+      if (parentDir !== base && existsSync(parentDir) && readdirSync(parentDir).length === 0) {
+        rmSync(parentDir, { recursive: true, force: true });
+      }
+    }
+    rmSync(manifestPath, { force: true });
+    console.log(`  ✓ ${target} → removed ${manifest.skills.length} skill(s)`);
+  }
+
+  console.log('\nDone.\n');
+}

package/src/version.js

@@ -0,0 +1,13 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+let cached;
+export async function getPackageVersion() {
+  if (cached) return cached;
+  const pkg = JSON.parse(await readFile(join(__dirname, '..', 'package.json'), 'utf8'));
+  cached = pkg.version;
+  return cached;
+}