@zibby/workflow-templates 0.1.0

package/index.js

@@ -0,0 +1,240 @@
+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'
+    ],
+    // ── Marketplace metadata ──────────────────────────────────────────
+    // Consumed by `backend/scripts/marketplace-sync-from-templates.mjs`.
+    // Templates without a `marketplace` field are excluded from sync —
+    // they're still scaffoldable via `zibby workflow new` but won't
+    // appear in the public catalog.
+    marketplace: {
+      slug: 'browser-test-automation',
+      tagline: 'Drive end-to-end browser tests authored as agent workflows.',
+      // Bespoke per-icon prompt. Each official template ships its own
+      // visual identity — different style, palette, motif, vibe —
+      // mirroring how the OpenAI GPT marketplace looks (Scholar GPT vs
+      // Canva vs Mia AI are all stylistically distinct). The icon
+      // generator uses `iconPrompt` verbatim when set.
+      iconPrompt: [
+        'A bold, energetic app icon for "Browser Test Automation" — a workflow that runs end-to-end browser tests like a sprinter.',
+        '',
+        'Visual style: cartoon mascot with personality, in the style of Duolingo\'s owl or Reddit\'s Snoo or Discord\'s Wumpus.',
+        'Subject: a friendly anthropomorphic cursor-arrow CHARACTER (white arrow shape with a tiny smiling face on its tail), captured mid-stride running to the right, with a small green checkmark trailing behind it like a comic-book speed line.',
+        'Background: a vibrant sunset gradient from coral-pink to amber-orange (#FF6B6B → #FFA94D), filling a softly-rounded square (1024×1024).',
+        'Composition: character centered, slight forward lean, dynamic motion lines. Mood: cheerful, playful, fast.',
+        'NO text, NO browser UI screenshots, NO outline wireframes.',
+      ].join('\n'),
+      category: 'Testing',
+      tags: ['testing', 'playwright', 'e2e', 'browser'],
+      capabilities: [
+        'Preflight LLM extracts assertions from a plain-English spec',
+        'Live Playwright execution with screenshots + DOM at every step',
+        'Cache-replay short-circuits expensive LLM runs on repeat flows',
+        'Emits a deterministic Playwright script with stable selectors',
+      ],
+      conversationStarters: [
+        'Run the checkout smoke test against staging',
+        'Test that signup → first-project works on prod',
+        'Generate a Playwright script from this spec',
+        'Replay yesterday\'s login test against the new build',
+      ],
+      // icon: optional — './icon.png' relative to template path,
+      // OR an external 'https://' URL. Omitted = fallback initials in UI.
+    },
+  },
+  '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'
+    ],
+    marketplace: {
+      slug: 'code-analysis',
+      tagline: 'Take a Jira ticket end-to-end: analyze, code, and emit test cases.',
+      iconPrompt: [
+        'A premium, hi-fi app icon for "Code Analysis" — a workflow that takes a Jira ticket end-to-end into shipping code.',
+        '',
+        'Visual style: 3D-rendered hero object floating in space, in the style of Apple Vision Pro icons, Linear\'s changelog hero illustrations, or a Stripe product render. Glossy, dimensional, with subtle reflections and a soft rim-light.',
+        'Subject: a 3D-rendered angle-bracket pair `</>` made of glossy chrome / brushed silver metal, slightly rotated in three-quarter perspective, with one bracket tilted forward and the other back so they read as a balanced "code" symbol with depth.',
+        'Background: a deep midnight-navy gradient (#0F172A at the top, #1E1B4B at the bottom), with a single soft violet glow behind the brackets and a few faint star-like specks scattered across the canvas. Square format, 1024×1024.',
+        'Composition: brackets centered, subtle drop shadow on the canvas. Mood: high-end, technical, confident — like the cover of a developer tool launch.',
+        'NO text, NO outline wireframes, NO flat sticker style — this one is DEEP and 3D-rendered.',
+      ].join('\n'),
+      category: 'Engineering',
+      tags: ['code-analysis', 'jira', 'github', 'test-generation'],
+      capabilities: [
+        'Clone repos + snapshot git baseline so changes are diff-able',
+        'LLM gate: skip code-gen when ticket can\'t be implemented as-is',
+        'Generates scoped patches plus test cases for the same change',
+        'Prompts live in prompts/*.md — overrideable per team',
+      ],
+      conversationStarters: [
+        'Analyze PROJ-1234 against the backend repo',
+        'Generate code + tests for the ticket I just linked',
+        'Decide if SRE-882 is implementable before I assign it',
+        'Show me what tests would cover the changes for this ticket',
+      ],
+    },
+  },
+  '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'
+    ],
+    marketplace: {
+      slug: 'generate-test-cases',
+      tagline: 'Hand it a PR diff; get back prioritized, AI-runnable test specs.',
+      iconPrompt: [
+        'A hand-illustrated, slightly whimsical app icon for "Generate Test Cases" — a workflow that turns a code diff into prioritized test specs.',
+        '',
+        'Visual style: hand-painted, slightly textured illustration with visible brush strokes, in the spirit of a Notion template cover, Mailchimp\'s mascot illustrations, or Studio Ghibli\'s soft warmth. Avoid sterile vector look.',
+        'Subject: a cozy laboratory scene — a smiling, friendly cartoon beaker character (with simple dot eyes and a tiny smile) sitting on a small stack of paper test-spec cards. Around the beaker, a tiny floating clipboard with three checkmarks gently drifts. The whole composition feels like a single mascot illustration.',
+        'Background: warm cream paper texture (#F5E8D3) with a few faint pencil-sketch dots, contained inside a softly-rounded square (1024×1024). NOT a flat saturated disc — this one is a painted illustration.',
+        'Mood: friendly, approachable, slightly handmade. Like a children\'s book illustration applied to a developer tool.',
+        'NO text, NO photo-realism, NO sleek 3D render — this one is hand-drawn and warm.',
+      ].join('\n'),
+      category: 'Testing',
+      tags: ['testing', 'test-generation', 'pull-request', 'review'],
+      capabilities: [
+        'Skips ticket analysis — feed it the diff directly',
+        'LLM explores the codebase to ground test steps in real components',
+        'Emits 4-8 specs labelled Critical / High / Medium / Low',
+        'Specs are plain English — runnable by any browser-driving agent',
+      ],
+      conversationStarters: [
+        'Generate test cases for this PR diff',
+        'What are the must-cover scenarios for the patch I just pasted?',
+        'Prioritise tests for the auth-refactor branch',
+        'Produce specs that an AI agent can execute end-to-end',
+      ],
+    },
+  }
+};
+
+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/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@zibby/workflow-templates",
+  "version": "0.1.0",
+  "description": "Built-in workflow templates for Zibby — browser-test-automation, code-analysis, generate-test-cases. Carved out of @zibby/core@0.4.6 so the engine ships without scaffolding payload.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./register-nodes.js": "./register-nodes.js",
+    "./global-setup.js": "./global-setup.js",
+    "./run-index-post-cli.js": "./run-index-post-cli.js",
+    "./browser-test-automation": "./browser-test-automation/graph.mjs",
+    "./browser-test-automation/*": "./browser-test-automation/*",
+    "./code-analysis": "./code-analysis/graph.js",
+    "./code-analysis/*": "./code-analysis/*",
+    "./generate-test-cases": "./generate-test-cases/graph.mjs",
+    "./generate-test-cases/*": "./generate-test-cases/*",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix ."
+  },
+  "keywords": [
+    "zibby",
+    "workflow",
+    "templates",
+    "agent",
+    "automation"
+  ],
+  "author": "Zibby",
+  "license": "MIT",
+  "homepage": "https://zibby.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ZibbyHQ/workflow-templates"
+  },
+  "bugs": {
+    "url": "https://github.com/ZibbyHQ/workflow-templates/issues"
+  },
+  "files": [
+    "browser-test-automation/",
+    "code-analysis/",
+    "generate-test-cases/",
+    "index.js",
+    "register-nodes.js",
+    "global-setup.js",
+    "run-index-post-cli.js",
+    "!**/__tests__/",
+    "!**/*.test.js",
+    "!**/*.spec.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.88.0",
+    "@zibby/agent-workflow": "^0.3.0",
+    "axios": "^1.15.0",
+    "handlebars": "^4.7.9",
+    "zod": "^3.23.0 || ^4.0.0"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.49.0",
+    "@zibby/core": ">=0.5.0",
+    "playwright": ">=1.49.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.0.2",
+    "globals": "^17.4.0"
+  }
+}

package/register-nodes.js

@@ -0,0 +1,24 @@
+/**
+ * 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/workflow-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/run-index-post-cli.js

@@ -0,0 +1,32 @@
+/**
+ * Post-CLI run-index hooks for the default `browser-test-automation` template.
+ *
+ * Historically this lived in `@zibby/core/src/utils/run-index-post-cli.js`
+ * as a "keep templates out of the engine" bridge. After the
+ * @zibby/core@0.5.0 carve-out, templates own this hook directly — the CLI
+ * imports from `@zibby/workflow-templates/run-index-post-cli.js`.
+ *
+ * - `postCliRunIndex` / `postCliInterruptedRunIndex` — JSONL +
+ *   `zibby-run-state.json` (template implements the shapes)
+ * - `createCliRunIndexPipelineProgressAppender` — optional `runTest`
+ *   pipeline hook
+ */
+import {
+  tryAppendBrowserTestRunIndex,
+  createBrowserTestPipelineProgressAppender,
+  tryAppendBrowserTestInterruptedRunIndex,
+} from './browser-test-automation/run-index.mjs';
+
+export function postCliRunIndex(payload) {
+  tryAppendBrowserTestRunIndex(payload);
+}
+
+/** SIGINT/SIGTERM — flush terminal index rows + session-state (template implements both). */
+export function postCliInterruptedRunIndex(payload) {
+  tryAppendBrowserTestInterruptedRunIndex(payload);
+}
+
+/** For `runTest` → `graph.run` optional `onPipelineProgress` (default browser-test template). */
+export function createCliRunIndexPipelineProgressAppender(opts) {
+  return createBrowserTestPipelineProgressAppender(opts);
+}