@zibby/core 0.1.20 → 0.1.22

package/src/agents/base.js

@@ -1,361 +0,0 @@
-import { spawn } from 'child_process';
-import { mkdirSync, existsSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { ContextLoader } from '../framework/context-loader.js';
-import { StreamingParser } from '../utils/streaming-parser.js';
-import { findCursorAgentPath } from '../utils/cursor-utils.js';
-import { DEFAULT_OUTPUT_BASE, SESSIONS_DIR, SESSION_INFO_FILE } from '../framework/constants.js';
-import { WorkflowGraph } from '../framework/graph.js';
-
-export class WorkflowAgent {
-  constructor(config = {}) {
-    this.config = config;
-    this.adapter = null;
-    this.paths = config.paths || { specs: 'test-specs', generated: 'tests' };
-    this.agentCommand = config.agentCommand || 'cursor-agent';
-    this.buildArgs = config.buildArgs || ((prompt, useStreaming = true) => {
-      const args = [
-        '-p', 
-        prompt, 
-        '--approve-mcps', 
-        '--force'
-      ];
-      
-      // Only use streaming for non-structured output
-      if (useStreaming) {
-        args.push('--output-format', 'stream-json');
-        args.push('--stream-partial-output');
-      }
-      
-      return args;
-    });
-  }
-
-  /**
-   * Extract JSON result from NDJSON streaming output
-   * Uses StreamingParser for clean, reliable extraction
-   */
-  static extractJsonFromStream(rawOutput) {
-    return StreamingParser.extractResult(rawOutput);
-  }
-
-  async initialize(adapter) {
-    this.adapter = adapter;
-    if (adapter && !adapter.isConnected()) {
-      await adapter.connect();
-    }
-  }
-
-  buildGraph() {
-    throw new Error('buildGraph() must be implemented by subclass');
-  }
-
-  async onComplete(_result) {
-    // Override in subclass for post-execution processing
-    // (e.g., save artifacts, enrich events, rename videos)
-  }
-
-  async run(input, options = {}) {
-    const graph = this.buildGraph();
-    const initialState = typeof input === 'object' && !Array.isArray(input)
-      ? { input, ...input, ...options }
-      : { input, ...options };
-    const result = await graph.run(this, initialState);
-    return result;
-  }
-
-  async executeNode(nodeConfig, state) {
-    const { prompt, outputSchema, model } = nodeConfig;
-    const promptText = typeof prompt === 'function' ? prompt(state) : prompt;
-    
-    console.log(`\n📝 Prompt:\n${promptText}\n`);
-    
-    const output = await this.executePrompt(promptText, state.cwd, 300000, model);
-    
-    console.log(`\n📤 Raw Output:\n${output}\n`);
-    
-    let parsedOutput = null;
-    if (outputSchema) {
-      try {
-        // Use the static helper to extract JSON from streaming output
-        parsedOutput = WorkflowAgent.extractJsonFromStream(output);
-        
-        if (!parsedOutput) {
-          throw new Error('No valid result JSON found in output');
-        }
-        
-        console.log(`\n✅ Parsed Output:\n${JSON.stringify(parsedOutput, null, 2)}\n`);
-      } catch (err) {
-        console.warn(`⚠️  Failed to parse output as JSON: ${err.message}`);
-      }
-    }
-    
-    return { success: true, output: parsedOutput, raw: output };
-  }
-
-  async cleanup() {
-    if (this.adapter && this.adapter.isConnected()) {
-      await this.adapter.disconnect();
-    }
-  }
-
-  async executePrompt(prompt, cwd = process.cwd(), timeoutMs = 300000, model = null, useStreaming = true) {
-    // Resolve cursor-agent path if needed (handles cases where PATH isn't set)
-    let agentCommand = this.agentCommand;
-    if (agentCommand === 'cursor-agent') {
-      const resolvedPath = await findCursorAgentPath();
-      if (resolvedPath) {
-        agentCommand = resolvedPath;
-      }
-      // If not found, keep original command - error will be clearer from spawn
-    }
-    
-    return new Promise((resolve, reject) => {
-      let output = '';
-      const args = this.buildArgs(prompt, useStreaming);
-      
-      if (model) {
-        args.push('--model', model);
-      }
-
-      const env = { ...process.env };
-      
-      const agent = spawn(agentCommand, args, {
-        cwd,
-        env,
-        stdio: ['inherit', 'pipe', 'inherit'], // Let stderr pass through for typewriter effect
-        shell: false,
-        detached: false,
-      });
-
-      const timeout = setTimeout(() => {
-        console.log(`\n⏱️  Timeout reached (${timeoutMs / 1000}s) - killing agent...`);
-        agent.kill('SIGTERM');
-        // Force kill if still running after 2 seconds
-        setTimeout(() => {
-          if (!agent.killed) {
-            console.log('⚠️  Forcing kill (SIGKILL)...');
-            agent.kill('SIGKILL');
-          }
-        }, 2000);
-        reject(new Error(`Agent timed out after ${timeoutMs / 1000}s. The agent may be stuck or waiting for user input.`));
-      }, timeoutMs);
-
-      let lastOutputLength = 0;
-      let lastOutputTime = Date.now();
-      const heartbeat = setInterval(() => {
-        if (output.length > lastOutputLength) {
-          // Output is coming in, no need to show heartbeat
-          lastOutputLength = output.length;
-          lastOutputTime = Date.now();
-        } else {
-          // Only show "thinking" message if no output for 10 seconds
-          const timeSinceLastOutput = Date.now() - lastOutputTime;
-          if (timeSinceLastOutput > 10000) {
-            console.log(`⏳ AI agent is thinking... (${Math.floor(timeSinceLastOutput / 1000)}s, ${output.length} bytes so far)`);
-          }
-        }
-      }, 10000);
-
-      // Handle Ctrl+C gracefully
-      const cleanup = () => {
-        clearTimeout(timeout);
-        clearInterval(heartbeat);
-        if (agent && !agent.killed) {
-          agent.kill('SIGTERM');
-          // Force kill if not dead after 2 seconds
-          setTimeout(() => {
-            if (!agent.killed) {
-              agent.kill('SIGKILL');
-            }
-          }, 2000);
-        }
-      };
-
-      const sigintHandler = () => {
-        console.log('\n\n🛑 Interrupted by user (Ctrl+C)');
-        cleanup();
-        // Don't reset terminal - it's too aggressive
-        reject(new Error('Interrupted by user'));
-      };
-
-      process.on('SIGINT', sigintHandler);
-
-      // Use StreamingParser for clean, reliable parsing
-      const parser = new StreamingParser();
-      
-      // Handle stdout - cursor-agent outputs NDJSON protocol messages
-      agent.stdout.on('data', (data) => {
-        const chunk = data.toString();
-        output += chunk; // Accumulate raw output
-        
-        const displayText = parser.processChunk(chunk);
-        
-        if (displayText) {
-          // Write the extracted text immediately (no buffering)
-          // This creates the typewriter effect as cursor-agent streams
-          process.stdout.write(displayText, 'utf8', () => {
-            // Flush immediately after write
-            if (process.stdout.isTTY) {
-              process.stdout._flush && process.stdout._flush();
-            }
-          });
-          lastOutputTime = Date.now();
-          lastOutputLength += displayText.length;
-        }
-      });
-      
-      agent.on('close', (code) => {
-        process.off('SIGINT', sigintHandler);
-        clearTimeout(timeout);
-        clearInterval(heartbeat);
-        
-        // Flush any remaining buffer
-        const remainingText = parser.flush();
-        if (remainingText) {
-          process.stdout.write(remainingText);
-        }
-        
-        // Get the complete output (for JSON extraction, includes protocol)
-        output = parser.getRawText();
-        
-        // Also store the extracted result for direct access
-        const extractedResult = parser.getResult();
-        
-        if (code === 0) {
-          // Return both raw output and extracted result
-          resolve({ raw: output, extracted: extractedResult });
-        } else {
-          reject(new Error(`Agent exited with code ${code}`));
-        }
-      });
-      
-      agent.on('error', (error) => {
-        process.off('SIGINT', sigintHandler);
-        clearTimeout(timeout);
-        clearInterval(heartbeat);
-        reject(new Error(`Failed to spawn agent: ${error.message}`));
-      });
-    });
-  }
-
-  /**
-   * Run a single node (for testing/debugging)
-   * This is a framework feature, not part of workflow definition
-   */
-  async runSingleNode(nodeName, nodeMap, initialState) {
-    const nodeConfig = nodeMap[nodeName];
-    if (!nodeConfig) {
-      throw new Error(`Unknown node: ${nodeName}. Available nodes: ${Object.keys(nodeMap).join(', ')}`);
-    }
-
-    const { cwd } = initialState;
-    if (!cwd) {
-      throw new Error('cwd is required for single node execution');
-    }
-    
-    // Reuse existing session if provided (--session flag), otherwise create new
-    let sessionPath = initialState.sessionPath;
-    let sessionTimestamp = initialState.sessionTimestamp;
-    const config = initialState.config || {};
-    
-    if (!sessionPath) {
-      // Generate CI-aware session ID
-      const ciSessionId = process.env.CI_JOB_ID || 
-                         process.env.GITHUB_RUN_ID || 
-                         process.env.CIRCLE_WORKFLOW_ID ||
-                         process.env.BUILD_ID;
-      
-      const baseId = ciSessionId || Date.now().toString();
-      const prefix = config.paths?.sessionPrefix;
-      const sessionId = prefix ? `${prefix}_${baseId}` : baseId;
-      
-      sessionTimestamp = sessionTimestamp || Date.now();
-      
-      // Use configurable output path
-      const outputBase = config.paths?.output || DEFAULT_OUTPUT_BASE;
-      sessionPath = join(cwd, outputBase, SESSIONS_DIR, sessionId);
-      
-      if (!existsSync(sessionPath)) {
-        mkdirSync(sessionPath, { recursive: true });
-      }
-    }
-    
-    // Write session info to output directory
-    const outputBase = config.paths?.output || DEFAULT_OUTPUT_BASE;
-    const sessionInfoPath = join(cwd, outputBase, SESSION_INFO_FILE);
-    mkdirSync(join(cwd, outputBase), { recursive: true });
-    writeFileSync(sessionInfoPath, JSON.stringify({ 
-      sessionPath, 
-      sessionTimestamp: sessionTimestamp || sessionPath.split('/').pop(), 
-      currentNode: nodeName,
-      createdAt: new Date().toISOString() 
-    }), 'utf-8');
-
-    console.log(`\n${'='.repeat(80)}`);
-    console.log(`🎯 SINGLE NODE EXECUTION: ${nodeName}`);
-    console.log(`📁 Session: ${sessionPath.split('/').pop()}${initialState.sessionPath ? ' (reusing)' : ''}`);
-    console.log(`${'='.repeat(80)}\n`);
-
-    const context = await ContextLoader.loadContext(
-      initialState.specPath || '',
-      cwd,
-      initialState.contextConfig || {}
-    );
-
-    // Use Node class for consistent behavior with workflow execution
-    const { Node } = await import('../framework/node.js');
-    const { WorkflowState } = await import('../framework/state.js');
-    
-    const state = new WorkflowState({
-      ...initialState,
-      sessionPath,
-      sessionTimestamp,
-      context
-    });
-    
-    const node = new Node(nodeConfig);
-    const result = await node.execute(this, state);
-    
-    console.log(`\n${'='.repeat(80)}`);
-    console.log(`✅ Node ${nodeName} completed`);
-    console.log(`${'='.repeat(80)}\n`);
-
-    return { success: true, output: result.output, outputPath: initialState.outputPath, state: result };
-  }
-
-  calculateOutputPath(specPath) {
-    const { specs, generated } = this.paths;
-    if (!specPath) return `${generated}/generated-test.spec.js`;
-    
-    const relativePath = specPath.replace(new RegExp(`^${specs}/`), '').replace(/\.[^.]+$/, '.spec.js');
-    return `${generated}/${relativePath}`.replace(/\/+/g, '/');
-  }
-}
-
-/**
- * Functional workflow factory — no class boilerplate needed.
- *
- *   const agent = workflow((graph) => {
- *     graph.addNode('plan',    { prompt: ..., outputSchema: ... });
- *     graph.addNode('execute', { skills: ['calculator'], prompt: ... });
- *     graph.setEntryPoint('plan');
- *     graph.addEdge('plan', 'execute');
- *     graph.addEdge('execute', 'END');
- *   });
- *
- *   await agent.run("What is 15 plus 27?");
- */
-export function workflow(builder, options = {}) {
-  const agent = new WorkflowAgent(options);
-  agent.buildGraph = function () {
-    const graph = new WorkflowGraph();
-    builder(graph);
-    return graph;
-  };
-  if (options.onComplete) {
-    agent.onComplete = options.onComplete;
-  }
-  return agent;
-}
-

package/src/constants.js

@@ -1,47 +0,0 @@
-/**
- * Zibby Framework Constants
- * Single source of truth for all configuration values
- */
-
-export const DEFAULT_MODELS = {
-  CLAUDE: 'claude-sonnet-4-6',
-  CURSOR: 'auto',
-  OPENAI_POSTPROCESSING: 'gpt-4o-mini'
-};
-
-export const AGENT_TYPES = {
-  CLAUDE: 'claude',
-  CURSOR: 'cursor'
-};
-
-export const LOG_LEVELS = {
-  DEBUG: 'debug',
-  INFO: 'info',
-  WARN: 'warn',
-  ERROR: 'error',
-  SILENT: 'silent'
-};
-
-export const CLAUDE_MODEL_MAP = {
-  'auto': 'claude-sonnet-4-6',
-  // 4.6 aliases
-  'sonnet-4.6': 'claude-sonnet-4-6',
-  'sonnet-4-6': 'claude-sonnet-4-6',
-  'opus-4.6': 'claude-opus-4-6',
-  'opus-4-6': 'claude-opus-4-6',
-  // 4.5 aliases
-  'sonnet-4.5': 'claude-sonnet-4-5-20250929',
-  'sonnet-4-5': 'claude-sonnet-4-5-20250929',
-  'opus-4.5': 'claude-opus-4-20250514',
-  'opus-4-5': 'claude-opus-4-20250514',
-  // Direct API IDs (pass-through)
-  'claude-sonnet-4-6': 'claude-sonnet-4-6',
-  'claude-opus-4-6': 'claude-opus-4-6',
-  'claude-sonnet-4-5-20250929': 'claude-sonnet-4-5-20250929',
-  'claude-opus-4-20250514': 'claude-opus-4-20250514',
-};
-
-export const TIMEOUTS = {
-  CURSOR_AGENT_DEFAULT: 20 * 60 * 1000,
-  OPENAI_REQUEST: 30000
-};

package/src/enrichment/base.js

@@ -1,49 +0,0 @@
-/**
- * Base Enrichment Pipeline Component
- * Each enricher adds specific data to events without affecting others
- */
-export class EventEnricher {
-  constructor(config = {}) {
-    this.config = config;
-    this.enabled = config.enabled !== false; // Default enabled
-    this.priority = config.priority || 50; // Default priority
-  }
-
-  /**
-   * Get enricher name for logging
-   */
-  getName() {
-    throw new Error('EventEnricher.getName() must be implemented');
-  }
-
-  /**
-   * Check if this enricher can run (dependencies met, etc)
-   * @param {Object} context - { page, element, event, session }
-   * @returns {boolean}
-   */
-  canEnrich(_context) {
-    return this.enabled;
-  }
-
-  /**
-   * Enrich the event with additional data
-   * @param {Object} event - The MCP event to enrich
-   * @param {Object} context - { page, element, ref }
-   * @returns {Promise<Object>} - Enriched data to merge into event
-   */
-  async enrich(_event, _context) {
-    throw new Error('EventEnricher.enrich() must be implemented');
-  }
-
-  /**
-   * Handle errors gracefully (never break the pipeline)
-   * @param {Error} error
-   * @param {Object} event
-   */
-  handleError(error, event) {
-    console.warn(`[${this.getName()}] Enrichment failed for event ${event.type}:`, error.message);
-    return null; // Return null = skip this enrichment
-  }
-}
-
-export default EventEnricher;

package/src/enrichment/enrichers/accessibility-enricher.js

@@ -1,197 +0,0 @@
-/**
- * Accessibility Enricher - Captures accessibility tree data and structural hash
- */
-import { EventEnricher } from '../base.js';
-import crypto from 'crypto';
-
-export class AccessibilityEnricher extends EventEnricher {
-  getName() {
-    return 'AccessibilityEnricher';
-  }
-
-  getPriority() {
-    return 100; // Highest priority - most stable identifier
-  }
-
-  canEnrich(context) {
-    if (!this.enabled) return false;
-    if (!context.element) return false;
-    if (!context.event) return false;
-    
-    return ['click', 'fill', 'type', 'selectOption', 'hover'].includes(context.event.type);
-  }
-
-  async enrich(event, context) {
-    try {
-      const { page, element } = context;
-      
-      // Get accessibility snapshot of entire page
-      const snapshot = await page.accessibility.snapshot();
-      
-      // Find the target element in AX tree
-      const axNode = await this.findAxNode(element, snapshot);
-      if (!axNode) return null;
-      
-      // Get parent and siblings
-      const axContext = await this.getAxContext(axNode, snapshot);
-      
-      // Calculate structural hash (hash of AX subtree)
-      const axTreeHash = this.hashAxSubtree(axNode);
-      const axPathHash = this.hashAxPath(axContext.path);
-      
-      return {
-        accessibility: {
-          role: axNode.role,
-          name: axNode.name || '',
-          level: axContext.level,
-          parent: axContext.parent,
-          siblings: axContext.siblings,
-          axTreeHash,
-          axPathHash
-        }
-      };
-    } catch (error) {
-      return this.handleError(error, event);
-    }
-  }
-
-  /**
-   * Find AX node for given element
-   */
-  async findAxNode(element, snapshot) {
-    // Get element's aria attributes for matching
-    const ariaProps = await element.evaluate(el => ({
-      role: el.getAttribute('role') || el.tagName.toLowerCase(),
-      name: el.getAttribute('aria-label') || el.textContent?.trim() || '',
-      tagName: el.tagName.toLowerCase()
-    }));
-    
-    // Search AX tree for matching node
-    return this.searchAxTree(snapshot, ariaProps);
-  }
-
-  /**
-   * Recursively search AX tree
-   */
-  searchAxTree(node, props) {
-    if (!node) return null;
-    
-    // Match by role and name
-    if (node.role === props.role && 
-        (node.name || '').includes(props.name.substring(0, 20))) {
-      return node;
-    }
-    
-    // Search children
-    if (node.children) {
-      for (const child of node.children) {
-        const found = this.searchAxTree(child, props);
-        if (found) return found;
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Get context (parent, siblings, path)
-   */
-  getAxContext(node, snapshot) {
-    const context = {
-      level: 0,
-      parent: null,
-      siblings: [],
-      path: []
-    };
-    
-    // Walk up tree to find parent and siblings
-    const parent = this.findParent(node, snapshot);
-    if (parent) {
-      context.parent = { role: parent.role, name: parent.name };
-      context.siblings = (parent.children || [])
-        .filter(c => c !== node)
-        .map(c => ({ role: c.role, name: c.name }))
-        .slice(0, 3); // Limit siblings
-    }
-    
-    // Calculate level (depth in tree)
-    context.level = this.calculateLevel(node, snapshot);
-    
-    // Build path from root to node
-    context.path = this.buildPath(node, snapshot);
-    
-    return context;
-  }
-
-  findParent(node, tree, current = tree) {
-    if (!current || !current.children) return null;
-    
-    if (current.children.includes(node)) {
-      return current;
-    }
-    
-    for (const child of current.children) {
-      const found = this.findParent(node, tree, child);
-      if (found) return found;
-    }
-    
-    return null;
-  }
-
-  calculateLevel(node, tree, current = tree, level = 0) {
-    if (current === node) return level;
-    
-    if (current.children) {
-      for (const child of current.children) {
-        const found = this.calculateLevel(node, tree, child, level + 1);
-        if (found >= 0) return found;
-      }
-    }
-    
-    return -1;
-  }
-
-  buildPath(node, tree, current = tree, path = []) {
-    if (current === node) {
-      return [...path, { role: current.role, name: current.name }];
-    }
-    
-    if (current.children) {
-      for (const child of current.children) {
-        const found = this.buildPath(node, tree, child, [
-          ...path,
-          { role: current.role, name: current.name }
-        ]);
-        if (found) return found;
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Hash AX subtree for stability detection
-   */
-  hashAxSubtree(node) {
-    const structure = JSON.stringify({
-      role: node.role,
-      name: node.name,
-      children: (node.children || []).map(c => ({
-        role: c.role,
-        name: c.name
-      }))
-    });
-    
-    return crypto.createHash('md5').update(structure).digest('hex').substring(0, 12);
-  }
-
-  /**
-   * Hash AX path from root to node
-   */
-  hashAxPath(path) {
-    const pathStr = path.map(p => `${p.role}:${p.name}`).join('/');
-    return crypto.createHash('md5').update(pathStr).digest('hex').substring(0, 12);
-  }
-}
-
-export default AccessibilityEnricher;