@luquimbo/bi-superpowers 1.0.0

package/bin/commands/diff.js

@@ -0,0 +1,325 @@
+/**
+ * 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');
+
+/**
+ * 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,
+  };
+
+  // Simple line-by-line diff (not a full diff algorithm, but good for display)
+  // Create maps of line content to track changes
+  const oldSet = new Set(oldLines);
+  const newSet = new Set(newLines);
+
+  // Track which lines are in both
+  const inBoth = new Set();
+  oldLines.forEach((line) => {
+    if (newSet.has(line)) {
+      inBoth.add(line);
+    }
+  });
+
+  // Process old lines
+  const processedOld = new Set();
+  oldLines.forEach((line, index) => {
+    if (inBoth.has(line) && !processedOld.has(line)) {
+      diff.lines.push({ type: 'unchanged', content: line, lineNum: index + 1 });
+      diff.unchanged++;
+      processedOld.add(line);
+    } else if (!inBoth.has(line)) {
+      diff.lines.push({ type: 'removed', content: line, lineNum: index + 1 });
+      diff.deletions++;
+    }
+  });
+
+  // Process new lines (additions)
+  newLines.forEach((line, index) => {
+    if (!oldSet.has(line)) {
+      diff.lines.push({ type: 'added', content: line, lineNum: index + 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,
+  };
+}
+
+/**
+ * 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':
+      return path.join(targetDir, '.claude', '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. Run "bi-superpowers unlock" first.');
+      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
+  let skillFiles = [];
+
+  if (options.skill) {
+    const skillName = options.skill.replace('.md', '');
+    const skillPath = path.join(skillsDir, `${skillName}.md`);
+    if (fs.existsSync(skillPath)) {
+      skillFiles = [skillPath];
+    } else {
+      tui.error(`Skill not found: ${options.skill}`);
+      process.exit(1);
+    }
+  } else {
+    skillFiles = fs
+      .readdirSync(skillsDir)
+      .filter((f) => f.endsWith('.md'))
+      .map((f) => path.join(skillsDir, f));
+  }
+
+  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
+  const results = skillFiles.map((skillPath) => {
+    const skillName = path.basename(skillPath, '.md');
+    const generatedPath = getGeneratedPath(skillName, options.tool, targetDir);
+
+    if (!generatedPath) {
+      return {
+        skill: skillName,
+        status: 'skipped',
+        message: 'Tool does not support per-skill diff',
+      };
+    }
+
+    return compareFiles(skillPath, generatedPath);
+  });
+
+  // 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!')}`);
+  }
+}
+
+module.exports = diffCommand;