bmad-module-skill-forge 0.2.0

package/tools/cli/commands/status.js

@@ -0,0 +1,195 @@
+/**
+ * SKF Status Command
+ * Shows installation state, version, tier, configured IDEs, and sidecar status.
+ */
+
+const chalk = require('chalk');
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const { readManifest } = require('../lib/manifest');
+
+const SKF_FOLDER = '_bmad/skf';
+const SIDECAR_FOLDER = '_bmad/_memory/forger-sidecar';
+
+const IDE_NAMES = {
+  'claude-code': 'Claude Code',
+  cline: 'Cline',
+  codex: 'Codex',
+  cursor: 'Cursor',
+  'github-copilot': 'GitHub Copilot',
+  roo: 'Roo Code',
+  windsurf: 'Windsurf',
+  other: 'Other',
+};
+
+async function readYaml(filePath) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    return yaml.load(content) || {};
+  } catch {
+    return null;
+  }
+}
+
+async function getStatus(projectDir) {
+  const skfDir = path.join(projectDir, SKF_FOLDER);
+  const sidecarDir = path.join(projectDir, SIDECAR_FOLDER);
+
+  const installed = await fs.pathExists(skfDir);
+  if (!installed) {
+    return { installed: false };
+  }
+
+  // Read config
+  const config = await readYaml(path.join(skfDir, 'config.yaml'));
+
+  // Read forge tier
+  const forgeTier = await readYaml(path.join(sidecarDir, 'forge-tier.yaml'));
+
+  // Read preferences
+  const preferences = await readYaml(path.join(sidecarDir, 'preferences.yaml'));
+
+  // Check agent file
+  const agentFile = path.join(skfDir, 'agents', 'forger.md');
+  const agentCompiled = await fs.pathExists(agentFile);
+
+  // Count workflows
+  const workflowsDir = path.join(skfDir, 'workflows', 'skillforge');
+  let workflowCount = 0;
+  if (await fs.pathExists(workflowsDir)) {
+    const entries = await fs.readdir(workflowsDir);
+    for (const entry of entries) {
+      const wfPath = path.join(workflowsDir, entry, 'workflow.md');
+      if (await fs.pathExists(wfPath)) {
+        workflowCount++;
+      }
+    }
+  }
+
+  // Check output folders
+  const skillsFolder = config?.skills_output_folder || 'skills';
+  const forgeDataFolder = config?.forge_data_folder || 'forge-data';
+  const skillsFolderExists = await fs.pathExists(path.join(projectDir, skillsFolder));
+  const forgeDataFolderExists = await fs.pathExists(path.join(projectDir, forgeDataFolder));
+
+  // Check sidecar state
+  const sidecarExists = await fs.pathExists(sidecarDir);
+  const tierDetected = forgeTier?.tier != null;
+
+  // Read manifest
+  const manifest = await readManifest(projectDir);
+
+  return {
+    installed: true,
+    config,
+    forgeTier,
+    preferences,
+    agentCompiled,
+    workflowCount,
+    skillsFolder,
+    skillsFolderExists,
+    forgeDataFolder,
+    forgeDataFolderExists,
+    sidecarExists,
+    tierDetected,
+    manifest,
+  };
+}
+
+function displayStatus(status, version) {
+  console.log('');
+  console.log(chalk.cyan.bold('  Skill Forge — Status'));
+  console.log(chalk.dim(`  v${version}`));
+  console.log('');
+
+  if (!status.installed) {
+    console.log(chalk.yellow('  Not installed.'));
+    console.log(chalk.dim('  Run: npx skill-forge install'));
+    console.log('');
+    return;
+  }
+
+  const config = status.config || {};
+
+  // Installation
+  const manifest = status.manifest;
+  console.log(chalk.white.bold('  Installation'));
+  console.log(`    Project:      ${chalk.cyan(config.project_name || '(unknown)')}`);
+  console.log(`    SKF folder:   ${chalk.dim(SKF_FOLDER + '/')}`);
+  console.log(`    Agent:        ${status.agentCompiled ? chalk.green('compiled') : chalk.yellow('not compiled')}`);
+  console.log(`    Workflows:    ${chalk.white(status.workflowCount)}`);
+  if (manifest) {
+    console.log(
+      `    Installed:    ${chalk.dim(manifest.installed_at ? new Date(manifest.installed_at).toLocaleDateString() : '(unknown)')}`,
+    );
+    console.log(`    Manifest:     ${chalk.green('present')}`);
+  } else {
+    console.log(`    Manifest:     ${chalk.yellow('missing')} ${chalk.dim('(reinstall to generate)')}`);
+  }
+  console.log('');
+
+  // IDEs
+  const ides = config.ides || [];
+  console.log(chalk.white.bold('  IDEs'));
+  if (ides.length > 0) {
+    for (const ide of ides) {
+      console.log(`    ${chalk.green('●')} ${IDE_NAMES[ide] || ide}`);
+    }
+  } else {
+    console.log(chalk.dim('    None configured'));
+  }
+  console.log('');
+
+  // Forge Tier
+  const ft = status.forgeTier || {};
+  const tools = ft.tools || {};
+  console.log(chalk.white.bold('  Forge Tier'));
+  if (status.tierDetected) {
+    const tierColors = { Quick: chalk.yellow, Forge: chalk.cyan, Deep: chalk.magenta };
+    const tierColor = tierColors[ft.tier] || chalk.white;
+    console.log(`    Tier:         ${tierColor(ft.tier)}`);
+    console.log(`    Detected:     ${chalk.dim(ft.tier_detected_at || '(unknown)')}`);
+  } else {
+    console.log(chalk.dim('    Not detected yet — run @Ferris SF'));
+  }
+  console.log(`    ast-grep:     ${formatTool(tools.ast_grep)}`);
+  console.log(`    gh CLI:       ${formatTool(tools.gh_cli)}`);
+  console.log(`    QMD:          ${formatTool(tools.qmd)}`);
+  console.log('');
+
+  // Output Folders
+  console.log(chalk.white.bold('  Output Folders'));
+  console.log(`    Skills:       ${status.skillsFolder}/ ${status.skillsFolderExists ? chalk.green('✓') : chalk.yellow('missing')}`);
+  console.log(`    Forge data:   ${status.forgeDataFolder}/ ${status.forgeDataFolderExists ? chalk.green('✓') : chalk.yellow('missing')}`);
+  console.log('');
+
+  // Sidecar
+  console.log(chalk.white.bold('  Sidecar'));
+  console.log(`    State:        ${status.sidecarExists ? chalk.green('initialized') : chalk.yellow('missing')}`);
+  console.log(`    Location:     ${chalk.dim(SIDECAR_FOLDER + '/')}`);
+  console.log('');
+}
+
+function formatTool(value) {
+  if (value === true || value === 'available') return chalk.green('available');
+  if (value == null) return chalk.dim('not detected');
+  return chalk.yellow(String(value));
+}
+
+module.exports = {
+  command: 'status',
+  description: 'Show SKF installation state, version, tier, and configuration',
+  options: [],
+  action: async () => {
+    try {
+      const projectDir = process.cwd();
+      const packageJson = require('../../../package.json');
+      const status = await getStatus(projectDir);
+      displayStatus(status, packageJson.version);
+    } catch (error) {
+      console.error(chalk.red('\nFailed to read status:'), error.message);
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/uninstall.js

@@ -0,0 +1,226 @@
+/**
+ * SKF Uninstall Command
+ * Clean removal of SKF files, IDE commands, sidecar, and output folders.
+ * Uses the manifest to know exactly what to remove.
+ */
+
+const chalk = require('chalk');
+const path = require('node:path');
+const fs = require('fs-extra');
+const { confirm, isCancel, spinner, log, outro } = require('@clack/prompts');
+const { readManifest, MANIFEST_DIR, MANIFEST_FILE } = require('../lib/manifest');
+
+/**
+ * Count files that still exist on disk from manifest lists.
+ */
+async function countExistingFiles(projectDir, manifest) {
+  const allFiles = [
+    ...(manifest.files.skf || []),
+    ...(manifest.files.sidecar || []),
+    ...(manifest.files.ide_commands || []),
+    ...(manifest.files.learning || []),
+    ...(manifest.files.output || []),
+  ];
+
+  let existing = 0;
+  for (const file of allFiles) {
+    if (await fs.pathExists(path.join(projectDir, file))) {
+      existing++;
+    }
+  }
+  return { total: allFiles.length, existing };
+}
+
+/**
+ * Display what will be removed, grouped by category.
+ */
+async function displayRemovalPlan(projectDir, manifest) {
+  const categories = [
+    { key: 'skf', label: 'SKF module files', dir: manifest.skf_folder },
+    { key: 'sidecar', label: 'Agent sidecar state', dir: '_bmad/_memory/forger-sidecar' },
+    { key: 'ide_commands', label: 'IDE command files' },
+    { key: 'learning', label: 'Learning material', dir: '_skf-learn' },
+    { key: 'output', label: 'Output folder scaffolding' },
+  ];
+
+  const lines = [];
+  for (const cat of categories) {
+    const files = manifest.files[cat.key] || [];
+    if (files.length === 0) continue;
+
+    // Count how many still exist
+    let existCount = 0;
+    for (const f of files) {
+      if (await fs.pathExists(path.join(projectDir, f))) existCount++;
+    }
+
+    if (existCount === 0) continue;
+
+    if (cat.dir) {
+      lines.push(`${chalk.red('×')} ${cat.label} ${chalk.dim(`(${cat.dir}/ — ${existCount} files)`)}`);
+    } else {
+      lines.push(`${chalk.red('×')} ${cat.label} ${chalk.dim(`(${existCount} files)`)}`);
+    }
+  }
+
+  // Manifest itself
+  lines.push(`${chalk.red('×')} Installation manifest ${chalk.dim(`(${MANIFEST_DIR}/${MANIFEST_FILE})`)}`);
+
+  log.warn(`The following will be removed:\n${lines.join('\n')}`);
+}
+
+/**
+ * Remove files listed in the manifest, then clean empty parent directories.
+ */
+async function removeFiles(projectDir, fileList) {
+  let removed = 0;
+  for (const file of fileList) {
+    const fullPath = path.join(projectDir, file);
+    if (await fs.pathExists(fullPath)) {
+      await fs.remove(fullPath);
+      removed++;
+    }
+  }
+  return removed;
+}
+
+/**
+ * Remove a directory if it exists and is empty (or force remove).
+ */
+async function removeEmptyDir(dirPath) {
+  if (!(await fs.pathExists(dirPath))) return;
+  try {
+    const entries = await fs.readdir(dirPath);
+    if (entries.length === 0) {
+      await fs.remove(dirPath);
+    }
+  } catch {
+    // ignore
+  }
+}
+
+module.exports = {
+  command: 'uninstall',
+  description: 'Remove SKF installation from the current project',
+  options: [],
+  action: async () => {
+    try {
+      const projectDir = process.cwd();
+      const manifest = await readManifest(projectDir);
+
+      if (!manifest) {
+        // Check if SKF exists without manifest
+        const skfExists = await fs.pathExists(path.join(projectDir, '_bmad/skf'));
+        if (skfExists) {
+          log.warn(
+            'No manifest found. Reinstall first to generate one,\nthen run uninstall again for clean removal.\nRun: npx skill-forge install',
+          );
+        } else {
+          log.warn('SKF is not installed in this directory.');
+        }
+        process.exit(0);
+        return;
+      }
+
+      const { existing } = await countExistingFiles(projectDir, manifest);
+      if (existing === 0) {
+        log.warn('No SKF files found to remove.');
+        // Clean up stale manifest
+        await fs.remove(path.join(projectDir, MANIFEST_DIR, MANIFEST_FILE));
+        process.exit(0);
+        return;
+      }
+
+      await displayRemovalPlan(projectDir, manifest);
+
+      const shouldProceed = await confirm({
+        message: 'Proceed with uninstall?',
+        initialValue: false,
+      });
+
+      if (isCancel(shouldProceed) || !shouldProceed) {
+        log.warn('Uninstall cancelled.');
+        process.exit(0);
+        return;
+      }
+
+      const s = spinner();
+
+      // Remove IDE commands first (scattered across project)
+      const ideFiles = manifest.files.ide_commands || [];
+      if (ideFiles.length > 0) {
+        s.start('Removing IDE commands...');
+        const ideRemoved = await removeFiles(projectDir, ideFiles);
+        // Clean empty IDE directories
+        const cleanedDirs = new Set();
+        for (const f of ideFiles) {
+          const dir = path.dirname(f);
+          if (!cleanedDirs.has(dir)) {
+            cleanedDirs.add(dir);
+            await removeEmptyDir(path.join(projectDir, dir));
+            await removeEmptyDir(path.join(projectDir, path.dirname(dir)));
+          }
+        }
+        s.stop(`Removed ${ideRemoved} IDE command files`);
+      }
+
+      // Remove learning material directory
+      const learnFiles = manifest.files.learning || [];
+      if (learnFiles.length > 0) {
+        s.start('Removing learning material...');
+        const learnDir = path.join(projectDir, '_skf-learn');
+        if (await fs.pathExists(learnDir)) {
+          await fs.remove(learnDir);
+        }
+        s.stop('Learning material removed');
+      }
+
+      // Remove output folder scaffolding (.gitkeep only)
+      const outputFiles = manifest.files.output || [];
+      if (outputFiles.length > 0) {
+        s.start('Removing output scaffolding...');
+        await removeFiles(projectDir, outputFiles);
+        // Remove empty output folders
+        for (const folder of [manifest.skills_output_folder, manifest.forge_data_folder]) {
+          if (folder) {
+            await removeEmptyDir(path.join(projectDir, folder));
+          }
+        }
+        s.stop('Output scaffolding removed');
+      }
+
+      // Remove sidecar
+      s.start('Removing agent sidecar...');
+      const sidecarDir = path.join(projectDir, '_bmad', '_memory', 'forger-sidecar');
+      if (await fs.pathExists(sidecarDir)) {
+        await fs.remove(sidecarDir);
+      }
+      await removeEmptyDir(path.join(projectDir, '_bmad', '_memory'));
+      s.stop('Agent sidecar removed');
+
+      // Remove SKF module directory
+      s.start('Removing SKF module...');
+      const skfDir = path.join(projectDir, manifest.skf_folder);
+      if (await fs.pathExists(skfDir)) {
+        await fs.remove(skfDir);
+      }
+      s.stop('SKF module removed');
+
+      // Remove manifest
+      const manifestPath = path.join(projectDir, MANIFEST_DIR, MANIFEST_FILE);
+      if (await fs.pathExists(manifestPath)) {
+        await fs.remove(manifestPath);
+      }
+      // Clean empty _bmad/_config/ and _bmad/ if we were the only occupant
+      await removeEmptyDir(path.join(projectDir, MANIFEST_DIR));
+      await removeEmptyDir(path.join(projectDir, '_bmad'));
+
+      outro('SKF uninstalled successfully.');
+
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('\nUninstall failed:'), error.message);
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/update.js

@@ -0,0 +1,63 @@
+/**
+ * SKF Quick Update Command
+ * Replaces SKF files and recompiles agents without re-prompting.
+ * Preserves config.yaml and sidecar state.
+ */
+
+const chalk = require('chalk');
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const { Installer } = require('../lib/installer');
+const { UI } = require('../lib/ui');
+
+const SKF_FOLDER = '_bmad/skf';
+
+module.exports = {
+  command: 'update',
+  description: 'Update SKF files and recompile agents (preserves config and sidecar)',
+  options: [],
+  action: async () => {
+    try {
+      const projectDir = process.cwd();
+      const skfDir = path.join(projectDir, SKF_FOLDER);
+
+      if (!(await fs.pathExists(skfDir))) {
+        console.log(chalk.yellow('\n  SKF is not installed in this directory.'));
+        console.log(chalk.dim('  Run: npx skill-forge install\n'));
+        process.exit(0);
+        return;
+      }
+
+      console.log('');
+      console.log(chalk.cyan.bold('  Skill Forge — Quick Update'));
+      console.log(chalk.dim('  Replacing SKF files, preserving config and sidecar.\n'));
+
+      const installer = new Installer();
+      const result = await installer.install({
+        projectDir,
+        skfFolder: SKF_FOLDER,
+        _action: 'update',
+      });
+
+      if (result && result.success) {
+        // Read config to get IDEs for post-update notes
+        let ides = [];
+        try {
+          const configContent = await fs.readFile(path.join(skfDir, 'config.yaml'), 'utf8');
+          const config = yaml.load(configContent);
+          ides = config?.ides || [];
+        } catch {
+          /* use empty */
+        }
+        const ui = new UI();
+        ui.displaySuccess(SKF_FOLDER, ides, 'update');
+      }
+
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('\nUpdate failed:'), error.message);
+      process.exit(1);
+    }
+  },
+};