@zibby/core 0.1.21 → 0.1.23

package/src/framework/tool-resolver.js

@@ -1,65 +0,0 @@
-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

@@ -1,345 +0,0 @@
-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;
-  const { agent: localAgent, error: localAgentError } = await loadLocalAgent(cwd, agentConfig);
-  let agent = localAgent;
-  
-  if (!agent && config.fallbackAgentModule) {
-    const mod = config.fallbackAgentModule;
-    const AgentClass = mod.BrowserTestAutomationAgent || mod.default;
-    if (AgentClass) {
-      agent = new AgentClass(agentConfig);
-    }
-  }
-
-  if (!agent && localAgentError) {
-    console.warn(`⚠️  Failed to load local agent: ${localAgentError}`);
-  }
-
-  if (!agent) {
-    throw new Error(
-      `No agent found. Please run:\n` +
-      `  zibby init\n\n` +
-      `This will create .zibby/graph.mjs 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.mjs');
-    
-    if (!fsExistsSync(localAgentPath)) {
-      return { available: [], default: null, error: 'No .zibby/graph.mjs 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.mjs');
-    
-    if (!fsExistsSync(localAgentPath)) {
-      return { agent: null, error: 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) {
-        return { agent: null, error: 'Could not find any WorkflowAgent export in local graph.js' };
-      }
-      
-      if (!AgentClass.name?.includes('auto-detected')) {
-        console.log('✓ Using local agent from .zibby/graph.mjs');
-      }
-    }
-    
-    return { agent: new AgentClass(config), error: null };
-  } catch (error) {
-    return { agent: null, error: error.message };
-  }
-}
-
-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

@@ -1,46 +0,0 @@
-/**
- * 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

@@ -1,70 +0,0 @@
-/**
- * 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;