@zibby/core 0.4.6 → 0.5.1

package/dist/templates/index.js

@@ -1,147 +0,0 @@
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { existsSync } from 'fs';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export const TEMPLATES = {
-  'browser-test-automation': {
-    name: 'browser-test-automation',
-    displayName: 'Browser Test Automation (Full Workflow)',
-    description: 'Complete browser test automation workflow with title generation, live execution, and script generation',
-    path: join(__dirname, 'browser-test-automation'),
-    default: true,
-    // Suggested slug for `zibby workflow new <slug> -t <name>`. Used in
-    // the `template list` scaffold hint so the printed command is
-    // copy-paste-ready instead of `your-workflow-name`. Users can still
-    // pick anything they want at scaffold time.
-    defaultSlug: 'browser-tests',
-    // Runtime deps the scaffolded copy needs in addition to @zibby/core.
-    // graph.mjs now imports state.js which `import { z } from 'zod'`s
-    // directly, so the user's package.json must declare zod or the
-    // scaffolded workflow fails on first import.
-    deps: {
-      zod: '^3.23.0',
-    },
-    features: [
-      'Preflight analysis: extract title + assertion checklist from spec',
-      'Execute test live with AI + browser (Claude or Cursor)',
-      'Generate Playwright script with stable IDs',
-      'Real-time streaming output',
-      'Video recording of browser sessions'
-    ]
-  },
-  'code-analysis': {
-    name: 'code-analysis',
-    displayName: 'Code Analysis (Ticket → Code + Tests)',
-    description: 'Multi-node workflow that analyzes a Jira ticket against a code repo, generates code changes, and emits test cases',
-    path: join(__dirname, 'code-analysis'),
-    defaultSlug: 'ticket-analyzer',
-    // Runtime deps the scaffolded copy needs in addition to @zibby/core.
-    // Merged into the generated package.json so `npm install` works
-    // without manual edits. Browser-test doesn't declare any because
-    // its nodes only depend on @zibby/core.
-    deps: {
-      axios: '^1.6.0',
-      handlebars: '^4.7.8',
-      zod: '^3.23.0',
-    },
-    features: [
-      'Clone repos + snapshot git baseline',
-      'LLM analysis of ticket against codebase (canProceed gate)',
-      'Conditional routing: skip code-gen if ticket is invalid',
-      'Generate scoped code changes',
-      'Generate test cases covering the changes',
-      'Customizable prompts in prompts/*.md'
-    ]
-  },
-  'generate-test-cases': {
-    name: 'generate-test-cases',
-    displayName: 'Generate Test Cases (Diff → Test Specs)',
-    description: 'Standalone slice — takes an existing code diff and generates plain-English test specifications for it. Skips ticket-analysis and code-gen.',
-    path: join(__dirname, 'generate-test-cases'),
-    defaultSlug: 'tests-from-diff',
-    deps: {
-      zod: '^3.23.0',
-    },
-    features: [
-      'Two-node graph: setup → generate_test_cases',
-      'Takes a PR diff directly as state input (no upstream code-gen needed)',
-      'LLM explores codebase routing/components for accurate test steps',
-      'Emits 4-8 prioritized test specs (Critical/High/Medium/Low)',
-      'Plain-English test steps — runnable by AI agents'
-    ]
-  }
-};
-
-export class TemplateFactory {
-  static listTemplates() {
-    return Object.values(TEMPLATES);
-  }
-
-  static getDefault() {
-    return Object.values(TEMPLATES).find(t => t.default) || TEMPLATES['browser-test-automation'];
-  }
-
-  static getTemplate(name) {
-    const template = TEMPLATES[name];
-    if (!template) {
-      const available = Object.keys(TEMPLATES).join(', ');
-      throw new Error(`Template "${name}" not found. Available: ${available}`);
-    }
-    return template;
-  }
-
-  static validateTemplate(templatePath) {
-    const requiredFiles = ['graph.mjs', 'nodes', 'README.md'];
-    
-    for (const file of requiredFiles) {
-      const filePath = join(templatePath, file);
-      if (!existsSync(filePath)) {
-        throw new Error(`Template missing required file: ${file}`);
-      }
-    }
-    
-    return true;
-  }
-
-  static getTemplateFiles(templateName) {
-    const template = this.getTemplate(templateName);
-    this.validateTemplate(template.path);
-    
-    const resultHandlerPath = join(template.path, 'result-handler.mjs');
-    return {
-      graphPath: join(template.path, 'graph.mjs'),
-      nodesPath: join(template.path, 'nodes'),
-      readmePath: join(template.path, 'README.md'),
-      resultHandlerPath: existsSync(resultHandlerPath) ? resultHandlerPath : null,
-      template
-    };
-  }
-
-  static registerCustomTemplate(name, config) {
-    if (TEMPLATES[name]) {
-      throw new Error(`Template "${name}" already exists`);
-    }
-    
-    if (!config.path || !config.displayName) {
-      throw new Error('Custom template must have "path" and "displayName"');
-    }
-    
-    this.validateTemplate(config.path);
-    
-    TEMPLATES[name] = {
-      name,
-      displayName: config.displayName,
-      description: config.description || '',
-      path: config.path,
-      features: config.features || [],
-      custom: true
-    };
-    
-    return TEMPLATES[name];
-  }
-}
-
-export default TemplateFactory;

package/dist/templates/register-nodes.js

@@ -1,24 +0,0 @@
-/**
- * Template node registrations
- * 
- * Import this module as a side-effect to register all built-in
- * template nodes with the framework's node registry.
- * 
- * Usage: import '@zibby/core/templates/register-nodes.js';
- */
-
-import { registerNode } from '@zibby/agent-workflow';
-import { setupNode } from './code-analysis/nodes/setup-node.js';
-import { analyzeTicketNode } from './code-analysis/nodes/analyze-ticket-node.js';
-import { generateCodeNode, implementCodeNode } from './code-analysis/nodes/generate-code-node.js';
-import { generateTestCasesNode } from './code-analysis/nodes/generate-test-cases-node.js';
-import { finalizeNode } from './code-analysis/nodes/finalize-node.js';
-import { createPRNode } from './code-analysis/nodes/create-pr-node.js';
-
-registerNode('setup', setupNode);
-registerNode('analyze_ticket', analyzeTicketNode);
-registerNode('generate_code', generateCodeNode);
-registerNode('generate_test_cases', generateTestCasesNode);
-registerNode('finalize', finalizeNode);
-registerNode('implement_code', implementCodeNode);
-registerNode('create_pr', createPRNode);

package/templates/browser-test-automation/README.md

@@ -1,136 +0,0 @@
-# Browser Test Automation Workflow
-
-This is YOUR workflow graph. You can customize it however you want!
-
-Works with **Claude** or **Cursor** agents (configured in `.zibby.config.mjs`).
-
-## Default Flow
-
-```
-preflight → execute_live → generate_script
-```
-
-The workflow generates a test title, executes the test live in a **browser** with AI assistance, and generates a Playwright script with stable selectors.
-
-## Customization
-
-### Add Custom Nodes
-
-Create a new file in `nodes/`:
-
-```javascript
-// nodes/send-slack.js
-export const sendSlackNode = {
-  name: 'send_slack',
-  agent: { type: 'openai', model: 'gpt-4o-mini' },
-  prompt: (state) => `Send Slack notification...`,
-  outputSchema: { success: { type: 'boolean', required: true } }
-};
-```
-
-Then add it to your graph in `graph.js`:
-
-```javascript
-import { sendSlackNode } from './nodes/send-slack.js';
-
-buildGraph() {
-  const graph = new WorkflowGraph();
-  // ... existing nodes
-  graph.addNode('send_slack', sendSlackNode);
-  graph.addEdge('verify_script', 'send_slack');
-  return graph;
-}
-```
-
-### Multi-Agent Configuration
-
-Each node can use a different LLM:
-
-```javascript
-graph.addNode('generate_title', {
-  agent: { type: 'claude', model: 'claude-sonnet-4' },
-  prompt: (state) => `Generate title...`
-});
-
-graph.addNode('verify_script', {
-  agent: { type: 'deepseek', model: 'deepseek-coder' }, // Cheap & fast
-  prompt: (state) => `Run test...`
-});
-
-graph.addNode('update_jira', {
-  agent: { type: 'ollama', model: 'llama3' }, // Local for privacy
-  prompt: (state) => `Update Jira...`
-});
-```
-
-### Skip Nodes
-
-Comment out nodes you don't need:
-
-```javascript
-// graph.addNode('verify_script', verifyScriptNode);
-graph.addEdge('generate_script', 'update_jira'); // Skip verification
-```
-
-### Parallel Execution
-
-Run multiple nodes in parallel:
-
-```javascript
-graph.addParallelEdges('verify_script', [
-  'send_slack',
-  'update_jira',
-  'log_datadog'
-]);
-```
-
-## Configuration
-
-Edit `.zibby.config.mjs` to set your default agent and optional per-node model overrides:
-
-```javascript
-export default {
-  agent: {
-    cursor: { model: 'auto' }, // or claude: { model: 'auto' }
-    strictMode: false,
-  },
-  models: {
-    default: 'auto',
-    execute_live: 'auto',
-    generate_script: 'auto',
-  },
-};
-```
-
-## Studio / Scripts tab (code discovery)
-
-Runs write `generate_script/result.json` with a `scriptPath` (often under your repo `tests/`). After the graph finishes, **`BrowserTestResultHandler.ensureStudioCodegenMirror`** copies that file into the session folder under stable names so tools don’t need Studio running at generation time:
-
-| File (under `.zibby/output/sessions/<sessionId>/generate_script/`) | Role |
-|---------------------------------------------------------------------|------|
-| `generated-test.spec.js` | Playwright (`.js`) |
-| `playwright.spec.ts` | Playwright (`.ts` / `.tsx` source) |
-| `test.selenium.py` | Selenium |
-
-**Electron Studio** resolves these via `discoverCodegenArtifactsElectron` (after `session/codegen/`).
-
-**Web Studio** (`VITE_STUDIO_API_ORIGIN`, e.g. `:3847`) should implement `GET /api/sessions/:id/codegen/playwright` (and `/selenium`) by reading, in order:
-
-1. `sessions/<id>/codegen/` legacy JIT names (`test.spec.ts`, `generated-test.spec.js`, …)
-2. **`sessions/<id>/generate_script/`** canonical names above
-3. `scriptPath` from `generate_script/result.json` (resolve relative to session / `cwd` from session meta)
-
-## Documentation
-
-- [Full Graph Framework Design](../../docs/GRAPH_FRAMEWORK_DESIGN.md)
-- [Multi-Agent Patterns](../../docs/FRAMEWORK_CONVERSATION_SUMMARY.md)
-
-## Updates
-
-To get latest template updates:
-
-```bash
-zibby update-graph --merge
-```
-
-This will merge bug fixes while preserving your customizations.

package/templates/browser-test-automation/chat.mjs

@@ -1,36 +0,0 @@
-/**
- * Zibby Chat Agent
- *
- * Interactive conversational node that acts as the default entry point
- * when users type `zibby` with no subcommand.
- *
- * This is a plain chat bot — no MCP servers, no middleware, no structured output.
- * Just streamed text conversation with the AI agent.
- *
- * The skill-installer skill injects its promptFragment so the LLM knows which
- * skills are available and can install/uninstall them via natural conversation.
- * Users can customize this file after `zibby init` copies it to .zibby/chat.mjs
- */
-
-import { SKILLS } from '@zibby/core';
-
-export const CHAT_CONFIG = {
-  name: 'zibby_chat',
-  skills: [SKILLS.CORE_TOOLS, SKILLS.SKILL_INSTALLER, SKILLS.CHAT_MEMORY, SKILLS.WORKFLOW_BUILDER],
-  timeout: 0,
-
-  systemPrompt: `You are Zibby, a helpful AI assistant. Capabilities come from installed skills.
-
-## How you work
-1. When you need data, call tools. You can chain up to 5 calls per turn.
-2. After each tool result, decide: "Would I be embarrassed to give this answer to a coworker?" If yes, call another tool.
-3. Only respond once you have something genuinely useful.
-4. Never claim you did something without actually calling the tool.
-5. After EVERY response, self-evaluate: is the user's goal fully achieved? Is anything still pending or running? If yes, DO NOT ASK — autonomously poll: call wait (you decide how long), then check status, then respond with an update. Repeat until done or the user interrupts.
-
-## How you talk
-- Talk like a teammate in Slack, not a report generator.
-- Summarize and paraphrase. Never copy-paste field values or list raw steps verbatim.
-- Short paragraphs, not numbered lists (unless the user specifically asks for steps).
-- Match the user's tone and energy. Be concise.`,
-};

package/templates/browser-test-automation/graph.mjs

@@ -1,80 +0,0 @@
-/**
- * Test Automation Workflow Graph
- * 
- * buildGraph() - define nodes, edges, routing
- * onComplete(result) - post-processing after graph finishes (save artifacts, etc.)
- */
-
-import { WorkflowAgent, WorkflowGraph } from '@zibby/core';
-import {
-  preflightNode,
-  cacheReplayNode,
-  executeLiveNode,
-  generateScriptNode,
-} from './nodes/index.mjs';
-import { BrowserTestResultHandler } from './result-handler.mjs';
-import { browserTestAutomationStateSchema } from './state.js';
-
-export class BrowserTestAutomationAgent extends WorkflowAgent {
-  buildGraph() {
-    const graph = new WorkflowGraph();
-    graph.setStateSchema(browserTestAutomationStateSchema);
-
-    graph.addNode('preflight', preflightNode);
-    graph.addNode('cache_replay', cacheReplayNode);
-    graph.addNode('execute_live', executeLiveNode);
-    graph.addNode('generate_script', generateScriptNode);
-
-    graph.setEntryPoint('preflight');
-
-    // Short-circuit when preflight produced nothing usable. Triggered when:
-    //   - the user invoked `zibby workflow run browser-tests` with no spec
-    //     (state.input is undefined / empty), so preflight had nothing to
-    //     analyze and the LLM came back with `assertions: []`
-    //   - the spec is so vague the LLM can't extract any assertions
-    // Without this gate the graph would barrel into execute_live, fire up
-    // a real browser session + a second expensive LLM call, then waste
-    // ~30s before failing — bad UX and bad bill.
-    graph.addConditionalEdges('preflight', (state) => {
-      const assertions = state.preflight?.assertions || [];
-      return assertions.length > 0 ? 'cache_replay' : 'END';
-    });
-
-    // Lever-#2 fork: cache_replay attempted a Playwright-only replay of
-    // a prior successful action sequence. On hit it side-wrote
-    // state.execute_live with synthesized output, so we can skip
-    // execute_live and jump straight to generate_script — zero LLM
-    // tokens. On miss / replay failure / cold cache, fall through to
-    // the normal LLM-driven execute_live path.
-    graph.addConditionalEdges('cache_replay', (state) => {
-      return state.cache_replay?.hit === true ? 'generate_script' : 'execute_live';
-    });
-
-    graph.addConditionalEdges('execute_live', (state) => {
-      const result = state.execute_live;
-      const hasExecution = (result?.steps?.length > 0) || (result?.actions?.length > 0);
-      return hasExecution ? 'generate_script' : 'END';
-    });
-
-    graph.addEdge('generate_script', 'END');
-    return graph;
-  }
-
-  async onComplete(result) {
-    const cwd = result.state.cwd || process.cwd();
-    BrowserTestResultHandler.saveTitle(result, cwd);
-    await BrowserTestResultHandler.saveExecutionData(result);
-    BrowserTestResultHandler.ensureStudioCodegenMirror(
-      result.state?.sessionPath,
-      result.state?.cwd || cwd,
-    );
-
-    // Memory end-run hook (if @zibby/ui-memory is installed)
-    try {
-      const { memoryEndRun, memorySyncPush } = await import('@zibby/ui-memory');
-      const sessionId = result.state.sessionPath?.split('/').pop();
-      memoryEndRun(cwd, { sessionId, passed: result.success !== false });
-      memorySyncPush(cwd);
-    } catch { /* @zibby/ui-memory not available */ }
-  }
-}

package/templates/browser-test-automation/nodes/cache-replay.mjs

@@ -1,213 +0,0 @@
-/**
- * cache_replay node — lever-#2 read path inside the workflow.
- *
- * Sits between `preflight` and `execute_live` in the graph. Tries to
- * replay a prior successful run's action sequence via Playwright
- * directly, completely skipping the LLM. On a clean cache hit it
- * populates `state.execute_live` with the result so downstream
- * `generate_script` works exactly as if execute_live had run.
- *
- * Conditional edge after this node:
- *   - state.cache_replay.hit === true → skip execute_live → generate_script
- *   - state.cache_replay.hit === false → execute_live (LLM-driven path)
- *
- * Not user-configurable per-spec — the cache key derivation handles
- * staleness (page fingerprint drift invalidates) and replay failures
- * fall through cleanly to the LLM path.
- */
-
-import { z } from '@zibby/core';
-import { chromium } from 'playwright';
-import { spawn } from 'child_process';
-import { extractDomain, replayActions } from '@zibby/ui-memory';
-import { join } from 'path';
-
-const REPLAY_TIMEOUT_MS = 60_000;
-
-export const cacheReplayNode = {
-  name: 'cache_replay',
-  skills: [],
-  timeout: 90000,
-  outputSchema: z.object({
-    hit: z.boolean(),
-    elapsed_ms: z.number().nullish(),
-    executed: z.number().nullish(),
-    total: z.number().nullish(),
-    cache_key: z.string().nullish(),
-    error: z.string().nullish(),
-    // When hit, we also write a synthesized execute_live block so the
-    // downstream generate_script node sees what it expects.
-    execute_live_synthesized: z.boolean().nullish(),
-  }),
-
-  execute: async (context) => {
-    // graph.js builds nodeContext as `{ state, invokeAgent, _coreInvokeAgent,
-    // ...state.getAll() }`. So `context.testSpec` works (spread) AND
-    // `context.state.get('testSpec')` works (instance). Reading from the
-    // spread is the natural shape — `context.state` is reserved for the
-    // .set(key, value) side-write below.
-    const cwd = context.cwd || context.workspace || process.cwd();
-    const testSpec = context.testSpec || '';
-    const specPath = context.specPath || '';
-
-    // Derive domain from the spec text (no DOM access yet — pure parse).
-    const domain = extractDomainFromSpec(testSpec);
-    if (!domain) {
-      return { hit: false, error: 'cannot derive domain from spec' };
-    }
-
-    // Cache key requires page_fingerprint, which is page-state-dependent
-    // and only available AFTER navigation. We compute a key WITHOUT
-    // fingerprint first and look up by (domain, spec_path) prefix —
-    // the persister wrote spec_path too. If we find a candidate, we
-    // use its stored fingerprint to compute the full key and verify.
-    //
-    // Lookup order:
-    //   1. Exact (domain, spec_path) match in action_cache.
-    //   2. If found, use its actions for replay attempt.
-    //   3. On replay success: signal hit, populate state.execute_live.
-    //   4. On replay failure (or cache miss): hit=false, fall back to LLM.
-    const cached = await lookupCacheByDomainAndSpec({ cwd, domain, specPath });
-    if (!cached) {
-      return { hit: false, error: 'no cached actions for this spec' };
-    }
-
-    // Run the replay in a freshly-launched Playwright browser. Cleanly
-    // independent from the @zibby/mcp-browser path execute_live uses.
-    const t0 = Date.now();
-    const browser = await chromium.launch({ headless: true });
-    const page = await browser.newPage();
-    let replayResult;
-    try {
-      replayResult = await Promise.race([
-        replayActions({
-          actions: cached.actions,
-          page,
-          log: (m) => console.log(`[cache_replay] ${m}`),
-        }),
-        new Promise((_, reject) =>
-          setTimeout(() => reject(new Error('replay timeout')), REPLAY_TIMEOUT_MS),
-        ),
-      ]);
-    } catch (err) {
-      replayResult = { success: false, error: err.message, executed: 0, total: cached.actions.length };
-    }
-    const finalUrl = page.url();
-    await browser.close().catch(() => {});
-    const elapsedMs = Date.now() - t0;
-
-    if (!replayResult.success) {
-      // Increment failure_count so we can drop chronic misses later.
-      await incrementCacheFailure({ cwd, cacheKey: cached.cache_key });
-      return {
-        hit: false,
-        elapsed_ms: elapsedMs,
-        executed: replayResult.executed,
-        total: replayResult.total,
-        cache_key: cached.cache_key,
-        error: replayResult.error,
-      };
-    }
-
-    // HIT path. Side-write the synthesized execute_live output via
-    // context.state.set so downstream generate_script reads the same
-    // shape it expects (actions[], finalUrl, …). The customExecute
-    // return-value lands in state.cache_replay; the execute_live slot
-    // has to be populated separately.
-    if (typeof context.state?.set === 'function') {
-      context.state.set('execute_live', {
-        success: true,
-        steps: cached.actions.map((a) => a.description),
-        actions: cached.actions,
-        assertions: [],
-        finalUrl,
-        browserClosed: true,
-        notes: 'cache_replay hit — actions replayed via Playwright, no LLM',
-      });
-    }
-
-    return {
-      hit: true,
-      elapsed_ms: elapsedMs,
-      executed: replayResult.executed,
-      total: replayResult.total,
-      cache_key: cached.cache_key,
-      execute_live_synthesized: true,
-    };
-  },
-};
-
-// ─── helpers ────────────────────────────────────────────────────────────
-
-function extractDomainFromSpec(spec) {
-  if (!spec) return null;
-  // Find the first http(s) URL in the spec and run it through the
-  // SAME `extractDomain` the persister uses, so the cache-key lookup
-  // matches what was actually written (notably: `www.` is stripped).
-  const m = String(spec).match(/https?:\/\/[^\s"'<>]+/);
-  if (!m) return null;
-  return extractDomain(m[0]);
-}
-
-/**
- * Find a cached row by (domain, spec_path). Picks the row with
- * highest success_count if multiple match.
- * Uses dolt via subprocess (matching the rest of the codebase's
- * Dolt-access pattern).
- */
-async function lookupCacheByDomainAndSpec({ cwd, domain, specPath }) {
-  const dbDir = join(cwd, '.zibby', 'memory');
-  const safeDomain = escapeSql(domain);
-  const safeSpec = escapeSql(specPath);
-  const sql = `SELECT cache_key, actions_json, page_fingerprint
-    FROM action_cache
-    WHERE domain = ${safeDomain} AND spec_path = ${safeSpec}
-    ORDER BY success_count DESC, last_used_at DESC
-    LIMIT 1`;
-  const rows = await runDoltJson(dbDir, sql);
-  if (!rows || rows.length === 0) return null;
-  try {
-    const actions = JSON.parse(rows[0].actions_json);
-    return { cache_key: rows[0].cache_key, actions, fingerprint: rows[0].page_fingerprint };
-  } catch {
-    return null;
-  }
-}
-
-async function incrementCacheFailure({ cwd, cacheKey }) {
-  const dbDir = join(cwd, '.zibby', 'memory');
-  const sql = `UPDATE action_cache
-    SET failure_count = failure_count + 1, last_replay_status = 'replay-failed'
-    WHERE cache_key = ${escapeSql(cacheKey)}`;
-  await runDoltExec(dbDir, sql).catch(() => { /* non-fatal */ });
-}
-
-function escapeSql(v) {
-  if (v == null) return 'NULL';
-  return `'${String(v).replace(/'/g, "''")}'`;
-}
-
-function runDoltJson(dir, sql) {
-  return new Promise((resolve) => {
-    const child = spawn('dolt', ['sql', '-r', 'json', '-q', sql], { cwd: dir });
-    let out = '';
-    child.stdout.on('data', (d) => { out += d; });
-    child.on('close', () => {
-      try {
-        const parsed = JSON.parse(out);
-        resolve(parsed.rows || []);
-      } catch {
-        resolve([]);
-      }
-    });
-    child.on('error', () => resolve([]));
-  });
-}
-
-function runDoltExec(dir, sql) {
-  return new Promise((resolve, reject) => {
-    const child = spawn('dolt', ['sql', '-q', sql], { cwd: dir });
-    child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`dolt exit ${code}`))));
-    child.on('error', reject);
-  });
-}