@luquimbo/bi-superpowers 1.0.0

package/bin/utils/pbix.js

@@ -0,0 +1,305 @@
+/**
+ * Power BI File Utilities for BI Agent Superpowers
+ * =================================================
+ *
+ * Handles extraction and manipulation of Power BI files (.pbix, .pbip).
+ *
+ * Note: .pbix files are ZIP archives containing:
+ * - DataModel (binary - Analysis Services database)
+ * - Report/Layout (JSON)
+ * - Connections (JSON)
+ * - Metadata (XML)
+ *
+ * For TMDL extraction, we rely on Power BI Desktop's "Save as PBIP" feature
+ * or the pbi-tools utility. Direct extraction from .pbix is complex.
+ *
+ * @module utils/pbix
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Supported file types and their handlers
+ */
+const FILE_TYPES = {
+  '.pbix': 'power-bi',
+  '.pbip': 'power-bi-project',
+  '.xlsx': 'excel',
+  '.xlsm': 'excel-macro',
+};
+
+/**
+ * Detect the type of BI file
+ * @param {string} filePath - Path to the file
+ * @returns {Object} File info object
+ */
+function detectFileType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const type = FILE_TYPES[ext] || 'unknown';
+
+  return {
+    path: filePath,
+    extension: ext,
+    type,
+    name: path.basename(filePath, ext),
+    exists: fs.existsSync(filePath),
+  };
+}
+
+/**
+ * Check if a file is a Power BI project (.pbip)
+ * @param {string} filePath - Path to check
+ * @returns {boolean} True if it's a PBIP project
+ */
+function isPbipProject(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext === '.pbip';
+}
+
+/**
+ * Get the TMDL definition folder for a PBIP project
+ * @param {string} pbipPath - Path to .pbip file
+ * @returns {string|null} Path to definition folder or null
+ */
+function getPbipDefinitionPath(pbipPath) {
+  const dir = path.dirname(pbipPath);
+  const name = path.basename(pbipPath, '.pbip');
+
+  // PBIP structure: Project.pbip + Project.SemanticModel/definition/
+  const semanticModelDir = path.join(dir, `${name}.SemanticModel`);
+  const definitionDir = path.join(semanticModelDir, 'definition');
+
+  if (fs.existsSync(definitionDir)) {
+    return definitionDir;
+  }
+
+  // Alternative structure: definition folder next to .pbip
+  const altDefinitionDir = path.join(dir, 'definition');
+  if (fs.existsSync(altDefinitionDir)) {
+    return altDefinitionDir;
+  }
+
+  return null;
+}
+
+/**
+ * Copy PBIP definition to the repo project folder
+ * @param {string} pbipPath - Path to .pbip file
+ * @param {string} projectDir - Target project directory in repo
+ * @returns {Object} Result with success status and copied files
+ */
+function extractPbipToRepo(pbipPath, projectDir) {
+  const result = {
+    success: false,
+    files: [],
+    error: null,
+  };
+
+  const definitionPath = getPbipDefinitionPath(pbipPath);
+
+  if (!definitionPath) {
+    result.error = 'Could not find TMDL definition folder for PBIP project';
+    return result;
+  }
+
+  const targetDir = path.join(projectDir, 'definition');
+
+  try {
+    // Create target directory
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    // Copy all files recursively
+    result.files = copyDirectoryRecursive(definitionPath, targetDir);
+    result.success = true;
+  } catch (e) {
+    result.error = e.message;
+  }
+
+  return result;
+}
+
+/**
+ * Copy directory recursively
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ * @returns {string[]} List of copied files (relative paths)
+ */
+function copyDirectoryRecursive(src, dest, baseSrc = src) {
+  const copied = [];
+
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copied.push(...copyDirectoryRecursive(srcPath, destPath, baseSrc));
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+      copied.push(path.relative(baseSrc, srcPath));
+    }
+  }
+
+  return copied;
+}
+
+/**
+ * Get file hash for change detection
+ * @param {string} filePath - Path to file
+ * @returns {string} Hash string
+ */
+function getFileHash(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return '';
+  }
+
+  const crypto = require('crypto');
+  const content = fs.readFileSync(filePath);
+  return crypto.createHash('md5').update(content).digest('hex');
+}
+
+/**
+ * Get last modified time of a file
+ * @param {string} filePath - Path to file
+ * @returns {Date|null} Last modified date or null
+ */
+function getLastModified(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  const stats = fs.statSync(filePath);
+  return stats.mtime;
+}
+
+/**
+ * Compare two directories and find differences
+ * @param {string} dir1 - First directory
+ * @param {string} dir2 - Second directory
+ * @returns {Object} Differences object
+ */
+function compareDirectories(dir1, dir2) {
+  const diff = {
+    added: [],
+    modified: [],
+    deleted: [],
+  };
+
+  const files1 = getAllFiles(dir1);
+  const files2 = getAllFiles(dir2);
+
+  const set1 = new Set(files1.map((f) => path.relative(dir1, f)));
+  const set2 = new Set(files2.map((f) => path.relative(dir2, f)));
+
+  // Find added (in dir2 but not dir1)
+  for (const file of set2) {
+    if (!set1.has(file)) {
+      diff.added.push(file);
+    }
+  }
+
+  // Find deleted (in dir1 but not dir2)
+  for (const file of set1) {
+    if (!set2.has(file)) {
+      diff.deleted.push(file);
+    }
+  }
+
+  // Find modified (in both but different)
+  for (const file of set1) {
+    if (set2.has(file)) {
+      const path1 = path.join(dir1, file);
+      const path2 = path.join(dir2, file);
+
+      if (getFileHash(path1) !== getFileHash(path2)) {
+        diff.modified.push(file);
+      }
+    }
+  }
+
+  return diff;
+}
+
+/**
+ * Get all files in a directory recursively
+ * @param {string} dir - Directory to scan
+ * @returns {string[]} Array of file paths
+ */
+function getAllFiles(dir) {
+  const files = [];
+
+  if (!fs.existsSync(dir)) {
+    return files;
+  }
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      files.push(...getAllFiles(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Create project.json for a new project
+ * @param {Object} options - Project options
+ * @returns {Object} Project configuration object
+ */
+function createProjectConfig(options) {
+  return {
+    name: options.name,
+    displayName: options.displayName || options.name,
+    type: options.type || 'power-bi',
+    profile: options.profile || 'default',
+    source: {
+      path: options.sourcePath,
+      lastSync: new Date().toISOString(),
+      hash: options.sourcePath ? getFileHash(options.sourcePath) : '',
+    },
+    created: new Date().toISOString(),
+    description: options.description || '',
+  };
+}
+
+/**
+ * Generate a slug from a display name
+ * @param {string} name - Display name
+ * @returns {string} URL-friendly slug
+ */
+function generateSlug(name) {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .substring(0, 50);
+}
+
+module.exports = {
+  FILE_TYPES,
+  detectFileType,
+  isPbipProject,
+  getPbipDefinitionPath,
+  extractPbipToRepo,
+  copyDirectoryRecursive,
+  getFileHash,
+  getLastModified,
+  compareDirectories,
+  getAllFiles,
+  createProjectConfig,
+  generateSlug,
+};

package/bin/utils/pbix.test.js

@@ -0,0 +1,37 @@
+/**
+ * Tests for Power BI file utilities
+ * @module utils/pbix.test
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const pbix = require('./pbix');
+
+function makeTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'bi-superpowers-pbix-'));
+}
+
+test('copyDirectoryRecursive returns relative paths for nested files', () => {
+  const dir = makeTempDir();
+
+  const src = path.join(dir, 'src');
+  const dest = path.join(dir, 'dest');
+
+  fs.mkdirSync(path.join(src, 'subdir'), { recursive: true });
+  fs.writeFileSync(path.join(src, 'root.txt'), 'root');
+  fs.writeFileSync(path.join(src, 'subdir', 'nested.txt'), 'nested');
+
+  const copied = pbix.copyDirectoryRecursive(src, dest);
+
+  // Returned paths should be relative to the source root
+  assert.ok(copied.includes('root.txt'));
+  assert.ok(copied.includes(path.join('subdir', 'nested.txt')));
+
+  // Files should exist in destination with the same structure
+  assert.equal(fs.readFileSync(path.join(dest, 'root.txt'), 'utf8'), 'root');
+  assert.equal(fs.readFileSync(path.join(dest, 'subdir', 'nested.txt'), 'utf8'), 'nested');
+});

package/bin/utils/profiles.js

@@ -0,0 +1,312 @@
+/**
+ * Profile Management Utilities for BI Agent Superpowers
+ * =====================================================
+ *
+ * Handles profile configuration, inheritance, and management.
+ * Profiles allow users to have different sets of snippets for
+ * different industries (finance, retail, healthcare, etc.)
+ *
+ * @module utils/profiles
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/** Base directory for BI Superpowers global config */
+const BASE_CONFIG_DIR = path.join(os.homedir(), '.bi-superpowers');
+
+/** Path to global config file */
+const CONFIG_FILE = path.join(BASE_CONFIG_DIR, 'config.json');
+
+/** Path to profiles directory */
+const PROFILES_DIR = path.join(BASE_CONFIG_DIR, 'profiles');
+
+/**
+ * Default configuration structure
+ */
+const DEFAULT_CONFIG = {
+  version: '3.0',
+  defaultProfile: 'default',
+  profiles: {},
+  repoPath: null,
+};
+
+/**
+ * Ensure the base config directory exists
+ */
+function ensureConfigDir() {
+  if (!fs.existsSync(BASE_CONFIG_DIR)) {
+    fs.mkdirSync(BASE_CONFIG_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(PROFILES_DIR)) {
+    fs.mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Load the global configuration
+ * @returns {Object} Configuration object
+ */
+function loadConfig() {
+  ensureConfigDir();
+
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf8');
+      return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+    } catch (e) {
+      return { ...DEFAULT_CONFIG };
+    }
+  }
+
+  return { ...DEFAULT_CONFIG };
+}
+
+/**
+ * Save the global configuration
+ * @param {Object} config - Configuration to save
+ */
+function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Get the path to the user's bi-repo
+ * @returns {string|null} Path to bi-repo or null if not configured
+ */
+function getRepoPath() {
+  const config = loadConfig();
+  return config.repoPath;
+}
+
+/**
+ * Set the path to the user's bi-repo
+ * @param {string} repoPath - Path to the bi-repo
+ */
+function setRepoPath(repoPath) {
+  const config = loadConfig();
+  config.repoPath = repoPath;
+  saveConfig(config);
+}
+
+/**
+ * Get list of available profiles
+ * @returns {string[]} Array of profile names
+ */
+function listProfiles() {
+  ensureConfigDir();
+
+  if (!fs.existsSync(PROFILES_DIR)) {
+    return ['default'];
+  }
+
+  const profiles = fs
+    .readdirSync(PROFILES_DIR)
+    .filter((f) => fs.statSync(path.join(PROFILES_DIR, f)).isDirectory());
+
+  // Always include default
+  if (!profiles.includes('default')) {
+    profiles.unshift('default');
+  }
+
+  return profiles;
+}
+
+/**
+ * Check if a profile exists
+ * @param {string} profileName - Name of the profile
+ * @returns {boolean} True if profile exists
+ */
+function profileExists(profileName) {
+  const profilePath = path.join(PROFILES_DIR, profileName);
+  return fs.existsSync(profilePath);
+}
+
+/**
+ * Create a new profile
+ * @param {string} profileName - Name of the new profile
+ * @param {Object} options - Options for the profile
+ * @param {string} options.inheritsFrom - Parent profile name
+ * @returns {boolean} True if successful
+ */
+function createProfile(profileName, options = {}) {
+  ensureConfigDir();
+
+  const profilePath = path.join(PROFILES_DIR, profileName);
+
+  if (fs.existsSync(profilePath)) {
+    return false;
+  }
+
+  // Create profile directory structure
+  fs.mkdirSync(profilePath, { recursive: true });
+  fs.mkdirSync(path.join(profilePath, 'snippets'), { recursive: true });
+
+  // Update config with inheritance
+  const config = loadConfig();
+  if (options.inheritsFrom) {
+    config.profiles[profileName] = { inheritsFrom: options.inheritsFrom };
+  } else {
+    config.profiles[profileName] = {};
+  }
+  saveConfig(config);
+
+  return true;
+}
+
+/**
+ * Get the inheritance chain for a profile
+ * @param {string} profileName - Name of the profile
+ * @returns {string[]} Array of profile names from most specific to base
+ */
+function getInheritanceChain(profileName) {
+  const config = loadConfig();
+  const chain = [profileName];
+
+  let current = profileName;
+  const visited = new Set([profileName]);
+
+  while (config.profiles[current]?.inheritsFrom) {
+    const parent = config.profiles[current].inheritsFrom;
+
+    // Prevent circular dependencies
+    if (visited.has(parent)) {
+      break;
+    }
+
+    chain.push(parent);
+    visited.add(parent);
+    current = parent;
+  }
+
+  return chain;
+}
+
+/**
+ * Get all snippets for a profile, including inherited ones
+ * @param {string} profileName - Name of the profile
+ * @returns {Object[]} Array of snippet objects with path and profile
+ */
+function getProfileSnippets(profileName) {
+  const chain = getInheritanceChain(profileName);
+  const snippets = [];
+  const seen = new Set();
+
+  // Process from most specific to least specific
+  for (const profile of chain) {
+    const profilePath = path.join(PROFILES_DIR, profile, 'snippets');
+
+    if (!fs.existsSync(profilePath)) {
+      continue;
+    }
+
+    // Recursively find all .md files
+    const files = findMdFiles(profilePath);
+
+    for (const file of files) {
+      const relativePath = path.relative(profilePath, file);
+
+      // Skip if we already have this snippet from a more specific profile
+      if (!seen.has(relativePath)) {
+        seen.add(relativePath);
+        snippets.push({
+          path: file,
+          relativePath,
+          profile,
+        });
+      }
+    }
+  }
+
+  return snippets;
+}
+
+/**
+ * Recursively find all .md files in a directory
+ * @param {string} dir - Directory to search
+ * @returns {string[]} Array of file paths
+ */
+function findMdFiles(dir) {
+  const files = [];
+
+  if (!fs.existsSync(dir)) {
+    return files;
+  }
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      files.push(...findMdFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Copy a snippet to a profile
+ * @param {string} sourcePath - Path to the source snippet
+ * @param {string} profileName - Target profile name
+ * @param {string} relativePath - Relative path within snippets folder
+ * @returns {boolean} True if successful
+ */
+function copySnippetToProfile(sourcePath, profileName, relativePath) {
+  const targetPath = path.join(PROFILES_DIR, profileName, 'snippets', relativePath);
+  const targetDir = path.dirname(targetPath);
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  try {
+    fs.copyFileSync(sourcePath, targetPath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Get the default profile name
+ * @returns {string} Default profile name
+ */
+function getDefaultProfile() {
+  const config = loadConfig();
+  return config.defaultProfile || 'default';
+}
+
+/**
+ * Set the default profile
+ * @param {string} profileName - Profile to set as default
+ */
+function setDefaultProfile(profileName) {
+  const config = loadConfig();
+  config.defaultProfile = profileName;
+  saveConfig(config);
+}
+
+module.exports = {
+  BASE_CONFIG_DIR,
+  PROFILES_DIR,
+  ensureConfigDir,
+  loadConfig,
+  saveConfig,
+  getRepoPath,
+  setRepoPath,
+  listProfiles,
+  profileExists,
+  createProfile,
+  getInheritanceChain,
+  getProfileSnippets,
+  findMdFiles,
+  copySnippetToProfile,
+  getDefaultProfile,
+  setDefaultProfile,
+};