@zibby/core 0.1.0

package/src/framework/tool-resolver.js

@@ -0,0 +1,65 @@
+import { getSkill } from './skill-registry.js';
+
+const NODE_DEFAULT_TOOLS = {};
+
+export function resolveNodeTools(nodeType, userToolIds) {
+  if (Array.isArray(userToolIds)) {
+    return getResolvedToolDefinitions(userToolIds);
+  }
+  const defaults = NODE_DEFAULT_TOOLS[nodeType];
+  if (!defaults || defaults.length === 0) return null;
+  return getResolvedToolDefinitions(defaults);
+}
+
+export function getResolvedToolDefinitions(toolIds) {
+  if (!Array.isArray(toolIds) || toolIds.length === 0) return null;
+
+  const claudeTools = [];
+  const mcpServers = {};
+  const validIds = [];
+
+  for (const toolId of toolIds) {
+    const skill = getSkill(toolId);
+    if (!skill) {
+      console.warn(`[ToolResolver] Unknown skill "${toolId}" — skipping`);
+      continue;
+    }
+
+    validIds.push(toolId);
+
+    for (const tool of (skill.tools || [])) {
+      claudeTools.push({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.input_schema || { type: 'object', properties: {} }
+      });
+    }
+
+    if (!mcpServers[skill.serverName]) {
+      if (typeof skill.resolve === 'function') {
+        const resolved = skill.resolve();
+        if (resolved) {
+          mcpServers[skill.serverName] = { ...resolved, toolPrefix: toolId };
+        }
+      } else {
+        const env = {};
+        for (const key of (skill.envKeys || [])) {
+          const value = process.env[key];
+          if (value) env[key] = value;
+        }
+        mcpServers[skill.serverName] = {
+          command: skill.command,
+          args: [...(skill.args || [])],
+          env,
+          toolPrefix: toolId,
+        };
+      }
+    }
+  }
+
+  if (validIds.length === 0) return null;
+
+  return { toolIds: validIds, claudeTools, mcpServers };
+}
+
+export { NODE_DEFAULT_TOOLS };

package/src/index.js

@@ -0,0 +1,342 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { DEFAULT_OUTPUT_BASE, SESSIONS_DIR, RESULT_FILE } from './framework/constants.js';
+
+import { WorkflowAgent, workflow } from './agents/base.js';
+export { WorkflowAgent, workflow };
+export { WorkflowGraph } from './framework/graph.js';
+export { ResultHandler } from './utils/result-handler.js';
+export { z } from 'zod';
+
+export { 
+  invokeAgent, 
+  getAgentStrategy,
+  CursorAgentStrategy,
+  ClaudeAgentStrategy,
+  AgentStrategy
+} from './framework/agents/index.js';
+
+export { SKILLS } from './framework/constants.js';
+export { registerSkill, getSkill, hasSkill, getAllSkills, listSkillIds } from './framework/skill-registry.js';
+
+export { organizeVideos } from './utils/video-organizer.js';
+export { ZibbyUploader, createUploader } from './sync/index.js';
+export { patchCursorAgentForCI, checkCursorAgentPatched, getApprovalKeys, saveApprovalKeys } from './utils/ci-setup.js';
+export { DEFAULT_MODELS, AGENT_TYPES, LOG_LEVELS as CORE_LOG_LEVELS } from './constants.js';
+export { 
+  DEFAULT_OUTPUT_BASE, 
+  SESSIONS_DIR, 
+  SESSION_INFO_FILE, 
+  RESULT_FILE, 
+  RAW_OUTPUT_FILE, 
+  EVENTS_FILE, 
+  CI_ENV_VARS 
+} from './framework/constants.js';
+export { RIPPLE_EFFECT_SCRIPT, injectRippleEffect, generateRippleHelperCode } from './utils/ripple-effect.js';
+export { checkCursorAgentInstalled, getCursorAgentInstallInstructions } from './utils/cursor-utils.js';
+export { SelectorGenerator } from './utils/selector-generator.js';
+export { TestPostProcessor } from './utils/test-post-processor.js';
+export { TraceParser } from './utils/trace-parser.js';
+export { StreamingParser } from './utils/streaming-parser.js';
+export { ZibbyRuntime } from './runtime/zibby-runtime.js';
+export { StableIdRuntime } from './runtime/stable-id-runtime.js';
+export { logger, Logger, LOG_LEVELS } from './utils/logger.js';
+export { timeline } from './utils/timeline.js';
+export { postProcessEvents } from './utils/post-process-events.js';
+export { runPlaywrightTestTool, resetExecutionCount } from './tools/run-playwright-test.js';
+
+export { 
+  testGenerationManager,
+  TestGenerationStrategy,
+  MCPRefStrategy,
+  StableIdStrategy
+} from './runtime/generation/index.js';
+
+export {
+  testVerificationManager,
+  TestVerificationStrategy,
+  PlaywrightJsonVerificationStrategy
+} from './runtime/verification/index.js';
+
+export {
+  EventEnricher,
+  EnrichmentPipeline,
+  PositionEnricher,
+  AccessibilityEnricher,
+  PageStateEnricher,
+  DOMEnricher,
+  createDefaultPipeline,
+  createMinimalPipeline,
+  createCustomPipeline
+} from './enrichment/index.js';
+
+export {
+  enrichRecordedEvents,
+  LiveEnrichmentRecorder
+} from './enrichment/mcp-integration.js';
+
+const mcpErrorHandler = (error) => {
+  if (error?.message?.includes('Connection closed') || 
+      error?.message?.includes('MCP error -32000') ||
+      error?.code === -32000) {
+    return;
+  }
+  console.error('Unhandled rejection:', error);
+};
+
+if (!process.listeners('unhandledRejection').includes(mcpErrorHandler)) {
+  process.on('unhandledRejection', mcpErrorHandler);
+}
+
+export async function runTest(specPath, config = {}) {
+  const {
+    agent: _agent,
+    mcp: _mcp,
+    headless: _headless,
+    cwd = process.cwd(),
+    specPath: relativeSpecPath,
+    ...agentConfig
+  } = config;
+
+  const testSpec = readFileSync(specPath, 'utf-8');
+  
+  const adapter = null;
+  let agent = await loadLocalAgent(cwd, agentConfig);
+  
+  if (!agent && config.fallbackAgentModule) {
+    const mod = config.fallbackAgentModule;
+    const AgentClass = mod.BrowserTestAutomationAgent || mod.default;
+    if (AgentClass) {
+      agent = new AgentClass(agentConfig);
+    }
+  }
+
+  if (!agent) {
+    throw new Error(
+      `No agent found. Please run:\n` +
+      `  zibby init\n\n` +
+      `This will create .zibby/graph.js with your workflow definition.`
+    );
+  }
+  
+  await agent.initialize(adapter);
+
+  try {
+    if (config.singleNode) {
+      console.log(`\n🎯 Running Single Node: ${config.singleNode} (Framework Mode)\n`);
+      
+      const outputPath = agent.calculateOutputPath(relativeSpecPath || specPath);
+      
+      const graph = agent.buildGraph();
+      const nodeMap = {};
+      for (const [name, node] of graph.nodes.entries()) {
+        nodeMap[name] = node.config || node;
+      }
+      
+      let sessionData = {};
+      if (config.sessionId) {
+        let sessionId = config.sessionId;
+        
+        // Get output base path from config (use new default)
+        const outputBase = config.paths?.output || DEFAULT_OUTPUT_BASE;
+
+        if (sessionId === 'last') {
+          const sessionsDir = join(cwd, outputBase, SESSIONS_DIR);
+          if (existsSync(sessionsDir)) {
+            const { readdirSync, statSync } = await import('fs');
+            const sessions = readdirSync(sessionsDir)
+              .filter(f => statSync(join(sessionsDir, f)).isDirectory())
+              .map(f => ({ name: f, time: statSync(join(sessionsDir, f)).mtimeMs }))
+              .sort((a, b) => b.time - a.time);
+
+            if (sessions.length > 0) {
+              sessionId = sessions[0].name;
+              console.log(`📂 Using latest session: ${sessionId}`);
+            } else {
+              console.log(`⚠️  No sessions found in ${sessionsDir}`);
+            }
+          }
+        }
+
+        const sessionPath = join(cwd, outputBase, SESSIONS_DIR, sessionId);
+        const executeLiveFolder = join(sessionPath, 'execute_live');
+        const resultPath = join(executeLiveFolder, RESULT_FILE);
+        
+        if (existsSync(resultPath)) {
+          console.log(`📂 Loading session: ${sessionId}`);
+          sessionData = {
+            sessionPath,
+            execute_live_output: JSON.parse(readFileSync(resultPath, 'utf-8'))
+          };
+        } else {
+          console.log(`⚠️  Session not found: ${sessionPath}`);
+        }
+      }
+      
+      const result = await agent.runSingleNode(
+        config.singleNode,
+        nodeMap,
+        { 
+          testSpec, 
+          outputPath,
+          cwd: cwd || process.cwd(),
+          contextConfig: config.contextConfig,
+          specPath: relativeSpecPath || specPath,
+          config,
+          ...sessionData
+        }
+      );
+      
+      if (typeof agent.onComplete === 'function') {
+        await agent.onComplete(result);
+      }
+
+      return result;
+    }
+
+    const result = await agent.run(testSpec, {
+      testSpec,
+      specPath: relativeSpecPath || specPath,
+      cwd: cwd || process.cwd(),
+      config
+    });
+
+    return result;
+  } finally {
+    await agent.cleanup();
+  }
+}
+
+function kebabToPascal(str) {
+  return str
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+function findWorkflow(agentModule, workflowName) {
+  if (agentModule[workflowName]) {
+    return agentModule[workflowName];
+  }
+  
+  const pascalCase = kebabToPascal(workflowName);
+  if (agentModule[pascalCase]) {
+    return agentModule[pascalCase];
+  }
+  
+  const withSuffix = `${pascalCase}Workflow`;
+  if (agentModule[withSuffix]) {
+    return agentModule[withSuffix];
+  }
+  
+  return null;
+}
+
+export async function listWorkflows(cwd = process.cwd()) {
+  try {
+    const { join: pathJoin } = await import('path');
+    const { existsSync: fsExistsSync } = await import('fs');
+    const { pathToFileURL } = await import('url');
+    
+    const localAgentPath = pathJoin(cwd, '.zibby/graph.js');
+    
+    if (!fsExistsSync(localAgentPath)) {
+      return { available: [], default: null, error: 'No .zibby/graph.js found' };
+    }
+    
+    const agentModule = await import(pathToFileURL(localAgentPath).href);
+    const available = Object.keys(agentModule).filter(k => 
+      k !== 'default' && 
+      typeof agentModule[k] === 'function' &&
+      agentModule[k].prototype instanceof WorkflowAgent
+    );
+    
+    const defaultWorkflow = agentModule.BrowserTestAutomationAgent ? 'BrowserTestAutomationAgent' :
+                           agentModule.CursorAgent ? 'CursorAgent' :
+                           agentModule.default ? 'default' :
+                           available[0] || null;
+    
+    return { available, default: defaultWorkflow, error: null };
+  } catch (error) {
+    return { available: [], default: null, error: error.message };
+  }
+}
+
+async function loadLocalAgent(cwd, config) {
+  try {
+    const { join: pathJoin } = await import('path');
+    const { existsSync: fsExistsSync } = await import('fs');
+    const { pathToFileURL } = await import('url');
+    
+    const localAgentPath = pathJoin(cwd, '.zibby/graph.js');
+    
+    if (!fsExistsSync(localAgentPath)) {
+      return null;
+    }
+    
+    const agentModule = await import(pathToFileURL(localAgentPath).href);
+    
+    const workflowName = config.workflow;
+    let AgentClass;
+    
+    if (workflowName) {
+      AgentClass = findWorkflow(agentModule, workflowName);
+      if (!AgentClass) {
+        const available = Object.keys(agentModule).filter(k => k !== 'default' && typeof agentModule[k] === 'function');
+        throw new Error(
+          `Workflow "${workflowName}" not found.\n` +
+          `Available workflows: ${available.join(', ')}\n` +
+          `Supported formats: QuickSmokeWorkflow, QuickSmoke, quick-smoke`
+        );
+      }
+      const actualName = Object.keys(agentModule).find(k => agentModule[k] === AgentClass);
+      console.log(`✓ Using workflow: ${actualName} (from --workflow ${workflowName})`);
+    } else {
+      // Try multiple fallbacks for default workflow
+      AgentClass = agentModule.BrowserTestAutomationAgent || 
+                   agentModule.CursorAgent || 
+                   agentModule.default;
+      
+      // If still not found, try to find any workflow class
+      if (!AgentClass) {
+        const availableClasses = Object.keys(agentModule).filter(k => 
+          k !== 'default' && 
+          typeof agentModule[k] === 'function' &&
+          agentModule[k].prototype instanceof WorkflowAgent
+        );
+        if (availableClasses.length > 0) {
+          AgentClass = agentModule[availableClasses[0]];
+          console.log(`✓ Using workflow: ${availableClasses[0]} (auto-detected)`);
+        }
+      }
+      
+      if (!AgentClass) {
+        console.warn('⚠️  Could not find any WorkflowAgent export in local graph.js');
+        return null;
+      }
+      
+      if (!AgentClass.name?.includes('auto-detected')) {
+        console.log('✓ Using local agent from .zibby/graph.js');
+      }
+    }
+    
+    return new AgentClass(config);
+  } catch (error) {
+    console.warn(`⚠️  Failed to load local agent: ${error.message}`);
+    return null;
+  }
+}
+
+export class TestAutomation {
+  constructor(config = {}) {
+    this.config = config;
+  }
+
+  async run(options) {
+    return runTest(options.spec || options.specPath, {
+      ...this.config,
+      ...options,
+    });
+  }
+}
+

package/src/runtime/generation/base.js

@@ -0,0 +1,46 @@
+/**
+ * Base class for test generation strategies
+ * Defines the interface that all generation strategies must implement
+ */
+export class TestGenerationStrategy {
+  /**
+   * Generate a test file from execution data
+   * @param {Object} context - Generation context
+   * @param {string} context.testFilePath - Where to write the test
+   * @param {string} context.sessionPath - Session data path
+   * @param {string} context.outputPath - Output file path
+   * @param {Object} context.state - Workflow state
+   * @param {Object} context.executionData - Data from execute_live node
+   * @returns {Promise<Object>} - { success: boolean, testPath: string, method: string }
+   */
+  async generate(_context) {
+    throw new Error('TestGenerationStrategy.generate() must be implemented');
+  }
+
+  /**
+   * Check if this strategy can be used with available data
+   * @param {Object} context - Same context as generate()
+   * @returns {boolean}
+   */
+  canGenerate(_context) {
+    throw new Error('TestGenerationStrategy.canGenerate() must be implemented');
+  }
+
+  /**
+   * Get strategy name for logging
+   * @returns {string}
+   */
+  getName() {
+    throw new Error('TestGenerationStrategy.getName() must be implemented');
+  }
+
+  /**
+   * Get strategy priority (higher = try first)
+   * @returns {number}
+   */
+  getPriority() {
+    return 0;
+  }
+}
+
+export default TestGenerationStrategy;

package/src/runtime/generation/index.js

@@ -0,0 +1,70 @@
+/**
+ * Test Generation Strategy Manager
+ * Automatically selects and runs the best available generation strategy
+ */
+import { MCPRefStrategy } from './mcp-ref-strategy.js';
+import { StableIdStrategy } from './stable-id-strategy.js';
+
+export class TestGenerationStrategyManager {
+  constructor() {
+    // Register all available strategies (auto-sorted by priority)
+    this.strategies = [
+      new StableIdStrategy(),  // Priority 300 - Highest (stable ID injection)
+      new MCPRefStrategy(),    // Priority 200 - Fallback (MCP descriptions)
+    ];
+
+    // Sort by priority (highest first)
+    this.strategies.sort((a, b) => b.getPriority() - a.getPriority());
+  }
+
+  /**
+   * Add a custom strategy
+   * @param {TestGenerationStrategy} strategy
+   */
+  registerStrategy(strategy) {
+    this.strategies.push(strategy);
+    this.strategies.sort((a, b) => b.getPriority() - a.getPriority());
+  }
+
+  /**
+   * Generate test using the best available strategy
+   * @param {Object} context - Generation context
+   * @returns {Promise<Object>} - Generation result
+   */
+  async generate(context) {
+    console.log(`\n📋 Available generation strategies (${this.strategies.length}):`);
+    this.strategies.forEach(s => {
+      const canUse = s.canGenerate(context);
+      console.log(`   ${canUse ? '✓' : '✗'} ${s.getName()} (priority: ${s.getPriority()})`);
+    });
+
+    // Find first strategy that can generate
+    for (const strategy of this.strategies) {
+      if (strategy.canGenerate(context)) {
+        console.log(`\n🎯 Selected: ${strategy.getName()}`);
+        return strategy.generate(context);
+      }
+    }
+
+    throw new Error('No generation strategy available for this context');
+  }
+
+  /**
+   * Get strategy by name
+   * @param {string} name - Strategy name
+   * @returns {TestGenerationStrategy|null}
+   */
+  getStrategy(name) {
+    return this.strategies.find(s => s.getName().includes(name)) || null;
+  }
+}
+
+// Export strategy classes for custom implementations
+export { MCPRefStrategy } from './mcp-ref-strategy.js';
+export { StableIdStrategy } from './stable-id-strategy.js';
+export { TestGenerationStrategy } from './base.js';
+
+// Export singleton instance
+export const testGenerationManager = new TestGenerationStrategyManager();
+
+export default testGenerationManager;