@joehom/awm-cli 0.0.1

package/src/commands/mcp.js

@@ -0,0 +1,253 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import fs from 'node:fs';
+import path from 'node:path';
+import { log } from '../utils/logger.js';
+import { listMcps, getMcp, saveMcp, removeMcp } from '../registry/mcpRegistry.js';
+import { requireWorkspace, writeWorkspace } from '../workspace/workspaceConfig.js';
+import { applyAll } from '../workspace/applyWorkspace.js';
+import { resolvePath } from '../utils/pathResolver.js';
+import { readJson } from '../utils/fileUtils.js';
+
+// Tool config files to scan for 'mcp import'
+const SCAN_TARGETS = [
+  '.mcp.json',
+  '.cursor/mcp.json',
+  '.gemini/settings.json',
+  '.vscode/mcp.json',
+];
+
+const GLOBAL_SCAN_TARGETS = [
+  '~/.copilot/mcp-config.json',
+  '~/.codeium/windsurf/mcp_config.json',
+];
+
+/** Returns false if the user cancelled (ESC / Ctrl+C), rethrows other errors. */
+async function prompt(questions) {
+  try {
+    return await inquirer.prompt(questions);
+  } catch (err) {
+    if (err.name === 'ExitPromptError') {
+      log.info('Cancelled.');
+      return null;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Extract MCP entries from a parsed JSON config object.
+ * Tries common root keys: mcpServers, servers
+ */
+function extractMcpsFromJson(data) {
+  const block = data?.mcpServers ?? data?.servers ?? {};
+  const results = [];
+  for (const [id, def] of Object.entries(block)) {
+    if (!def.command) continue;
+    results.push({
+      id,
+      transport: 'stdio',
+      command: def.command,
+      ...(def.args ? { args: def.args } : {}),
+      ...(def.env ? { env: def.env } : {}),
+    });
+  }
+  return results;
+}
+
+export function makeMcpCommand() {
+  const mcp = new Command('mcp').description('Manage MCP server definitions');
+
+  // register — save to global registry
+  mcp
+    .command('register [id]')
+    .description('Interactively register an MCP server in the global registry')
+    .action(async (idArg) => {
+      const questions = [];
+      if (!idArg) {
+        questions.push({ type: 'input', name: 'id', message: 'MCP ID (unique slug):', validate: v => !!v || 'Required' });
+      }
+      questions.push(
+        { type: 'list', name: 'transport', message: 'Transport:', choices: ['stdio', 'sse', 'http'] },
+        { type: 'input', name: 'command', message: 'Command:', validate: v => !!v || 'Required' },
+        { type: 'input', name: 'args', message: 'Args (space-separated, optional):' },
+        { type: 'input', name: 'env', message: 'Env vars (KEY=VALUE pairs, space-separated, optional):' },
+      );
+      const answers = await inquirer.prompt(questions);
+      if (idArg) answers.id = idArg;
+
+      const mcpDef = {
+        id: answers.id,
+        transport: answers.transport,
+        command: answers.command,
+      };
+      if (answers.args?.trim()) {
+        mcpDef.args = answers.args.trim().split(/\s+/);
+      }
+      if (answers.env?.trim()) {
+        mcpDef.env = {};
+        for (const pair of answers.env.trim().split(/\s+/)) {
+          const idx = pair.indexOf('=');
+          if (idx > 0) mcpDef.env[pair.slice(0, idx)] = pair.slice(idx + 1);
+        }
+      }
+
+      saveMcp(mcpDef);
+      log.success(`MCP "${mcpDef.id}" registered in global registry`);
+    });
+
+  // unregister — remove from global registry
+  mcp
+    .command('unregister <id>')
+    .description('Remove an MCP from the global registry')
+    .action((id) => {
+      removeMcp(id);
+      log.success(`MCP "${id}" removed from registry`);
+    });
+
+  // import — scan current dir tool configs and register MCPs found
+  mcp
+    .command('import')
+    .description('Scan cwd tool config files and import MCPs into the global registry')
+    .action(() => {
+      const allTargets = [
+        ...SCAN_TARGETS.map(f => path.join(process.cwd(), f)),
+        ...GLOBAL_SCAN_TARGETS.map(f => resolvePath(f)),
+      ];
+
+      let imported = 0;
+      let skipped = 0;
+
+      for (const filePath of allTargets) {
+        if (!fs.existsSync(filePath)) continue;
+        const data = readJson(filePath);
+        if (!data) continue;
+
+        const entries = extractMcpsFromJson(data);
+        for (const entry of entries) {
+          if (getMcp(entry.id)) {
+            log.info(`  Skipping "${entry.id}" (already in registry)`);
+            skipped++;
+          } else {
+            try {
+              saveMcp(entry);
+              log.success(`  Registered "${entry.id}" from ${path.basename(filePath)}`);
+              imported++;
+            } catch (e) {
+              log.warn(`  Could not register "${entry.id}": ${e.message}`);
+            }
+          }
+        }
+      }
+
+      if (imported === 0 && skipped === 0) {
+        log.info('No MCP entries found in tool config files.');
+      } else {
+        log.info(`Import complete: ${imported} registered, ${skipped} skipped.`);
+      }
+    });
+
+  // add — select from registry, add to .awm.json, apply
+  mcp
+    .command('add')
+    .description('Add MCPs from the registry to this workspace and apply to all tools')
+    .option('--dry-run', 'Preview what would be written without making changes')
+    .action(async (opts) => {
+      const ws = requireWorkspace();
+      const allIds = listMcps();
+
+      if (allIds.length === 0) {
+        log.info('No MCPs in registry. Run "awm mcp register" to add one.');
+        return;
+      }
+
+      const available = allIds.filter(id => !ws.mcps.includes(id));
+      if (available.length === 0) {
+        log.info('All registry MCPs are already in this workspace.');
+        return;
+      }
+
+      const answer = await prompt([{
+        type: 'checkbox',
+        name: 'chosen',
+        message: 'Select MCPs to add to this workspace:',
+        choices: available,
+        validate: v => v.length > 0 || 'Select at least one MCP',
+      }]);
+      if (!answer) return;
+
+      const updated = { ...ws, mcps: [...ws.mcps, ...answer.chosen] };
+      writeWorkspace(updated);
+      await applyAll(updated, opts.dryRun);
+      if (!opts.dryRun) {
+        log.success(`Added MCPs: ${answer.chosen.join(', ')}`);
+      }
+    });
+
+  // delete — select from workspace list, remove from .awm.json, re-apply
+  mcp
+    .command('delete')
+    .description('Select MCPs to remove from this workspace and re-apply all tools')
+    .option('--dry-run', 'Preview what would be written without making changes')
+    .action(async (opts) => {
+      const ws = requireWorkspace();
+      if (!ws.mcps.length) {
+        log.info('No MCPs in this workspace to remove.');
+        return;
+      }
+
+      const answer = await prompt([{
+        type: 'checkbox',
+        name: 'chosen',
+        message: 'Select MCPs to remove from this workspace:',
+        choices: ws.mcps,
+        validate: v => v.length > 0 || 'Select at least one MCP',
+      }]);
+      if (!answer) return;
+
+      const updated = { ...ws, mcps: ws.mcps.filter(m => !answer.chosen.includes(m)) };
+      writeWorkspace(updated);
+      await applyAll(updated, opts.dryRun);
+      if (!opts.dryRun) {
+        log.success(`Removed MCPs: ${answer.chosen.join(', ')}`);
+      }
+    });
+
+  // list — project workspace or global registry
+  mcp
+    .command('list')
+    .description('List MCPs in this workspace; use -g to list the global registry')
+    .option('-g, --global', 'List all MCPs in the global registry instead')
+    .action((opts) => {
+      if (opts.global) {
+        const ids = listMcps();
+        log.info('Global registry MCPs:');
+        if (ids.length === 0) {
+          log.info('  (none)');
+        } else {
+          ids.forEach(id => log.info(`  ${id}`));
+        }
+        return;
+      }
+
+      const ws = requireWorkspace();
+      log.info('Workspace MCPs:');
+      if (ws.mcps?.length) {
+        ws.mcps.forEach(id => log.info(`  ${id}`));
+      } else {
+        log.info('  (none)');
+      }
+    });
+
+  // show — unchanged
+  mcp
+    .command('show <id>')
+    .description('Show details of a registered MCP')
+    .action((id) => {
+      const def = getMcp(id);
+      if (!def) throw new Error(`MCP "${id}" not found`);
+      log.info(JSON.stringify(def, null, 2));
+    });
+
+  return mcp;
+}

package/src/commands/pull.js

@@ -0,0 +1,168 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import TOML from '@iarna/toml';
+import { log } from '../utils/logger.js';
+import { resolvePath } from '../utils/pathResolver.js';
+import { readJson } from '../utils/fileUtils.js';
+import { listTools, loadTool } from '../registry/toolRegistry.js';
+import { getMcp, saveMcp } from '../registry/mcpRegistry.js';
+import { listSkills, addSkill } from '../registry/skillRegistry.js';
+
+/**
+ * Extract MCPs from a tool's global config file.
+ * @param {object} tool
+ * @returns {{id: string, transport: string, command: string, args?: string[], env?: object}[]}
+ */
+function extractMcpsFromTool(tool) {
+  if (!tool.mcp?.global) return [];
+
+  const resolvedPath = resolvePath(tool.mcp.global.targetFile);
+  if (!fs.existsSync(resolvedPath)) return [];
+
+  let data;
+  if (tool.mcp.format === 'toml') {
+    try {
+      const raw = fs.readFileSync(resolvedPath, 'utf8');
+      data = TOML.parse(raw);
+    } catch (e) {
+      log.warn(`Could not parse TOML at ${resolvedPath}: ${e.message}`);
+      return [];
+    }
+  } else {
+    data = readJson(resolvedPath);
+    if (!data) return [];
+  }
+
+  const entries = data[tool.mcp.global.rootObject] ?? {};
+  const results = [];
+
+  for (const [id, def] of Object.entries(entries)) {
+    if (!def.command) continue;
+    const entry = { id, transport: 'stdio', command: def.command };
+    if (def.args) entry.args = def.args;
+    if (def.env) entry.env = def.env;
+    results.push(entry);
+  }
+
+  return results;
+}
+
+/**
+ * Extract skills from a tool's global skills folder.
+ * @param {object} tool
+ * @returns {{name: string, srcPath: string}[]}
+ */
+function extractSkillsFromTool(tool) {
+  if (!tool.skills?.global) return [];
+
+  const folderPath = resolvePath(tool.skills.global.targetFolder);
+  if (!fs.existsSync(folderPath)) return [];
+
+  const entries = fs.readdirSync(folderPath, { withFileTypes: true });
+  const results = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillMd = path.join(folderPath, entry.name, 'SKILL.md');
+    if (!fs.existsSync(skillMd)) continue;
+    results.push({ name: entry.name, srcPath: path.join(folderPath, entry.name) });
+  }
+
+  return results;
+}
+
+export function makePullCommand() {
+  const cmd = new Command('pull');
+
+  cmd
+    .description('Pull skills and MCPs from global tool config files into the AWM registry')
+    .argument('[type]', 'What to pull: "skills" or "mcps" (default: both)')
+    .option('--tool <id>', 'Scope to a specific tool ID')
+    .option('--force', 'Overwrite existing registry entries')
+    .option('--dry-run', 'Show what would be imported without making changes')
+    .action(async (type, opts) => {
+      // Phase A — Resolve tool list
+      const toolIds = opts.tool ? [opts.tool] : listTools();
+
+      if (opts.tool) {
+        const check = loadTool(opts.tool);
+        if (!check) {
+          log.error(`Unknown tool: "${opts.tool}"`);
+          process.exit(1);
+        }
+      }
+
+      // Phase B — Determine what to pull
+      const pullMcps   = !type || type === 'mcps';
+      const pullSkills = !type || type === 'skills';
+
+      if (!pullMcps && !pullSkills) {
+        log.error(`Unknown type: "${type}". Use "skills" or "mcps".`);
+        process.exit(1);
+      }
+
+      let mcpPulled = 0, mcpSkipped = 0;
+      let skillPulled = 0, skillSkipped = 0;
+
+      // Phase C — Per-tool loop
+      for (const id of toolIds) {
+        const tool = loadTool(id);
+        if (!tool) continue;
+
+        if (pullMcps) {
+          for (const entry of extractMcpsFromTool(tool)) {
+            const exists = getMcp(entry.id) !== null;
+            if (exists && !opts.force) {
+              log.info(`  [mcp] Skipping "${entry.id}" (already registered)`);
+              mcpSkipped++;
+              continue;
+            }
+            if (opts.dryRun) {
+              log.dryRun(`Would register MCP "${entry.id}" from ${id}`);
+              continue;
+            }
+            try {
+              saveMcp(entry);
+              log.success(`  [mcp] Registered "${entry.id}" from ${id}`);
+              mcpPulled++;
+            } catch (e) {
+              log.warn(`  [mcp] Could not register "${entry.id}": ${e.message}`);
+            }
+          }
+        }
+
+        if (pullSkills) {
+          for (const entry of extractSkillsFromTool(tool)) {
+            const exists = listSkills().includes(entry.name);
+            if (exists && !opts.force) {
+              log.info(`  [skill] Skipping "${entry.name}" (already registered)`);
+              skillSkipped++;
+              continue;
+            }
+            if (opts.dryRun) {
+              log.dryRun(`Would register skill "${entry.name}" from ${id}`);
+              continue;
+            }
+            try {
+              await addSkill(entry.name, entry.srcPath);
+              log.success(`  [skill] Registered "${entry.name}" from ${id}`);
+              skillPulled++;
+            } catch (e) {
+              log.warn(`  [skill] Could not register "${entry.name}": ${e.message}`);
+            }
+          }
+        }
+      }
+
+      // Phase D — Summary
+      if (!opts.dryRun) {
+        const parts = [];
+        if (pullMcps)   parts.push(`MCPs: ${mcpPulled} pulled, ${mcpSkipped} skipped`);
+        if (pullSkills) parts.push(`Skills: ${skillPulled} pulled, ${skillSkipped} skipped`);
+        log.info(parts.join(' | '));
+      }
+    });
+
+  return cmd;
+}

package/src/commands/setup.js

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import { log } from '../utils/logger.js';
+import { runSeed } from '../seed.js';
+
+export function makeSetupCommand() {
+  return new Command('setup')
+    .description('Seed the registry with default MCPs and skills')
+    .option('--force', 'Overwrite existing defaults with fresh copies')
+    .action((opts) => {
+      const force = !!opts.force;
+      const results = runSeed(force);
+
+      if (results.tools.length > 0) {
+        log.success(`Seeded tools: ${results.tools.join(', ')}`);
+      }
+      if (results.mcps.length > 0) {
+        log.success(`Seeded MCPs: ${results.mcps.join(', ')}`);
+      }
+      if (results.skills.length > 0) {
+        log.success(`Seeded skills: ${results.skills.join(', ')}`);
+      }
+      if (results.skipped.length > 0) {
+        log.info(`Skipped (already present): ${results.skipped.join(', ')}`);
+        log.info('Use --force to overwrite existing defaults.');
+      }
+      const seeded = results.tools.length + results.mcps.length + results.skills.length;
+      if (seeded === 0 && results.skipped.length === 0) {
+        log.info('Nothing to seed.');
+      }
+    });
+}

package/src/commands/skill.js

@@ -0,0 +1,187 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import fs from 'node:fs';
+import path from 'node:path';
+import { log } from '../utils/logger.js';
+import { listSkills, addSkill, showSkill, removeSkill } from '../registry/skillRegistry.js';
+import { requireWorkspace, writeWorkspace } from '../workspace/workspaceConfig.js';
+import { applyAll } from '../workspace/applyWorkspace.js';
+
+/** Returns null if the user cancelled (ESC / Ctrl+C), rethrows other errors. */
+async function prompt(questions) {
+  try {
+    return await inquirer.prompt(questions);
+  } catch (err) {
+    if (err.name === 'ExitPromptError') {
+      log.info('Cancelled.');
+      return null;
+    }
+    throw err;
+  }
+}
+
+// Directories to scan for 'skill import'
+const SKILL_SCAN_DIRS = [
+  '.claude/skills',
+  '.agents/skills',
+];
+
+export function makeSkillCommand() {
+  const skill = new Command('skill').description('Manage skills');
+
+  // register — copy into global registry
+  skill
+    .command('register <name>')
+    .description('Register a skill from a directory or .md file into the global registry')
+    .requiredOption('--from <path>', 'Source directory or .md file')
+    .action(async (name, opts) => {
+      const src = path.resolve(opts.from);
+      await addSkill(name, src);
+      log.success(`Skill "${name}" registered in global registry`);
+    });
+
+  // unregister — remove from global registry
+  skill
+    .command('unregister <name>')
+    .description('Remove a skill from the global registry')
+    .action((name) => {
+      removeSkill(name);
+      log.success(`Skill "${name}" removed from registry`);
+    });
+
+  // import — scan cwd skill dirs and register found skills
+  skill
+    .command('import')
+    .description('Scan cwd skill directories and import skills into the global registry')
+    .action(async () => {
+      let imported = 0;
+      let skipped = 0;
+
+      for (const relDir of SKILL_SCAN_DIRS) {
+        const scanDir = path.join(process.cwd(), relDir);
+        if (!fs.existsSync(scanDir)) continue;
+
+        for (const entry of fs.readdirSync(scanDir)) {
+          const skillPath = path.join(scanDir, entry);
+          if (!fs.statSync(skillPath).isDirectory()) continue;
+          const skillMd = path.join(skillPath, 'SKILL.md');
+          if (!fs.existsSync(skillMd)) continue;
+
+          if (listSkills().includes(entry)) {
+            log.info(`  Skipping "${entry}" (already in registry)`);
+            skipped++;
+          } else {
+            await addSkill(entry, skillPath);
+            log.success(`  Registered "${entry}" from ${relDir}`);
+            imported++;
+          }
+        }
+      }
+
+      if (imported === 0 && skipped === 0) {
+        log.info('No skill directories found to import.');
+      } else {
+        log.info(`Import complete: ${imported} registered, ${skipped} skipped.`);
+      }
+    });
+
+  // add — select from registry, add to .awm.json, apply
+  skill
+    .command('add')
+    .description('Add skills from the registry to this workspace and apply to all tools')
+    .option('--dry-run', 'Preview what would be written without making changes')
+    .action(async (opts) => {
+      const ws = requireWorkspace();
+      const allNames = listSkills();
+
+      if (allNames.length === 0) {
+        log.info('No skills in registry. Run "awm skill register --from <path>" to add one.');
+        return;
+      }
+
+      const available = allNames.filter(n => !ws.skills.includes(n));
+      if (available.length === 0) {
+        log.info('All registry skills are already in this workspace.');
+        return;
+      }
+
+      const answer = await prompt([{
+        type: 'checkbox',
+        name: 'chosen',
+        message: 'Select skills to add to this workspace:',
+        choices: available,
+        validate: v => v.length > 0 || 'Select at least one skill',
+      }]);
+      if (!answer) return;
+
+      const updated = { ...ws, skills: [...ws.skills, ...answer.chosen] };
+      writeWorkspace(updated);
+      await applyAll(updated, opts.dryRun);
+      if (!opts.dryRun) {
+        log.success(`Added skills: ${answer.chosen.join(', ')}`);
+      }
+    });
+
+  // delete — select from workspace list, remove from .awm.json (no file deletion)
+  skill
+    .command('delete')
+    .description('Select skills to remove from this workspace (does not delete files from tool dirs)')
+    .action(async () => {
+      const ws = requireWorkspace();
+      if (!ws.skills.length) {
+        log.info('No skills in this workspace to remove.');
+        return;
+      }
+
+      const answer = await prompt([{
+        type: 'checkbox',
+        name: 'chosen',
+        message: 'Select skills to remove from this workspace:',
+        choices: ws.skills,
+        validate: v => v.length > 0 || 'Select at least one skill',
+      }]);
+      if (!answer) return;
+
+      const updated = { ...ws, skills: ws.skills.filter(s => !answer.chosen.includes(s)) };
+      writeWorkspace(updated);
+      log.success(`Removed skills: ${answer.chosen.join(', ')}`);
+    });
+
+  // list — project workspace or global registry
+  skill
+    .command('list')
+    .description('List skills in this workspace; use -g to list the global registry')
+    .option('-g, --global', 'List all skills in the global registry instead')
+    .action((opts) => {
+      if (opts.global) {
+        const names = listSkills();
+        log.info('Global registry skills:');
+        if (names.length === 0) {
+          log.info('  (none)');
+        } else {
+          names.forEach(n => log.info(`  ${n}`));
+        }
+        return;
+      }
+
+      const ws = requireWorkspace();
+      log.info('Workspace skills:');
+      if (ws.skills?.length) {
+        ws.skills.forEach(n => log.info(`  ${n}`));
+      } else {
+        log.info('  (none)');
+      }
+    });
+
+  // show — unchanged
+  skill
+    .command('show <name>')
+    .description('Show SKILL.md for a registered skill')
+    .action((name) => {
+      const content = showSkill(name);
+      if (content === null) throw new Error(`Skill "${name}" not found or missing SKILL.md`);
+      log.info(content);
+    });
+
+  return skill;
+}

package/src/commands/status.js

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { log } from '../utils/logger.js';
+import { requireWorkspace } from '../workspace/workspaceConfig.js';
+
+export function makeStatusCommand() {
+  return new Command('status')
+    .description('Show current workspace state (.awm.json)')
+    .action(() => {
+      const ws = requireWorkspace();
+
+      log.info('Workspace status:');
+      log.info(`  Tools:    ${ws.tools?.length ? ws.tools.join(', ') : '(none)'}`);
+      log.info(`  MCPs:     ${ws.mcps?.length ? ws.mcps.join(', ') : '(none)'}`);
+      log.info(`  Skills:   ${ws.skills?.length ? ws.skills.join(', ') : '(none)'}`);
+      log.info(`  lastSync: ${ws.lastSync ?? '(never)'}`);
+    });
+}