@zibby/workflow-templates 0.2.1 → 0.4.1

package/browser-test-automation/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.5","results":[[":__tests__/preflight-early-exit.test.mjs",{"duration":6.5747499999999945,"failed":false}]]}

package/browser-test-automation/package.json

@@ -7,6 +7,7 @@
   "main": "graph.mjs",
   "dependencies": {
     "@zibby/core": "^0.5.1",
+    "@zibby/ui-memory": "^1.0.0",
     "zod": "^3.23.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/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.5","results":[[":nodes/__tests__/middleware.integration.test.js",{"duration":0,"failed":true}],[":nodes/__tests__/finalizeNode.test.js",{"duration":8.396791000000007,"failed":false}]]}

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

@@ -5,14 +5,24 @@
  */
 
 import { spawn } from 'child_process';
-import { join, resolve } from 'path';
+import { dirname, join, resolve } from 'path';
 import { existsSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
 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';
 
+// Prompts ship inside the workflow bundle at `<template>/prompts/`.
+// state.promptsDir is the runner-injection slot for callers that want
+// to override (legacy analyze-graph CLI set it explicitly); when unset,
+// resolve relative to this node file so the template is self-contained
+// and works for any runner.
+const __nodeDir = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_PROMPTS_DIR = join(__nodeDir, '..', 'prompts');
+
 const CodeImplementationOutputSchema = z.object({
   success: z.boolean(),
   codeImplementation: z.object({
@@ -59,19 +69,22 @@ export function createCodeGenerationNode(options = {}) {
       const mode = commitAndPush ? 'implementing' : 'generating preview of';
       console.log(`\n💻 ${commitAndPush ? 'Implementing' : 'Generating'} code implementation...`);
       
-      const { workspace, ticketContext, repos, promptsDir, model, nodeConfigs = {} } = state;
+      const { workspace, ticketContext, repos, model, nodeConfigs = {} } = state;
+      const promptsDir = state.promptsDir || DEFAULT_PROMPTS_DIR;
       const aiModel = model || ticketContext.model || 'auto';
       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 +109,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 +166,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 +327,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 +356,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');