create-byan-agent 2.6.2 → 2.7.0

package/install/src/byan-v2/orchestrator/interview-state.js

@@ -1,271 +0,0 @@
-/**
- * InterviewState - Story 4.2
- * Manages structured interview flow through 4 phases
- * 
- * Phases:
- * 1. CONTEXT: Project context, domain, users
- * 2. BUSINESS: Goals, problems, success criteria
- * 3. AGENT_NEEDS: Agent capabilities, behavior, constraints
- * 4. VALIDATION: Confirm understanding, clarifications
- * 
- * Integrates with SessionState to persist interview data
- */
-
-const Logger = require('../observability/logger');
-const crypto = require('crypto');
-
-class InterviewState {
-  constructor(sessionState) {
-    this.sessionState = sessionState;
-    this.logger = new Logger();
-
-    // AC1: Define 4 phases
-    this.PHASES = {
-      CONTEXT: 'CONTEXT',
-      BUSINESS: 'BUSINESS',
-      AGENT_NEEDS: 'AGENT_NEEDS',
-      VALIDATION: 'VALIDATION'
-    };
-
-    // Current interview state
-    this.currentPhase = this.PHASES.CONTEXT;
-    this.currentQuestionIndex = 0;
-    this.awaitingResponse = false;
-    this.lastAskedQuestion = null;
-
-    // AC4: Track responses per phase
-    this.phaseResponses = {
-      CONTEXT: [],
-      BUSINESS: [],
-      AGENT_NEEDS: [],
-      VALIDATION: []
-    };
-
-    // AC1: Question banks for each phase (min 3 per phase)
-    this.questionBanks = {
-      CONTEXT: [
-        'What is the main purpose or domain of your project?',
-        'Who are the primary users or stakeholders?',
-        'What is the current workflow or process this agent will support?',
-        'What technologies or platforms are you using?',
-        'What is the scale or scope of your project?'
-      ],
-      BUSINESS: [
-        'What specific problem or challenge does this agent need to solve?',
-        'What are the key goals or objectives for this agent?',
-        'How will you measure the success of this agent?',
-        'What are the most time-consuming or error-prone tasks currently?',
-        'What business value or ROI do you expect?'
-      ],
-      AGENT_NEEDS: [
-        'What specific capabilities should this agent have?',
-        'What knowledge or expertise should the agent possess?',
-        'How should the agent interact with users (tone, style, format)?',
-        'What are the critical constraints or limitations for the agent?',
-        'What level of autonomy should the agent have in decision-making?'
-      ],
-      VALIDATION: [
-        'Let me confirm: The agent will help with [SUMMARY]. Is this correct?',
-        'Are there any critical requirements or edge cases we haven\'t covered?',
-        'What would make this agent a complete failure in your eyes?',
-        'Is there anything else important I should know about this agent?'
-      ]
-    };
-
-    this.phaseOrder = ['CONTEXT', 'BUSINESS', 'AGENT_NEEDS', 'VALIDATION'];
-    this.minResponsesPerPhase = 3;
-  }
-
-  /**
-   * AC2: Ask next question based on phase and responses
-   * @returns {Object|null} Question object or null if complete
-   */
-  askNextQuestion() {
-    // Check if waiting for response to last question
-    if (this.awaitingResponse && this.lastAskedQuestion) {
-      this.logger.warn('Awaiting response to previous question');
-      return this.lastAskedQuestion;
-    }
-
-    // Check if interview complete
-    if (this.isInterviewComplete()) {
-      this.logger.info('Interview complete - no more questions');
-      return null;
-    }
-
-    // Check if current phase needs transition
-    if (this.isPhaseComplete(this.currentPhase)) {
-      this._transitionToNextPhase();
-    }
-
-    // Get question from current phase
-    const phaseQuestions = this.questionBanks[this.currentPhase];
-    const phaseResponseCount = this.phaseResponses[this.currentPhase].length;
-    
-    // Use response count as index (allows revisiting questions)
-    const questionIndex = Math.min(phaseResponseCount, phaseQuestions.length - 1);
-    const questionText = phaseQuestions[questionIndex];
-
-    // Build question object
-    const question = {
-      questionId: crypto.randomUUID(),
-      text: questionText,
-      phase: this.currentPhase,
-      questionNumber: this.currentQuestionIndex + 1,
-      totalInPhase: phaseQuestions.length,
-      phaseProgress: `${phaseResponseCount + 1}/${this.minResponsesPerPhase} (min)`
-    };
-
-    // Store in SessionState
-    this.sessionState.addQuestion(questionText);
-
-    // Mark as awaiting response
-    this.awaitingResponse = true;
-    this.lastAskedQuestion = question;
-
-    this.logger.info('Question asked', {
-      phase: this.currentPhase,
-      questionNumber: question.questionNumber,
-      phaseProgress: question.phaseProgress
-    });
-
-    return question;
-  }
-
-  /**
-   * AC3: Process user response and store
-   * @param {string} response - User's response
-   */
-  processResponse(response) {
-    if (!this.awaitingResponse) {
-      this.logger.warn('No question pending - ignoring response');
-      return false;
-    }
-
-    // Store response in current phase
-    const responseData = {
-      questionId: this.lastAskedQuestion.questionId,
-      response: response || '',
-      timestamp: Date.now(),
-      phase: this.currentPhase
-    };
-
-    this.phaseResponses[this.currentPhase].push(responseData);
-
-    // Store in SessionState
-    this.sessionState.addResponse(this.lastAskedQuestion.questionId, response);
-
-    // Update state
-    this.currentQuestionIndex++;
-    this.awaitingResponse = false;
-    this.lastAskedQuestion = null;
-
-    this.logger.info('Response processed', {
-      phase: this.currentPhase,
-      responseCount: this.phaseResponses[this.currentPhase].length,
-      phaseComplete: this.isPhaseComplete(this.currentPhase)
-    });
-
-    // Transition to next phase if current phase is complete
-    if (this.isPhaseComplete(this.currentPhase)) {
-      const currentPhaseIndex = this.phaseOrder.indexOf(this.currentPhase);
-      if (currentPhaseIndex < this.phaseOrder.length - 1) {
-        this._transitionToNextPhase();
-      }
-    }
-
-    return this.isInterviewComplete();
-  }
-
-  /**
-   * AC4: Check if phase has minimum responses
-   * @param {string} phase - Phase name
-   * @returns {boolean} True if phase complete
-   */
-  isPhaseComplete(phase) {
-    return this.phaseResponses[phase].length >= this.minResponsesPerPhase;
-  }
-
-  /**
-   * AC5: Check if all phases complete and can transition to ANALYSIS
-   * @returns {boolean} True if interview complete
-   */
-  canTransitionToAnalysis() {
-    return this.phaseOrder.every(phase => this.isPhaseComplete(phase));
-  }
-
-  /**
-   * Check if interview is complete
-   * @returns {boolean} True if all phases done
-   */
-  isInterviewComplete() {
-    return this.canTransitionToAnalysis();
-  }
-
-  /**
-   * Get all collected responses
-   * @returns {Object} All phase responses
-   */
-  getAllResponses() {
-    return { ...this.phaseResponses };
-  }
-
-  /**
-   * Get responses for specific phase
-   * @param {string} phase - Phase name
-   * @returns {Array} Phase responses
-   */
-  getPhaseResponses(phase) {
-    return [...this.phaseResponses[phase]];
-  }
-
-  /**
-   * Get interview progress summary
-   * @returns {Object} Progress data
-   */
-  getProgress() {
-    const phaseProgress = {};
-    
-    this.phaseOrder.forEach(phase => {
-      const count = this.phaseResponses[phase].length;
-      phaseProgress[phase] = {
-        responses: count,
-        complete: this.isPhaseComplete(phase),
-        progress: `${count}/${this.minResponsesPerPhase}`
-      };
-    });
-
-    return {
-      currentPhase: this.currentPhase,
-      totalQuestions: this.currentQuestionIndex,
-      phases: phaseProgress,
-      canTransitionToAnalysis: this.canTransitionToAnalysis()
-    };
-  }
-
-  /**
-   * Transition to next phase
-   * @private
-   */
-  _transitionToNextPhase() {
-    const currentIndex = this.phaseOrder.indexOf(this.currentPhase);
-    
-    if (currentIndex === -1 || currentIndex >= this.phaseOrder.length - 1) {
-      // Already at last phase or invalid
-      return;
-    }
-
-    const nextPhase = this.phaseOrder[currentIndex + 1];
-    const previousPhase = this.currentPhase;
-    
-    this.currentPhase = nextPhase;
-
-    this.logger.info('Interview phase transition', {
-      from: previousPhase,
-      to: nextPhase,
-      previousPhaseResponses: this.phaseResponses[previousPhase].length
-    });
-  }
-}
-
-module.exports = InterviewState;

package/install/src/byan-v2/orchestrator/state-machine.js

@@ -1,204 +0,0 @@
-/**
- * StateMachine Core - Story 4.1
- * Manages workflow state transitions for BYAN v2 orchestrator
- * 
- * States: INTERVIEW → ANALYSIS → GENERATION → COMPLETED (+ ERROR from any state)
- */
-
-const Logger = require('../observability/logger');
-const ErrorTracker = require('../observability/error-tracker');
-
-class StateMachine {
-  constructor(options = {}) {
-    this.logger = options.logger || new Logger();
-    this.errorTracker = options.errorTracker || new ErrorTracker();
-
-    // AC1: Define five states
-    this.STATES = {
-      INTERVIEW: 'INTERVIEW',
-      ANALYSIS: 'ANALYSIS',
-      GENERATION: 'GENERATION',
-      COMPLETED: 'COMPLETED',
-      ERROR: 'ERROR'
-    };
-
-    // AC2: Valid state transitions
-    this.validTransitions = {
-      INTERVIEW: ['ANALYSIS', 'ERROR'],
-      ANALYSIS: ['GENERATION', 'ERROR'],
-      GENERATION: ['COMPLETED', 'ERROR'],
-      COMPLETED: [], // Terminal state
-      ERROR: []      // Terminal state
-    };
-
-    // State metadata
-    this.currentState = this.STATES.INTERVIEW;
-    this.stateMetadata = {
-      name: this.STATES.INTERVIEW,
-      timestamp: Date.now(),
-      attempts: 0
-    };
-
-    // AC5: Hooks for state enter/exit
-    this.enterHooks = {}; // { stateName: [callbacks] }
-    this.exitHooks = {};  // { stateName: [callbacks] }
-  }
-
-  /**
-   * AC3: Validate and execute state transition
-   * @param {string} newState - Target state
-   * @returns {Object} { success, previousState, newState, error? }
-   */
-  transition(newState) {
-    const previousState = this.currentState;
-
-    // Validate newState exists
-    if (!newState || !this.STATES[newState]) {
-      const error = new Error(`Unknown state: ${newState}`);
-      this.errorTracker.trackError({
-        error,
-        component: 'StateMachine',
-        operation: 'transition',
-        currentState: this.currentState,
-        attemptedState: newState
-      });
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-
-    // Validate transition is allowed
-    if (!this.validTransitions[this.currentState].includes(newState)) {
-      const error = new Error(
-        `Invalid transition from ${this.currentState} to ${newState}`
-      );
-      this.errorTracker.trackError({
-        error,
-        component: 'StateMachine',
-        operation: 'transition',
-        currentState: this.currentState,
-        attemptedState: newState
-      });
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-
-    // Execute transition with hooks
-    try {
-      // AC5: Call exit hooks
-      this._executeHooks(this.exitHooks[this.currentState], {
-        from: this.currentState,
-        to: newState
-      });
-
-      // Update state
-      this.currentState = newState;
-      this.stateMetadata = {
-        name: newState,
-        timestamp: Date.now(),
-        attempts: 0
-      };
-
-      // AC5: Call enter hooks
-      this._executeHooks(this.enterHooks[newState], {
-        from: previousState,
-        to: newState
-      });
-
-      // Log successful transition
-      this.logger.info('State transition', {
-        from: previousState,
-        to: newState,
-        timestamp: this.stateMetadata.timestamp
-      });
-
-      return {
-        success: true,
-        previousState,
-        newState
-      };
-    } catch (error) {
-      // If hooks fail, track but complete transition
-      this.errorTracker.trackError({
-        error,
-        component: 'StateMachine',
-        operation: 'transition-hooks',
-        state: newState
-      });
-
-      return {
-        success: true,
-        previousState,
-        newState,
-        hookError: error.message
-      };
-    }
-  }
-
-  /**
-   * AC4: Get current state with metadata
-   * @returns {Object} { name, timestamp, attempts }
-   */
-  getCurrentState() {
-    return { ...this.stateMetadata };
-  }
-
-  /**
-   * Increment retry attempts for current state
-   */
-  incrementAttempts() {
-    this.stateMetadata.attempts++;
-  }
-
-  /**
-   * AC5: Register state enter hook
-   * @param {string} stateName - State to hook into
-   * @param {Function} callback - Hook function
-   */
-  onStateEnter(stateName, callback) {
-    if (!this.enterHooks[stateName]) {
-      this.enterHooks[stateName] = [];
-    }
-    this.enterHooks[stateName].push(callback);
-  }
-
-  /**
-   * AC5: Register state exit hook
-   * @param {string} stateName - State to hook into
-   * @param {Function} callback - Hook function
-   */
-  onStateExit(stateName, callback) {
-    if (!this.exitHooks[stateName]) {
-      this.exitHooks[stateName] = [];
-    }
-    this.exitHooks[stateName].push(callback);
-  }
-
-  /**
-   * Execute all hooks for a state
-   * @private
-   */
-  _executeHooks(hooks, context) {
-    if (!hooks || hooks.length === 0) return;
-
-    hooks.forEach(hook => {
-      try {
-        hook(context);
-      } catch (error) {
-        // Track hook error but don't block transition
-        this.errorTracker.trackError({
-          error,
-          component: 'StateMachine',
-          operation: 'hook-execution',
-          context
-        });
-        throw error; // Re-throw to be caught by transition()
-      }
-    });
-  }
-}
-
-module.exports = StateMachine;

package/install/src/core/cache/cache.js

@@ -1,126 +0,0 @@
-/**
- * Simple Cache with TTL support for reducing token consumption
- * Provides in-memory caching with automatic expiration
- * 
- * @class SimpleCache
- * @example
- * const cache = new SimpleCache();
- * cache.set('key1', 'value1', 5000); // TTL 5 seconds
- * const value = cache.get('key1');
- */
-class SimpleCache {
-  /**
-   * Initialize a new SimpleCache instance
-   */
-  constructor() {
-    this.store = new Map();
-  }
-
-  /**
-   * Store a value in cache with optional TTL
-   * @param {string} key - Cache key
-   * @param {*} value - Value to cache
-   * @param {number} [ttl] - Time to live in milliseconds (optional)
-   * @throws {Error} If key is not a string
-   * @returns {void}
-   */
-  set(key, value, ttl) {
-    if (typeof key !== 'string' || !key) {
-      throw new Error('Cache key must be a non-empty string');
-    }
-
-    const entry = {
-      value,
-      timestamp: Date.now(),
-      ttl: ttl || null
-    };
-
-    this.store.set(key, entry);
-  }
-
-  /**
-   * Retrieve a value from cache
-   * @param {string} key - Cache key
-   * @returns {*|null} Cached value or null if not found or expired
-   */
-  get(key) {
-    const entry = this.store.get(key);
-
-    if (!entry) {
-      return null;
-    }
-
-    // Check if TTL has expired
-    if (entry.ttl && (Date.now() - entry.timestamp) > entry.ttl) {
-      this.store.delete(key);
-      return null;
-    }
-
-    return entry.value;
-  }
-
-  /**
-   * Check if a key exists and is not expired
-   * @param {string} key - Cache key
-   * @returns {boolean} True if key exists and not expired
-   */
-  has(key) {
-    const value = this.get(key);
-    return value !== null;
-  }
-
-  /**
-   * Delete a specific cache entry
-   * @param {string} key - Cache key to delete
-   * @returns {boolean} True if key was deleted, false if not found
-   */
-  delete(key) {
-    return this.store.delete(key);
-  }
-
-  /**
-   * Clear all cache entries
-   * @returns {void}
-   */
-  clear() {
-    this.store.clear();
-  }
-
-  /**
-   * Get the number of entries in cache (includes expired but not cleaned)
-   * @returns {number} Number of cache entries
-   */
-  size() {
-    return this.store.size;
-  }
-
-  /**
-   * Get all non-expired keys
-   * @returns {string[]} Array of valid keys
-   */
-  keys() {
-    const validKeys = [];
-    for (const [key] of this.store) {
-      if (this.get(key) !== null) {
-        validKeys.push(key);
-      }
-    }
-    return validKeys;
-  }
-
-  /**
-   * Clean up expired entries
-   * @returns {number} Number of entries removed
-   */
-  cleanup() {
-    let removed = 0;
-    for (const [key] of this.store) {
-      if (this.get(key) === null) {
-        removed++;
-      }
-    }
-    return removed;
-  }
-}
-
-module.exports = SimpleCache;

package/install/src/core/context/context.js

@@ -1,86 +0,0 @@
-/**
- * Context Layer for managing conversational context across agents
- * Provides a hierarchical structure for storing and retrieving context data
- * 
- * @class ContextLayer
- * @example
- * const ctx = new ContextLayer();
- * ctx.addLayer('user', { name: 'Yan', role: 'dev' });
- * const userData = ctx.getLayer('user');
- */
-class ContextLayer {
-  /**
-   * Initialize a new ContextLayer instance
-   */
-  constructor() {
-    this.layers = {};
-  }
-
-  /**
-   * Add or update a context layer
-   * @param {string} name - Layer name/identifier
-   * @param {object} data - Layer data to store
-   * @throws {Error} If name is not a string or data is not an object
-   * @returns {void}
-   */
-  addLayer(name, data) {
-    if (typeof name !== 'string' || !name) {
-      throw new Error('Layer name must be a non-empty string');
-    }
-    if (typeof data !== 'object' || data === null) {
-      throw new Error('Layer data must be an object');
-    }
-    this.layers[name] = { ...data, _timestamp: Date.now() };
-  }
-
-  /**
-   * Retrieve a specific context layer
-   * @param {string} name - Layer name to retrieve
-   * @returns {object|null} Layer data (deep copy) or null if not found
-   */
-  getLayer(name) {
-    if (!this.layers[name]) {
-      return null;
-    }
-    return JSON.parse(JSON.stringify(this.layers[name]));
-  }
-
-  /**
-   * Get all context layers
-   * @returns {object} All layers as a key-value object (deep copy)
-   */
-  getAllLayers() {
-    return JSON.parse(JSON.stringify(this.layers));
-  }
-
-  /**
-   * Remove a specific context layer
-   * @param {string} name - Layer name to remove
-   * @returns {boolean} True if layer was removed, false if not found
-   */
-  clearLayer(name) {
-    if (this.layers[name]) {
-      delete this.layers[name];
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Serialize all layers to JSON string
-   * @returns {string} JSON representation of all layers
-   */
-  serialize() {
-    return JSON.stringify(this.layers);
-  }
-
-  /**
-   * Clear all context layers
-   * @returns {void}
-   */
-  clearAll() {
-    this.layers = {};
-  }
-}
-
-module.exports = ContextLayer;