@luquimbo/bi-superpowers 1.0.0

package/bin/commands/mcp-setup.js

@@ -0,0 +1,246 @@
+/**
+ * MCP Setup Command
+ * =================
+ * Configures the official Microsoft MCP servers for the Claude Code plugin
+ * and legacy adapter formats.
+ *
+ * Usage:
+ *   super mcp-setup
+ *   super mcp-setup --tool claude-plugin
+ *   super mcp-setup --dry-run
+ */
+
+const fs = require('fs');
+const path = require('path');
+const tui = require('../utils/tui');
+const mcpDetect = require('../utils/mcp-detect');
+const {
+  ABSOLUTE_LAUNCHER_MODE,
+  PLUGIN_ROOT_LAUNCHER_MODE,
+  createMcpConfigForFormat,
+  mergeMcpConfig,
+} = require('../lib/microsoft-mcp');
+
+const MCP_CONFIGS = {
+  'claude-plugin': {
+    name: 'Claude Code Plugin',
+    configPath: '.mcp.json',
+    format: 'plugin',
+  },
+  'claude-code': {
+    name: 'Claude Code (legacy standalone)',
+    configPath: '.claude/settings.json',
+    format: 'claude',
+  },
+  cursor: {
+    name: 'Cursor (legacy)',
+    configPath: '.cursor/mcp.json',
+    format: 'cursor',
+  },
+  kilocode: {
+    name: 'Kilo Code (legacy)',
+    configPath: '.kilocode/mcp.json',
+    format: 'kilo',
+  },
+  'open-code': {
+    name: 'OpenCode (legacy)',
+    configPath: 'opencode.config.json',
+    format: 'opencode',
+  },
+  vscode: {
+    name: 'VS Code (legacy)',
+    configPath: '.vscode/settings.json',
+    format: 'vscode',
+  },
+};
+
+function parseArgs(args) {
+  const options = {
+    tool: null,
+    dryRun: false,
+    targetDir: process.cwd(),
+    deprecatedFlags: [],
+  };
+
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+
+    if (arg === '--tool' || arg === '-t') {
+      options.tool = args[++index];
+    } else if (arg === '--dry-run') {
+      options.dryRun = true;
+    } else if (
+      arg === '--port' ||
+      arg === '-p' ||
+      arg === '--github' ||
+      arg === '-g' ||
+      arg === '--fabric'
+    ) {
+      options.deprecatedFlags.push(arg);
+      if (args[index + 1] && !args[index + 1].startsWith('-')) {
+        index++;
+      }
+    } else if (!arg.startsWith('-')) {
+      options.targetDir = arg;
+    }
+  }
+
+  return options;
+}
+
+function loadConfiguredTools(targetDir) {
+  const configPath = path.join(targetDir, '.bi-superpowers.json');
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (Array.isArray(config.tools) && config.tools.length > 0) {
+        return Array.from(new Set(config.tools));
+      }
+    } catch (error) {
+      // Ignore invalid config and fall back below.
+    }
+  }
+
+  const pluginManifest = path.join(targetDir, '.claude-plugin', 'plugin.json');
+  if (fs.existsSync(pluginManifest)) {
+    return ['claude-plugin'];
+  }
+
+  return ['claude-plugin'];
+}
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    return {};
+  }
+}
+
+function writeConfig(filePath, config, dryRun) {
+  const directory = path.dirname(filePath);
+
+  if (dryRun) {
+    tui.info(`Would write: ${tui.formatPath(filePath)}`);
+    tui.muted(JSON.stringify(config, null, 2).slice(0, 220) + '...');
+    return true;
+  }
+
+  try {
+    if (!fs.existsSync(directory)) {
+      fs.mkdirSync(directory, { recursive: true });
+    }
+
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n');
+    return true;
+  } catch (error) {
+    tui.error(`Failed to write ${filePath}: ${error.message}`);
+    return false;
+  }
+}
+
+function getLauncherMode(targetDir, packageDir, tool) {
+  if (tool === 'claude-plugin' && path.resolve(targetDir) === path.resolve(packageDir)) {
+    return PLUGIN_ROOT_LAUNCHER_MODE;
+  }
+
+  return ABSOLUTE_LAUNCHER_MODE;
+}
+
+function mcpSetupCommand(args, config) {
+  const options = parseArgs(args);
+  const targetDir = path.resolve(options.targetDir);
+
+  tui.header('BI Agent Superpowers', 'Microsoft MCP Setup');
+
+  if (options.dryRun) {
+    tui.dryRunNotice();
+  }
+
+  if (options.deprecatedFlags.length > 0) {
+    tui.warning(
+      `Deprecated flags ignored: ${options.deprecatedFlags.join(', ')}. MCP setup is now plugin-first and uses the official Microsoft servers.`
+    );
+  }
+
+  let configuredTools = loadConfiguredTools(targetDir);
+
+  if (options.tool) {
+    if (!MCP_CONFIGS[options.tool]) {
+      tui.error(`Unknown tool: ${options.tool}`);
+      tui.info(`Available tools: ${Object.keys(MCP_CONFIGS).join(', ')}`);
+      process.exit(1);
+    }
+
+    configuredTools = [options.tool];
+  }
+
+  tui.section('Configured Outputs');
+  configuredTools.forEach((tool) => {
+    tui.success(MCP_CONFIGS[tool].name);
+  });
+
+  const status = mcpDetect.getMcpStatus();
+
+  tui.section('Official Microsoft MCP Status');
+  if (status.local.installed) {
+    tui.success(`Power BI Modeling MCP detected: ${status.local.path}`);
+    if (status.local.version) {
+      tui.info(`Version: ${status.local.version}`);
+    }
+  } else {
+    tui.warning('Power BI Modeling MCP not detected locally.');
+    tui.info(mcpDetect.getModelingMcpError());
+  }
+
+  tui.success(`Power BI Remote MCP: ${status.remote.url}`);
+  tui.success(`Fabric MCP package: ${status.fabric.package}`);
+
+  const results = {
+    success: [],
+    failed: [],
+  };
+
+  tui.section('Writing Configurations');
+  configuredTools.forEach((tool) => {
+    const toolConfig = MCP_CONFIGS[tool];
+    const filePath = path.join(targetDir, toolConfig.configPath);
+    const existingConfig = readJson(filePath);
+    const generatedConfig = createMcpConfigForFormat(toolConfig.format, {
+      packageDir: config.packageDir,
+      launcherMode: getLauncherMode(targetDir, config.packageDir, tool),
+    });
+    const mergedConfig = mergeMcpConfig(existingConfig, generatedConfig, toolConfig.format);
+    const ok = writeConfig(filePath, mergedConfig, options.dryRun);
+
+    if (ok) {
+      results.success.push(toolConfig.name);
+      tui.success(`${toolConfig.name}: ${tui.formatPath(toolConfig.configPath)}`);
+    } else {
+      results.failed.push(toolConfig.name);
+    }
+  });
+
+  console.log('');
+  tui.section('Next Steps');
+  tui.listItem(
+    'Install the official Microsoft Power BI Modeling MCP extension in VS Code/Cursor on Windows if you need write access to Desktop/Fabric/PBIP models.'
+  );
+  tui.listItem('Refresh or restart your MCP client after config changes.');
+
+  if (configuredTools.includes('claude-plugin')) {
+    tui.listItem(`Run Claude Code with the plugin: claude --plugin-dir ${targetDir}`);
+  }
+
+  if (results.failed.length > 0) {
+    console.log('');
+    tui.warning(`Completed with failures: ${results.failed.join(', ')}`);
+    process.exit(1);
+  }
+}
+
+module.exports = mcpSetupCommand;

package/bin/commands/pull.js

@@ -0,0 +1,287 @@
+/**
+ * Pull Command - Sync from Original to Repo
+ * ==========================================
+ *
+ * Pulls changes from the original BI file to the repo.
+ * Extracts updated TMDL/content and creates a Git commit.
+ *
+ * Usage:
+ *   super pull                   Pull current project
+ *   super pull <project-name>    Pull specific project
+ *   super pull --all             Pull all projects
+ *
+ * @module commands/pull
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const git = require('../utils/git');
+const profiles = require('../utils/profiles');
+const pbix = require('../utils/pbix');
+const { getAllProjects, getProject, detectCurrentProject } = require('../utils/projects');
+
+/**
+ * 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 pull - Traer cambios del archivo original al repo
+
+Uso:
+  super pull                   Pull del proyecto actual (si estás en la carpeta)
+  super pull <nombre-proyecto> Pull de un proyecto específico
+  super pull --all             Pull de todos los proyectos
+
+Opciones:
+  --all, -a        Pull de todos los proyectos
+  --force, -f      Forzar pull aunque no haya cambios detectados
+  --help, -h       Mostrar esta ayuda
+
+Ejemplos:
+  super pull sales-q4
+  super pull --all
+  super pull hr-dashboard --force
+`);
+}
+
+// Note: getAllProjects, getProject, and detectCurrentProject are imported from ../utils/projects
+
+/**
+ * Pull changes for a single project
+ * @param {Object} project - Project config
+ * @param {boolean} force - Force pull even if no changes
+ * @returns {Object} Result object
+ */
+function pullProject(project, force = false) {
+  const result = {
+    success: false,
+    project: project.name,
+    message: '',
+    filesChanged: 0,
+  };
+
+  // Check if source file exists
+  const sourcePath = project.source?.path;
+  if (!sourcePath || !fs.existsSync(sourcePath)) {
+    result.message = `Archivo original no encontrado: ${sourcePath || 'no configurado'}`;
+    return result;
+  }
+
+  // Check if file has changed (by modification time or hash)
+  const currentHash = pbix.getFileHash(sourcePath);
+  const lastHash = project.source?.hash || '';
+
+  if (currentHash === lastHash && !force) {
+    result.success = true;
+    result.message = 'Sin cambios';
+    return result;
+  }
+
+  // Detect file type and extract
+  const fileInfo = pbix.detectFileType(sourcePath);
+
+  if (fileInfo.type === 'power-bi-project') {
+    // PBIP - extract TMDL
+    const definitionPath = pbix.getPbipDefinitionPath(sourcePath);
+
+    if (definitionPath) {
+      const targetDef = path.join(project.projectPath, 'definition');
+
+      // Compare directories to show changes
+      const changes = pbix.compareDirectories(targetDef, definitionPath);
+
+      // Copy new content
+      const extraction = pbix.extractPbipToRepo(sourcePath, project.projectPath);
+
+      if (extraction.success) {
+        result.success = true;
+        result.filesChanged =
+          changes.added.length + changes.modified.length + changes.deleted.length;
+        result.message = `Actualizado: +${changes.added.length} ~${changes.modified.length} -${changes.deleted.length}`;
+      } else {
+        result.message = extraction.error;
+      }
+    } else {
+      result.message = 'No se encontró carpeta definition en PBIP';
+    }
+  } else if (fileInfo.type === 'power-bi') {
+    // PBIX - just update modification time and hash
+    result.success = true;
+    result.message = 'Archivo .pbix actualizado (binario, sin diff detallado)';
+
+    // Update the README with latest info
+    const readmePath = path.join(project.projectPath, 'README.md');
+    if (fs.existsSync(readmePath)) {
+      let content = fs.readFileSync(readmePath, 'utf8');
+      const lastMod = pbix.getLastModified(sourcePath);
+
+      // Add update note
+      if (!content.includes('## Historial de Actualizaciones')) {
+        content += '\n\n## Historial de Actualizaciones\n';
+      }
+      content += `\n- ${lastMod?.toISOString()}: Pull desde archivo original`;
+      fs.writeFileSync(readmePath, content);
+    }
+  } else if (fileInfo.type === 'excel' || fileInfo.type === 'excel-macro') {
+    // Excel - update modification tracking
+    result.success = true;
+    result.message = 'Archivo Excel actualizado';
+  } else {
+    result.message = 'Tipo de archivo no soportado para pull';
+  }
+
+  // Update project.json with new hash and sync time
+  if (result.success) {
+    project.source.hash = currentHash;
+    project.source.lastSync = new Date().toISOString();
+
+    const configPath = path.join(project.projectPath, 'project.json');
+    fs.writeFileSync(configPath, JSON.stringify(project, null, 2));
+  }
+
+  return result;
+}
+
+/**
+ * Main pull command handler
+ */
+async function pullCommand(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(`
+════════════════════════════════════════════════════════════════
+  Pull - Traer cambios de archivos originales
+════════════════════════════════════════════════════════════════
+`);
+
+  let projectsToPull = [];
+
+  if (options.all) {
+    // Pull all projects
+    projectsToPull = getAllProjects(repoPath);
+    console.log(`Proyectos encontrados: ${projectsToPull.length}\n`);
+  } else if (options.projectName) {
+    // Pull specific project
+    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);
+    }
+    projectsToPull = [project];
+  } else {
+    // Try to detect current project
+    const current = detectCurrentProject(repoPath);
+    if (current) {
+      projectsToPull = [current];
+    } else {
+      // No project specified, show help
+      console.log('Especifica un proyecto o usa --all:\n');
+      console.log('  super pull <nombre-proyecto>');
+      console.log('  super pull --all\n');
+      console.log('Proyectos disponibles:');
+      getAllProjects(repoPath).forEach((p) => {
+        console.log(`  - ${p.name}`);
+      });
+      return;
+    }
+  }
+
+  if (projectsToPull.length === 0) {
+    console.log('No hay proyectos para actualizar.');
+    return;
+  }
+
+  // Pull each project
+  const results = [];
+
+  for (const project of projectsToPull) {
+    process.stdout.write(`  ${project.name}... `);
+
+    const result = pullProject(project, options.force);
+    results.push(result);
+
+    if (result.success) {
+      console.log(`✓ ${result.message}`);
+    } else {
+      console.log(`✗ ${result.message}`);
+    }
+  }
+
+  // Git commit if there were changes
+  const changedProjects = results.filter((r) => r.success && r.filesChanged > 0);
+
+  if (changedProjects.length > 0 && git.isGitRepo(repoPath)) {
+    console.log('\nGuardando cambios en Git...');
+
+    git.stageFiles(repoPath, '.');
+
+    const projectNames = changedProjects.map((r) => r.project).join(', ');
+    git.commit(repoPath, `Pull updates: ${projectNames}`);
+
+    console.log(`  ✓ Commit: "Pull updates: ${projectNames}"`);
+  }
+
+  // Summary
+  const successful = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+
+  console.log(`
+════════════════════════════════════════════════════════════════
+  Resumen: ${successful} exitosos, ${failed} fallidos
+════════════════════════════════════════════════════════════════
+`);
+}
+
+module.exports = pullCommand;

package/bin/commands/pull.test.js

@@ -0,0 +1,36 @@
+/**
+ * Tests for Pull Command
+ * @module commands/pull.test
+ */
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert');
+
+describe('Pull Command', () => {
+  test('module exports a function', () => {
+    const pullCommand = require('./pull');
+    assert.strictEqual(typeof pullCommand, 'function');
+  });
+});
+
+describe('Pull Command - Directory Comparison', () => {
+  test('compareDirectories returns diff structure', () => {
+    const pbix = require('../utils/pbix');
+
+    // Test with non-existent directories (should return empty diff)
+    const result = pbix.compareDirectories('/non/existent/dir1', '/non/existent/dir2');
+
+    assert.ok(Array.isArray(result.added));
+    assert.ok(Array.isArray(result.modified));
+    assert.ok(Array.isArray(result.deleted));
+  });
+});
+
+describe('Pull Command - File Hashing', () => {
+  test('getFileHash returns empty string for non-existent file', () => {
+    const pbix = require('../utils/pbix');
+    const result = pbix.getFileHash('/non/existent/file.txt');
+
+    assert.strictEqual(result, '');
+  });
+});