aios-core 1.0.0

package/.aios-core/cli/commands/workers/formatters/list-table.js

@@ -0,0 +1,265 @@
+/**
+ * List Table Formatter
+ *
+ * Formats worker list as a table with columns.
+ *
+ * @module cli/commands/workers/formatters/list-table
+ * @version 1.0.0
+ * @story 2.8-2.9 - Discovery CLI Info & List
+ */
+
+const yaml = require('js-yaml');
+
+/**
+ * Column definitions with default widths
+ */
+const COLUMNS = {
+  num: { header: '#', width: 4 },
+  id: { header: 'ID', width: 30 },
+  name: { header: 'NAME', width: 30 },
+  category: { header: 'CATEGORY', width: 12 },
+  subcategory: { header: 'SUBCATEGORY', width: 15 },
+};
+
+/**
+ * Format workers as table
+ * @param {Array} workers - Array of workers
+ * @param {object} options - Formatting options
+ * @param {object} options.pagination - Pagination info
+ * @param {boolean} options.verbose - Show verbose output
+ * @returns {string} Table formatted output
+ */
+function formatTable(workers, options = {}) {
+  const { pagination, verbose = false } = options;
+
+  if (workers.length === 0) {
+    return 'No workers found.\n';
+  }
+
+  // Calculate dynamic column widths based on content
+  const idWidth = Math.min(35, Math.max(COLUMNS.id.width, ...workers.map(w => w.id.length)));
+  const nameWidth = Math.min(35, Math.max(COLUMNS.name.width, ...workers.map(w => w.name.length)));
+  const categoryWidth = Math.min(15, Math.max(COLUMNS.category.width, ...workers.map(w => (w.category || '').length)));
+  const subcategoryWidth = Math.min(15, Math.max(COLUMNS.subcategory.width, ...workers.map(w => (w.subcategory || '').length)));
+
+  let output = '';
+
+  // Table header
+  output += `${'#'.padEnd(4)}  `;
+  output += `${'ID'.padEnd(idWidth)}  `;
+  output += `${'NAME'.padEnd(nameWidth)}  `;
+  output += `${'CATEGORY'.padEnd(categoryWidth)}  `;
+  output += `${'SUBCATEGORY'.padEnd(subcategoryWidth)}\n`;
+
+  // Header separator
+  output += `${'─'.repeat(4)}  `;
+  output += `${'─'.repeat(idWidth)}  `;
+  output += `${'─'.repeat(nameWidth)}  `;
+  output += `${'─'.repeat(categoryWidth)}  `;
+  output += `${'─'.repeat(subcategoryWidth)}\n`;
+
+  // Determine starting row number based on pagination
+  const startNum = pagination ? pagination.startIndex : 1;
+
+  // Table rows
+  workers.forEach((worker, index) => {
+    const num = (startNum + index).toString().padEnd(4);
+    const id = truncate(worker.id, idWidth).padEnd(idWidth);
+    const name = truncate(worker.name, nameWidth).padEnd(nameWidth);
+    const category = truncate(worker.category || '', categoryWidth).padEnd(categoryWidth);
+    const subcategory = truncate(worker.subcategory || '', subcategoryWidth).padEnd(subcategoryWidth);
+
+    output += `${num}  ${id}  ${name}  ${category}  ${subcategory}\n`;
+  });
+
+  // Pagination info
+  if (pagination) {
+    output += `\n${formatPaginationLine(pagination)}`;
+  }
+
+  // Verbose debug info
+  if (verbose) {
+    output += '\n[Debug Info]\n';
+    output += `  Displayed: ${workers.length} workers\n`;
+    if (pagination) {
+      output += `  Page: ${pagination.page}/${pagination.totalPages}\n`;
+    }
+  }
+
+  return output;
+}
+
+/**
+ * Format workers as JSON list
+ * @param {Array} workers - Array of workers
+ * @param {object} options - Formatting options
+ * @param {object} options.pagination - Pagination info
+ * @returns {string} JSON string
+ */
+function formatJSON(workers, options = {}) {
+  const { pagination } = options;
+
+  const output = workers.map(worker => ({
+    id: worker.id,
+    name: worker.name,
+    category: worker.category,
+    subcategory: worker.subcategory || null,
+    tags: worker.tags || [],
+    path: worker.path,
+  }));
+
+  if (pagination) {
+    return JSON.stringify({
+      data: output,
+      pagination: {
+        page: pagination.page,
+        limit: pagination.limit,
+        totalItems: pagination.totalItems,
+        totalPages: pagination.totalPages,
+      },
+    }, null, 2);
+  }
+
+  return JSON.stringify(output, null, 2);
+}
+
+/**
+ * Format workers as YAML list
+ * @param {Array} workers - Array of workers
+ * @param {object} options - Formatting options
+ * @param {object} options.pagination - Pagination info
+ * @returns {string} YAML string
+ */
+function formatYAML(workers, options = {}) {
+  const { pagination } = options;
+
+  const output = workers.map(worker => ({
+    id: worker.id,
+    name: worker.name,
+    category: worker.category,
+    subcategory: worker.subcategory || null,
+    tags: worker.tags || [],
+    path: worker.path,
+  }));
+
+  if (pagination) {
+    return yaml.dump({
+      data: output,
+      pagination: {
+        page: pagination.page,
+        limit: pagination.limit,
+        totalItems: pagination.totalItems,
+        totalPages: pagination.totalPages,
+      },
+    }, {
+      indent: 2,
+      lineWidth: 120,
+      noRefs: true,
+    });
+  }
+
+  return yaml.dump(output, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+  });
+}
+
+/**
+ * Format count summary
+ * @param {object} categories - Categories object with counts
+ * @param {number} totalWorkers - Total worker count
+ * @param {object} options - Formatting options
+ * @returns {string} Count summary output
+ */
+function formatCount(categories, totalWorkers, options = {}) {
+  const { verbose = false } = options;
+
+  let output = `Total: ${totalWorkers} workers\n\n`;
+
+  // Sort categories by count descending
+  const sorted = Object.entries(categories)
+    .sort((a, b) => b[1].count - a[1].count);
+
+  for (const [name, data] of sorted) {
+    output += `${name.toUpperCase().padEnd(15)} ${data.count.toString().padStart(4)} workers\n`;
+
+    // Show subcategories if verbose
+    if (verbose && data.subcategories && data.subcategories.length > 0) {
+      for (const sub of data.subcategories) {
+        output += `  └── ${sub}\n`;
+      }
+    }
+  }
+
+  return output;
+}
+
+/**
+ * Format list output based on format option
+ * @param {Array} workers - Array of workers
+ * @param {object} options - Formatting options
+ * @param {string} options.format - Output format (table, json, yaml, tree)
+ * @param {object} options.pagination - Pagination info
+ * @param {boolean} options.verbose - Show verbose output
+ * @returns {string} Formatted output
+ */
+function formatList(workers, options = {}) {
+  const format = (options.format || 'table').toLowerCase();
+
+  switch (format) {
+    case 'json':
+      return formatJSON(workers, options);
+    case 'yaml':
+      return formatYAML(workers, options);
+    case 'table':
+    default:
+      return formatTable(workers, options);
+  }
+}
+
+/**
+ * Truncate string with ellipsis
+ * @param {string} str - String to truncate
+ * @param {number} maxLen - Maximum length
+ * @returns {string} Truncated string
+ */
+function truncate(str, maxLen) {
+  if (!str) return '';
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 1) + '…';
+}
+
+/**
+ * Format pagination line
+ * @param {object} pagination - Pagination object
+ * @returns {string} Pagination line
+ */
+function formatPaginationLine(pagination) {
+  const { startIndex, endIndex, totalItems, page, totalPages } = pagination;
+
+  if (totalItems === 0) return 'No items found.';
+  if (totalPages === 1) return `Showing all ${totalItems} workers.`;
+
+  let line = `Showing ${startIndex}-${endIndex} of ${totalItems} workers`;
+  line += ` (page ${page}/${totalPages})`;
+
+  const hints = [];
+  if (page > 1) hints.push(`--page=${page - 1} prev`);
+  if (page < totalPages) hints.push(`--page=${page + 1} next`);
+
+  if (hints.length > 0) {
+    line += `  [${hints.join(', ')}]`;
+  }
+
+  return line;
+}
+
+module.exports = {
+  formatTable,
+  formatJSON,
+  formatYAML,
+  formatList,
+  formatCount,
+  truncate,
+};

package/.aios-core/cli/commands/workers/formatters/list-tree.js

@@ -0,0 +1,159 @@
+/**
+ * List Tree Formatter
+ *
+ * Formats worker list as a tree view grouped by category/subcategory.
+ *
+ * @module cli/commands/workers/formatters/list-tree
+ * @version 1.0.0
+ * @story 2.8-2.9 - Discovery CLI Info & List
+ */
+
+/**
+ * Tree drawing characters
+ */
+const TREE = {
+  branch: '├──',
+  lastBranch: '└──',
+  vertical: '│',
+  empty: '   ',
+};
+
+/**
+ * Group workers by category and subcategory
+ * @param {Array} workers - Array of workers
+ * @returns {object} Grouped workers
+ */
+function groupWorkers(workers) {
+  const groups = {};
+
+  for (const worker of workers) {
+    const category = worker.category || 'uncategorized';
+    const subcategory = worker.subcategory || 'general';
+
+    if (!groups[category]) {
+      groups[category] = {
+        count: 0,
+        subcategories: {},
+      };
+    }
+
+    if (!groups[category].subcategories[subcategory]) {
+      groups[category].subcategories[subcategory] = [];
+    }
+
+    groups[category].subcategories[subcategory].push(worker);
+    groups[category].count++;
+  }
+
+  return groups;
+}
+
+/**
+ * Format workers as tree view
+ * @param {Array} workers - Array of workers
+ * @param {object} options - Formatting options
+ * @param {boolean} options.collapsed - Show collapsed view (hide individual workers)
+ * @param {number} options.maxPerSubcategory - Max workers to show per subcategory
+ * @param {boolean} options.verbose - Show verbose output
+ * @returns {string} Tree formatted output
+ */
+function formatTree(workers, options = {}) {
+  const { collapsed = false, maxPerSubcategory = 4, verbose = false } = options;
+
+  if (workers.length === 0) {
+    return 'No workers found.\n';
+  }
+
+  const groups = groupWorkers(workers);
+  const categories = Object.keys(groups).sort();
+
+  let output = '';
+  output += `${workers.length} workers available in ${categories.length} categories:\n\n`;
+
+  for (let catIdx = 0; catIdx < categories.length; catIdx++) {
+    const category = categories[catIdx];
+    const group = groups[category];
+    const isLastCategory = catIdx === categories.length - 1;
+
+    // Category header (uppercase)
+    output += `${category.toUpperCase()} (${group.count} workers)\n`;
+
+    // Subcategories
+    const subcategories = Object.keys(group.subcategories).sort();
+
+    for (let subIdx = 0; subIdx < subcategories.length; subIdx++) {
+      const subcategory = subcategories[subIdx];
+      const subWorkers = group.subcategories[subcategory];
+      const isLastSubcategory = subIdx === subcategories.length - 1;
+      const subPrefix = isLastSubcategory ? TREE.lastBranch : TREE.branch;
+
+      // Subcategory header with count
+      const subcategoryTitle = capitalize(subcategory);
+      output += `${subPrefix} ${subcategoryTitle} (${subWorkers.length})\n`;
+
+      // Workers (if not collapsed)
+      if (!collapsed) {
+        const workersToShow = subWorkers.slice(0, maxPerSubcategory);
+        const hiddenCount = subWorkers.length - workersToShow.length;
+        const continuePrefix = isLastSubcategory ? TREE.empty : TREE.vertical;
+
+        for (let workerIdx = 0; workerIdx < workersToShow.length; workerIdx++) {
+          const worker = workersToShow[workerIdx];
+          const isLastWorker = workerIdx === workersToShow.length - 1 && hiddenCount === 0;
+          const workerPrefix = isLastWorker ? TREE.lastBranch : TREE.branch;
+
+          output += `${continuePrefix}   ${workerPrefix} ${worker.id}\n`;
+        }
+
+        // Show hidden count
+        if (hiddenCount > 0) {
+          output += `${continuePrefix}   ${TREE.lastBranch} ... (+${hiddenCount} more)\n`;
+        }
+      }
+    }
+
+    // Add blank line between categories (except last)
+    if (!isLastCategory) {
+      output += '\n';
+    }
+  }
+
+  // Footer hints
+  output += '\nUse \'aios workers info <id>\' for details.\n';
+  output += 'Use \'aios workers search <query>\' to search.\n';
+
+  // Verbose debug info
+  if (verbose) {
+    output += '\n[Debug Info]\n';
+    output += `  Total workers: ${workers.length}\n`;
+    output += `  Categories: ${categories.join(', ')}\n`;
+  }
+
+  return output;
+}
+
+/**
+ * Format workers as collapsed tree (categories only)
+ * @param {Array} workers - Array of workers
+ * @param {object} options - Formatting options
+ * @returns {string} Collapsed tree output
+ */
+function formatTreeCollapsed(workers, options = {}) {
+  return formatTree(workers, { ...options, collapsed: true });
+}
+
+/**
+ * Capitalize first letter
+ * @param {string} str - String to capitalize
+ * @returns {string} Capitalized string
+ */
+function capitalize(str) {
+  if (!str) return '';
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+module.exports = {
+  formatTree,
+  formatTreeCollapsed,
+  groupWorkers,
+};

package/.aios-core/cli/commands/workers/index.js

@@ -0,0 +1,56 @@
+/**
+ * Workers Command Module
+ *
+ * Entry point for all workers-related CLI commands.
+ * Includes search, list, and info subcommands.
+ *
+ * @module cli/commands/workers
+ * @version 1.1.0
+ * @story 2.7 - Discovery CLI Search
+ * @story 2.8-2.9 - Discovery CLI Info & List
+ */
+
+const { Command } = require('commander');
+const { createSearchCommand } = require('./search');
+const { createInfoCommand } = require('./info');
+const { createListCommand } = require('./list');
+
+/**
+ * Create the workers command with all subcommands
+ * @returns {Command} Commander command instance
+ */
+function createWorkersCommand() {
+  const workers = new Command('workers');
+
+  workers
+    .description('Manage and discover workers in the service registry')
+    .addHelpText('after', `
+Commands:
+  search <query>    Search for workers matching a query
+  list              List all workers grouped by category
+  info <id>         Show detailed information about a worker
+
+Examples:
+  $ aios workers search "json transformation"
+  $ aios workers search "data" --category=etl
+  $ aios workers list --category=testing
+  $ aios workers list --format=table --page=2
+  $ aios workers info json-csv-transformer
+  $ aios workers info architect-checklist --format=json
+`);
+
+  // Add search subcommand (Story 2.7)
+  workers.addCommand(createSearchCommand());
+
+  // Add info subcommand (Story 2.8)
+  workers.addCommand(createInfoCommand());
+
+  // Add list subcommand (Story 2.9)
+  workers.addCommand(createListCommand());
+
+  return workers;
+}
+
+module.exports = {
+  createWorkersCommand,
+};

package/.aios-core/cli/commands/workers/info.js

@@ -0,0 +1,194 @@
+/**
+ * Info Command - Show detailed worker information
+ *
+ * Implements `aios workers info <id>` CLI command.
+ * Displays complete worker metadata, usage examples, and related workers.
+ *
+ * @module cli/commands/workers/info
+ * @version 1.0.0
+ * @story 2.8-2.9 - Discovery CLI Info & List
+ */
+
+const { Command } = require('commander');
+const { getRegistry } = require('../../../core/registry/registry-loader');
+const { formatInfo, formatNotFoundError } = require('./formatters/info-formatter');
+const { levenshteinDistance } = require('./search-keyword');
+
+/**
+ * Create the info command
+ * @returns {Command} Commander command instance
+ */
+function createInfoCommand() {
+  const info = new Command('info');
+
+  info
+    .description('Show detailed information about a worker')
+    .argument('<id>', 'Worker ID to display')
+    .option('-f, --format <format>', 'Output format: pretty, json, yaml', 'pretty')
+    .option('-v, --verbose', 'Show verbose/debug output')
+    .addHelpText('after', `
+Examples:
+  $ aios workers info json-csv-transformer
+  $ aios workers info architect-checklist --format=json
+  $ aios workers info create-story --format=yaml
+  $ aios workers info data-analyzer --verbose
+
+Output Formats:
+  pretty   Formatted text with sections and boxes (default)
+  json     JSON object with all metadata
+  yaml     YAML document with all metadata
+`)
+    .action(executeInfo);
+
+  return info;
+}
+
+/**
+ * Execute the info command
+ * @param {string} id - Worker ID to lookup
+ * @param {object} options - Command options
+ */
+async function executeInfo(id, options) {
+  const startTime = Date.now();
+
+  try {
+    // Validate ID
+    if (!id || id.trim().length === 0) {
+      console.error('Error: Worker ID cannot be empty');
+      process.exit(1);
+    }
+
+    const trimmedId = id.trim().toLowerCase();
+    const registry = getRegistry();
+
+    if (options.verbose) {
+      console.log(`Looking up worker: "${trimmedId}"`);
+      console.log(`Output format: ${options.format}`);
+      console.log('');
+    }
+
+    // Try to get worker by exact ID
+    const worker = await registry.getById(trimmedId);
+
+    if (!worker) {
+      // Worker not found - find suggestions
+      const suggestions = await findSuggestions(registry, trimmedId);
+      console.error(formatNotFoundError(trimmedId, suggestions));
+      process.exit(1);
+    }
+
+    // Find related workers (same category/subcategory or shared tags)
+    const relatedWorkers = await findRelatedWorkers(registry, worker);
+
+    // Format and output
+    const output = formatInfo(worker, {
+      format: options.format,
+      relatedWorkers,
+      verbose: options.verbose,
+    });
+
+    console.log(output);
+
+    // Performance check
+    const duration = Date.now() - startTime;
+    if (options.verbose) {
+      console.log(`\n[Performance: ${duration}ms]`);
+    }
+
+    // Warn if over target
+    if (duration > 500) {
+      console.warn(`\nWarning: Info command took ${duration}ms (target: < 500ms)`);
+    }
+
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    if (options.verbose) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Find worker suggestions for "did you mean?" feature
+ * @param {ServiceRegistry} registry - Registry instance
+ * @param {string} invalidId - Invalid ID entered by user
+ * @returns {Promise<Array>} Array of suggested workers
+ */
+async function findSuggestions(registry, invalidId) {
+  const workers = await registry.getAll();
+  const suggestions = [];
+
+  for (const worker of workers) {
+    const idLower = worker.id.toLowerCase();
+
+    // Check for partial match
+    if (idLower.includes(invalidId) || invalidId.includes(idLower)) {
+      suggestions.push({ worker, score: 90 });
+      continue;
+    }
+
+    // Check Levenshtein distance for similar IDs
+    const distance = levenshteinDistance(invalidId, idLower);
+    const maxLen = Math.max(invalidId.length, idLower.length);
+    const similarity = 1 - (distance / maxLen);
+
+    if (similarity >= 0.5) {
+      suggestions.push({ worker, score: Math.round(similarity * 100) });
+    }
+  }
+
+  // Sort by score descending and return top 5
+  suggestions.sort((a, b) => b.score - a.score);
+  return suggestions.slice(0, 5).map(s => s.worker);
+}
+
+/**
+ * Find related workers based on category and tags
+ * @param {ServiceRegistry} registry - Registry instance
+ * @param {object} worker - Current worker
+ * @returns {Promise<Array>} Array of related workers
+ */
+async function findRelatedWorkers(registry, worker) {
+  const related = new Map();
+
+  // Get workers in same category/subcategory
+  const categoryWorkers = await registry.getByCategory(worker.category);
+
+  for (const catWorker of categoryWorkers) {
+    if (catWorker.id === worker.id) continue;
+
+    // Higher priority for same subcategory
+    const score = catWorker.subcategory === worker.subcategory ? 10 : 5;
+    related.set(catWorker.id, { worker: catWorker, score });
+  }
+
+  // Get workers with shared tags
+  for (const tag of worker.tags || []) {
+    const tagWorkers = await registry.getByTag(tag);
+
+    for (const tagWorker of tagWorkers) {
+      if (tagWorker.id === worker.id) continue;
+
+      if (related.has(tagWorker.id)) {
+        // Increment score for shared tag
+        related.get(tagWorker.id).score += 2;
+      } else {
+        related.set(tagWorker.id, { worker: tagWorker, score: 2 });
+      }
+    }
+  }
+
+  // Sort by score descending
+  const sorted = Array.from(related.values())
+    .sort((a, b) => b.score - a.score);
+
+  return sorted.slice(0, 5).map(r => r.worker);
+}
+
+module.exports = {
+  createInfoCommand,
+  executeInfo,
+  findSuggestions,
+  findRelatedWorkers,
+};