@luquimbo/bi-superpowers 1.0.0

package/bin/utils/projects.js

@@ -0,0 +1,168 @@
+/**
+ * Projects Utility
+ * =================
+ *
+ * Shared functions for working with bi-repo projects.
+ * Extracted from add.js, pull.js, push.js to reduce duplication.
+ *
+ * @module utils/projects
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get a specific project by name
+ * @param {string} repoPath - Path to bi-repo
+ * @param {string} projectName - Name of the project
+ * @returns {Object|null} Project config with projectPath added, or null
+ */
+function getProject(repoPath, projectName) {
+  const projectPath = path.join(repoPath, 'projects', projectName);
+  const configPath = path.join(projectPath, 'project.json');
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return {
+      ...config,
+      projectPath,
+    };
+  } catch (e) {
+    // Invalid JSON in config file
+    if (process.env.DEBUG === 'true') {
+      console.error(`[DEBUG] Failed to parse project config: ${configPath}`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Get list of all projects in the repo
+ * @param {string} repoPath - Path to bi-repo
+ * @returns {Object[]} Array of project configs with projectPath added
+ */
+function getAllProjects(repoPath) {
+  const projectsDir = path.join(repoPath, 'projects');
+
+  if (!fs.existsSync(projectsDir)) {
+    return [];
+  }
+
+  const projects = [];
+  const dirs = fs.readdirSync(projectsDir);
+
+  for (const dir of dirs) {
+    const projectPath = path.join(projectsDir, dir);
+
+    // Skip if not a directory
+    try {
+      if (!fs.statSync(projectPath).isDirectory()) {
+        continue;
+      }
+    } catch (e) {
+      continue;
+    }
+
+    const configPath = path.join(projectPath, 'project.json');
+
+    if (fs.existsSync(configPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        projects.push({
+          ...config,
+          projectPath,
+        });
+      } catch (e) {
+        // Skip invalid configs
+        if (process.env.DEBUG === 'true') {
+          console.error(`[DEBUG] Skipping invalid config: ${configPath}`);
+        }
+      }
+    }
+  }
+
+  return projects;
+}
+
+/**
+ * Detect current project based on working directory
+ * @param {string} repoPath - Path to bi-repo
+ * @returns {Object|null} Project config or null if not in a project folder
+ */
+function detectCurrentProject(repoPath) {
+  const cwd = process.cwd();
+  const projectsBase = path.join(repoPath, 'projects');
+
+  // Check if we're inside a project folder
+  if (cwd.startsWith(projectsBase)) {
+    const relative = path.relative(projectsBase, cwd);
+    const projectName = relative.split(path.sep)[0];
+
+    if (projectName && projectName !== '..') {
+      return getProject(repoPath, projectName);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * List project names
+ * @param {string} repoPath - Path to bi-repo
+ * @returns {string[]} Array of project names
+ */
+function listProjectNames(repoPath) {
+  return getAllProjects(repoPath).map((p) => p.name);
+}
+
+/**
+ * Check if a project exists
+ * @param {string} repoPath - Path to bi-repo
+ * @param {string} projectName - Name of the project
+ * @returns {boolean} True if project exists
+ */
+function projectExists(repoPath, projectName) {
+  const projectPath = path.join(repoPath, 'projects', projectName);
+  const configPath = path.join(projectPath, 'project.json');
+  return fs.existsSync(configPath);
+}
+
+/**
+ * Get project path
+ * @param {string} repoPath - Path to bi-repo
+ * @param {string} projectName - Name of the project
+ * @returns {string} Path to project directory
+ */
+function getProjectPath(repoPath, projectName) {
+  return path.join(repoPath, 'projects', projectName);
+}
+
+/**
+ * Print available projects to console
+ * @param {string} repoPath - Path to bi-repo
+ * @param {string} prefix - Prefix for each line (default: '  - ')
+ */
+function printAvailableProjects(repoPath, prefix = '  - ') {
+  const projects = getAllProjects(repoPath);
+  if (projects.length === 0) {
+    console.log(`${prefix}(no projects found)`);
+  } else {
+    projects.forEach((p) => {
+      console.log(`${prefix}${p.name}`);
+    });
+  }
+}
+
+module.exports = {
+  getProject,
+  getAllProjects,
+  detectCurrentProject,
+  listProjectNames,
+  projectExists,
+  getProjectPath,
+  printAvailableProjects,
+};

package/bin/utils/readline.js

@@ -0,0 +1,206 @@
+/**
+ * Readline Utilities for BI Agent Superpowers
+ * ============================================
+ *
+ * Shared readline functions for interactive CLI commands.
+ * Consolidates duplicated code from setup.js, add.js, sync-source.js, sync-profile.js
+ *
+ * @module utils/readline
+ */
+
+const readline = require('readline');
+
+/**
+ * Create a readline interface for interactive prompts
+ * @returns {readline.Interface} Readline interface
+ */
+function createReadline() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+/**
+ * Prompt the user for input
+ * @param {readline.Interface} rl - Readline interface
+ * @param {string} question - Question to ask
+ * @returns {Promise<string>} User's answer (trimmed)
+ */
+function prompt(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Ask for yes/no confirmation
+ * @param {readline.Interface} rl - Readline interface
+ * @param {string} question - Question to ask (without y/n suffix)
+ * @param {boolean} defaultValue - Default value if user just presses Enter
+ * @returns {Promise<boolean>} True if confirmed, false otherwise
+ */
+function confirm(rl, question, defaultValue = false) {
+  const suffix = defaultValue ? ' (S/n): ' : ' (s/N): ';
+  return new Promise((resolve) => {
+    rl.question(question + suffix, (answer) => {
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === '') {
+        resolve(defaultValue);
+      } else {
+        resolve(trimmed === 's' || trimmed === 'y' || trimmed === 'si' || trimmed === 'yes');
+      }
+    });
+  });
+}
+
+/**
+ * Ask user to select from a list of options
+ * @param {readline.Interface} rl - Readline interface
+ * @param {string} question - Question to ask
+ * @param {string[]} options - Array of option strings
+ * @param {number} defaultIndex - Default option index (0-based)
+ * @returns {Promise<{index: number, value: string}>} Selected option
+ */
+async function select(rl, question, options, defaultIndex = 0) {
+  console.log(`\n${question}\n`);
+
+  options.forEach((option, i) => {
+    const marker = i === defaultIndex ? '>' : ' ';
+    console.log(`  ${marker} ${i + 1}. ${option}`);
+  });
+
+  console.log('');
+
+  const answer = await prompt(rl, `Elige una opción (1-${options.length}) [${defaultIndex + 1}]: `);
+
+  if (answer === '') {
+    return { index: defaultIndex, value: options[defaultIndex] };
+  }
+
+  const num = parseInt(answer, 10);
+  if (isNaN(num) || num < 1 || num > options.length) {
+    console.log('Opción no válida, usando la predeterminada.');
+    return { index: defaultIndex, value: options[defaultIndex] };
+  }
+
+  return { index: num - 1, value: options[num - 1] };
+}
+
+/**
+ * Ask user to select multiple options from a list
+ * @param {readline.Interface} rl - Readline interface
+ * @param {string} question - Question to ask
+ * @param {Array<{label: string, value: any, selected?: boolean}>} options - Options with labels and values
+ * @returns {Promise<any[]>} Array of selected values
+ */
+async function multiSelect(rl, question, options) {
+  console.log(`\n${question}\n`);
+  console.log('  Instrucciones:');
+  console.log('  - Escribe números separados por comas (ej: 1,3,5)');
+  console.log('  - "a" para seleccionar todos');
+  console.log('  - "n" para deseleccionar todos');
+  console.log('  - Enter para confirmar selección actual\n');
+
+  // Show options with current selection
+  options.forEach((option, i) => {
+    const marker = option.selected ? '[x]' : '[ ]';
+    console.log(`  ${marker} ${i + 1}. ${option.label}`);
+  });
+
+  console.log('');
+
+  const answer = await prompt(rl, 'Selección: ');
+
+  if (answer.toLowerCase() === 'a') {
+    return options.map((o) => o.value);
+  }
+
+  if (answer.toLowerCase() === 'n' || answer === '') {
+    return options.filter((o) => o.selected).map((o) => o.value);
+  }
+
+  // Parse comma-separated numbers
+  const indices = answer
+    .split(',')
+    .map((s) => parseInt(s.trim(), 10) - 1)
+    .filter((n) => !isNaN(n) && n >= 0 && n < options.length);
+
+  return indices.map((i) => options[i].value);
+}
+
+/**
+ * Show a spinner while executing an async operation
+ * @param {string} message - Message to show
+ * @param {Promise} promise - Promise to wait for
+ * @returns {Promise} Result of the promise
+ */
+async function withSpinner(message, promise) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+
+  const interval = setInterval(() => {
+    process.stdout.write(`\r${frames[i]} ${message}`);
+    i = (i + 1) % frames.length;
+  }, 80);
+
+  try {
+    const result = await promise;
+    clearInterval(interval);
+    process.stdout.write(`\r✓ ${message}\n`);
+    return result;
+  } catch (error) {
+    clearInterval(interval);
+    process.stdout.write(`\r✗ ${message}\n`);
+    throw error;
+  }
+}
+
+/**
+ * Exit with error message
+ * @param {string} message - Error message
+ * @param {number} code - Exit code (default 1)
+ */
+function exitWithError(message, code = 1) {
+  console.error(`\n✗ ${message}\n`);
+  process.exit(code);
+}
+
+/**
+ * Show success message
+ * @param {string} message - Success message
+ */
+function showSuccess(message) {
+  console.log(`✓ ${message}`);
+}
+
+/**
+ * Show warning message
+ * @param {string} message - Warning message
+ */
+function showWarning(message) {
+  console.log(`⚠ ${message}`);
+}
+
+/**
+ * Show info message
+ * @param {string} message - Info message
+ */
+function showInfo(message) {
+  console.log(`ℹ ${message}`);
+}
+
+module.exports = {
+  createReadline,
+  prompt,
+  confirm,
+  select,
+  multiSelect,
+  withSpinner,
+  exitWithError,
+  showSuccess,
+  showWarning,
+  showInfo,
+};

package/bin/utils/readline.test.js

@@ -0,0 +1,47 @@
+/**
+ * Tests for Readline Utilities
+ * @module utils/readline.test
+ */
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert');
+
+const readline = require('./readline');
+
+describe('Readline Utilities', () => {
+  test('exports createReadline function', () => {
+    assert.strictEqual(typeof readline.createReadline, 'function');
+  });
+
+  test('exports prompt function', () => {
+    assert.strictEqual(typeof readline.prompt, 'function');
+  });
+
+  test('exports confirm function', () => {
+    assert.strictEqual(typeof readline.confirm, 'function');
+  });
+
+  test('exports select function', () => {
+    assert.strictEqual(typeof readline.select, 'function');
+  });
+
+  test('exports multiSelect function', () => {
+    assert.strictEqual(typeof readline.multiSelect, 'function');
+  });
+
+  test('exports exitWithError function', () => {
+    assert.strictEqual(typeof readline.exitWithError, 'function');
+  });
+
+  test('exports showSuccess function', () => {
+    assert.strictEqual(typeof readline.showSuccess, 'function');
+  });
+
+  test('exports showWarning function', () => {
+    assert.strictEqual(typeof readline.showWarning, 'function');
+  });
+
+  test('exports showInfo function', () => {
+    assert.strictEqual(typeof readline.showInfo, 'function');
+  });
+});