@luquimbo/bi-superpowers 1.0.0

package/bin/lib/skills.js

@@ -0,0 +1,84 @@
+/**
+ * Skill Loading Utilities
+ * =======================
+ *
+ * Centralizes how BI Agent Superpowers loads skill source files.
+ * During local development we prefer the repository sources, while
+ * installed package usage can fall back to the premium content cache.
+ *
+ * @module lib/skills
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Read all markdown skills from a directory.
+ *
+ * @param {string} directory - Directory containing skill markdown files
+ * @returns {Array<{name: string, path: string, content: string}>}
+ */
+function readSkillDirectory(directory) {
+  if (!directory || !fs.existsSync(directory)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(directory)
+    .filter((file) => file.endsWith('.md'))
+    .sort()
+    .map((file) => {
+      const filePath = path.join(directory, file);
+      return {
+        name: file.replace(/\.md$/, ''),
+        path: filePath,
+        content: fs.readFileSync(filePath, 'utf8'),
+      };
+    });
+}
+
+/**
+ * Resolve candidate skill directories in preferred order.
+ *
+ * @param {Object} options - Resolution options
+ * @param {string} options.packageDir - Package installation directory
+ * @param {string} [options.contentCacheDir] - Premium content cache directory
+ * @param {boolean} [options.preferLocal] - Prefer repository-local sources first
+ * @returns {string[]} Ordered list of candidate directories
+ */
+function getSkillDirectories(options = {}) {
+  const { packageDir, contentCacheDir, preferLocal = false } = options;
+  const localDir = packageDir ? path.join(packageDir, 'src', 'content', 'skills') : null;
+  const cacheDir = contentCacheDir ? path.join(contentCacheDir, 'src', 'content', 'skills') : null;
+
+  const ordered = preferLocal ? [localDir, cacheDir] : [cacheDir, localDir];
+  return ordered.filter(Boolean);
+}
+
+/**
+ * Load skills from the first directory that contains them.
+ *
+ * @param {Object} options - Resolution options
+ * @param {string} options.packageDir - Package installation directory
+ * @param {string} [options.contentCacheDir] - Premium content cache directory
+ * @param {boolean} [options.preferLocal] - Prefer repository-local sources first
+ * @returns {Array<{name: string, path: string, content: string}>}
+ */
+function loadSkills(options = {}) {
+  const directories = getSkillDirectories(options);
+
+  for (const directory of directories) {
+    const skills = readSkillDirectory(directory);
+    if (skills.length > 0) {
+      return skills;
+    }
+  }
+
+  return [];
+}
+
+module.exports = {
+  readSkillDirectory,
+  getSkillDirectories,
+  loadSkills,
+};

package/bin/mcp/powerbi-modeling-launcher.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+/**
+ * Power BI Modeling MCP Launcher
+ * ==============================
+ *
+ * Wrapper that locates the official Microsoft Power BI Modeling MCP
+ * executable and starts it with stdio transport for Claude Code.
+ */
+
+const { spawn } = require('child_process');
+const { findLocalMcp, getModelingMcpError } = require('../utils/mcp-detect');
+
+const executablePath = findLocalMcp();
+
+if (!executablePath) {
+  console.error(getModelingMcpError());
+  process.exit(1);
+}
+
+const child = spawn(executablePath, ['--start', ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+child.on('error', (error) => {
+  console.error(`Failed to launch Power BI Modeling MCP: ${error.message}`);
+  process.exit(1);
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+
+  process.exit(code === null ? 1 : code);
+});

package/bin/postinstall.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script for BI Agent Superpowers
+ * Shows helpful information after npm install
+ * Developed by Lucas Sanchez (@luquimbo)
+ */
+
+const VERSION = require('../package.json').version;
+
+console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   BI Agent Superpowers v${VERSION.padEnd(34)}║
+║   AI-powered toolkit for Power BI, Fabric & Excel        ║
+║   Developed by Lucas Sanchez (@luquimbo)                 ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+
+Installed successfully!
+
+Quick Start:
+  1. super unlock          Activate your license key
+  2. super kickoff         Configure for your AI tool(s)
+  3. super powers          List available skills & resources
+
+Get your license at: https://acadevor.com/bi-superpowers
+
+Works with:
+  • Claude Code        Native plugin (skills + commands + MCP)
+  • 1code.dev          Uses Claude Code SDK (full plugin support)
+  • Claude Desktop     Via MCPB extension (super build-desktop)
+
+After activation, you'll have access to 20+ skills including:
+  /project-kickoff       Analyze and plan BI projects
+  /data-model-design     Design star schema data models
+  /dax-doctor            Debug and optimize DAX measures
+  /dax                   DAX writing best practices
+  /power-query           Power Query patterns
+  /report-design         Report design and visualization
+  ... and more!
+
+Documentation: https://github.com/luquimbo/bi-superpowers
+`);

package/bin/utils/errors.js

@@ -0,0 +1,159 @@
+/**
+ * Error Handling Utilities
+ * ========================
+ *
+ * Standardized error handling for the CLI.
+ * Provides consistent error messages and exit codes.
+ *
+ * @module utils/errors
+ */
+
+/**
+ * Custom CLI Error class
+ * Extends Error with exit code and optional suggestion
+ */
+class CLIError extends Error {
+  /**
+   * Create a CLI error
+   * @param {string} message - Error message
+   * @param {number} code - Exit code (default: 1)
+   * @param {string|null} suggestion - Optional suggestion for fixing the error
+   */
+  constructor(message, code = 1, suggestion = null) {
+    super(message);
+    this.name = 'CLIError';
+    this.code = code;
+    this.suggestion = suggestion;
+  }
+}
+
+/**
+ * Error codes for common scenarios
+ */
+const ErrorCodes = {
+  GENERAL: 1,
+  INVALID_INPUT: 2,
+  FILE_NOT_FOUND: 3,
+  PERMISSION_DENIED: 4,
+  NETWORK_ERROR: 5,
+  CONFIG_ERROR: 6,
+  GIT_ERROR: 7,
+  VALIDATION_ERROR: 8,
+};
+
+/**
+ * Handle an error with consistent formatting
+ * @param {Error} error - The error to handle
+ * @param {Object} options - Options for handling
+ * @param {boolean} options.exit - Whether to exit the process (default: true)
+ * @param {boolean} options.verbose - Show stack trace (default: false)
+ */
+function handleError(error, options = {}) {
+  const { exit = true, verbose = process.env.DEBUG === 'true' } = options;
+
+  if (error instanceof CLIError) {
+    console.error(`Error: ${error.message}`);
+    if (error.suggestion) {
+      console.error(`\nSuggestion: ${error.suggestion}`);
+    }
+    if (exit) {
+      process.exit(error.code);
+    }
+  } else if (error instanceof Error) {
+    console.error(`Error: ${error.message}`);
+    if (verbose && error.stack) {
+      console.error(`\nStack trace:\n${error.stack}`);
+    }
+    if (exit) {
+      process.exit(ErrorCodes.GENERAL);
+    }
+  } else {
+    console.error(`Error: ${String(error)}`);
+    if (exit) {
+      process.exit(ErrorCodes.GENERAL);
+    }
+  }
+}
+
+/**
+ * Wrap an async function with error handling
+ * @param {Function} fn - Async function to wrap
+ * @param {Object} options - Error handling options
+ * @returns {Function} Wrapped function
+ */
+function withErrorHandling(fn, options = {}) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      handleError(error, options);
+    }
+  };
+}
+
+/**
+ * Log a warning without exiting
+ * @param {string} message - Warning message
+ * @param {Object} context - Additional context (optional)
+ */
+function logWarning(message, context = null) {
+  console.warn(`Warning: ${message}`);
+  if (context && process.env.DEBUG === 'true') {
+    console.warn('Context:', context);
+  }
+}
+
+/**
+ * Create a CLIError for common scenarios
+ */
+const createError = {
+  fileNotFound: (path) =>
+    new CLIError(
+      `File not found: ${path}`,
+      ErrorCodes.FILE_NOT_FOUND,
+      'Check that the file path is correct.'
+    ),
+
+  invalidInput: (message, suggestion = null) =>
+    new CLIError(message, ErrorCodes.INVALID_INPUT, suggestion),
+
+  configError: (message) =>
+    new CLIError(
+      message,
+      ErrorCodes.CONFIG_ERROR,
+      'Run "bi-superpowers setup" to configure the repository.'
+    ),
+
+  gitError: (message) =>
+    new CLIError(
+      message,
+      ErrorCodes.GIT_ERROR,
+      'Make sure Git is installed and you are in a Git repository.'
+    ),
+
+  networkError: (message) =>
+    new CLIError(
+      message,
+      ErrorCodes.NETWORK_ERROR,
+      'Check your internet connection and try again.'
+    ),
+
+  permissionDenied: (path) =>
+    new CLIError(
+      `Permission denied: ${path}`,
+      ErrorCodes.PERMISSION_DENIED,
+      'Check file permissions.'
+    ),
+
+  validationError: (message, suggestion = null) =>
+    new CLIError(message, ErrorCodes.VALIDATION_ERROR, suggestion),
+};
+
+module.exports = {
+  CLIError,
+  ErrorCodes,
+  handleError,
+  withErrorHandling,
+  logWarning,
+  createError,
+};

package/bin/utils/git.js

@@ -0,0 +1,298 @@
+/**
+ * Git Utilities for BI Agent Superpowers
+ * =======================================
+ *
+ * Provides Git operations for the multi-project repo system.
+ * Uses simple-git for robust cross-platform Git operations.
+ *
+ * @module utils/git
+ */
+
+const { execSync, spawnSync } = require('child_process');
+
+/**
+ * Check if Git is installed on the system
+ * @returns {boolean} True if Git is available
+ */
+function isGitInstalled() {
+  try {
+    execSync('git --version', { stdio: 'pipe' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Check if a directory is a Git repository
+ * @param {string} dir - Directory path to check
+ * @returns {boolean} True if directory is a Git repo
+ */
+function isGitRepo(dir) {
+  try {
+    const result = spawnSync('git', ['rev-parse', '--git-dir'], {
+      cwd: dir,
+      stdio: 'pipe',
+    });
+    return result.status === 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Initialize a new Git repository
+ * @param {string} dir - Directory to initialize
+ * @returns {boolean} True if successful
+ */
+function initRepo(dir) {
+  try {
+    const result = spawnSync('git', ['init'], {
+      cwd: dir,
+      stdio: 'pipe',
+    });
+    return result.status === 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Stage files in Git
+ * @param {string} dir - Repository directory
+ * @param {string|string[]} files - Files to stage (use '.' for all)
+ * @returns {boolean} True if successful
+ */
+function stageFiles(dir, files = '.') {
+  try {
+    const fileArgs = Array.isArray(files) ? files : [files];
+    const result = spawnSync('git', ['add', ...fileArgs], {
+      cwd: dir,
+      stdio: 'pipe',
+    });
+    return result.status === 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Create a Git commit
+ * @param {string} dir - Repository directory
+ * @param {string} message - Commit message
+ * @returns {boolean} True if successful
+ */
+function commit(dir, message) {
+  try {
+    const result = spawnSync('git', ['commit', '-m', message], {
+      cwd: dir,
+      stdio: 'pipe',
+    });
+    return result.status === 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Get the current branch name
+ * @param {string} dir - Repository directory
+ * @returns {string|null} Branch name or null if not in a repo
+ */
+function getCurrentBranch(dir) {
+  try {
+    const result = spawnSync('git', ['branch', '--show-current'], {
+      cwd: dir,
+      stdio: 'pipe',
+    });
+    if (result.status === 0) {
+      return result.stdout.toString().trim();
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get the status of the repository
+ * @param {string} dir - Repository directory
+ * @returns {Object} Status object with modified, staged, untracked files
+ */
+function getStatus(dir) {
+  try {
+    const result = spawnSync('git', ['status', '--porcelain'], {
+      cwd: dir,
+      stdio: 'pipe',
+    });
+
+    if (result.status !== 0) {
+      return { modified: [], staged: [], untracked: [] };
+    }
+
+    const lines = result.stdout.toString().trim().split('\n').filter(Boolean);
+    const status = { modified: [], staged: [], untracked: [] };
+
+    for (const line of lines) {
+      const code = line.substring(0, 2);
+      const file = line.substring(3);
+
+      if (code.includes('?')) {
+        status.untracked.push(file);
+      } else if (code[0] !== ' ') {
+        status.staged.push(file);
+      } else if (code[1] !== ' ') {
+        status.modified.push(file);
+      }
+    }
+
+    return status;
+  } catch (e) {
+    return { modified: [], staged: [], untracked: [] };
+  }
+}
+
+/**
+ * Get commit log
+ * @param {string} dir - Repository directory
+ * @param {number} count - Number of commits to retrieve
+ * @returns {Array} Array of commit objects
+ */
+function getLog(dir, count = 10) {
+  try {
+    const result = spawnSync(
+      'git',
+      ['log', `--max-count=${count}`, '--pretty=format:%H|%s|%ai|%an'],
+      {
+        cwd: dir,
+        stdio: 'pipe',
+      }
+    );
+
+    if (result.status !== 0) {
+      return [];
+    }
+
+    const lines = result.stdout.toString().trim().split('\n').filter(Boolean);
+    return lines.map((line) => {
+      const [hash, subject, date, author] = line.split('|');
+      return { hash, subject, date, author };
+    });
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Check if there are uncommitted changes
+ * @param {string} dir - Repository directory
+ * @returns {boolean} True if there are uncommitted changes
+ */
+function hasUncommittedChanges(dir) {
+  const status = getStatus(dir);
+  return status.modified.length > 0 || status.staged.length > 0 || status.untracked.length > 0;
+}
+
+/**
+ * Checkout a specific commit or branch
+ * @param {string} dir - Repository directory
+ * @param {string} ref - Reference to checkout (commit hash, branch, tag)
+ * @returns {boolean} True if successful
+ */
+function checkout(dir, ref) {
+  try {
+    const result = spawnSync('git', ['checkout', ref], {
+      cwd: dir,
+      stdio: 'pipe',
+    });
+    return result.status === 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Get diff between two commits or current changes
+ * @param {string} dir - Repository directory
+ * @param {string} from - Starting reference (optional)
+ * @param {string} to - Ending reference (optional)
+ * @returns {string} Diff output
+ */
+function getDiff(dir, from = null, to = null) {
+  try {
+    const args = ['diff'];
+    if (from) args.push(from);
+    if (to) args.push(to);
+
+    const result = spawnSync('git', args, {
+      cwd: dir,
+      stdio: 'pipe',
+    });
+
+    return result.stdout.toString();
+  } catch (e) {
+    return '';
+  }
+}
+
+/**
+ * Execute a raw Git command and return output
+ * @param {string} dir - Repository directory
+ * @param {string[]} args - Git command arguments
+ * @returns {string|null} Command output or null on failure
+ */
+function execGitCommand(dir, args) {
+  try {
+    const result = spawnSync('git', args, {
+      cwd: dir,
+      stdio: 'pipe',
+      maxBuffer: 1024 * 1024 * 10, // 10MB buffer for large outputs
+    });
+
+    if (result.status === 0) {
+      return result.stdout.toString();
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get file modification date from last commit
+ * @param {string} dir - Repository directory
+ * @param {string} filePath - Path to file relative to repo root
+ * @returns {Date|null} Last modification date or null
+ */
+function getFileLastModified(dir, filePath) {
+  try {
+    const result = spawnSync('git', ['log', '-1', '--format=%ai', '--', filePath], {
+      cwd: dir,
+      stdio: 'pipe',
+    });
+
+    if (result.status === 0) {
+      const dateStr = result.stdout.toString().trim();
+      return dateStr ? new Date(dateStr) : null;
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+module.exports = {
+  isGitInstalled,
+  isGitRepo,
+  initRepo,
+  stageFiles,
+  commit,
+  getCurrentBranch,
+  getStatus,
+  getLog,
+  hasUncommittedChanges,
+  checkout,
+  getDiff,
+  execGitCommand,
+  getFileLastModified,
+};