@zibby/workflow-templates 0.2.1 → 0.3.0

package/code-analysis/graph.js

@@ -21,17 +21,18 @@ function loadPrompt(filename) {
 }
 
 // Load prompt templates at graph definition time
+const setupPrompt = loadPrompt('setup.md');
 const analyzeTicketPrompt = loadPrompt('analyze-ticket.md');
 const generateCodePrompt = loadPrompt('generate-code.md');
 const generateTestCasesPrompt = loadPrompt('generate-test-cases.md');
 
 export function buildAnalysisGraph(graph) {
   graph.setStateSchema(analysisStateSchema);
-  
+
   graph
-    .addNode('setup', setupNode)
-    .addNode('analyze_ticket', analyzeTicketNode, { 
-      prompt: analyzeTicketPrompt 
+    .addNode('setup', setupNode, { prompt: setupPrompt })
+    .addNode('analyze_ticket', analyzeTicketNode, {
+      prompt: analyzeTicketPrompt,
     })
     .addConditionalNode('validation_check', {
       condition: (state) => {

package/code-analysis/nodes/analyze-ticket-node.js

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { randomBytes } from 'crypto';
-import { z } from 'zod';
+import { z, SKILLS } from '@zibby/core';
 import { adfToText } from '@zibby/core/utils/adf-converter.js';
+import { getRepoPath } from './utils/get-repo-path.js';
 
 const generateId = () => randomBytes(16).toString('hex');
 
@@ -85,6 +86,12 @@ const AnalyzeTicketNodeOutputSchema = z.object({
 
 export const analyzeTicketNode = {
   name: 'analyze_ticket',
+  // skills:['jira'] makes the LLM aware of jira_search / jira_get_issue
+  // tools (handy when the ticketContext only carries a key and the agent
+  // needs to pull the full issue). Also drives the marketplace card's
+  // "Required Integrations: Jira" badge so users connect Jira before
+  // installing this workflow.
+  skills: [SKILLS.JIRA],
   outputSchema: AnalyzeTicketNodeOutputSchema,
   
   execute: async (context) => {
@@ -116,7 +123,7 @@ export const analyzeTicketNode = {
       additionalContext: ticketContext.additionalContext || null,
       repositories: Array.isArray(repos) ? repos.map(r => ({
         name: r.name,
-        ...detectProjectInfo(join(workspace, r.name))
+        ...detectProjectInfo(getRepoPath(state, r.name))
       })) : []
     };
     

package/code-analysis/nodes/generate-code-node.js

@@ -11,6 +11,7 @@ import Handlebars from 'handlebars';
 import { invokeAgent } from '@zibby/core';
 import { generatePRMeta } from './services/prMetaService.js';
 import { adfToText } from '@zibby/core/utils/adf-converter.js';
+import { getRepoPath } from './utils/get-repo-path.js';
 import { z } from 'zod';
 
 const CodeImplementationOutputSchema = z.object({
@@ -64,14 +65,16 @@ export function createCodeGenerationNode(options = {}) {
       const _nodeConfig = nodeConfigs[nodeName] || {};
       const analysis = state.analyze_ticket?.analysis;
       
-      // Build implementation prompt from template
+      // Build implementation prompt from template. Pass `state` so the
+      // prompt builder can resolve cloned repo paths from state.setup
+      // (populated by the LLM-driven setup node).
       const implementPrompt = buildImplementationPrompt(
         promptsDir,
         ticketContext,
         analysis,
         commitAndPush,
         repos,
-        workspace
+        state
       );
       
       console.log(`🚀 Running AI Agent to ${mode} changes with model: ${aiModel}...`);
@@ -96,7 +99,7 @@ export function createCodeGenerationNode(options = {}) {
         commitMessage = `${ticketContext.ticketKey}: ${ticketContext.summary}\n\n${commitDesc}\n\nImplemented by Zibby Agent`;
 
         for (const repo of reposToCommit) {
-          const repoPath = join(workspace, repo.name);
+          const repoPath = getRepoPath(state, repo.name);
           
           // Check if this repo has any changes
           const status = await execCommand('git', ['status', '--porcelain'], repoPath);
@@ -153,9 +156,9 @@ export function createCodeGenerationNode(options = {}) {
         : [{ name: '.' }];
       
       for (const repo of reposToCheck) {
-        const currentRepoPath = repo.name === '.' 
-          ? workspace 
-          : join(workspace, repo.name);
+        const currentRepoPath = repo.name === '.'
+          ? workspace
+          : getRepoPath(state, repo.name);
         
         try {
           let repoDiff, repoDiffStat, repoChangedFiles;
@@ -314,7 +317,8 @@ export const implementCodeNode = createCodeGenerationNode({
   nodeName: 'implement_code'
 });
 
-function buildImplementationPrompt(promptsDir, ticketContext, analysis, isCommitting, repos, workspace) {
+function buildImplementationPrompt(promptsDir, ticketContext, analysis, isCommitting, repos, state) {
+  const workspace = state?.workspace;
   const templatePath = join(promptsDir, 'generate-code.md');
   if (!existsSync(templatePath)) {
     throw new Error(`Template not found: ${templatePath}`);
@@ -342,9 +346,11 @@ function buildImplementationPrompt(promptsDir, ticketContext, analysis, isCommit
     }
   }
 
-  // Build repo metadata for the template
+  // Build repo metadata for the template. Use getRepoPath() so we
+  // detect language from wherever the setup node actually checked the
+  // repo out (state.setup.clonedRepos[].path).
   const repositories = (repos && repos.length > 0) ? repos.map(r => {
-    const info = detectRepoLanguage(workspace ? join(workspace, r.name) : null);
+    const info = detectRepoLanguage(getRepoPath(state, r.name));
     return { name: r.name, ...info };
   }) : null;
 

package/code-analysis/nodes/setup-node.js

@@ -1,142 +1,62 @@
 /**
- * Setup Node - Clone repositories and initialize git baseline
- * Used by: analysisGraph, implementationGraph
+ * Setup Node — LLM-driven workspace bootstrap.
+ *
+ * The agent receives the `git` skill (which exposes git_checkout +
+ * git_list_repos + git_explore as tools) plus a Bash tool, and is
+ * prompted to:
+ *   1. Clone each repo in state.repos. git_checkout auto-authenticates
+ *      with GITHUB_TOKEN / GITLAB_TOKEN injected by the runner — works
+ *      for both providers without the prompt needing to know which.
+ *   2. Initialize a baseline git repo at state.workspace so downstream
+ *      diff tooling can compute generated changes.
+ *   3. Return the structured outputSchema below — downstream nodes read
+ *      state.setup.clonedRepos[].path to find each repo locally.
+ *
+ * Why LLM-driven instead of raw `git clone` (the previous design):
+ *   - User-customizable via prompts/setup.md (no JS edits needed)
+ *   - Same node handles GitHub + GitLab transparently — the agent picks
+ *     the right tool based on what's connected
+ *   - Composable with state.repos changes: add a new repo to the project
+ *     config and the agent clones it next run, no node code touched
  */
 
-import { spawn } from 'child_process';
-import { join } from 'path';
-import { z } from 'zod';
+import { readFileSync, existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { z, SKILLS } from '@zibby/core';
+
+// Prompt is loaded at module-import time from prompts/setup.md so users
+// can edit it without touching this file. We attach it inline on the
+// node config (rather than via graph.addNode(..., { prompt })) because
+// the inline form is what other LLM nodes in this codebase use (see
+// browser-test-automation/nodes/execute-live.mjs); same place agents
+// look the prompt up at run time, no nodePrompts map indirection.
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const promptPath = join(__dirname, '..', 'prompts', 'setup.md');
+const setupPrompt = existsSync(promptPath)
+  ? readFileSync(promptPath, 'utf-8')
+  : '';
 
 const SetupOutputSchema = z.object({
-  success: z.boolean(),
+  success: z.boolean().describe('true if all repos cloned + baseline initialized'),
   clonedRepos: z.array(z.object({
-    name: z.string(),
-    path: z.string(),
-    isPrimary: z.boolean().optional()
-  })),
-  baselineCommit: z.string()
+    name: z.string().describe('Repo name (matches state.repos[].name)'),
+    path: z.string().describe('Absolute local path where the repo was cloned'),
+    isPrimary: z.boolean().optional().describe('True for the project\'s primary repo'),
+  })).describe('Every repo from state.repos must appear here once'),
+  baselineCommit: z.string().describe('git rev-parse HEAD at state.workspace after baseline commit'),
 });
 
 export const setupNode = {
   name: 'setup',
+  // SKILLS.GIT gives the LLM git_checkout / git_list_repos / git_explore.
+  // The skill auto-auths against whichever provider is connected
+  // (GitHub OR GitLab) — having either one satisfies the requirement.
+  // Marketplace gating: the backend maps `git → github` for display
+  // (most-common-case heuristic); GitLab users hit the same workflow
+  // and gitSkill picks up GITLAB_TOKEN at runtime.
+  skills: [SKILLS.GIT],
   outputSchema: SetupOutputSchema,
-  execute: async (state) => {
-    console.log('\n🔧 Setting up environment...');
-    
-    const { workspace, repos, githubToken } = state;
-    const gitlabToken = process.env.GITLAB_TOKEN || '';
-    const gitlabUrl = process.env.GITLAB_URL || '';
-    
-    // DEBUG: Log token status
-    console.log(`🔑 GitHub Token: ${githubToken ? 'Present' : 'MISSING'}`);
-    console.log(`🔑 GitLab Token: ${gitlabToken ? 'Present' : 'MISSING'}`);
-    if (gitlabUrl) console.log(`🔑 GitLab URL: ${gitlabUrl}`);
-    
-    // Log environment
-    console.log('Container: ECS Fargate');
-    console.log('Memory: 4GB');
-    console.log('CPU: 2 vCPU');
-    console.log('Tools: Node.js, Git, Cursor CLI, Zibby CLI');
-    console.log(`Working directory: ${workspace}`);
-    
-    // Clone repositories
-    console.log('\n📦 Cloning repositories...');
-    
-    const clonedRepos = [];
-    for (const repo of repos) {
-      console.log(`Cloning ${repo.name}...`);
-      
-      const repoDir = join(workspace, repo.name);
-      
-      // Use token for authentication based on provider
-      let cloneUrl = repo.url;
-      let cloneEnv = {};
-      const isGitlab = repo.provider === 'gitlab' || (gitlabUrl && repo.url.includes(new URL(gitlabUrl).host));
-      const isGithub = repo.provider === 'github' || repo.url.includes('github.com');
-      
-      if (isGithub && githubToken) {
-        cloneUrl = repo.url.replace('https://github.com', `https://x-access-token:${githubToken}@github.com`);
-        cloneEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: 'echo' };
-      } else if (isGitlab && gitlabToken && gitlabUrl) {
-        try {
-          const gitlabHost = new URL(gitlabUrl).host;
-          cloneUrl = repo.url.replace(`https://${gitlabHost}`, `https://oauth2:${gitlabToken}@${gitlabHost}`);
-        } catch (e) {
-          console.warn(`⚠️ Failed to parse GITLAB_URL: ${e.message}`);
-        }
-        cloneEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: 'echo' };
-      }
-      
-      // Shallow clone with progress output (async, non-blocking)
-      await execCommand(
-        `git clone --progress --depth 1 --branch ${repo.branch} "${cloneUrl}" "${repoDir}"`,
-        workspace,
-        cloneEnv
-      );
-      console.log(`✓ Cloned ${repo.name} on branch ${repo.branch}`);
-      
-      clonedRepos.push({
-        name: repo.name,
-        path: repoDir,
-        isPrimary: repo.isPrimary
-      });
-    }
-    
-    // Initialize git in workspace for diff tracking
-    await execCommand('git init', workspace);
-    await execCommand('git config user.email "zibby@agent.com"', workspace);
-    await execCommand('git config user.name "Zibby Agent"', workspace);
-    await execCommand('git add .', workspace);
-    await execCommand('git commit --allow-empty -m "baseline"', workspace);
-    
-    console.log('✅ Environment ready');
-    
-    const baselineCommit = await execCommand('git rev-parse HEAD', workspace);
-    
-    return {
-      success: true,
-      clonedRepos,
-      baselineCommit: baselineCommit.trim()
-    };
-  }
+  timeout: 5 * 60 * 1000, // 5min for cold clone of multiple repos + baseline
+  prompt: setupPrompt,
 };
-
-// Async version using spawn - streams output in real-time, doesn't block event loop
-async function execCommand(command, cwd, env = {}) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, {
-      cwd,
-      shell: true,
-      env: Object.keys(env).length > 0 ? env : process.env
-    });
-    
-    let stdout = '';
-    let stderr = '';
-    
-    // Stream stdout as it comes (triggers middleware setInterval!)
-    proc.stdout.on('data', (data) => {
-      const output = data.toString();
-      stdout += output;
-      console.log(output.trimEnd());
-    });
-    
-    // Stream stderr as it comes
-    proc.stderr.on('data', (data) => {
-      const output = data.toString();
-      stderr += output;
-      console.log(output.trimEnd());
-    });
-    
-    proc.on('close', (code) => {
-      if (code !== 0) {
-        reject(new Error(`Command failed with exit code ${code}: ${command}`));
-      } else {
-        resolve(stdout || stderr || '');
-      }
-    });
-    
-    proc.on('error', (err) => {
-      reject(new Error(`Command error: ${command} - ${err.message}`));
-    });
-  });
-}

package/code-analysis/nodes/utils/get-repo-path.js

@@ -0,0 +1,32 @@
+import { join } from 'path';
+
+/**
+ * Resolve the on-disk path for a repo.
+ *
+ * Source of truth: state.setup.clonedRepos[].path — populated by the
+ * LLM-driven setup node that calls git_checkout (via the `git` skill).
+ *
+ * Fallback: <workspace>/<name>. Kept so a workflow that never ran
+ * setup (e.g. zibby workflow run for unit testing a single node) still
+ * has a sensible path. Returns null if neither state.setup nor a
+ * workspace is available.
+ *
+ * Accepts either a raw state object OR a WorkflowState instance with
+ * .getAll(). Downstream nodes use both shapes across the template.
+ *
+ * @param {object | { getAll(): object }} stateOrAllState
+ * @param {string} repoName
+ * @returns {string | null}
+ */
+export function getRepoPath(stateOrAllState, repoName) {
+  if (!stateOrAllState || !repoName) return null;
+  const s = typeof stateOrAllState.getAll === 'function'
+    ? stateOrAllState.getAll()
+    : stateOrAllState;
+  const cloned = Array.isArray(s.setup?.clonedRepos)
+    ? s.setup.clonedRepos.find((r) => r?.name === repoName)
+    : null;
+  if (cloned?.path) return cloned.path;
+  if (s.workspace) return join(s.workspace, repoName);
+  return null;
+}

package/code-analysis/prompts/setup.md

@@ -0,0 +1,71 @@
+# Setup — clone repos + initialize baseline
+
+You are setting up the workspace for code analysis. Two tasks:
+
+## 1. Clone each repo in `state.repos`
+
+```
+state.repos = {{state.repos}}
+state.workspace = {{state.workspace}}
+```
+
+For each entry, call `git_checkout`:
+- `url`: the repo's `url` field
+- `branch`: the repo's `branch` field (omit if not set — defaults to repo's default branch)
+- `shallow`: true (the default — faster, depth=1)
+
+`git_checkout` auto-authenticates against GitHub or GitLab using the
+project's connected integration — you don't need to know which provider
+the repo is hosted on. If the clone fails for one repo, continue with
+the others and surface the failure in the final output.
+
+After every repo is cloned, the `path` field that `git_checkout` returns
+is what downstream nodes will read off state. Keep that path verbatim.
+
+## 2. Initialize a baseline git repo at `state.workspace`
+
+Downstream nodes (especially `generate_code`) diff your future changes
+against this baseline. Use the Bash tool:
+
+```bash
+cd {{state.workspace}}
+git init
+git config user.email "zibby@agent.com"
+git config user.name "Zibby Agent"
+git add .
+git commit --allow-empty -m "baseline"
+git rev-parse HEAD
+```
+
+The output of `git rev-parse HEAD` is the `baselineCommit` you'll return.
+
+## 3. Return JSON matching the outputSchema
+
+```json
+{
+  "success": true,
+  "clonedRepos": [
+    { "name": "<repo name>", "path": "<absolute path from git_checkout>", "isPrimary": true }
+  ],
+  "baselineCommit": "<HEAD sha from rev-parse>"
+}
+```
+
+If any repo fails to clone, set `success: false` and still include the
+ones that succeeded with their paths.
+
+---
+
+### Customizing this prompt
+
+This file ships as a template default. Edit it freely to change setup
+behavior — e.g.:
+- Skip the baseline commit if you don't need diff tracking
+- Add a `git_explore` call after cloning to give later nodes a structural
+  overview in state
+- Filter `state.repos` (only clone repos matching a pattern)
+- Run post-clone tooling (`npm install`, `bundle install`, etc) via Bash
+
+The agent will follow whatever instructions you put here. The
+outputSchema in `nodes/setup-node.js` is the contract — keep that field
+shape so downstream nodes don't break.

package/code-analysis/state.js

@@ -70,6 +70,22 @@ export const analysisContextSchema = z.object({
 
   nodeConfigs: z.record(z.string(), z.any()).optional()
     .describe('Per-node configuration overrides — set at deploy time, not trigger time'),
+
+  // ── Node outputs (mid-graph, runner-populated) ────────────────────
+  // Each LLM node writes its outputSchema-validated result at
+  // state.<nodeName>. These are declared optional so initialState
+  // validates before any node has run.
+
+  setup: z.object({
+    success: z.boolean(),
+    clonedRepos: z.array(z.object({
+      name: z.string(),
+      path: z.string(),
+      isPrimary: z.boolean().optional(),
+    })),
+    baselineCommit: z.string(),
+  }).optional()
+    .describe('Output of the setup node — clone paths + baseline commit (downstream nodes read clonedRepos[].path)'),
 });
 
 // Derived: what the engine actually validates initialState against at

package/generate-test-cases/graph.mjs

@@ -18,6 +18,9 @@
  *   sync; the win is each template is independently editable.
  */
 
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { WorkflowAgent, WorkflowGraph } from '@zibby/core';
 import { setupNode } from './nodes/setup-node.js';
 import { generateTestCasesNode } from './nodes/generate-test-cases-node.js';
@@ -26,6 +29,13 @@ import {
   generateTestCasesContextSchema,
 } from './state.js';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function loadPrompt(filename) {
+  const path = join(__dirname, 'prompts', filename);
+  return existsSync(path) ? readFileSync(path, 'utf-8') : null;
+}
+const setupPrompt = loadPrompt('setup.md');
+
 export class GenerateTestCasesAgent extends WorkflowAgent {
   buildGraph() {
     const graph = new WorkflowGraph();
@@ -33,7 +43,7 @@ export class GenerateTestCasesAgent extends WorkflowAgent {
       .setInputSchema(generateTestCasesInputSchema)
       .setContextSchema(generateTestCasesContextSchema);
 
-    graph.addNode('setup', setupNode);
+    graph.addNode('setup', setupNode, { prompt: setupPrompt });
     graph.addNode('generate_test_cases', generateTestCasesNode);
 
     graph.setEntryPoint('setup');

package/generate-test-cases/nodes/setup-node.js

@@ -1,142 +1,44 @@
 /**
- * Setup Node - Clone repositories and initialize git baseline
- * Used by: analysisGraph, implementationGraph
+ * Setup Node — LLM-driven workspace bootstrap.
+ *
+ * Mirrors code-analysis/setup-node.js. The agent receives the `git`
+ * skill (git_checkout, git_list_repos, git_explore) plus Bash, and is
+ * prompted to clone each repo from state.repos and initialize a
+ * baseline commit at state.workspace for diff tracking. The output
+ * lands at state.setup.{clonedRepos[], baselineCommit} where downstream
+ * nodes read it.
+ *
+ * Prompt is loaded by graph.mjs from prompts/setup.md so users can
+ * customize setup behavior without editing this file.
  */
 
-import { spawn } from 'child_process';
-import { join } from 'path';
-import { z } from 'zod';
+import { readFileSync, existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { z, SKILLS } from '@zibby/core';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const promptPath = join(__dirname, '..', 'prompts', 'setup.md');
+const setupPrompt = existsSync(promptPath)
+  ? readFileSync(promptPath, 'utf-8')
+  : '';
 
 const SetupOutputSchema = z.object({
-  success: z.boolean(),
+  success: z.boolean().describe('true if all repos cloned + baseline initialized'),
   clonedRepos: z.array(z.object({
-    name: z.string(),
-    path: z.string(),
-    isPrimary: z.boolean().optional()
-  })),
-  baselineCommit: z.string()
+    name: z.string().describe('Repo name (matches state.repos[].name)'),
+    path: z.string().describe('Absolute local path where the repo was cloned'),
+    isPrimary: z.boolean().optional().describe('True for the project\'s primary repo'),
+  })).describe('Every repo from state.repos must appear here once'),
+  baselineCommit: z.string().describe('git rev-parse HEAD at state.workspace after baseline commit'),
 });
 
 export const setupNode = {
   name: 'setup',
+  // SKILLS.GIT gives the LLM clone tools that auto-auth against GitHub
+  // OR GitLab — either connected integration satisfies the workflow.
+  skills: [SKILLS.GIT],
   outputSchema: SetupOutputSchema,
-  execute: async (state) => {
-    console.log('\n🔧 Setting up environment...');
-    
-    const { workspace, repos, githubToken } = state;
-    const gitlabToken = process.env.GITLAB_TOKEN || '';
-    const gitlabUrl = process.env.GITLAB_URL || '';
-    
-    // DEBUG: Log token status
-    console.log(`🔑 GitHub Token: ${githubToken ? 'Present' : 'MISSING'}`);
-    console.log(`🔑 GitLab Token: ${gitlabToken ? 'Present' : 'MISSING'}`);
-    if (gitlabUrl) console.log(`🔑 GitLab URL: ${gitlabUrl}`);
-    
-    // Log environment
-    console.log('Container: ECS Fargate');
-    console.log('Memory: 4GB');
-    console.log('CPU: 2 vCPU');
-    console.log('Tools: Node.js, Git, Cursor CLI, Zibby CLI');
-    console.log(`Working directory: ${workspace}`);
-    
-    // Clone repositories
-    console.log('\n📦 Cloning repositories...');
-    
-    const clonedRepos = [];
-    for (const repo of repos) {
-      console.log(`Cloning ${repo.name}...`);
-      
-      const repoDir = join(workspace, repo.name);
-      
-      // Use token for authentication based on provider
-      let cloneUrl = repo.url;
-      let cloneEnv = {};
-      const isGitlab = repo.provider === 'gitlab' || (gitlabUrl && repo.url.includes(new URL(gitlabUrl).host));
-      const isGithub = repo.provider === 'github' || repo.url.includes('github.com');
-      
-      if (isGithub && githubToken) {
-        cloneUrl = repo.url.replace('https://github.com', `https://x-access-token:${githubToken}@github.com`);
-        cloneEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: 'echo' };
-      } else if (isGitlab && gitlabToken && gitlabUrl) {
-        try {
-          const gitlabHost = new URL(gitlabUrl).host;
-          cloneUrl = repo.url.replace(`https://${gitlabHost}`, `https://oauth2:${gitlabToken}@${gitlabHost}`);
-        } catch (e) {
-          console.warn(`⚠️ Failed to parse GITLAB_URL: ${e.message}`);
-        }
-        cloneEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: 'echo' };
-      }
-      
-      // Shallow clone with progress output (async, non-blocking)
-      await execCommand(
-        `git clone --progress --depth 1 --branch ${repo.branch} "${cloneUrl}" "${repoDir}"`,
-        workspace,
-        cloneEnv
-      );
-      console.log(`✓ Cloned ${repo.name} on branch ${repo.branch}`);
-      
-      clonedRepos.push({
-        name: repo.name,
-        path: repoDir,
-        isPrimary: repo.isPrimary
-      });
-    }
-    
-    // Initialize git in workspace for diff tracking
-    await execCommand('git init', workspace);
-    await execCommand('git config user.email "zibby@agent.com"', workspace);
-    await execCommand('git config user.name "Zibby Agent"', workspace);
-    await execCommand('git add .', workspace);
-    await execCommand('git commit --allow-empty -m "baseline"', workspace);
-    
-    console.log('✅ Environment ready');
-    
-    const baselineCommit = await execCommand('git rev-parse HEAD', workspace);
-    
-    return {
-      success: true,
-      clonedRepos,
-      baselineCommit: baselineCommit.trim()
-    };
-  }
+  timeout: 5 * 60 * 1000,
+  prompt: setupPrompt,
 };
-
-// Async version using spawn - streams output in real-time, doesn't block event loop
-async function execCommand(command, cwd, env = {}) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, {
-      cwd,
-      shell: true,
-      env: Object.keys(env).length > 0 ? env : process.env
-    });
-    
-    let stdout = '';
-    let stderr = '';
-    
-    // Stream stdout as it comes (triggers middleware setInterval!)
-    proc.stdout.on('data', (data) => {
-      const output = data.toString();
-      stdout += output;
-      console.log(output.trimEnd());
-    });
-    
-    // Stream stderr as it comes
-    proc.stderr.on('data', (data) => {
-      const output = data.toString();
-      stderr += output;
-      console.log(output.trimEnd());
-    });
-    
-    proc.on('close', (code) => {
-      if (code !== 0) {
-        reject(new Error(`Command failed with exit code ${code}: ${command}`));
-      } else {
-        resolve(stdout || stderr || '');
-      }
-    });
-    
-    proc.on('error', (err) => {
-      reject(new Error(`Command error: ${command} - ${err.message}`));
-    });
-  });
-}

package/generate-test-cases/prompts/setup.md

@@ -0,0 +1,50 @@
+# Setup — clone repos + initialize baseline
+
+You are setting up the workspace for test-case generation. Two tasks:
+
+## 1. Clone each repo in `state.repos`
+
+```
+state.repos = {{state.repos}}
+state.workspace = {{state.workspace}}
+```
+
+For each entry, call `git_checkout`:
+- `url`: the repo's `url` field
+- `branch`: the repo's `branch` field (omit if not set)
+- `shallow`: true (default)
+
+`git_checkout` auto-authenticates against GitHub or GitLab using the
+project's connected integration. If one repo fails, continue with the
+others and surface the failure in the final output.
+
+## 2. Initialize a baseline git repo at `state.workspace`
+
+```bash
+cd {{state.workspace}}
+git init
+git config user.email "zibby@agent.com"
+git config user.name "Zibby Agent"
+git add .
+git commit --allow-empty -m "baseline"
+git rev-parse HEAD
+```
+
+The `git rev-parse HEAD` output is the `baselineCommit` you'll return.
+
+## 3. Return JSON matching the outputSchema
+
+```json
+{
+  "success": true,
+  "clonedRepos": [
+    { "name": "<repo name>", "path": "<absolute path from git_checkout>", "isPrimary": true }
+  ],
+  "baselineCommit": "<HEAD sha>"
+}
+```
+
+---
+
+Edit this prompt to customize setup behavior — e.g. skip baseline,
+filter repos, or run post-clone tooling (`npm install`, etc).

package/generate-test-cases/state.js

@@ -59,6 +59,18 @@ export const generateTestCasesContextSchema = z.object({
 
   nodeConfigs: z.record(z.string(), z.any()).optional()
     .describe('Per-node configuration overrides — set at deploy time, not trigger time'),
+
+  // ── Node outputs (mid-graph, runner-populated) ────────────────────
+  setup: z.object({
+    success: z.boolean(),
+    clonedRepos: z.array(z.object({
+      name: z.string(),
+      path: z.string(),
+      isPrimary: z.boolean().optional(),
+    })),
+    baselineCommit: z.string(),
+  }).optional()
+    .describe('Output of the setup node — clone paths + baseline commit'),
 });
 
 // Derived: full runtime state. Exported for tests + tooling.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zibby/workflow-templates",
-  "version": "0.2.1",
+  "version": "0.3.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",
@@ -57,7 +57,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.88.0",
-    "@zibby/agent-workflow": "^0.4.0",
+    "@zibby/agent-workflow": "^0.4.1",
     "axios": "^1.15.0",
     "handlebars": "^4.7.9",
     "zod": "^3.23.0 || ^4.0.0"