aios-core 1.0.0

package/.aios-core/cli/utils/output-formatter-cli.js

@@ -0,0 +1,232 @@
+/**
+ * CLI Output Formatter
+ *
+ * Formats search results for CLI output in table, JSON, or YAML format.
+ *
+ * @module cli/utils/output-formatter-cli
+ * @version 1.0.0
+ * @story 2.7 - Discovery CLI Search
+ */
+
+const yaml = require('js-yaml');
+
+/**
+ * Format output based on specified format
+ * @param {Array} results - Search results
+ * @param {object} options - Formatting options
+ * @param {string} options.format - Output format: table, json, yaml
+ * @param {string} options.query - Original search query
+ * @param {string} options.duration - Search duration
+ * @param {string} options.searchMethod - Search method used
+ * @param {boolean} options.verbose - Show verbose output
+ * @returns {string} Formatted output string
+ */
+function formatOutput(results, options = {}) {
+  const { format = 'table', query, duration, searchMethod, verbose } = options;
+
+  switch (format.toLowerCase()) {
+    case 'json':
+      return formatJSON(results, options);
+    case 'yaml':
+      return formatYAML(results, options);
+    case 'table':
+    default:
+      return formatTable(results, options);
+  }
+}
+
+/**
+ * Format results as table
+ * @param {Array} results - Search results
+ * @param {object} options - Options
+ * @returns {string} Table formatted string
+ */
+function formatTable(results, options = {}) {
+  const { query = '', duration = '0', searchMethod = 'keyword', verbose = false } = options;
+
+  if (results.length === 0) {
+    return `No workers found matching "${query}".\n\nTry different search terms or check available categories with 'aios workers list --categories'.`;
+  }
+
+  // Header
+  let output = `Found ${results.length} worker${results.length !== 1 ? 's' : ''} (took ${duration}s):\n\n`;
+
+  // Column widths
+  const idWidth = Math.min(25, Math.max(4, ...results.map(r => r.id.length)));
+  const nameWidth = Math.min(30, Math.max(4, ...results.map(r => r.name.length)));
+  const categoryWidth = Math.min(15, Math.max(8, ...results.map(r => (r.category || '').length)));
+
+  // Table header
+  output += `  ${'#'.padEnd(3)}  ${'ID'.padEnd(idWidth)}  ${'NAME'.padEnd(nameWidth)}  ${'CATEGORY'.padEnd(categoryWidth)}  SCORE\n`;
+  output += `  ${'─'.repeat(3)}  ${'─'.repeat(idWidth)}  ${'─'.repeat(nameWidth)}  ${'─'.repeat(categoryWidth)}  ${'─'.repeat(5)}\n`;
+
+  // Table rows
+  results.forEach((result, index) => {
+    const num = (index + 1).toString().padEnd(3);
+    const id = truncate(result.id, idWidth).padEnd(idWidth);
+    const name = truncate(result.name, nameWidth).padEnd(nameWidth);
+    const category = truncate(result.category || '', categoryWidth).padEnd(categoryWidth);
+    const score = `${result.score}%`;
+
+    output += `  ${num}  ${id}  ${name}  ${category}  ${score}\n`;
+  });
+
+  // Footer
+  output += '\nUse \'aios workers info <id>\' for details.';
+
+  // Verbose info
+  if (verbose) {
+    output += `\n\n[Debug: method=${searchMethod}]`;
+  }
+
+  return output;
+}
+
+/**
+ * Format results as JSON
+ * @param {Array} results - Search results
+ * @param {object} options - Options
+ * @returns {string} JSON formatted string
+ */
+function formatJSON(results, options = {}) {
+  const output = results.map(result => ({
+    id: result.id,
+    name: result.name,
+    description: result.description,
+    category: result.category,
+    subcategory: result.subcategory || null,
+    tags: result.tags || [],
+    score: result.score,
+    path: result.path,
+  }));
+
+  return JSON.stringify(output, null, 2);
+}
+
+/**
+ * Format results as YAML
+ * @param {Array} results - Search results
+ * @param {object} options - Options
+ * @returns {string} YAML formatted string
+ */
+function formatYAML(results, options = {}) {
+  const output = results.map(result => ({
+    id: result.id,
+    name: result.name,
+    description: result.description,
+    category: result.category,
+    subcategory: result.subcategory || null,
+    tags: result.tags || [],
+    score: result.score,
+    path: result.path,
+  }));
+
+  return yaml.dump(output, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+  });
+}
+
+/**
+ * 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 a single worker for detailed view
+ * @param {object} worker - Worker object
+ * @returns {string} Formatted worker details
+ */
+function formatWorkerDetails(worker) {
+  let output = '';
+
+  output += `📦 ${worker.name}\n`;
+  output += `${'─'.repeat(40)}\n`;
+  output += `ID:          ${worker.id}\n`;
+  output += `Category:    ${worker.category}`;
+  if (worker.subcategory) {
+    output += ` / ${worker.subcategory}`;
+  }
+  output += '\n';
+
+  output += `\n📝 Description:\n${worker.description}\n`;
+
+  if (worker.tags && worker.tags.length > 0) {
+    output += `\n🏷️  Tags: ${worker.tags.join(', ')}\n`;
+  }
+
+  if (worker.inputs && worker.inputs.length > 0) {
+    output += '\n📥 Inputs:\n';
+    worker.inputs.forEach(input => {
+      output += `   • ${input}\n`;
+    });
+  }
+
+  if (worker.outputs && worker.outputs.length > 0) {
+    output += '\n📤 Outputs:\n';
+    worker.outputs.forEach(out => {
+      output += `   • ${out}\n`;
+    });
+  }
+
+  output += `\n📁 Path: ${worker.path}\n`;
+  output += `📋 Format: ${worker.taskFormat}\n`;
+
+  if (worker.executorTypes && worker.executorTypes.length > 0) {
+    output += `⚙️  Executors: ${worker.executorTypes.join(', ')}\n`;
+  }
+
+  if (worker.performance) {
+    output += '\n⏱️  Performance:\n';
+    if (worker.performance.avgDuration) {
+      output += `   • Avg Duration: ${worker.performance.avgDuration}\n`;
+    }
+    if (worker.performance.cacheable !== undefined) {
+      output += `   • Cacheable: ${worker.performance.cacheable ? 'Yes' : 'No'}\n`;
+    }
+    if (worker.performance.parallelizable !== undefined) {
+      output += `   • Parallelizable: ${worker.performance.parallelizable ? 'Yes' : 'No'}\n`;
+    }
+  }
+
+  return output;
+}
+
+/**
+ * Format category summary
+ * @param {object} categories - Categories object from registry
+ * @returns {string} Formatted categories
+ */
+function formatCategories(categories) {
+  let output = 'Available Categories:\n\n';
+
+  const sortedCategories = Object.entries(categories)
+    .sort((a, b) => b[1].count - a[1].count);
+
+  for (const [name, data] of sortedCategories) {
+    output += `  ${name.padEnd(20)} ${data.count.toString().padStart(4)} workers\n`;
+    if (data.subcategories && data.subcategories.length > 0) {
+      output += `    └─ ${data.subcategories.join(', ')}\n`;
+    }
+  }
+
+  return output;
+}
+
+module.exports = {
+  formatOutput,
+  formatTable,
+  formatJSON,
+  formatYAML,
+  formatWorkerDetails,
+  formatCategories,
+  truncate,
+};

package/.aios-core/cli/utils/score-calculator.js

@@ -0,0 +1,221 @@
+/**
+ * Score Calculator Module
+ *
+ * Calculates and normalizes relevance scores for search results.
+ *
+ * @module cli/utils/score-calculator
+ * @version 1.0.0
+ * @story 2.7 - Discovery CLI Search
+ */
+
+/**
+ * Calculate scores for search results
+ * @param {Array} results - Search results (may already have scores)
+ * @param {string} query - Original search query
+ * @returns {Array} Results with calculated/adjusted scores
+ */
+function calculateScores(results, query) {
+  const queryLower = query.toLowerCase();
+  const queryWords = queryLower.split(/\s+/).filter(w => w.length > 0);
+
+  return results.map(result => {
+    let score = result.score || 0;
+
+    // Boost for exact ID match
+    if (result.id === queryLower) {
+      score = Math.max(score, 100);
+    } else if (result.id.toLowerCase() === queryLower) {
+      score = Math.max(score, 99);
+    } else if (result.id.toLowerCase().includes(queryLower)) {
+      score = Math.max(score, 95);
+    }
+
+    // Boost for exact name match
+    if (result.name.toLowerCase() === queryLower) {
+      score = Math.max(score, 98);
+    } else if (result.name.toLowerCase().includes(queryLower)) {
+      score = Math.max(score, 90);
+    }
+
+    // Boost for tag matches
+    const tags = (result.tags || []).map(t => t.toLowerCase());
+    const tagMatchCount = queryWords.filter(word =>
+      tags.some(tag => tag === word || tag.includes(word)),
+    ).length;
+
+    if (tagMatchCount > 0) {
+      const tagBoost = Math.min(15, tagMatchCount * 5);
+      score = Math.min(100, score + tagBoost);
+    }
+
+    // Boost for category match
+    if (result.category && queryWords.some(w => result.category.toLowerCase().includes(w))) {
+      score = Math.min(100, score + 5);
+    }
+
+    // Normalize score to 0-100
+    score = Math.max(0, Math.min(100, Math.round(score)));
+
+    return {
+      ...result,
+      score,
+    };
+  });
+}
+
+/**
+ * Sort results by score descending
+ * @param {Array} results - Search results with scores
+ * @returns {Array} Sorted results
+ */
+function sortByScore(results) {
+  return [...results].sort((a, b) => {
+    // Primary sort by score
+    if (b.score !== a.score) {
+      return b.score - a.score;
+    }
+    // Secondary sort by name length (shorter = more relevant)
+    return a.name.length - b.name.length;
+  });
+}
+
+/**
+ * Normalize scores to ensure even distribution
+ * @param {Array} results - Search results
+ * @returns {Array} Results with normalized scores
+ */
+function normalizeScores(results) {
+  if (results.length === 0) return results;
+
+  const scores = results.map(r => r.score);
+  const maxScore = Math.max(...scores);
+  const minScore = Math.min(...scores);
+  const range = maxScore - minScore;
+
+  if (range === 0) {
+    // All same score, just return as-is
+    return results;
+  }
+
+  return results.map(result => ({
+    ...result,
+    score: Math.round(((result.score - minScore) / range) * 100),
+  }));
+}
+
+/**
+ * Calculate relevance score based on multiple factors
+ * @param {object} worker - Worker object
+ * @param {string} query - Search query
+ * @param {object} options - Scoring options
+ * @returns {number} Relevance score 0-100
+ */
+function calculateRelevanceScore(worker, query, options = {}) {
+  const weights = {
+    idMatch: options.idWeight || 1.5,
+    nameMatch: options.nameWeight || 1.3,
+    tagMatch: options.tagWeight || 1.1,
+    descriptionMatch: options.descriptionWeight || 0.8,
+    categoryMatch: options.categoryWeight || 0.7,
+  };
+
+  const queryLower = query.toLowerCase();
+  let score = 0;
+
+  // ID matching
+  if (worker.id.toLowerCase() === queryLower) {
+    score += 100 * weights.idMatch;
+  } else if (worker.id.toLowerCase().includes(queryLower)) {
+    score += 80 * weights.idMatch;
+  }
+
+  // Name matching
+  const nameLower = worker.name.toLowerCase();
+  if (nameLower === queryLower) {
+    score += 100 * weights.nameMatch;
+  } else if (nameLower.includes(queryLower)) {
+    score += 70 * weights.nameMatch;
+  }
+
+  // Tag matching
+  const tags = (worker.tags || []).map(t => t.toLowerCase());
+  for (const tag of tags) {
+    if (tag === queryLower) {
+      score += 50 * weights.tagMatch;
+      break;
+    } else if (tag.includes(queryLower) || queryLower.includes(tag)) {
+      score += 30 * weights.tagMatch;
+    }
+  }
+
+  // Description matching
+  if (worker.description && worker.description.toLowerCase().includes(queryLower)) {
+    score += 30 * weights.descriptionMatch;
+  }
+
+  // Category matching
+  if (worker.category && worker.category.toLowerCase().includes(queryLower)) {
+    score += 20 * weights.categoryMatch;
+  }
+
+  // Normalize to 0-100
+  return Math.min(100, Math.round(score));
+}
+
+/**
+ * Boost score for exact matches
+ * @param {Array} results - Search results
+ * @param {string} query - Search query
+ * @returns {Array} Results with boosted exact matches
+ */
+function boostExactMatches(results, query) {
+  const queryLower = query.toLowerCase();
+
+  return results.map(result => {
+    let boostedScore = result.score;
+
+    // Exact ID match gets top score
+    if (result.id.toLowerCase() === queryLower) {
+      boostedScore = 100;
+    }
+
+    return {
+      ...result,
+      score: boostedScore,
+    };
+  });
+}
+
+/**
+ * Calculate search accuracy for testing
+ * @param {Array} results - Search results
+ * @param {string} expectedId - Expected first result ID
+ * @returns {object} Accuracy metrics
+ */
+function calculateSearchAccuracy(results, expectedId) {
+  if (results.length === 0) {
+    return {
+      found: false,
+      position: -1,
+      accuracy: 0,
+    };
+  }
+
+  const position = results.findIndex(r => r.id === expectedId);
+
+  return {
+    found: position !== -1,
+    position: position,
+    isFirst: position === 0,
+    accuracy: position === 0 ? 100 : position > 0 ? Math.max(0, 100 - (position * 10)) : 0,
+  };
+}
+
+module.exports = {
+  calculateScores,
+  sortByScore,
+  normalizeScores,
+  calculateRelevanceScore,
+  boostExactMatches,
+  calculateSearchAccuracy,
+};

package/.aios-core/core/README.md

@@ -0,0 +1,229 @@
+# AIOS Core Module
+
+> Central runtime module providing essential framework functionality for Synkra AIOS.
+
+**Version:** 2.0.0
+**Created:** Story 2.2 - Core Module Creation
+**Architecture:** ADR-002 Modular Architecture
+
+## Overview
+
+The Core module contains the foundational runtime components that all other AIOS modules depend on. It provides configuration management, session handling, elicitation workflows, and essential utilities.
+
+## Installation
+
+The core module is automatically available within the Synkra AIOS framework:
+
+```javascript
+// CommonJS
+const core = require('./.aios-core/core');
+
+// ES Modules
+import { ConfigCache, ElicitationEngine } from './.aios-core/core/index.esm.js';
+```
+
+## Module Structure
+
+```
+core/
+├── config/                 # Configuration management
+│   ├── config-cache.js     # Global configuration cache with TTL support
+│   └── config-loader.js    # Lazy-loading configuration system
+├── data/                   # Framework knowledge and patterns
+│   ├── aios-kb.md          # AIOS knowledge base
+│   ├── workflow-patterns.yaml
+│   └── agent-config-requirements.yaml
+├── docs/                   # Internal documentation
+│   ├── agent-creation.md
+│   ├── component-overview.md
+│   ├── elicitation-guide.md
+│   ├── system-overview.md
+│   └── task-authoring.md
+├── elicitation/            # Interactive prompting system
+│   ├── elicitation-engine.js
+│   ├── session-manager.js
+│   ├── agent-elicitation.js
+│   ├── task-elicitation.js
+│   └── workflow-elicitation.js
+├── session/                # Session context management
+│   ├── context-detector.js
+│   └── context-loader.js
+├── utils/                  # Utility functions
+│   ├── output-formatter.js
+│   └── yaml-validator.js
+├── index.js                # CommonJS exports
+└── index.esm.js            # ES Module exports
+```
+
+## API Reference
+
+### Configuration
+
+#### `ConfigCache` / `globalConfigCache`
+Global configuration cache with TTL support.
+
+```javascript
+const { globalConfigCache } = require('./.aios-core/core');
+
+// Store configuration
+globalConfigCache.set('my-key', { value: 42 }, 300000); // 5 min TTL
+
+// Retrieve configuration
+const config = globalConfigCache.get('my-key');
+```
+
+#### `loadAgentConfig(agentId)`
+Load configuration for a specific agent with lazy loading.
+
+```javascript
+const { loadAgentConfig } = require('./.aios-core/core');
+const agentConfig = await loadAgentConfig('dev');
+```
+
+#### `loadConfigSections(sections)`
+Load specific configuration sections.
+
+```javascript
+const { loadConfigSections } = require('./.aios-core/core');
+const config = await loadConfigSections(['persona', 'commands']);
+```
+
+### Session Management
+
+#### `ContextDetector`
+Detects current execution context (IDE, terminal, environment).
+
+```javascript
+const { ContextDetector } = require('./.aios-core/core');
+const detector = new ContextDetector();
+const context = detector.detectContext();
+```
+
+#### `SessionContextLoader`
+Manages session context loading and updates.
+
+```javascript
+const { SessionContextLoader } = require('./.aios-core/core');
+const loader = new SessionContextLoader();
+const context = await loader.loadContext(sessionId);
+```
+
+### Elicitation System
+
+#### `ElicitationEngine`
+Core engine for interactive prompting workflows.
+
+```javascript
+const { ElicitationEngine } = require('./.aios-core/core');
+const engine = new ElicitationEngine();
+
+const session = await engine.startSession('create-agent');
+const response = await engine.processStep(session.id, userInput);
+```
+
+#### `ElicitationSessionManager`
+Manages elicitation session state.
+
+```javascript
+const { ElicitationSessionManager } = require('./.aios-core/core');
+const manager = new ElicitationSessionManager();
+```
+
+#### Elicitation Steps
+Pre-defined elicitation workflows:
+- `agentElicitationSteps` - Steps for creating agents
+- `taskElicitationSteps` - Steps for creating tasks
+- `workflowElicitationSteps` - Steps for creating workflows
+
+### Utilities
+
+#### `YAMLValidator`
+Validates YAML content with type-specific rules.
+
+```javascript
+const { YAMLValidator, validateYAML } = require('./.aios-core/core');
+
+// Quick validation
+const result = await validateYAML(yamlContent, 'agent');
+
+// Full validator
+const validator = new YAMLValidator();
+const validation = await validator.validateFile('agent.yaml', 'agent');
+```
+
+#### `PersonalizedOutputFormatter`
+Formats agent output with personalization.
+
+```javascript
+const { PersonalizedOutputFormatter } = require('./.aios-core/core');
+const formatter = new PersonalizedOutputFormatter(agent, task, result);
+const output = formatter.format();
+```
+
+## Exports Summary
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `ConfigCache` | Class | Configuration cache class |
+| `globalConfigCache` | Instance | Global cache singleton |
+| `loadAgentConfig` | Function | Load agent configuration |
+| `loadConfigSections` | Function | Load config sections |
+| `loadMinimalConfig` | Function | Load minimal configuration |
+| `loadFullConfig` | Function | Load complete configuration |
+| `preloadConfig` | Function | Preload configuration |
+| `clearConfigCache` | Function | Clear configuration cache |
+| `getConfigPerformanceMetrics` | Function | Get cache performance stats |
+| `ContextDetector` | Class | Context detection |
+| `SessionContextLoader` | Class | Session context management |
+| `ElicitationEngine` | Class | Elicitation workflow engine |
+| `ElicitationSessionManager` | Class | Session state management |
+| `agentElicitationSteps` | Object | Agent creation steps |
+| `taskElicitationSteps` | Object | Task creation steps |
+| `workflowElicitationSteps` | Object | Workflow creation steps |
+| `PersonalizedOutputFormatter` | Class | Output formatting |
+| `YAMLValidator` | Class | YAML validation |
+| `validateYAML` | Function | Quick YAML validation |
+| `version` | String | Module version (2.0.0) |
+| `moduleName` | String | Module name ('core') |
+
+## Regression Tests
+
+The core module includes regression tests (CORE-01 to CORE-07):
+
+| Test ID | Name | Priority | Description |
+|---------|------|----------|-------------|
+| CORE-01 | Config Loading | P0 | Verifies config system loads |
+| CORE-02 | Config Caching | P1 | Verifies cache operations |
+| CORE-03 | Session Management | P0 | Verifies session loader |
+| CORE-04 | Elicitation Engine | P0 | Verifies elicitation system |
+| CORE-05 | YAML Validation | P1 | Verifies YAML validator |
+| CORE-06 | Output Formatting | P1 | Verifies output formatter |
+| CORE-07 | Package Exports | P0 | Verifies all exports |
+
+Run tests:
+```bash
+npm run test:core
+```
+
+## Dependencies
+
+- `js-yaml` - YAML parsing
+- `fs-extra` - Enhanced file operations
+
+## Migration Notes
+
+Files were migrated from various locations to create this unified module:
+
+| Original Location | New Location |
+|-------------------|--------------|
+| `config/config-loader.js` | `core/config/config-loader.js` |
+| `config/config-cache.js` | `core/config/config-cache.js` |
+| `session/context-*.js` | `core/session/context-*.js` |
+| `elicitation/*.js` | `core/elicitation/*.js` |
+| Various utils | `core/utils/` |
+
+Scripts that import these modules have been updated to reference the new paths.
+
+---
+
+*Synkra AIOS Core Module v2.0.0*