bi-superpowers 1.0.0

package/bin/commands/diff.js

@@ -0,0 +1,435 @@
+/**
+ * Diff Command (scan)
+ * ===================
+ * Shows differences between source skills and generated configs.
+ *
+ * Usage:
+ *   super scan                    Show all pending changes
+ *   super scan --skill dax        Show changes for specific skill
+ *   super scan --tool claude-code Show changes for specific tool
+ */
+
+const fs = require('fs');
+const path = require('path');
+const tui = require('../utils/tui');
+const { readSkillDirectory, normalizeSkillName } = require('../lib/skills');
+const { buildCommandMarkdown } = require('../lib/generators/claude-plugin');
+
+/**
+ * Generate a simple diff between two strings
+ * @param {string} oldContent - Original content
+ * @param {string} newContent - New content
+ * @returns {Object} Diff result with lines and stats
+ */
+function generateDiff(oldContent, newContent) {
+  const oldLines = oldContent.split('\n');
+  const newLines = newContent.split('\n');
+
+  const diff = {
+    lines: [],
+    additions: 0,
+    deletions: 0,
+    unchanged: 0,
+  };
+
+  // Multiset-based diff: track per-line frequency so duplicate lines
+  // (blank lines, repeated patterns like `---`) are matched independently
+  // rather than collapsing into a single Set entry.
+  const newCounts = new Map();
+  for (const line of newLines) {
+    newCounts.set(line, (newCounts.get(line) || 0) + 1);
+  }
+
+  // Walk old lines. Consume one slot from newCounts when the line exists
+  // in the new file; mark as removed otherwise.
+  for (let i = 0; i < oldLines.length; i++) {
+    const line = oldLines[i];
+    const available = newCounts.get(line) || 0;
+    if (available > 0) {
+      diff.lines.push({ type: 'unchanged', content: line, lineNum: i + 1 });
+      diff.unchanged++;
+      newCounts.set(line, available - 1);
+    } else {
+      diff.lines.push({ type: 'removed', content: line, lineNum: i + 1 });
+      diff.deletions++;
+    }
+  }
+
+  // Walk new lines. Lines whose old-count was already consumed are additions.
+  const oldCounts = new Map();
+  for (const line of oldLines) {
+    oldCounts.set(line, (oldCounts.get(line) || 0) + 1);
+  }
+  const consumed = new Map();
+  for (let i = 0; i < newLines.length; i++) {
+    const line = newLines[i];
+    const total = oldCounts.get(line) || 0;
+    const used = consumed.get(line) || 0;
+    if (used < total) {
+      consumed.set(line, used + 1);
+    } else {
+      diff.lines.push({ type: 'added', content: line, lineNum: i + 1 });
+      diff.additions++;
+    }
+  }
+
+  return diff;
+}
+
+/**
+ * Compare a source skill with its generated output
+ * @param {string} skillPath - Path to source skill
+ * @param {string} generatedPath - Path to generated file
+ * @returns {Object|null} Comparison result or null if no difference
+ */
+function compareFiles(skillPath, generatedPath) {
+  if (!fs.existsSync(skillPath)) {
+    return {
+      skill: path.basename(skillPath),
+      status: 'missing-source',
+      message: 'Source skill file not found',
+    };
+  }
+
+  if (!fs.existsSync(generatedPath)) {
+    return {
+      skill: path.basename(skillPath),
+      status: 'not-generated',
+      message: 'Generated file does not exist (will be created on sync)',
+    };
+  }
+
+  const sourceContent = fs.readFileSync(skillPath, 'utf8');
+  const generatedContent = fs.readFileSync(generatedPath, 'utf8');
+
+  if (sourceContent === generatedContent) {
+    return {
+      skill: path.basename(skillPath),
+      status: 'unchanged',
+      message: 'No changes',
+    };
+  }
+
+  const diff = generateDiff(generatedContent, sourceContent);
+
+  return {
+    skill: path.basename(skillPath),
+    status: 'changed',
+    diff,
+    sourcePath: skillPath,
+    generatedPath,
+  };
+}
+
+/**
+ * Compare a loaded skill against the content that should have been generated
+ * for a specific tool. This avoids false drift from generator-owned wrappers
+ * such as Claude command frontmatter, generated comments, and update-check
+ * preambles.
+ *
+ * @param {{name: string, path: string, content: string}} skill - Loaded source skill
+ * @param {string} generatedPath - Path to generated file
+ * @param {Object} [options] - Comparison options
+ * @param {string} [options.tool] - Tool id
+ * @param {string} [options.libraryPrefix] - Library prefix used by the generator
+ * @returns {Object} Comparison result
+ */
+function compareSkillToGenerated(skill, generatedPath, options = {}) {
+  if (!skill || !fs.existsSync(skill.path)) {
+    return {
+      skill: skill && skill.name ? skill.name : 'unknown',
+      status: 'missing-source',
+      message: 'Source skill file not found',
+    };
+  }
+
+  if (!fs.existsSync(generatedPath)) {
+    return {
+      skill: skill.name,
+      status: 'not-generated',
+      message: 'Generated file does not exist (will be created on sync)',
+    };
+  }
+
+  const generatedContent = fs.readFileSync(generatedPath, 'utf8');
+  const expectedContent = buildExpectedGeneratedContent(skill, options);
+
+  if (expectedContent === generatedContent) {
+    return {
+      skill: skill.name,
+      status: 'unchanged',
+      message: 'No changes',
+    };
+  }
+
+  const diff = generateDiff(generatedContent, expectedContent);
+
+  return {
+    skill: skill.name,
+    status: 'changed',
+    diff,
+    sourcePath: skill.path,
+    generatedPath,
+  };
+}
+
+/**
+ * @param {{name: string, content: string}} skill - Loaded source skill
+ * @param {Object} options - Comparison options
+ * @returns {string} Expected generated output for the scan target
+ */
+function buildExpectedGeneratedContent(skill, options = {}) {
+  if (options.tool === 'claude-code') {
+    return buildCommandMarkdown(skill, options.libraryPrefix || 'library');
+  }
+
+  return skill.content;
+}
+
+/**
+ * Get generated file path for a skill based on tool
+ * @param {string} skillName - Skill name (without .md)
+ * @param {string} tool - AI tool name
+ * @param {string} targetDir - Target project directory
+ * @returns {string|null} Path to generated file or null
+ */
+function getGeneratedPath(skillName, tool, targetDir) {
+  switch (tool) {
+    case 'claude-code':
+      // The Claude Code plugin generator (bin/lib/generators/claude-plugin.js)
+      // writes slash commands to `<targetDir>/commands/<skill>.md` — NOT
+      // `.claude/commands/...`. An earlier path here pointed at the old
+      // location and silently made `super scan --tool claude-code`
+      // report every skill as "not-generated".
+      return path.join(targetDir, 'commands', `${skillName}.md`);
+    case 'cursor':
+      // Cursor uses a single file, can't diff per-skill
+      return null;
+    case 'copilot':
+      // Copilot uses a single file, can't diff per-skill
+      return null;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Display diff for a single comparison
+ * @param {Object} comparison - Comparison result
+ * @param {boolean} verbose - Show full diff
+ */
+function displayComparison(comparison, verbose = false) {
+  const { skill, status, diff } = comparison;
+
+  switch (status) {
+    case 'unchanged':
+      console.log(`${tui.icons.success} ${tui.colors.muted(skill)} - No changes`);
+      break;
+
+    case 'not-generated':
+      console.log(`${tui.icons.info} ${tui.colors.info(skill)} - Will be created`);
+      break;
+
+    case 'missing-source':
+      console.log(`${tui.icons.warning} ${tui.colors.warning(skill)} - Source missing`);
+      break;
+
+    case 'changed':
+      console.log(`\n${tui.icons.warning} ${tui.colors.highlight(skill)} - Changes detected`);
+      console.log(
+        `   ${tui.colors.success(`+${diff.additions}`)} additions, ${tui.colors.error(`-${diff.deletions}`)} deletions`
+      );
+
+      if (verbose && diff.lines) {
+        console.log('');
+        diff.lines.forEach((line) => {
+          if (line.type === 'added') {
+            tui.diffAdd(tui.truncate(line.content, 100));
+          } else if (line.type === 'removed') {
+            tui.diffRemove(tui.truncate(line.content, 100));
+          }
+        });
+      }
+      break;
+  }
+}
+
+/**
+ * Parse command line arguments
+ * @param {string[]} args - CLI arguments
+ * @returns {Object} Parsed options
+ */
+function parseArgs(args) {
+  const options = {
+    skill: null,
+    tool: 'claude-code', // Default to claude-code as it supports per-skill diffs
+    verbose: false,
+    targetDir: process.cwd(),
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--skill' || arg === '-s') {
+      options.skill = args[++i];
+    } else if (arg === '--tool' || arg === '-t') {
+      options.tool = args[++i];
+    } else if (arg === '--verbose' || arg === '-v') {
+      options.verbose = true;
+    } else if (!arg.startsWith('-')) {
+      options.targetDir = arg;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Main diff command handler
+ * @param {string[]} args - Command arguments
+ * @param {Object} config - CLI configuration with paths
+ */
+function diffCommand(args, config) {
+  const options = parseArgs(args);
+  const targetDir = options.targetDir;
+
+  // Try cache directory first, fall back to local skills
+  let skillsDir = config.skillsDir;
+  const localSkills = path.join(config.packageDir, '.agents', 'prompts', 'skills');
+
+  if (!fs.existsSync(skillsDir)) {
+    if (fs.existsSync(localSkills)) {
+      skillsDir = localSkills;
+    } else {
+      tui.error('Skills directory not found. Try reinstalling: npm install -g bi-superpowers');
+      process.exit(1);
+    }
+  }
+
+  tui.header('BI Agent Superpowers', 'Diff: Source vs Generated');
+
+  // Check if tool supports per-skill diff
+  if (options.tool !== 'claude-code') {
+    tui.warning(`Tool "${options.tool}" uses a combined config file.`);
+    tui.info('Per-skill diff is only available for Claude Code.');
+    console.log('\nTo see changes, compare:');
+    console.log(`  Source: ${skillsDir}`);
+
+    switch (options.tool) {
+      case 'cursor':
+        console.log(`  Generated: ${path.join(targetDir, '.cursorrules')}`);
+        break;
+      case 'copilot':
+        console.log(`  Generated: ${path.join(targetDir, '.github', 'copilot-instructions.md')}`);
+        break;
+    }
+    return;
+  }
+
+  // Get skill files to compare. Use the shared skill loader so both
+  // flat (`<name>.md`) and folder-based (`<name>/SKILL.md`) skills
+  // are picked up — a previous version filtered with
+  // `f.endsWith('.md')` and silently dropped every folder-based skill.
+  const allSkills = readSkillDirectory(skillsDir);
+  const skillsByName = new Map(allSkills.map((s) => [s.name, s]));
+  const skillNameByPath = new Map(allSkills.map((s) => [s.path, s.name]));
+  let skillFiles = [];
+
+  if (options.skill) {
+    // normalizeSkillName accepts `dax`, `dax.md`, `folder-skill`, or
+    // `folder-skill/SKILL.md` and returns the canonical skill name.
+    const skill = skillsByName.get(normalizeSkillName(options.skill));
+    if (skill) {
+      skillFiles = [skill.path];
+    } else {
+      tui.error(`Skill not found: ${options.skill}`);
+      process.exit(1);
+    }
+  } else {
+    skillFiles = allSkills.map((s) => s.path);
+  }
+
+  if (skillFiles.length === 0) {
+    tui.warning('No skill files found');
+    return;
+  }
+
+  tui.info(`Comparing ${skillFiles.length} skill(s) for ${options.tool}...`);
+  tui.section('Changes');
+
+  // Compare each skill. Use the loader-built map to derive the canonical
+  // skill name — for folder-based skills the path is `<folder>/SKILL.md`
+  // and `path.basename(...)` would return `SKILL`, breaking the diff.
+  const results = skillFiles.map((skillPath) => {
+    const skillName = skillNameByPath.get(skillPath) || path.basename(skillPath, '.md');
+    const skill = skillsByName.get(skillName);
+    const generatedPath = getGeneratedPath(skillName, options.tool, targetDir);
+
+    if (!generatedPath) {
+      return {
+        skill: skillName,
+        status: 'skipped',
+        message: 'Tool does not support per-skill diff',
+      };
+    }
+
+    return compareSkillToGenerated(skill, generatedPath, {
+      tool: options.tool,
+      libraryPrefix: getLibraryPrefix(targetDir, config.packageDir),
+    });
+  });
+
+  // Display results
+  results.forEach((result) => {
+    displayComparison(result, options.verbose);
+  });
+
+  // Summary
+  const changed = results.filter((r) => r.status === 'changed').length;
+  const unchanged = results.filter((r) => r.status === 'unchanged').length;
+  const notGenerated = results.filter((r) => r.status === 'not-generated').length;
+
+  console.log('');
+  tui.section('Summary');
+
+  const table = tui.createTable(
+    ['Status', 'Count'],
+    [
+      ['Unchanged', unchanged.toString()],
+      ['Changed', tui.colors.warning(changed.toString())],
+      ['New (will create)', tui.colors.info(notGenerated.toString())],
+    ]
+  );
+  console.log(table);
+
+  if (changed > 0 || notGenerated > 0) {
+    console.log(
+      `\n${tui.colors.muted('Run')} super recharge ${tui.colors.muted('to apply changes')}`
+    );
+  } else {
+    console.log(`\n${tui.icons.success} ${tui.colors.success('Everything is in sync!')}`);
+  }
+}
+
+// Expose primitives for tests (B3 — replace fake tests with real ones).
+module.exports = Object.assign(diffCommand, {
+  generateDiff,
+  compareFiles,
+  compareSkillToGenerated,
+  buildExpectedGeneratedContent,
+  getGeneratedPath,
+  parseArgs,
+});
+
+/**
+ * Match the Claude plugin generator's library reference behavior.
+ *
+ * @param {string} targetDir - Target project directory
+ * @param {string} packageDir - Package root
+ * @returns {string} Library prefix used in generated markdown
+ */
+function getLibraryPrefix(targetDir, packageDir) {
+  return fs.existsSync(path.join(targetDir, 'library'))
+    ? 'library'
+    : path.join(packageDir, 'library');
+}