aios-core 2.1.0

package/.aios-core/core/registry/validate-registry.js

@@ -0,0 +1,340 @@
+/**
+ * Service Registry Validator
+ *
+ * Validates the service registry against schema and checks file paths.
+ * Runs smoke tests REG-01 to REG-06.
+ *
+ * @module validate-registry
+ * @version 1.0.0
+ * @created Story 2.6 - Service Registry Creation
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const Ajv = require('ajv');
+const addFormats = require('ajv-formats');
+
+/**
+ * Smoke test definitions
+ */
+const SMOKE_TESTS = {
+  'REG-01': {
+    name: 'Registry Loads',
+    description: 'Registry file loads without errors',
+    priority: 'P0',
+    test: async (ctx) => {
+      try {
+        JSON.parse(ctx.registryContent);
+        return { passed: true };
+      } catch (error) {
+        return { passed: false, error: `JSON parse failed: ${error.message}` };
+      }
+    },
+  },
+  'REG-02': {
+    name: 'Schema Valid',
+    description: 'Registry validates against schema',
+    priority: 'P0',
+    test: async (ctx) => {
+      const ajv = new Ajv({ allErrors: true, strict: false });
+      addFormats(ajv);
+      const validate = ajv.compile(ctx.schema);
+      const valid = validate(ctx.registry);
+      if (!valid) {
+        return {
+          passed: false,
+          error: 'Schema validation failed',
+          details: validate.errors.slice(0, 5),
+        };
+      }
+      return { passed: true };
+    },
+  },
+  'REG-03': {
+    name: 'Worker Count',
+    description: 'Registry has 97+ workers',
+    priority: 'P0',
+    test: async (ctx) => {
+      const count = ctx.registry.workers?.length || 0;
+      if (count >= 97) {
+        return { passed: true, details: `Found ${count} workers` };
+      }
+      return {
+        passed: false,
+        error: `Expected 97+ workers, found ${count}`,
+      };
+    },
+  },
+  'REG-04': {
+    name: 'Paths Exist',
+    description: 'All worker paths point to existing files',
+    priority: 'P1',
+    test: async (ctx) => {
+      const missing = [];
+      for (const worker of ctx.registry.workers || []) {
+        const fullPath = path.join(ctx.baseDir, worker.path);
+        try {
+          await fs.access(fullPath);
+        } catch {
+          missing.push({ id: worker.id, path: worker.path });
+        }
+      }
+      if (missing.length === 0) {
+        return { passed: true };
+      }
+      return {
+        passed: false,
+        error: `${missing.length} paths not found`,
+        details: missing.slice(0, 10),
+      };
+    },
+  },
+  'REG-05': {
+    name: 'IDs Unique',
+    description: 'All worker IDs are unique',
+    priority: 'P1',
+    test: async (ctx) => {
+      const ids = ctx.registry.workers?.map(w => w.id) || [];
+      const seen = new Set();
+      const duplicates = [];
+      for (const id of ids) {
+        if (seen.has(id)) {
+          duplicates.push(id);
+        }
+        seen.add(id);
+      }
+      if (duplicates.length === 0) {
+        return { passed: true };
+      }
+      return {
+        passed: false,
+        error: `${duplicates.length} duplicate IDs found`,
+        details: duplicates,
+      };
+    },
+  },
+  'REG-06': {
+    name: 'Load Performance',
+    description: 'Registry loads in < 500ms',
+    priority: 'P1',
+    test: async (ctx) => {
+      const start = Date.now();
+      JSON.parse(ctx.registryContent);
+      const loadTime = Date.now() - start;
+      if (loadTime < 500) {
+        return { passed: true, details: `Load time: ${loadTime}ms` };
+      }
+      return {
+        passed: false,
+        error: `Load time ${loadTime}ms exceeds 500ms limit`,
+      };
+    },
+  },
+};
+
+/**
+ * Run all smoke tests
+ */
+async function runSmokeTests(registryPath, schemaPath, baseDir) {
+  console.log('Running Registry Smoke Tests');
+  console.log('='.repeat(50));
+
+  // Load registry content
+  let registryContent, registry, schema;
+  try {
+    registryContent = await fs.readFile(registryPath, 'utf8');
+    registry = JSON.parse(registryContent);
+    schema = JSON.parse(await fs.readFile(schemaPath, 'utf8'));
+  } catch (error) {
+    console.error('Failed to load files:', error.message);
+    return { allPassed: false, p0Failed: true, results: {} };
+  }
+
+  const ctx = { registryContent, registry, schema, baseDir };
+  const results = {};
+  let p0Failed = false;
+  let p1Failed = false;
+
+  for (const [testId, testDef] of Object.entries(SMOKE_TESTS)) {
+    console.log(`\n[${testId}] ${testDef.name} (${testDef.priority})`);
+    console.log(`  ${testDef.description}`);
+
+    try {
+      const result = await testDef.test(ctx);
+      results[testId] = {
+        ...testDef,
+        ...result,
+      };
+
+      if (result.passed) {
+        console.log('  Result: PASSED');
+        if (result.details) {
+          console.log(`  Details: ${JSON.stringify(result.details)}`);
+        }
+      } else {
+        console.log('  Result: FAILED');
+        console.log(`  Error: ${result.error}`);
+        if (result.details) {
+          console.log(`  Details: ${JSON.stringify(result.details).slice(0, 200)}`);
+        }
+
+        if (testDef.priority === 'P0') {
+          p0Failed = true;
+        } else {
+          p1Failed = true;
+        }
+      }
+    } catch (error) {
+      console.log('  Result: ERROR');
+      console.log(`  Error: ${error.message}`);
+      results[testId] = {
+        ...testDef,
+        passed: false,
+        error: error.message,
+      };
+      if (testDef.priority === 'P0') {
+        p0Failed = true;
+      }
+    }
+  }
+
+  console.log('\n' + '='.repeat(50));
+  console.log('SUMMARY');
+  console.log('='.repeat(50));
+
+  const passed = Object.values(results).filter(r => r.passed).length;
+  const total = Object.keys(results).length;
+
+  console.log(`Tests: ${passed}/${total} passed`);
+  console.log(`P0 Status: ${p0Failed ? 'FAILED' : 'PASSED'}`);
+  console.log(`P1 Status: ${p1Failed ? 'FAILED' : 'PASSED'}`);
+
+  return {
+    allPassed: !p0Failed && !p1Failed,
+    p0Failed,
+    p1Failed,
+    results,
+  };
+}
+
+/**
+ * Validate registry fields
+ */
+async function validateFields(registryPath) {
+  console.log('\nValidating registry fields...');
+
+  const content = await fs.readFile(registryPath, 'utf8');
+  const registry = JSON.parse(content);
+
+  const issues = [];
+
+  for (const worker of registry.workers) {
+    // Check required fields
+    if (!worker.id) {
+      issues.push({ id: worker.name, issue: 'Missing ID' });
+    }
+    if (!worker.name) {
+      issues.push({ id: worker.id, issue: 'Missing name' });
+    }
+    if (!worker.description || worker.description === 'No description available') {
+      issues.push({ id: worker.id, issue: 'Missing or default description' });
+    }
+    if (!worker.path) {
+      issues.push({ id: worker.id, issue: 'Missing path' });
+    }
+    if (!worker.taskFormat) {
+      issues.push({ id: worker.id, issue: 'Missing taskFormat' });
+    }
+
+    // Check ID format
+    if (worker.id && !/^[a-z0-9-]+$/.test(worker.id)) {
+      issues.push({ id: worker.id, issue: 'Invalid ID format (must be kebab-case)' });
+    }
+
+    // Check path format
+    if (worker.path && !worker.path.startsWith('.aios-core/')) {
+      issues.push({ id: worker.id, issue: 'Invalid path prefix (must start with .aios-core/)' });
+    }
+  }
+
+  if (issues.length === 0) {
+    console.log('All fields valid!');
+  } else {
+    console.log(`Found ${issues.length} field issues:`);
+    issues.slice(0, 20).forEach(i => {
+      console.log(`  - ${i.id}: ${i.issue}`);
+    });
+    if (issues.length > 20) {
+      console.log(`  ... and ${issues.length - 20} more`);
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * CLI entry point
+ */
+async function main() {
+  const baseDir = process.argv[2] || process.cwd();
+  const registryPath = path.join(baseDir, '.aios-core/core/registry/service-registry.json');
+  const schemaPath = path.join(baseDir, '.aios-core/core/registry/registry-schema.json');
+
+  console.log('Service Registry Validator');
+  console.log('='.repeat(50));
+  console.log(`Base directory: ${baseDir}`);
+  console.log(`Registry: ${registryPath}`);
+  console.log(`Schema: ${schemaPath}`);
+
+  // Check files exist
+  try {
+    await fs.access(registryPath);
+  } catch {
+    console.error(`\nError: Registry file not found at ${registryPath}`);
+    console.error('Run build-registry.js first to generate the registry.');
+    process.exit(1);
+  }
+
+  try {
+    await fs.access(schemaPath);
+  } catch {
+    console.error(`\nError: Schema file not found at ${schemaPath}`);
+    process.exit(1);
+  }
+
+  // Run smoke tests
+  const testResults = await runSmokeTests(registryPath, schemaPath, baseDir);
+
+  // Run field validation
+  const fieldIssues = await validateFields(registryPath);
+
+  // Summary
+  console.log('\n' + '='.repeat(50));
+  console.log('FINAL RESULT');
+  console.log('='.repeat(50));
+
+  if (testResults.p0Failed) {
+    console.log('STATUS: FAILED (P0 tests failed)');
+    process.exit(1);
+  } else if (testResults.p1Failed) {
+    console.log('STATUS: WARNING (P1 tests failed, but P0 passed)');
+    process.exit(0);
+  } else {
+    console.log('STATUS: PASSED (All tests passed)');
+    process.exit(0);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main().catch(error => {
+    console.error('Validation failed:', error);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  runSmokeTests,
+  validateFields,
+  SMOKE_TESTS,
+};

package/.aios-core/core/session/context-detector.js

@@ -0,0 +1,229 @@
+/**
+ * Context Detector - Hybrid Session Type Detection
+ *
+ * Detects session type using conversation history (preferred)
+ * with fallback to file-based session tracking.
+ *
+ * Session Types:
+ * - 'new': Fresh session, no prior context
+ * - 'existing': Ongoing session with some history
+ * - 'workflow': Active workflow detected (e.g., story development)
+ *
+ * @module core/session/context-detector
+ * @migrated Story 2.2 - Core Module Creation
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SESSION_STATE_PATH = path.join(process.cwd(), '.aios', 'session-state.json');
+const SESSION_TTL = 60 * 60 * 1000; // 1 hour
+
+class ContextDetector {
+  /**
+   * Detect session type using hybrid approach
+   * @param {Array} conversationHistory - Recent conversation messages
+   * @param {string} sessionFilePath - Optional custom session file path
+   * @returns {string} 'new' | 'existing' | 'workflow'
+   */
+  detectSessionType(conversationHistory = [], sessionFilePath = SESSION_STATE_PATH) {
+    // Hybrid approach: Prefer conversation history
+    // FIX: Check for null/undefined explicitly to avoid empty array bypassing file detection
+    if (conversationHistory != null && conversationHistory.length > 0) {
+      return this._detectFromConversation(conversationHistory);
+    }
+
+    // Fallback to file-based detection
+    return this._detectFromFile(sessionFilePath);
+  }
+
+  /**
+   * Detect session type from conversation history
+   * @private
+   * @param {Array} conversationHistory - Recent conversation messages
+   * @returns {string} 'new' | 'existing' | 'workflow'
+   */
+  _detectFromConversation(conversationHistory) {
+    if (conversationHistory.length === 0) {
+      return 'new';
+    }
+
+    // Extract last 10 commands from conversation
+    const recentCommands = this._extractCommands(conversationHistory);
+
+    // Check for workflow patterns
+    if (this._detectWorkflowPattern(recentCommands)) {
+      return 'workflow';
+    }
+
+    // Has history but no workflow
+    return 'existing';
+  }
+
+  /**
+   * Detect session type from file
+   * @private
+   * @param {string} sessionFilePath - Path to session state file
+   * @returns {string} 'new' | 'existing' | 'workflow'
+   */
+  _detectFromFile(sessionFilePath) {
+    try {
+      if (!fs.existsSync(sessionFilePath)) {
+        return 'new';
+      }
+
+      const sessionData = JSON.parse(fs.readFileSync(sessionFilePath, 'utf8'));
+
+      // Check if session expired (TTL)
+      const now = Date.now();
+      const lastActivity = sessionData.lastActivity || 0;
+
+      if (now - lastActivity > SESSION_TTL) {
+        return 'new';
+      }
+
+      // Check for active workflow
+      if (sessionData.workflowActive && sessionData.lastCommands && sessionData.lastCommands.length > 0) {
+        return 'workflow';
+      }
+
+      // Valid session with some history
+      if (sessionData.lastCommands && sessionData.lastCommands.length > 0) {
+        return 'existing';
+      }
+
+      return 'new';
+    } catch (error) {
+      // File read error or invalid JSON - assume new session
+      console.warn('[ContextDetector] File read error, defaulting to new session:', error.message);
+      return 'new';
+    }
+  }
+
+  /**
+   * Extract command names from conversation history
+   * @private
+   * @param {Array} conversationHistory - Recent conversation messages
+   * @returns {Array<string>} Command names
+   */
+  _extractCommands(conversationHistory) {
+    const commands = [];
+    const commandPattern = /\*([a-z0-9-]+)/g;
+
+    // Take last 10 messages for analysis
+    const recentMessages = conversationHistory.slice(-10);
+
+    for (const message of recentMessages) {
+      const text = message.content || message.text || '';
+      const matches = text.matchAll(commandPattern);
+
+      for (const match of matches) {
+        commands.push(match[1]);
+      }
+    }
+
+    return commands.slice(-10); // Last 10 commands
+  }
+
+  /**
+   * Detect if commands match a known workflow pattern
+   * @private
+   * @param {Array<string>} commands - Recent command history
+   * @returns {boolean} True if workflow pattern detected
+   */
+  _detectWorkflowPattern(commands) {
+    if (commands.length < 2) {
+      return false;
+    }
+
+    // Common workflow patterns (simplified detection)
+    const workflows = {
+      story_development: ['validate-story-draft', 'develop', 'review-qa'],
+      epic_creation: ['create-epic', 'create-story', 'validate-story-draft'],
+      backlog_management: ['backlog-review', 'backlog-prioritize', 'backlog-schedule'],
+    };
+
+    // Check if recent commands match any workflow sequence
+    for (const [workflowName, pattern] of Object.entries(workflows)) {
+      if (this._matchesPattern(commands, pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if commands contain workflow pattern
+   * @private
+   * @param {Array<string>} commands - Recent command history
+   * @param {Array<string>} pattern - Workflow pattern to match
+   * @returns {boolean} True if pattern found
+   */
+  _matchesPattern(commands, pattern) {
+    // Simple containment check - commands contain at least 2 from pattern
+    const matchCount = pattern.filter(p => commands.includes(p)).length;
+    return matchCount >= 2;
+  }
+
+  /**
+   * Update session state file
+   * @param {Object} state - Session state data
+   * @param {string} sessionFilePath - Optional custom session file path
+   */
+  updateSessionState(state, sessionFilePath = SESSION_STATE_PATH) {
+    try {
+      // Ensure directory exists
+      const dir = path.dirname(sessionFilePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      const sessionData = {
+        sessionId: state.sessionId || this._generateSessionId(),
+        startTime: state.startTime || Date.now(),
+        lastActivity: Date.now(),
+        workflowActive: state.workflowActive || null,
+        lastCommands: state.lastCommands || [],
+        agentSequence: state.agentSequence || [],
+      };
+
+      fs.writeFileSync(sessionFilePath, JSON.stringify(sessionData, null, 2), 'utf8');
+    } catch (error) {
+      console.warn('[ContextDetector] Failed to update session state:', error.message);
+    }
+  }
+
+  /**
+   * Generate unique session ID
+   * @private
+   * @returns {string} UUID-like session ID
+   */
+  _generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Clear expired sessions
+   * @param {string} sessionFilePath - Optional custom session file path
+   */
+  clearExpiredSession(sessionFilePath = SESSION_STATE_PATH) {
+    try {
+      if (!fs.existsSync(sessionFilePath)) {
+        return;
+      }
+
+      const sessionData = JSON.parse(fs.readFileSync(sessionFilePath, 'utf8'));
+      const now = Date.now();
+      const lastActivity = sessionData.lastActivity || 0;
+
+      if (now - lastActivity > SESSION_TTL) {
+        fs.unlinkSync(sessionFilePath);
+      }
+    } catch (error) {
+      console.warn('[ContextDetector] Failed to clear expired session:', error.message);
+    }
+  }
+}
+
+module.exports = ContextDetector;