@girardmedia/bootspring 1.1.0

package/cli/telemetry.js

@@ -0,0 +1,114 @@
+/**
+ * Bootspring Telemetry Command
+ * Inspect and upload telemetry events.
+ */
+
+const utils = require('../core/utils');
+const telemetry = require('../core/telemetry');
+
+function showStatus() {
+  const status = telemetry.getStatus();
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Telemetry Status${utils.COLORS.reset}
+${utils.COLORS.dim}File: ${status.file}${utils.COLORS.reset}
+${utils.COLORS.dim}Events: ${status.count}${utils.COLORS.reset}
+${utils.COLORS.dim}Last event: ${status.lastEventAt || 'none'}${utils.COLORS.reset}
+`);
+}
+
+function listEvents(options = {}) {
+  const records = telemetry.listEvents(options);
+  if (records.length === 0) {
+    utils.print.warning('No telemetry events found');
+    return;
+  }
+
+  records.forEach(record => {
+    console.log(`${utils.COLORS.cyan}${record.timestamp}${utils.COLORS.reset} ${record.event}`);
+  });
+  console.log(`\n${utils.COLORS.dim}${records.length} event(s)${utils.COLORS.reset}`);
+}
+
+async function upload(options = {}) {
+  const spinner = utils.createSpinner('Uploading telemetry events').start();
+  try {
+    const result = await telemetry.uploadEvents({
+      endpoint: options.endpoint,
+      token: options.token,
+      event: options.event,
+      limit: options.limit,
+      clearOnSuccess: options.clear
+    });
+    spinner.succeed(`Uploaded ${result.uploaded} event(s)`);
+    utils.print.dim(`Endpoint: ${result.endpoint}`);
+    utils.print.dim(`Remaining local events: ${result.remaining}`);
+  } catch (error) {
+    spinner.fail(`Upload failed: ${error.message}`);
+  }
+}
+
+function clear() {
+  const result = telemetry.clearEvents();
+  utils.print.success(`Cleared ${result.cleared} event(s)`);
+}
+
+function help() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring Telemetry${utils.COLORS.reset}
+
+${utils.COLORS.cyan}Usage:${utils.COLORS.reset}
+  bootspring telemetry <command> [options]
+
+${utils.COLORS.cyan}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}status${utils.COLORS.reset}                   Show telemetry status
+  ${utils.COLORS.cyan}list${utils.COLORS.reset}                     List telemetry events
+  ${utils.COLORS.cyan}upload${utils.COLORS.reset}                   Upload events to endpoint
+  ${utils.COLORS.cyan}clear${utils.COLORS.reset}                    Clear local event log
+
+${utils.COLORS.cyan}Options:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}--event <name>${utils.COLORS.reset}           Filter by event name
+  ${utils.COLORS.cyan}--limit <n>${utils.COLORS.reset}              Limit listed/uploaded events
+  ${utils.COLORS.cyan}--endpoint <url>${utils.COLORS.reset}         Upload endpoint override
+  ${utils.COLORS.cyan}--token <value>${utils.COLORS.reset}          Upload bearer token
+  ${utils.COLORS.cyan}--clear${utils.COLORS.reset}                  Clear local events on successful upload
+`);
+}
+
+async function run(args) {
+  const parsed = utils.parseArgs(args);
+  const command = parsed._[0] || 'status';
+
+  switch (command) {
+    case 'status':
+      showStatus();
+      break;
+    case 'list':
+      listEvents({
+        event: parsed.event,
+        limit: parsed.limit ? Number(parsed.limit) : undefined
+      });
+      break;
+    case 'upload':
+      await upload({
+        endpoint: parsed.endpoint,
+        token: parsed.token,
+        event: parsed.event,
+        limit: parsed.limit ? Number(parsed.limit) : undefined,
+        clear: Boolean(parsed.clear)
+      });
+      break;
+    case 'clear':
+      clear();
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+      help();
+      break;
+    default:
+      utils.print.error(`Unknown telemetry command: ${command}`);
+      help();
+  }
+}
+
+module.exports = { run };

package/cli/todo.js

@@ -0,0 +1,614 @@
+/**
+ * Bootspring Todo Command
+ * Simple and powerful todo management
+ *
+ * @package bootspring
+ * @command todo
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('../core/config');
+const utils = require('../core/utils');
+
+// ============================================================================
+// Utility Functions (for programmatic/test use)
+// ============================================================================
+
+/**
+ * Parse todo file and return todos
+ * @param {string} filePath - Path to todo file
+ * @returns {object[]} Array of todos with { done, text } format
+ */
+function parseTodoFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const todos = [];
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      const match = line.match(/^(\s*)-\s*\[([ xX])\]\s*(.+)$/);
+      if (match) {
+        todos.push({
+          done: match[2].toLowerCase() === 'x',
+          text: match[3].trim()
+        });
+      }
+    }
+
+    return todos;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Write todos to file
+ * @param {string} filePath - Path to todo file
+ * @param {object[]} items - Array of todos with { done, text } format
+ */
+function writeTodoFile(filePath, items) {
+  const lines = ['# Todo', ''];
+
+  for (const item of items) {
+    const checkbox = item.done ? '[x]' : '[ ]';
+    lines.push(`- ${checkbox} ${item.text}`);
+  }
+
+  lines.push(''); // trailing newline
+  fs.writeFileSync(filePath, lines.join('\n'), 'utf-8');
+}
+
+/**
+ * Add a todo to file (utility function)
+ * @param {string} filePath - Path to todo file
+ * @param {string} text - Todo text
+ */
+function addTodoUtil(filePath, text) {
+  const todos = parseTodoFile(filePath);
+  todos.push({ done: false, text });
+  writeTodoFile(filePath, todos);
+}
+
+/**
+ * Mark a todo as done (utility function)
+ * @param {string} filePath - Path to todo file
+ * @param {number} index - Zero-based index
+ */
+function markDone(filePath, index) {
+  const todos = parseTodoFile(filePath);
+  if (index >= 0 && index < todos.length) {
+    todos[index].done = true;
+    writeTodoFile(filePath, todos);
+  }
+}
+
+/**
+ * Mark a todo as not done (utility function)
+ * @param {string} filePath - Path to todo file
+ * @param {number} index - Zero-based index
+ */
+function markUndone(filePath, index) {
+  const todos = parseTodoFile(filePath);
+  if (index >= 0 && index < todos.length) {
+    todos[index].done = false;
+    writeTodoFile(filePath, todos);
+  }
+}
+
+/**
+ * Remove a todo by index (utility function)
+ * @param {string} filePath - Path to todo file
+ * @param {number} index - Zero-based index
+ */
+function removeTodoUtil(filePath, index) {
+  const todos = parseTodoFile(filePath);
+  if (index >= 0 && index < todos.length) {
+    todos.splice(index, 1);
+    writeTodoFile(filePath, todos);
+  }
+}
+
+/**
+ * Clear todos (utility function)
+ * @param {string} filePath - Path to todo file
+ * @param {string} type - 'completed' or 'all'
+ */
+function clearTodos(filePath, type = 'completed') {
+  const todos = parseTodoFile(filePath);
+
+  if (type === 'all') {
+    writeTodoFile(filePath, []);
+  } else if (type === 'completed') {
+    const remaining = todos.filter(t => !t.done);
+    writeTodoFile(filePath, remaining);
+  }
+}
+
+/**
+ * List all todos from file (utility function)
+ * @param {string} filePath - Path to todo file
+ * @returns {object[]} Array of todos
+ */
+function listTodosUtil(filePath) {
+  return parseTodoFile(filePath);
+}
+
+// ============================================================================
+// Internal Parsing (for CLI use)
+// ============================================================================
+
+/**
+ * Parse todo.md file content
+ * @param {string} content - File content
+ * @returns {object[]} Array of todos with full metadata
+ */
+function parseTodos(content) {
+  const todos = [];
+  const lines = content.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Match todo items: - [ ] or - [x]
+    const match = line.match(/^(\s*)-\s*\[([ xX])\]\s*(.+)$/);
+    if (match) {
+      todos.push({
+        index: todos.length + 1,
+        indent: match[1].length,
+        completed: match[2].toLowerCase() === 'x',
+        text: match[3].trim(),
+        line: i
+      });
+    }
+  }
+
+  return todos;
+}
+
+/**
+ * Format todos for display
+ * @param {object[]} todos - Array of todos
+ * @param {object} options - Display options
+ */
+function displayTodos(todos, options = {}) {
+  const { showCompleted = true, showIndex = true } = options;
+
+  const pending = todos.filter(t => !t.completed);
+  const completed = todos.filter(t => t.completed);
+
+  if (pending.length === 0 && completed.length === 0) {
+    utils.print.dim('No todos found. Add one with: bootspring todo add "Your task"');
+    return;
+  }
+
+  // Display pending
+  if (pending.length > 0) {
+    console.log(`\n${utils.COLORS.bold}Pending (${pending.length})${utils.COLORS.reset}\n`);
+    for (const todo of pending) {
+      const index = showIndex ? `${utils.COLORS.dim}${String(todo.index).padStart(2)}${utils.COLORS.reset} ` : '';
+      const indent = ' '.repeat(todo.indent);
+      console.log(`${index}${indent}${utils.COLORS.yellow}○${utils.COLORS.reset} ${todo.text}`);
+    }
+  }
+
+  // Display completed
+  if (showCompleted && completed.length > 0) {
+    console.log(`\n${utils.COLORS.bold}Completed (${completed.length})${utils.COLORS.reset}\n`);
+    for (const todo of completed) {
+      const index = showIndex ? `${utils.COLORS.dim}${String(todo.index).padStart(2)}${utils.COLORS.reset} ` : '';
+      const indent = ' '.repeat(todo.indent);
+      console.log(`${index}${indent}${utils.COLORS.green}●${utils.COLORS.reset} ${utils.COLORS.dim}${todo.text}${utils.COLORS.reset}`);
+    }
+  }
+
+  console.log();
+}
+
+/**
+ * Get todo file path
+ * @returns {string} Todo file path
+ */
+function getTodoPath() {
+  const cfg = config.load();
+  return path.join(cfg._projectRoot, cfg.paths?.todo || 'todo.md');
+}
+
+/**
+ * Read todo file
+ * @returns {string} File content
+ */
+function readTodoFile() {
+  const todoPath = getTodoPath();
+  if (!utils.fileExists(todoPath)) {
+    // Create default todo file
+    const defaultContent = `# Todo List\n\n## Pending\n\n## Completed\n`;
+    utils.writeFile(todoPath, defaultContent);
+    return defaultContent;
+  }
+  return utils.readFile(todoPath);
+}
+
+/**
+ * Save todo file content (internal CLI use)
+ * @param {string} content - File content
+ */
+function saveTodoContent(content) {
+  const todoPath = getTodoPath();
+  utils.writeFile(todoPath, content);
+}
+
+/**
+ * List all todos
+ */
+function listTodos(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+
+  console.log(`${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Todo${utils.COLORS.reset}`);
+
+  displayTodos(todos, {
+    showCompleted: !parsedArgs.pending,
+    showIndex: true
+  });
+
+  // Summary
+  const pending = todos.filter(t => !t.completed).length;
+  const completed = todos.filter(t => t.completed).length;
+  utils.print.dim(`${pending} pending, ${completed} completed`);
+}
+
+/**
+ * Add a new todo
+ */
+function addTodo(args) {
+  const text = args.join(' ').trim();
+
+  if (!text) {
+    utils.print.error('Please provide a todo text');
+    utils.print.dim('Usage: bootspring todo add "Your task"');
+    return;
+  }
+
+  const content = readTodoFile();
+  const lines = content.split('\n');
+
+  // Find the "Pending" section or add after first heading
+  let insertIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/^##?\s*(Pending|In Progress|Todo)/i)) {
+      insertIndex = i + 1;
+      // Skip empty lines after heading
+      while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+        insertIndex++;
+      }
+      break;
+    }
+  }
+
+  // If no section found, add after first heading
+  if (insertIndex === -1) {
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith('#')) {
+        insertIndex = i + 1;
+        break;
+      }
+    }
+  }
+
+  // If still no good place, add at the end
+  if (insertIndex === -1) {
+    insertIndex = lines.length;
+  }
+
+  // Insert the new todo
+  const newTodo = `- [ ] ${text}`;
+  lines.splice(insertIndex, 0, newTodo);
+
+  saveTodoContent(lines.join('\n'));
+
+  utils.print.success(`Added: ${text}`);
+
+  // Show count
+  const todos = parseTodos(lines.join('\n'));
+  const pending = todos.filter(t => !t.completed).length;
+  utils.print.dim(`${pending} pending todos`);
+}
+
+/**
+ * Mark todo as done
+ */
+function doneTodo(args) {
+  const indexStr = args[0];
+
+  if (!indexStr) {
+    utils.print.error('Please provide a todo number');
+    utils.print.dim('Usage: bootspring todo done <number>');
+    return;
+  }
+
+  const index = parseInt(indexStr, 10);
+  if (isNaN(index) || index < 1) {
+    utils.print.error('Invalid todo number');
+    return;
+  }
+
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+
+  const todo = todos.find(t => t.index === index);
+  if (!todo) {
+    utils.print.error(`Todo #${index} not found`);
+    return;
+  }
+
+  if (todo.completed) {
+    utils.print.warning(`Todo #${index} is already completed`);
+    return;
+  }
+
+  // Update the line
+  const lines = content.split('\n');
+  const originalLine = lines[todo.line];
+  lines[todo.line] = originalLine.replace('[ ]', '[x]');
+
+  saveTodoContent(lines.join('\n'));
+
+  utils.print.success(`Completed: ${todo.text}`);
+
+  // Show remaining
+  const remaining = todos.filter(t => !t.completed && t.index !== index).length;
+  utils.print.dim(`${remaining} pending todos remaining`);
+}
+
+/**
+ * Undo a completed todo
+ */
+function undoTodo(args) {
+  const indexStr = args[0];
+
+  if (!indexStr) {
+    utils.print.error('Please provide a todo number');
+    utils.print.dim('Usage: bootspring todo undo <number>');
+    return;
+  }
+
+  const index = parseInt(indexStr, 10);
+  if (isNaN(index) || index < 1) {
+    utils.print.error('Invalid todo number');
+    return;
+  }
+
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+
+  const todo = todos.find(t => t.index === index);
+  if (!todo) {
+    utils.print.error(`Todo #${index} not found`);
+    return;
+  }
+
+  if (!todo.completed) {
+    utils.print.warning(`Todo #${index} is not completed`);
+    return;
+  }
+
+  // Update the line
+  const lines = content.split('\n');
+  const originalLine = lines[todo.line];
+  lines[todo.line] = originalLine.replace(/\[[xX]\]/, '[ ]');
+
+  saveTodoContent(lines.join('\n'));
+
+  utils.print.success(`Reopened: ${todo.text}`);
+}
+
+/**
+ * Remove a todo
+ */
+function removeTodo(args) {
+  const indexStr = args[0];
+
+  if (!indexStr) {
+    utils.print.error('Please provide a todo number');
+    utils.print.dim('Usage: bootspring todo remove <number>');
+    return;
+  }
+
+  const index = parseInt(indexStr, 10);
+  if (isNaN(index) || index < 1) {
+    utils.print.error('Invalid todo number');
+    return;
+  }
+
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+
+  const todo = todos.find(t => t.index === index);
+  if (!todo) {
+    utils.print.error(`Todo #${index} not found`);
+    return;
+  }
+
+  // Remove the line
+  const lines = content.split('\n');
+  lines.splice(todo.line, 1);
+
+  saveTodoContent(lines.join('\n'));
+
+  utils.print.success(`Removed: ${todo.text}`);
+}
+
+/**
+ * Clear completed todos
+ */
+function clearCompleted() {
+  const content = readTodoFile();
+  const todos = parseTodos(content);
+  const completedTodos = todos.filter(t => t.completed);
+
+  if (completedTodos.length === 0) {
+    utils.print.info('No completed todos to clear');
+    return;
+  }
+
+  // Remove completed lines (in reverse order to maintain indices)
+  const lines = content.split('\n');
+  const linesToRemove = completedTodos.map(t => t.line).sort((a, b) => b - a);
+
+  for (const lineIndex of linesToRemove) {
+    lines.splice(lineIndex, 1);
+  }
+
+  saveTodoContent(lines.join('\n'));
+
+  utils.print.success(`Cleared ${completedTodos.length} completed todos`);
+}
+
+/**
+ * Show todo help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Todo${utils.COLORS.reset}
+${utils.COLORS.dim}Simple and powerful todo management${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring todo <command> [args]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}list${utils.COLORS.reset}              List all todos
+  ${utils.COLORS.cyan}add${utils.COLORS.reset} <text>       Add a new todo
+  ${utils.COLORS.cyan}done${utils.COLORS.reset} <number>    Mark todo as completed
+  ${utils.COLORS.cyan}undo${utils.COLORS.reset} <number>    Reopen a completed todo
+  ${utils.COLORS.cyan}remove${utils.COLORS.reset} <number>  Remove a todo
+  ${utils.COLORS.cyan}clear${utils.COLORS.reset}            Clear all completed todos
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring todo add "Implement user auth"
+  bootspring todo done 1
+  bootspring todo list --pending
+  bootspring todo clear
+`);
+}
+
+/**
+ * Run todo command
+ */
+async function run(args) {
+  const subcommand = args[0] || 'list';
+  const subargs = args.slice(1);
+
+  switch (subcommand) {
+    case 'list':
+    case 'ls':
+      listTodos(subargs);
+      break;
+
+    case 'add':
+    case 'a':
+    case 'new':
+      addTodo(subargs);
+      break;
+
+    case 'done':
+    case 'd':
+    case 'complete':
+    case 'check':
+      doneTodo(subargs);
+      break;
+
+    case 'undo':
+    case 'u':
+    case 'reopen':
+      undoTodo(subargs);
+      break;
+
+    case 'remove':
+    case 'rm':
+    case 'delete':
+      removeTodo(subargs);
+      break;
+
+    case 'clear':
+      clearCompleted();
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      // If it looks like a todo text, treat as add
+      if (subcommand && !subcommand.startsWith('-')) {
+        addTodo([subcommand, ...subargs]);
+      } else {
+        utils.print.error(`Unknown subcommand: ${subcommand}`);
+        showHelp();
+      }
+  }
+}
+
+// Smart wrapper that detects if called with file path or CLI args
+function addTodoSmart(firstArg, secondArg) {
+  if (typeof firstArg === 'string' && typeof secondArg === 'string') {
+    // Utility mode: addTodo(filePath, text)
+    return addTodoUtil(firstArg, secondArg);
+  } else if (Array.isArray(firstArg)) {
+    // CLI mode: addTodo(args)
+    return addTodo(firstArg);
+  } else {
+    // Default CLI mode with single arg treated as array
+    return addTodo([firstArg, secondArg].filter(Boolean));
+  }
+}
+
+function removeTodoSmart(firstArg, secondArg) {
+  if (typeof firstArg === 'string' && typeof secondArg === 'number') {
+    // Utility mode: removeTodo(filePath, index)
+    return removeTodoUtil(firstArg, secondArg);
+  } else if (Array.isArray(firstArg)) {
+    // CLI mode: removeTodo(args)
+    return removeTodo(firstArg);
+  } else {
+    return removeTodo([firstArg]);
+  }
+}
+
+function listTodosSmart(firstArg) {
+  if (typeof firstArg === 'string' && (firstArg.includes('/') || firstArg.includes('\\'))) {
+    // Utility mode: listTodos(filePath)
+    return listTodosUtil(firstArg);
+  } else if (Array.isArray(firstArg)) {
+    // CLI mode: listTodos(args)
+    return listTodos(firstArg);
+  } else {
+    return listTodos([firstArg].filter(Boolean));
+  }
+}
+
+module.exports = {
+  // CLI command runner
+  run,
+
+  // CLI-focused internal functions
+  parseTodos,
+  doneTodo,
+  undoTodo,
+  clearCompleted,
+
+  // Utility functions (for programmatic/test use)
+  parseTodoFile,
+  writeTodoFile,
+  markDone,
+  markUndone,
+  clearTodos,
+
+  // Smart wrappers that work in both modes
+  addTodo: addTodoSmart,
+  removeTodo: removeTodoSmart,
+  listTodos: listTodosSmart
+};