@orbweva/academy 0.2.0

package/src/cli.js

@@ -0,0 +1,207 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { banner } from './banner.js';
+import { confirm, select } from './prompts.js';
+import { detectOS } from './os.js';
+import { installSkills } from './install.js';
+import { runCliSetup } from './cli-tools.js';
+import { runMcpSetup } from './mcp.js';
+import { c } from './color.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const manifest = JSON.parse(readFileSync(join(__dirname, '..', 'manifest.json'), 'utf8'));
+
+function parseArgs(argv) {
+  const flags = { global: false, local: false, yes: false, skillsOnly: false, dryRun: false, noRun: false, track: null, packs: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--global' || a === '-g') flags.global = true;
+    else if (a === '--local' || a === '-l') flags.local = true;
+    else if (a === '--yes' || a === '-y') flags.yes = true;
+    else if (a === '--skills-only') flags.skillsOnly = true;
+    else if (a === '--no-run') flags.noRun = true;
+    else if (a === '--dry-run') flags.dryRun = true;
+    else if (a === '--help' || a === '-h') { printHelp(); process.exit(0); }
+    else if (a === '--track' || a === '-t') flags.track = argv[++i];
+    else if (a.startsWith('--track=')) flags.track = a.slice(8);
+    else if (a === '--pack' || a === '-p') flags.packs.push(argv[++i]);
+    else if (a.startsWith('--pack=')) flags.packs.push(a.slice(7));
+  }
+  return flags;
+}
+
+function printHelp() {
+  const tracks = Object.entries(manifest.tracks)
+    .map(([k, t]) => `    ${k.padEnd(14)} ${c.dim(t.tagline)}`).join('\n');
+  const packs = Object.entries(manifest.packs)
+    .map(([k, p]) => `    ${k.padEnd(14)} ${c.dim(p.tagline)}`).join('\n');
+
+  console.log(`
+${c.bold('orbweva-academy')} — install ORBWEVA skills into Claude Code
+
+Usage:
+  npx @orbweva/academy [options]
+
+Tracks  ${c.dim('(pick one base program)')}:
+${tracks}
+
+Specialization packs  ${c.dim('(stackable, pick zero or more)')}:
+${packs}
+
+Options:
+  -t, --track <name>   Pick a track (skip the menu)
+  -p, --pack <name>    Add a specialization pack (repeatable)
+  -g, --global         Install to ~/.claude/skills (all projects)
+  -l, --local          Install to ./.claude/skills (current project only)
+  -y, --yes            Accept all defaults and run all CLI/MCP commands — no prompts
+      --skills-only    Install skills only; skip CLI tools + MCP setup entirely
+      --no-run         Print CLI / MCP commands (don't run them), skills still install
+      --dry-run        Show plan, touch nothing
+  -h, --help           Show this help
+
+Examples:
+  npx @orbweva/academy --track accelerator --pack loka
+  npx @orbweva/academy --track founder
+  npx @orbweva/academy --track accelerator --pack marketing --pack web-video --yes
+`);
+}
+
+function resolveTrack(key) {
+  const t = manifest.tracks[key];
+  if (!t) throw new Error(`Unknown track "${key}". Options: ${Object.keys(manifest.tracks).join(', ')}`);
+  return t;
+}
+
+function resolvePack(key) {
+  const p = manifest.packs[key];
+  if (!p) throw new Error(`Unknown pack "${key}". Options: ${Object.keys(manifest.packs).join(', ')}`);
+  return p;
+}
+
+function repoEntry(repoKey) {
+  const r = manifest.skillRepos[repoKey];
+  if (!r) throw new Error(`Unknown skill repo key "${repoKey}" referenced in manifest`);
+  return { key: repoKey, ...r };
+}
+
+// Merge repos across track + packs, deduping by repoKey.
+// Returns { required: [...repos], optional: [{repo, source}], planned: [repos with status:planned] }
+function planInstall(track, packs) {
+  const requiredKeys = new Set(track.required);
+  for (const pack of packs) for (const k of pack.required) requiredKeys.add(k);
+
+  const optionalEntries = new Map(); // key → { sources: Set<label> }
+  for (const k of track.optional) {
+    if (!optionalEntries.has(k)) optionalEntries.set(k, new Set());
+    optionalEntries.get(k).add(track.label);
+  }
+  for (const pack of packs) {
+    for (const k of pack.optional) {
+      if (requiredKeys.has(k)) continue;
+      if (!optionalEntries.has(k)) optionalEntries.set(k, new Set());
+      optionalEntries.get(k).add(pack.label);
+    }
+  }
+
+  const required = [...requiredKeys].map(repoEntry);
+  const optional = [...optionalEntries.entries()].map(([k, sources]) => ({
+    ...repoEntry(k),
+    sources: [...sources],
+  }));
+  const planned = [...required, ...optional].filter(r => r.status === 'planned');
+
+  return { required, optional, planned };
+}
+
+export async function run(argv) {
+  const flags = parseArgs(argv);
+  const os = detectOS();
+
+  console.log(banner());
+  console.log(c.dim(`Detected platform: ${os.name} (${os.arch})\n`));
+
+  // Track
+  let trackKey = flags.track;
+  if (!trackKey) {
+    if (flags.yes) trackKey = 'accelerator';
+    else trackKey = await select('Which Academy track?', Object.entries(manifest.tracks).map(([k, t]) => ({
+      value: k, label: `${c.bold(t.label)} — ${c.dim(t.tagline)}`,
+    })));
+  }
+  const track = resolveTrack(trackKey);
+  console.log(`\n${c.green('→')} Track: ${c.bold(track.label)}`);
+
+  // Packs
+  let packKeys = [...flags.packs];
+  if (packKeys.length === 0 && !flags.yes && Object.keys(manifest.packs).length > 0) {
+    console.log(`\n${c.bold('Add specialization packs?')} ${c.dim('(optional, stackable)')}`);
+    for (const [k, p] of Object.entries(manifest.packs)) {
+      const add = await confirm(`  ${c.cyan(p.label)} ${c.dim(`— ${p.tagline}`)}?`, false);
+      if (add) packKeys.push(k);
+    }
+  }
+  const packs = packKeys.map(resolvePack);
+  if (packs.length > 0) console.log(`${c.green('→')} Packs: ${packs.map(p => c.bold(p.label)).join(', ')}`);
+
+  // Scope
+  let scope;
+  if (flags.global) scope = 'global';
+  else if (flags.local) scope = 'local';
+  else if (flags.yes) scope = 'global';
+  else scope = await select('Install scope', [
+    { value: 'global', label: `Global — ${c.dim('~/.claude/skills/ (recommended, all projects)')}` },
+    { value: 'local',  label: `Local  — ${c.dim('./.claude/skills/ (current project only)')}` },
+  ]);
+
+  // Plan
+  const plan = planInstall(track, packs);
+
+  // Warn about planned (not-yet-created) repos
+  if (plan.planned.length > 0) {
+    console.log(`\n${c.yellow('⚠')}  Some pack repos are planned but not yet published:`);
+    for (const r of plan.planned) console.log(`   ${c.dim('•')} ${r.repo} (${r.skills.join(', ')})`);
+    console.log(c.dim('   These will be skipped during install. They\'ll work once the repos are public.\n'));
+  }
+
+  // Approve optional
+  let approvedOptional = [];
+  if (!flags.yes && plan.optional.length > 0) {
+    console.log(`\n${c.bold('Required skills')} (always installed):`);
+    for (const r of plan.required) console.log(`  ${c.green('•')} ${r.skills.join(', ')} ${c.dim(`(${r.repo})`)}`);
+
+    console.log(`\n${c.bold('Optional')}:`);
+    for (const r of plan.optional) {
+      const src = c.dim(`[${r.sources.join(', ')}]`);
+      const include = await confirm(`  Install ${c.cyan(r.skills.join(', '))} ${src}?`, true);
+      if (include) approvedOptional.push(r);
+    }
+  } else {
+    approvedOptional = plan.optional;
+  }
+
+  const selectedRepos = [...plan.required, ...approvedOptional].filter(r => r.status !== 'planned');
+
+  // Confirm
+  const totalSkills = selectedRepos.reduce((n, r) => n + r.skills.length, 0);
+  console.log(`\n${c.bold('Ready to install:')} ${totalSkills} skills from ${selectedRepos.length} repos → ${scope === 'global' ? '~/.claude/skills/' : './.claude/skills/'}`);
+
+  if (!flags.yes && !flags.dryRun) {
+    const go = await confirm('Proceed?', true);
+    if (!go) { console.log('Aborted.'); return; }
+  }
+
+  await installSkills(selectedRepos, scope, { dryRun: flags.dryRun });
+
+  if (flags.skillsOnly || flags.dryRun) {
+    console.log(`\n${c.green('✓')} Skills ${flags.dryRun ? 'would be' : 'are'} installed. Open Claude Code to use them.`);
+    return;
+  }
+
+  // Interactive CLI + MCP setup (or print-only if --no-run)
+  const interactive = !flags.noRun;
+  await runCliSetup(os, { assumeYes: flags.yes, interactive });
+  await runMcpSetup(manifest.mcpServers, { assumeYes: flags.yes, interactive });
+
+  console.log(`\n${c.green('✓')} Setup complete. Open Claude Code and try ${c.cyan('/discovery:help')} to verify.\n`);
+}

package/src/color.js

@@ -0,0 +1,13 @@
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const wrap = (code, str) => (useColor ? `\x1b[${code}m${str}\x1b[0m` : String(str));
+
+export const c = {
+  bold:    (s) => wrap('1', s),
+  dim:     (s) => wrap('2', s),
+  red:     (s) => wrap('31', s),
+  green:   (s) => wrap('32', s),
+  yellow:  (s) => wrap('33', s),
+  blue:    (s) => wrap('34', s),
+  magenta: (s) => wrap('35', s),
+  cyan:    (s) => wrap('36', s),
+};

package/src/exec.js

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process';
+import { c } from './color.js';
+import { confirm } from './prompts.js';
+
+function runShell(cmd) {
+  return new Promise((resolve) => {
+    const p = spawn(cmd, { shell: true, stdio: 'inherit' });
+    p.on('close', (code) => resolve({ ok: code === 0, code }));
+    p.on('error', (err) => resolve({ ok: false, code: -1, error: err.message }));
+  });
+}
+
+export async function promptAndRun(steps, { assumeYes } = {}) {
+  let ran = 0, skipped = 0, failed = 0;
+  for (const step of steps) {
+    const { cmd, desc, note } = step;
+    console.log('');
+    if (desc) console.log(`  ${c.bold(desc)}`);
+    console.log(`  ${c.cyan('$')} ${cmd}`);
+    if (note) console.log(`  ${c.yellow(note)}`);
+    const go = assumeYes ? true : await confirm(`  Run now?`, true);
+    if (!go) { console.log(`  ${c.dim('skipped')}`); skipped++; continue; }
+    const { ok, code, error } = await runShell(cmd);
+    if (ok) { console.log(`  ${c.green('✓ ok')}`); ran++; }
+    else    { console.log(`  ${c.red(`✗ exit ${code}${error ? ' — ' + error : ''}`)}`); failed++; }
+  }
+  return { ran, skipped, failed };
+}
+
+export function summary({ ran, skipped, failed }) {
+  const parts = [];
+  if (ran)     parts.push(c.green(`${ran} ran`));
+  if (skipped) parts.push(c.dim(`${skipped} skipped`));
+  if (failed)  parts.push(c.red(`${failed} failed`));
+  return parts.join(', ') || c.dim('nothing to do');
+}

package/src/install.js

@@ -0,0 +1,74 @@
+import { mkdir, cp, rm, access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { spawn } from 'node:child_process';
+import { c } from './color.js';
+
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(cmd, args, { stdio: 'pipe', ...opts });
+    let stderr = '';
+    p.stderr.on('data', (d) => (stderr += d.toString()));
+    p.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} exited ${code}: ${stderr.trim()}`))));
+    p.on('error', reject);
+  });
+}
+
+async function exists(path) {
+  try { await access(path, constants.F_OK); return true; } catch { return false; }
+}
+
+export async function installSkills(repos, scope, { dryRun } = {}) {
+  const destRoot = scope === 'global'
+    ? join(homedir(), '.claude', 'skills')
+    : join(process.cwd(), '.claude', 'skills');
+
+  if (dryRun) {
+    console.log(`\n${c.yellow('DRY RUN')} — would install to ${destRoot}`);
+    for (const r of repos) {
+      for (const s of r.skills) console.log(`  ${c.dim('•')} ${s} ${c.dim(`(from ${r.repo})`)}`);
+    }
+    return;
+  }
+
+  await mkdir(destRoot, { recursive: true });
+
+  const tmpBase = join(tmpdir(), `orbweva-install-${Date.now()}`);
+  await mkdir(tmpBase, { recursive: true });
+
+  console.log('');
+  let i = 0;
+  for (const r of repos) {
+    i++;
+    const [owner, name] = r.repo.split('/');
+    const cloneDir = join(tmpBase, name);
+    const url = `https://github.com/${owner}/${name}.git`;
+    process.stdout.write(`${c.cyan(`[${i}/${repos.length}]`)} ${r.repo} ... `);
+
+    try {
+      await run('git', ['clone', '--depth', '1', '--quiet', url, cloneDir]);
+    } catch (err) {
+      console.log(c.red('clone failed'));
+      console.log(c.dim(`  ${err.message}`));
+      continue;
+    }
+
+    let copied = 0;
+    for (const skillName of r.skills) {
+      const src = join(cloneDir, 'skills', skillName);
+      const dst = join(destRoot, skillName);
+      if (!(await exists(src))) {
+        console.log(c.yellow(`skill "${skillName}" not found in repo, skipping`));
+        continue;
+      }
+      if (await exists(dst)) await rm(dst, { recursive: true, force: true });
+      await cp(src, dst, { recursive: true });
+      copied++;
+    }
+    console.log(c.green(`✓ ${copied} skill${copied === 1 ? '' : 's'}`));
+  }
+
+  await rm(tmpBase, { recursive: true, force: true });
+  console.log(`\n${c.green('✓')} Installed to ${c.bold(destRoot)}`);
+}

package/src/mcp.js

@@ -0,0 +1,28 @@
+import { c } from './color.js';
+import { promptAndRun, summary } from './exec.js';
+
+function stepsFromManifest(servers) {
+  return Object.entries(servers).map(([name, cfg]) => ({
+    cmd: `claude mcp add ${name} ${cfg.cmd}`,
+    desc: `Add MCP: ${name}`,
+    note: cfg.envKey ? `Needs ${cfg.envKey} in your shell env before Claude Code can actually connect.` : null,
+  }));
+}
+
+export async function runMcpSetup(servers, { assumeYes, interactive }) {
+  console.log(`\n${c.bold('─── MCP servers')}`);
+  const steps = stepsFromManifest(servers);
+
+  if (!interactive) {
+    for (const s of steps) {
+      console.log(`  ${c.cyan('$')} ${s.cmd}${s.note ? c.dim('  # ' + s.note) : ''}`);
+    }
+    console.log(c.dim(`\n  Docs: https://docs.claude.com/en/docs/claude-code/mcp`));
+    return null;
+  }
+
+  const result = await promptAndRun(steps, { assumeYes });
+  console.log(`\n  ${c.bold('MCP servers:')} ${summary(result)}`);
+  console.log(c.dim(`  Docs: https://docs.claude.com/en/docs/claude-code/mcp`));
+  return result;
+}

package/src/os.js

@@ -0,0 +1,7 @@
+import { platform, arch } from 'node:os';
+
+export function detectOS() {
+  const p = platform();
+  const name = p === 'darwin' ? 'macOS' : p === 'win32' ? 'Windows' : p === 'linux' ? 'Linux' : p;
+  return { platform: p, name, arch: arch() };
+}

package/src/prompts.js

@@ -0,0 +1,31 @@
+import readline from 'node:readline';
+import { c } from './color.js';
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => rl.question(question, (a) => { rl.close(); resolve(a.trim()); }));
+}
+
+export async function prompt(label, def = '') {
+  const hint = def ? c.dim(` (${def})`) : '';
+  const a = await ask(`${label}${hint}: `);
+  return a || def;
+}
+
+export async function confirm(label, def = true) {
+  const hint = def ? 'Y/n' : 'y/N';
+  const a = (await ask(`${label} ${c.dim(`[${hint}]`)} `)).toLowerCase();
+  if (!a) return def;
+  return a.startsWith('y');
+}
+
+export async function select(label, options) {
+  console.log(`\n${c.bold(label)}:`);
+  options.forEach((o, i) => console.log(`  ${c.cyan(`${i + 1})`)} ${o.label}`));
+  while (true) {
+    const a = await ask(c.dim(`  Choice [1-${options.length}, default 1]: `));
+    const n = a === '' ? 1 : parseInt(a, 10);
+    if (n >= 1 && n <= options.length) return options[n - 1].value;
+    console.log(c.red('  Invalid choice.'));
+  }
+}