@luquimbo/bi-superpowers 1.0.0

package/bin/commands/sync-source.js

@@ -0,0 +1,418 @@
+/**
+ * Sync Source Command - Bidirectional Synchronization
+ * =====================================================
+ *
+ * Detects which is newer (repo or original file) and syncs accordingly.
+ * Combines pull and push logic with automatic conflict detection.
+ *
+ * Usage:
+ *   super sync                   Sync current project
+ *   super sync <project-name>    Sync specific project
+ *   super sync --all             Sync all projects
+ *
+ * @module commands/sync-source
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const profiles = require('../utils/profiles');
+const pbix = require('../utils/pbix');
+const git = require('../utils/git');
+const rl = require('../utils/readline');
+const { getAllProjects, getProject, detectCurrentProject } = require('../utils/projects');
+
+// Using shared readline utilities
+const { createReadline } = rl;
+
+/**
+ * Parse command line arguments
+ * @param {string[]} args - CLI arguments
+ * @returns {Object} Parsed options
+ */
+function parseArgs(args) {
+  const options = {
+    projectName: null,
+    all: false,
+    force: false,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--all' || arg === '-a') {
+      options.all = true;
+    } else if (arg === '--force' || arg === '-f') {
+      options.force = true;
+    } else if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (!arg.startsWith('-') && !options.projectName) {
+      options.projectName = arg;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Show help message
+ */
+function showHelp() {
+  console.log(`
+super sync - Sincronización bidireccional
+
+Detecta automáticamente qué es más nuevo (repo o archivo original)
+y sincroniza en la dirección correcta.
+
+Usage:
+  super sync                   Sync proyecto actual
+  super sync <proyecto>        Sync proyecto específico
+  super sync --all             Sync todos los proyectos
+
+Options:
+  --all, -a        Sincronizar todos los proyectos
+  --force, -f      Forzar sin confirmación
+  --help, -h       Mostrar esta ayuda
+
+Ejemplos:
+  super sync sales-q4
+  super sync --all
+`);
+}
+
+// Note: getAllProjects, getProject, and detectCurrentProject are imported from ../utils/projects
+
+/**
+ * Determine sync direction based on timestamps and hashes
+ * @param {Object} project - Project config
+ * @returns {Object} Sync info { direction, reason, sourceModified, repoModified }
+ */
+function determineSyncDirection(project) {
+  const result = {
+    direction: 'none', // 'pull', 'push', 'conflict', 'none'
+    reason: '',
+    sourceModified: null,
+    repoModified: null,
+    hasChanges: false,
+  };
+
+  const sourcePath = project.source?.path;
+  if (!sourcePath || !fs.existsSync(sourcePath)) {
+    result.reason = 'Archivo original no encontrado';
+    return result;
+  }
+
+  // Get source file modification time
+  const sourceStats = fs.statSync(sourcePath);
+  result.sourceModified = sourceStats.mtime;
+
+  // Get repo definition modification time
+  const definitionPath = path.join(project.projectPath, 'definition');
+  if (fs.existsSync(definitionPath)) {
+    const repoFiles = pbix.getAllFiles(definitionPath);
+    if (repoFiles.length > 0) {
+      // Find most recent repo file
+      let latestRepoTime = new Date(0);
+      for (const file of repoFiles) {
+        const stats = fs.statSync(file);
+        if (stats.mtime > latestRepoTime) {
+          latestRepoTime = stats.mtime;
+        }
+      }
+      result.repoModified = latestRepoTime;
+    }
+  }
+
+  // Get last sync time
+  const lastSync = project.source?.lastSync ? new Date(project.source.lastSync) : null;
+
+  // Determine direction
+  if (!result.repoModified) {
+    // No repo content yet, need to pull
+    result.direction = 'pull';
+    result.reason = 'Repo vacío - necesita pull inicial';
+    result.hasChanges = true;
+  } else if (!lastSync) {
+    // Never synced, check which is newer
+    if (result.sourceModified > result.repoModified) {
+      result.direction = 'pull';
+      result.reason = 'Archivo original más nuevo (nunca sincronizado)';
+      result.hasChanges = true;
+    } else if (result.repoModified > result.sourceModified) {
+      result.direction = 'push';
+      result.reason = 'Repo más nuevo (nunca sincronizado)';
+      result.hasChanges = true;
+    }
+  } else {
+    // Check what changed since last sync
+    const sourceChangedSinceSync = result.sourceModified > lastSync;
+    const repoChangedSinceSync = result.repoModified > lastSync;
+
+    if (sourceChangedSinceSync && repoChangedSinceSync) {
+      result.direction = 'conflict';
+      result.reason = 'Ambos modificados desde último sync';
+      result.hasChanges = true;
+    } else if (sourceChangedSinceSync) {
+      result.direction = 'pull';
+      result.reason = 'Archivo original modificado';
+      result.hasChanges = true;
+    } else if (repoChangedSinceSync) {
+      result.direction = 'push';
+      result.reason = 'Repo modificado';
+      result.hasChanges = true;
+    } else {
+      result.direction = 'none';
+      result.reason = 'Sin cambios desde último sync';
+      result.hasChanges = false;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Execute pull for a project
+ * @param {Object} project - Project config
+ * @returns {Object} Result
+ */
+function executePull(project) {
+  const result = { success: false, message: '', filesChanged: 0 };
+
+  if (project.type === 'power-bi-project') {
+    const extractResult = pbix.extractPbipToRepo(project.source.path, project.projectPath);
+
+    if (extractResult.success) {
+      // Update project.json
+      project.source.lastSync = new Date().toISOString();
+      project.source.hash = pbix.getFileHash(project.source.path);
+
+      const configPath = path.join(project.projectPath, 'project.json');
+      fs.writeFileSync(configPath, JSON.stringify(project, null, 2));
+
+      result.success = true;
+      result.filesChanged = extractResult.files.length;
+      result.message = `Pulled ${extractResult.files.length} files`;
+    } else {
+      result.message = extractResult.error;
+    }
+  } else {
+    result.message = `Pull no soportado para tipo: ${project.type}`;
+  }
+
+  return result;
+}
+
+/**
+ * Execute push for a project
+ * @param {Object} project - Project config
+ * @returns {Object} Result
+ */
+function executePush(project) {
+  const result = { success: false, message: '', filesChanged: 0 };
+
+  if (project.type === 'power-bi-project') {
+    const definitionPath = pbix.getPbipDefinitionPath(project.source.path);
+    const repoDefinition = path.join(project.projectPath, 'definition');
+
+    if (!definitionPath) {
+      result.message = 'No se encontró carpeta definition en PBIP';
+      return result;
+    }
+
+    if (!fs.existsSync(repoDefinition)) {
+      result.message = 'No hay definition en el repo';
+      return result;
+    }
+
+    try {
+      const files = pbix.copyDirectoryRecursive(repoDefinition, definitionPath);
+
+      // Update project.json
+      project.source.lastSync = new Date().toISOString();
+      const configPath = path.join(project.projectPath, 'project.json');
+      fs.writeFileSync(configPath, JSON.stringify(project, null, 2));
+
+      result.success = true;
+      result.filesChanged = files.length;
+      result.message = `Pushed ${files.length} files`;
+    } catch (e) {
+      result.message = e.message;
+    }
+  } else {
+    result.message = `Push no soportado para tipo: ${project.type}`;
+  }
+
+  return result;
+}
+
+/**
+ * Sync a single project
+ * @param {Object} project - Project config
+ * @param {Object} options - Sync options
+ * @param {readline.Interface} rl - Readline interface for prompts
+ * @returns {Promise<Object>} Sync result
+ */
+async function syncProject(project, options, rl) {
+  const syncInfo = determineSyncDirection(project);
+
+  console.log(`\n  ${project.name}`);
+  console.log(`    Tipo: ${project.type}`);
+  console.log(`    Original: ${project.source?.path || 'No configurado'}`);
+  console.log(`    Estado: ${syncInfo.reason}`);
+
+  if (!syncInfo.hasChanges) {
+    console.log('    → Sin cambios necesarios');
+    return { synced: false, direction: 'none' };
+  }
+
+  if (syncInfo.direction === 'conflict') {
+    console.log('    ⚠ CONFLICTO: Ambos han sido modificados');
+
+    if (!options.force) {
+      const answer = await new Promise((resolve) => {
+        rl.question('    ¿Qué hacer? (pull/push/skip): ', resolve);
+      });
+
+      if (answer === 'pull') {
+        syncInfo.direction = 'pull';
+      } else if (answer === 'push') {
+        syncInfo.direction = 'push';
+      } else {
+        console.log('    → Omitido');
+        return { synced: false, direction: 'skip' };
+      }
+    } else {
+      // Force mode defaults to pull (safer)
+      syncInfo.direction = 'pull';
+      console.log('    → Forzando pull (más seguro)');
+    }
+  }
+
+  let result;
+  if (syncInfo.direction === 'pull') {
+    console.log('    → Ejecutando pull...');
+    result = executePull(project);
+  } else if (syncInfo.direction === 'push') {
+    console.log('    → Ejecutando push...');
+    result = executePush(project);
+  }
+
+  if (result.success) {
+    console.log(`    ✓ ${result.message}`);
+    return { synced: true, direction: syncInfo.direction, filesChanged: result.filesChanged };
+  } else {
+    console.log(`    ✗ ${result.message}`);
+    return { synced: false, direction: syncInfo.direction, error: result.message };
+  }
+}
+
+/**
+ * Main sync command handler
+ */
+async function syncSourceCommand(args, _config) {
+  const options = parseArgs(args);
+
+  if (options.help) {
+    showHelp();
+    return;
+  }
+
+  // Check if repo exists
+  const repoPath = profiles.getRepoPath();
+  if (!repoPath || !fs.existsSync(repoPath)) {
+    console.log(`
+No se encontró el repositorio de BI.
+
+Ejecuta primero:
+  super setup
+`);
+    process.exit(1);
+  }
+
+  console.log(`
+════════════════════════════════════════════════════════════════
+  Sync - Sincronización Bidireccional
+════════════════════════════════════════════════════════════════
+
+Repositorio: ${repoPath}
+`);
+
+  // Get projects to sync
+  let projects = [];
+
+  if (options.all) {
+    projects = getAllProjects(repoPath);
+    if (projects.length === 0) {
+      console.log('No hay proyectos en el repo.\n');
+      console.log('Añade uno con: super add "ruta/archivo.pbix"');
+      return;
+    }
+    console.log(`Sincronizando ${projects.length} proyecto(s)...`);
+  } else if (options.projectName) {
+    const project = getProject(repoPath, options.projectName);
+    if (!project) {
+      console.log(`✗ Proyecto no encontrado: ${options.projectName}`);
+      console.log('\nProyectos disponibles:');
+      getAllProjects(repoPath).forEach((p) => {
+        console.log(`  - ${p.name}`);
+      });
+      process.exit(1);
+    }
+    projects = [project];
+  } else {
+    const current = detectCurrentProject(repoPath);
+    if (current) {
+      projects = [current];
+    } else {
+      // Show all projects status
+      projects = getAllProjects(repoPath);
+      if (projects.length === 0) {
+        console.log('No hay proyectos en el repo.\n');
+        console.log('Añade uno con: super add "ruta/archivo.pbix"');
+        return;
+      }
+      console.log('Estado de todos los proyectos:');
+    }
+  }
+
+  // Create readline interface
+  const rlInterface = createReadline();
+
+  // Sync each project
+  let syncedCount = 0;
+  let totalFilesChanged = 0;
+
+  for (const project of projects) {
+    const result = await syncProject(project, options, rlInterface);
+    if (result.synced) {
+      syncedCount++;
+      totalFilesChanged += result.filesChanged || 0;
+    }
+  }
+
+  rlInterface.close();
+
+  // Commit changes if any
+  if (syncedCount > 0 && git.isGitRepo(repoPath)) {
+    console.log('\nCommiteando cambios...');
+    git.stageFiles(repoPath, '.');
+    const projectNames = projects
+      .filter((p) => p)
+      .map((p) => p.name)
+      .join(', ');
+    git.commit(repoPath, `Sync: ${projectNames}`);
+    console.log('✓ Cambios commiteados');
+  }
+
+  console.log(`
+════════════════════════════════════════════════════════════════
+  Resumen
+════════════════════════════════════════════════════════════════
+
+  Proyectos sincronizados: ${syncedCount}/${projects.length}
+  Archivos cambiados: ${totalFilesChanged}
+`);
+}
+
+module.exports = syncSourceCommand;

package/bin/commands/sync-source.test.js

@@ -0,0 +1,14 @@
+/**
+ * Tests for Sync Source Command
+ * @module commands/sync-source.test
+ */
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert');
+
+describe('Sync Source Command', () => {
+  test('module exports a function', () => {
+    const syncSourceCommand = require('./sync-source');
+    assert.strictEqual(typeof syncSourceCommand, 'function');
+  });
+});

package/bin/commands/watch.js

@@ -0,0 +1,206 @@
+/**
+ * Watch Command (sentinel)
+ * ========================
+ * Watches for changes in skills and auto-regenerates the Claude Code plugin
+ * plus any configured legacy adapters.
+ *
+ * Usage:
+ *   super sentinel                      Watch all configured outputs
+ *   super sentinel --tool claude-plugin Watch a specific output only
+ */
+
+const fs = require('fs');
+const path = require('path');
+const tui = require('../utils/tui');
+
+// Try to require chokidar, but handle if not available
+let chokidar;
+try {
+  chokidar = require('chokidar');
+} catch (e) {
+  chokidar = null;
+}
+
+/**
+ * Parse command line arguments
+ * @param {string[]} args - CLI arguments
+ * @returns {Object} Parsed options
+ */
+function parseArgs(args) {
+  const options = {
+    tool: null, // null means all configured outputs
+    targetDir: process.cwd(),
+    debounce: 500, // ms
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--tool' || arg === '-t') {
+      options.tool = args[++i];
+    } else if (arg === '--debounce') {
+      options.debounce = parseInt(args[++i], 10) || 500;
+    } else if (!arg.startsWith('-')) {
+      options.targetDir = arg;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Main watch command handler
+ * @param {string[]} args - Command arguments
+ * @param {Object} config - CLI configuration with paths
+ * @param {Object} cliModule - Reference to main CLI module for regeneration
+ */
+function watchCommand(args, config, cliModule) {
+  if (!chokidar) {
+    tui.error('Watch mode requires the chokidar package.');
+    tui.info('Install dependencies with: npm install');
+    process.exit(1);
+  }
+
+  const options = parseArgs(args);
+  const skillsDir = config.skillsDir;
+  const targetDir = options.targetDir;
+
+  if (!fs.existsSync(skillsDir)) {
+    tui.error('Skills directory not found. Run "bi-superpowers unlock" first.');
+    process.exit(1);
+  }
+
+  tui.header('BI Agent Superpowers', 'Watch Mode');
+
+  tui.info(`Watching: ${skillsDir}`);
+  tui.info(`Target: ${targetDir}`);
+  if (options.tool) {
+    tui.info(`Tool: ${options.tool}`);
+  } else {
+    tui.info('Tool: All configured tools');
+  }
+
+  console.log('');
+  tui.muted('Press Ctrl+C to stop watching');
+  console.log('');
+
+  // Debounce timer
+  let debounceTimer = null;
+  const pendingChanges = new Set();
+
+  // Create watcher
+  const watcher = chokidar.watch(path.join(skillsDir, '*.md'), {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 200,
+      pollInterval: 100,
+    },
+  });
+
+  /**
+   * Handle file change
+   * @param {string} changedPath - Path to changed file
+   * @param {string} eventType - Type of event (add, change, unlink)
+   */
+  function handleChange(changedPath, _eventType) {
+    const filename = path.basename(changedPath);
+    pendingChanges.add(filename);
+
+    // Clear existing timer
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+
+    // Set new timer
+    debounceTimer = setTimeout(() => {
+      const changes = Array.from(pendingChanges);
+      pendingChanges.clear();
+
+      const timestamp = new Date().toLocaleTimeString();
+      console.log(`\n${tui.colors.muted(`[${timestamp}]`)} ${tui.icons.watch} Changes detected:`);
+      changes.forEach((file) => {
+        console.log(`  ${tui.icons.bullet} ${tui.colors.info(file)}`);
+      });
+
+      // Trigger regeneration
+      regenerateConfigs(targetDir, options.tool, cliModule);
+    }, options.debounce);
+  }
+
+  // Watch events
+  watcher
+    .on('add', (path) => handleChange(path, 'add'))
+    .on('change', (path) => handleChange(path, 'change'))
+    .on('unlink', (path) => handleChange(path, 'unlink'))
+    .on('error', (error) => {
+      tui.error(`Watcher error: ${error.message}`);
+    })
+    .on('ready', () => {
+      tui.success('Watching for changes...');
+    });
+
+  // Handle graceful shutdown
+  process.on('SIGINT', () => {
+    console.log('\n');
+    tui.info('Stopping watch mode...');
+    watcher.close();
+    process.exit(0);
+  });
+}
+
+/**
+ * Regenerate configs after changes detected
+ * @param {string} targetDir - Target directory
+ * @param {string|null} specificTool - Specific tool or null for all
+ * @param {Object} cliModule - CLI module reference
+ */
+function regenerateConfigs(targetDir, specificTool, cliModule) {
+  const ora = require('ora');
+  const spinner = ora('Regenerating configs...').start();
+
+  try {
+    // Load the saved tool config
+    const configPath = path.join(targetDir, '.bi-superpowers.json');
+    let tools = ['claude-plugin'];
+
+    if (fs.existsSync(configPath)) {
+      try {
+        const savedConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (savedConfig.tools) {
+          tools = savedConfig.tools;
+        }
+      } catch (e) {
+        // Ignore parse errors, use defaults
+      }
+    }
+
+    if (!tools.includes('claude-plugin')) {
+      tools = ['claude-plugin', ...tools];
+    }
+
+    // Filter to specific tool if requested
+    if (specificTool) {
+      tools = tools.filter((t) => t === specificTool);
+    }
+
+    if (tools.length === 0) {
+      spinner.warn('No tools configured');
+      return;
+    }
+
+    // Call the sync logic from CLI module
+    if (cliModule && typeof cliModule.syncProjectInternal === 'function') {
+      cliModule.syncProjectInternal(targetDir, tools);
+      spinner.succeed(`Regenerated configs for: ${tools.join(', ')}`);
+    } else {
+      // Fallback: just report what would be done
+      spinner.succeed(`Would regenerate configs for: ${tools.join(', ')}`);
+      tui.muted('Note: Run "bi-superpowers recharge" manually to apply changes');
+    }
+  } catch (error) {
+    spinner.fail(`Regeneration failed: ${error.message}`);
+  }
+}
+
+module.exports = watchCommand;