@luquimbo/bi-superpowers 1.0.0

package/bin/commands/push.js

@@ -0,0 +1,231 @@
+/**
+ * Push Command - Apply Repo Changes to Original File
+ * ====================================================
+ *
+ * Pushes changes from the repo back to the original BI file.
+ * This is a Phase 2 feature - currently provides guidance for PBIP workflow.
+ *
+ * Usage:
+ *   super push                   Push current project
+ *   super push <project-name>    Push specific project
+ *
+ * @module commands/push
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+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,
+    force: false,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    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 push - Aplicar cambios del repo al archivo original
+
+Uso:
+  super push                   Push del proyecto actual
+  super push <nombre-proyecto> Push de un proyecto específico
+
+Opciones:
+  --force, -f      Forzar push aunque haya advertencias
+  --help, -h       Mostrar esta ayuda
+
+Nota:
+  Este comando actualmente soporta proyectos PBIP.
+  Para archivos .pbix, usa el workflow PBIP (recomendado).
+
+Ejemplos:
+  super push sales-q4
+  super push --force
+`);
+}
+
+// Note: getAllProjects, getProject, and detectCurrentProject are imported from ../utils/projects
+
+/**
+ * Push changes for a PBIP project
+ * @param {Object} project - Project config
+ * @returns {Object} Result object
+ */
+function pushPbipProject(project) {
+  const result = {
+    success: false,
+    message: '',
+  };
+
+  const sourcePath = project.source?.path;
+  if (!sourcePath) {
+    result.message = 'No source path configured';
+    return result;
+  }
+
+  const definitionPath = pbix.getPbipDefinitionPath(sourcePath);
+  if (!definitionPath) {
+    result.message = 'Could not find PBIP definition folder';
+    return result;
+  }
+
+  const repoDefinition = path.join(project.projectPath, 'definition');
+  if (!fs.existsSync(repoDefinition)) {
+    result.message = 'No definition folder in repo';
+    return result;
+  }
+
+  try {
+    // Copy files from repo to PBIP project
+    const files = pbix.copyDirectoryRecursive(repoDefinition, definitionPath);
+
+    // Update project.json with sync time
+    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.message = `Pushed ${files.length} files to PBIP project`;
+  } catch (e) {
+    result.message = `Error: ${e.message}`;
+  }
+
+  return result;
+}
+
+/**
+ * Main push command handler
+ */
+async function pushCommand(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(`
+════════════════════════════════════════════════════════════════
+  Push - Aplicar cambios del repo al archivo original
+════════════════════════════════════════════════════════════════
+`);
+
+  let project;
+
+  if (options.projectName) {
+    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);
+    }
+  } else {
+    project = detectCurrentProject(repoPath);
+    if (!project) {
+      console.log('Especifica un proyecto:\n');
+      console.log('  super push <nombre-proyecto>\n');
+      console.log('Proyectos disponibles:');
+      getAllProjects(repoPath).forEach((p) => {
+        console.log(`  - ${p.name}`);
+      });
+      return;
+    }
+  }
+
+  console.log(`Proyecto: ${project.name}`);
+  console.log(`Tipo: ${project.type}`);
+  console.log(`Archivo original: ${project.source?.path || 'No configurado'}\n`);
+
+  // Handle based on project type
+  if (project.type === 'power-bi-project') {
+    // PBIP - we can push directly
+    const result = pushPbipProject(project);
+
+    if (result.success) {
+      console.log(`✓ ${result.message}`);
+      console.log(`
+Los cambios se han aplicado al proyecto PBIP.
+Abre Power BI Desktop y recarga el proyecto para ver los cambios.
+`);
+    } else {
+      console.log(`✗ ${result.message}`);
+    }
+  } else if (project.type === 'power-bi') {
+    // PBIX - binary file, cannot push directly
+    console.log(`
+⚠ Los archivos .pbix son binarios y no se pueden modificar directamente.
+
+Para aplicar cambios del repo al modelo, tienes estas opciones:
+
+OPCIÓN 1: Convertir a PBIP (Recomendado)
+  1. Abre el .pbix en Power BI Desktop
+  2. File → Save as → Power BI Project (.pbip)
+  3. Ejecuta: super add "ruta/al/proyecto.pbip"
+  4. Los cambios del repo se pueden aplicar con: super push
+
+OPCIÓN 2: Copiar manualmente
+  1. Abre el .pbix en Power BI Desktop
+  2. Copia las medidas/queries del repo manualmente
+  3. Guarda el archivo
+
+Los archivos del repo están en:
+  ${project.projectPath}
+`);
+  } else if (project.type === 'excel' || project.type === 'excel-macro') {
+    console.log(`
+⚠ Los archivos Excel no se pueden modificar automáticamente.
+
+La documentación del workbook está en:
+  ${path.join(project.projectPath, 'workbook')}
+
+Usa esta documentación como referencia para aplicar
+cambios manualmente en Excel.
+`);
+  } else {
+    console.log(`✗ Tipo de proyecto no soportado para push: ${project.type}`);
+  }
+}
+
+module.exports = pushCommand;

package/bin/commands/push.test.js

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

package/bin/commands/search.js

@@ -0,0 +1,344 @@
+/**
+ * Search Command (xray)
+ * =====================
+ * Fuzzy search across snippets, skills, and library content.
+ *
+ * Usage:
+ *   super xray "query"
+ *   super xray --category dax "query"
+ *   super xray --tag performance
+ */
+
+const fs = require('fs');
+const path = require('path');
+const Fuse = require('fuse.js');
+const tui = require('../utils/tui');
+
+// Fuse.js configuration for fuzzy search
+const FUSE_OPTIONS = {
+  keys: [
+    { name: 'title', weight: 0.4 },
+    { name: 'content', weight: 0.3 },
+    { name: 'category', weight: 0.2 },
+    { name: 'tags', weight: 0.1 },
+  ],
+  threshold: 0.4,
+  ignoreLocation: true,
+  includeScore: true,
+  includeMatches: true,
+};
+
+/**
+ * Build search index from library content
+ * @param {string} libraryDir - Path to library directory
+ * @returns {Object[]} Array of searchable items
+ */
+function buildSearchIndex(libraryDir) {
+  const items = [];
+
+  if (!fs.existsSync(libraryDir)) {
+    return items;
+  }
+
+  // Index snippets
+  const snippetsDir = path.join(libraryDir, 'snippets');
+  if (fs.existsSync(snippetsDir)) {
+    indexDirectory(snippetsDir, items, 'snippet');
+  }
+
+  // Index templates
+  const templatesDir = path.join(libraryDir, 'templates');
+  if (fs.existsSync(templatesDir)) {
+    indexDirectory(templatesDir, items, 'template');
+  }
+
+  // Index examples
+  const examplesDir = path.join(libraryDir, 'examples');
+  if (fs.existsSync(examplesDir)) {
+    indexDirectory(examplesDir, items, 'example');
+  }
+
+  return items;
+}
+
+/**
+ * Recursively index a directory
+ * @param {string} dir - Directory path
+ * @param {Object[]} items - Items array to populate
+ * @param {string} type - Content type
+ */
+function indexDirectory(dir, items, type) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      indexDirectory(fullPath, items, type);
+    } else if (entry.name.endsWith('.md') && entry.name !== 'README.md') {
+      const item = parseMarkdownFile(fullPath, type);
+      if (item) {
+        items.push(item);
+      }
+    }
+  }
+}
+
+/**
+ * Parse a markdown file for search indexing
+ * @param {string} filePath - File path
+ * @param {string} type - Content type
+ * @returns {Object|null} Parsed item or null
+ */
+function parseMarkdownFile(filePath, type) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    // Extract title from first H1 or filename
+    let title = path.basename(filePath, '.md');
+    const h1Match = content.match(/^#\s+(.+)/m);
+    if (h1Match) {
+      title = h1Match[1];
+    }
+
+    // Extract category from parent directory
+    const pathParts = filePath.split(path.sep);
+    const snippetsIndex = pathParts.indexOf('snippets');
+    const templatesIndex = pathParts.indexOf('templates');
+    const examplesIndex = pathParts.indexOf('examples');
+
+    let category = '';
+    const typeIndex = Math.max(snippetsIndex, templatesIndex, examplesIndex);
+    if (typeIndex !== -1 && typeIndex + 1 < pathParts.length) {
+      category = pathParts[typeIndex + 1];
+    }
+
+    // Extract tags from content (look for patterns like `tag`, **tag**, or explicit tags)
+    const tags = [];
+    const tagMatches = content.match(/`([^`]+)`/g);
+    if (tagMatches) {
+      tagMatches.slice(0, 10).forEach((match) => {
+        const tag = match.replace(/`/g, '').toLowerCase();
+        if (tag.length > 2 && tag.length < 30 && !tags.includes(tag)) {
+          tags.push(tag);
+        }
+      });
+    }
+
+    // Extract first paragraph as preview
+    let preview = '';
+    for (let i = 0; i < lines.length && i < 20; i++) {
+      const line = lines[i].trim();
+      if (line && !line.startsWith('#') && !line.startsWith('```') && !line.startsWith('|')) {
+        preview = line;
+        break;
+      }
+    }
+
+    return {
+      title,
+      path: filePath,
+      relativePath: filePath.split('library')[1] || filePath,
+      content: content.substring(0, 2000), // Index first 2000 chars
+      category,
+      type,
+      tags,
+      preview,
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Filter results by category
+ * @param {Object[]} results - Search results
+ * @param {string} category - Category filter
+ * @returns {Object[]} Filtered results
+ */
+function filterByCategory(results, category) {
+  const lowerCategory = category.toLowerCase();
+  return results.filter(
+    (r) =>
+      r.item.category.toLowerCase().includes(lowerCategory) ||
+      r.item.type.toLowerCase().includes(lowerCategory)
+  );
+}
+
+/**
+ * Filter results by tag
+ * @param {Object[]} results - Search results
+ * @param {string} tag - Tag filter
+ * @returns {Object[]} Filtered results
+ */
+function filterByTag(results, tag) {
+  const lowerTag = tag.toLowerCase();
+  return results.filter(
+    (r) =>
+      r.item.tags.some((t) => t.toLowerCase().includes(lowerTag)) ||
+      r.item.content.toLowerCase().includes(lowerTag)
+  );
+}
+
+/**
+ * Display search results
+ * @param {Object[]} results - Search results from Fuse.js
+ * @param {string} query - Original search query
+ */
+function displayResults(results, query) {
+  if (results.length === 0) {
+    tui.warning(`No results found for "${query}"`);
+    console.log(
+      tui.colors.muted(
+        '\nTry a different search term or check available content with: super powers'
+      )
+    );
+    return;
+  }
+
+  tui.section(`Found ${results.length} result${results.length > 1 ? 's' : ''} for "${query}"`);
+
+  // Group by category
+  const grouped = {};
+  results.forEach((result) => {
+    const cat = result.item.category || result.item.type || 'other';
+    if (!grouped[cat]) {
+      grouped[cat] = [];
+    }
+    grouped[cat].push(result);
+  });
+
+  // Display grouped results
+  Object.entries(grouped).forEach(([category, categoryResults]) => {
+    console.log(`\n${tui.colors.primary(category.toUpperCase())}`);
+
+    categoryResults.slice(0, 5).forEach((result) => {
+      const score = (1 - result.score) * 100;
+      const scoreColor =
+        score > 70 ? tui.colors.success : score > 40 ? tui.colors.warning : tui.colors.muted;
+
+      console.log(`  ${tui.icons.bullet} ${tui.colors.highlight(result.item.title)}`);
+      console.log(`    ${tui.colors.muted('Path:')} ${tui.formatPath(result.item.relativePath)}`);
+
+      if (result.item.preview) {
+        console.log(`    ${tui.colors.muted(tui.truncate(result.item.preview, 80))}`);
+      }
+
+      console.log(`    ${tui.colors.muted('Match:')} ${scoreColor(score.toFixed(0) + '%')}`);
+    });
+
+    if (categoryResults.length > 5) {
+      console.log(tui.colors.muted(`    ... and ${categoryResults.length - 5} more`));
+    }
+  });
+
+  console.log('');
+}
+
+/**
+ * Parse command line arguments
+ * @param {string[]} args - CLI arguments
+ * @returns {Object} Parsed options
+ */
+function parseArgs(args) {
+  const options = {
+    query: '',
+    category: null,
+    tag: null,
+    limit: 20,
+  };
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === '--category' || arg === '-c') {
+      options.category = args[++i];
+    } else if (arg === '--tag' || arg === '-t') {
+      options.tag = args[++i];
+    } else if (arg === '--limit' || arg === '-l') {
+      options.limit = parseInt(args[++i], 10) || 20;
+    } else if (!arg.startsWith('-')) {
+      options.query = arg;
+    }
+    i++;
+  }
+
+  return options;
+}
+
+/**
+ * Main search command handler
+ * @param {string[]} args - Command arguments
+ * @param {Object} config - CLI configuration with paths
+ */
+function searchCommand(args, config) {
+  const options = parseArgs(args);
+
+  if (!options.query && !options.category && !options.tag) {
+    tui.error('Please provide a search query');
+    console.log('\nUsage:');
+    console.log('  super xray "query"           Search for a term');
+    console.log('  super xray --category dax    Filter by category');
+    console.log('  super xray --tag performance Filter by tag');
+    console.log('\nExamples:');
+    console.log('  super xray "YTD"');
+    console.log('  super xray --category dax "time intelligence"');
+    console.log('  super xray --tag performance');
+    process.exit(1);
+  }
+
+  // Try cache directory first, fall back to local library
+  let libraryDir = config.libraryDir;
+  const localLibrary = path.join(config.packageDir, 'library');
+
+  if (!fs.existsSync(libraryDir)) {
+    if (fs.existsSync(localLibrary)) {
+      libraryDir = localLibrary;
+    } else {
+      tui.error('Library not found. Run "bi-superpowers unlock" first.');
+      process.exit(1);
+    }
+  }
+
+  tui.header('BI Agent Superpowers', 'Search Library');
+
+  // Build search index
+  const items = buildSearchIndex(libraryDir);
+
+  if (items.length === 0) {
+    tui.warning('No content found in library');
+    return;
+  }
+
+  tui.info(`Indexed ${items.length} items`);
+
+  // Perform search
+  const fuse = new Fuse(items, FUSE_OPTIONS);
+
+  let results;
+  if (options.query) {
+    results = fuse.search(options.query);
+  } else {
+    // If no query, return all items as "results"
+    results = items.map((item) => ({ item, score: 0 }));
+  }
+
+  // Apply filters
+  if (options.category) {
+    results = filterByCategory(results, options.category);
+  }
+
+  if (options.tag) {
+    results = filterByTag(results, options.tag);
+  }
+
+  // Limit results
+  results = results.slice(0, options.limit);
+
+  // Display results
+  displayResults(results, options.query || `category:${options.category}` || `tag:${options.tag}`);
+}
+
+module.exports = searchCommand;

package/bin/commands/search.test.js

@@ -0,0 +1,115 @@
+/**
+ * Unit tests for the search command (xray)
+ *
+ * Run with: npm test
+ */
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert');
+
+// Mock content for testing search functionality
+const mockContent = `# Time Intelligence Patterns
+
+## Overview
+DAX time intelligence functions for YTD, MTD, QTD calculations.
+
+## YTD Pattern
+
+\`\`\`dax
+Sales YTD = TOTALYTD([Total Sales], 'Date'[Date])
+\`\`\`
+
+## Rolling Average
+
+\`\`\`dax
+Rolling 12M Average =
+AVERAGEX(
+    DATESINPERIOD('Date'[Date], MAX('Date'[Date]), -12, MONTH),
+    [Total Sales]
+)
+\`\`\`
+`;
+
+describe('Search Index Building', () => {
+  test('should extract title from H1 heading', () => {
+    const h1Match = mockContent.match(/^#\s+(.+)/m);
+    assert.ok(h1Match, 'Should find H1 heading');
+    assert.strictEqual(h1Match[1], 'Time Intelligence Patterns');
+  });
+
+  test('should extract tags from backtick code', () => {
+    const tagMatches = mockContent.match(/`([^`]+)`/g);
+    assert.ok(tagMatches, 'Should find backtick tags');
+    assert.ok(tagMatches.length > 0, 'Should have at least one tag');
+  });
+
+  test('should find DAX code blocks', () => {
+    const daxBlocks = mockContent.match(/```dax[\s\S]*?```/g);
+    assert.ok(daxBlocks, 'Should find DAX code blocks');
+    assert.strictEqual(daxBlocks.length, 2, 'Should have 2 DAX code blocks');
+  });
+});
+
+describe('Search Filtering', () => {
+  test('category filter should be case-insensitive', () => {
+    const category = 'dax';
+    const testCategories = ['DAX', 'dax', 'Dax'];
+
+    testCategories.forEach((testCat) => {
+      const matches = testCat.toLowerCase().includes(category.toLowerCase());
+      assert.strictEqual(matches, true, `${testCat} should match ${category}`);
+    });
+  });
+
+  test('tag filter should find partial matches', () => {
+    const tags = ['ytd', 'rolling', 'average', 'time-intelligence'];
+    const searchTag = 'roll';
+
+    const found = tags.some((t) => t.toLowerCase().includes(searchTag.toLowerCase()));
+    assert.strictEqual(found, true, 'Should find partial tag match');
+  });
+});
+
+describe('Search Result Scoring', () => {
+  test('perfect match should score higher than partial', () => {
+    // Simulating Fuse.js scoring (lower is better, 0 is perfect)
+    const perfectScore = 0;
+    const partialScore = 0.3;
+
+    assert.ok(perfectScore < partialScore, 'Perfect match should have lower score');
+  });
+
+  test('title match should have higher weight', () => {
+    const titleWeight = 0.4;
+    const contentWeight = 0.3;
+    const categoryWeight = 0.2;
+    const tagsWeight = 0.1;
+
+    const totalWeight = titleWeight + contentWeight + categoryWeight + tagsWeight;
+    // Use tolerance for floating point comparison
+    assert.ok(Math.abs(totalWeight - 1.0) < 0.0001, 'Weights should sum to 1.0');
+    assert.ok(titleWeight > contentWeight, 'Title should have highest weight');
+  });
+});
+
+describe('Argument Parsing', () => {
+  test('should parse query argument', () => {
+    const args = ['YTD'];
+    const query = args.find((arg) => !arg.startsWith('-'));
+    assert.strictEqual(query, 'YTD');
+  });
+
+  test('should parse category flag', () => {
+    const args = ['--category', 'dax', 'YTD'];
+    const categoryIndex = args.indexOf('--category');
+    const category = categoryIndex !== -1 ? args[categoryIndex + 1] : null;
+    assert.strictEqual(category, 'dax');
+  });
+
+  test('should parse short category flag', () => {
+    const args = ['-c', 'power-query', 'transform'];
+    const categoryIndex = args.indexOf('-c');
+    const category = categoryIndex !== -1 ? args[categoryIndex + 1] : null;
+    assert.strictEqual(category, 'power-query');
+  });
+});