@zibby/workflow-templates 0.2.1 → 0.4.1

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/index.js

@@ -165,6 +165,142 @@ export const TEMPLATES = {
         'Produce specs that an AI agent can execute end-to-end',
       ],
     },
+  },
+
+  // ── notify-slack: reusable notifier child workflow ────────────────
+  // Dispatched as a sub-graph from any parent that wants Slack alerts.
+  // Single-node graph, no LLM, deterministic API call.
+  'notify-slack': {
+    name: 'notify-slack',
+    displayName: 'Notify Slack',
+    description: 'Reusable child workflow — posts a structured Block Kit alert to a Slack channel. Dispatched by other workflows (Sentry triage, autofix, incident) via sub-graph.',
+    path: join(__dirname, 'notify-slack'),
+    defaultSlug: 'alert-slack',
+    deps: { zod: '^3.23.0' },
+    features: [
+      'Single-node, no LLM — deterministic ~500ms post',
+      'Block Kit message with severity-coded color + emoji',
+      'Optional Sentry-flavored fields (users affected, events, release)',
+      'Action buttons + caller-supplied @-mentions',
+      'Returns messageTs so parent can thread follow-ups',
+    ],
+    marketplace: {
+      slug: 'notify-slack',
+      tagline: 'Reusable Slack alert worker — dispatch from any workflow.',
+      iconPrompt: [
+        'Flat geometric vector illustration with subtle clean gradients, in the spirit of Linear / Notion / Stripe iconography — crisp, no painterly textures.',
+        'Subject: the iconic Slack pinwheel mark — four chunky rounded-rectangle "petals" arranged in a plus / asterisk configuration, colored with Slack\'s signature palette (top-left red #E01E5A, top-right yellow #ECB22E, bottom-right green #2EB67D, bottom-left blue #36C5F0), painted as if it\'s the focal brand mark of the icon. A small bright magenta notification dot floats in the upper-right corner of the pinwheel suggesting an incoming alert/ping.',
+        'Background: deep navy (#0B0F1A) rounded square (1024×1024) with a faint radial glow centered behind the pinwheel so the colors pop without becoming oversaturated.',
+        'Centered composition with the pinwheel as the dominant focal element, the notification dot as a small secondary accent in the upper-right; plenty of breathing room so the silhouette reads at 64×64 in the marketplace grid.',
+        'Mood: focused, energetic, signal-not-noise — the canonical Slack-flavored notification worker.',
+        'NO text, NO letters, NO photo-realism, NO sleek 3D render, NO literal Slack wordmark — the colored pinwheel shape is allowed as the brand reference.',
+      ].join('\n'),
+      category: 'Notifications',
+      tags: ['slack', 'notification', 'alert', 'child-workflow'],
+      capabilities: [
+        'Severity-coded Block Kit message (low/medium/high/critical)',
+        'Code snippet + action button + caller mentions',
+        'Sub-graph dispatchable from any parent workflow',
+        'Returns messageTs for thread replies',
+      ],
+      conversationStarters: [
+        'Post a CRITICAL alert to #incidents from this workflow',
+        'Send a daily summary to #dev-updates',
+        'Notify @oncall when a Sentry issue exceeds threshold',
+        'Forward the deploy-fail message to #ops',
+      ],
+    },
+  },
+
+  // ── notify-lark: same as notify-slack, Lark / Feishu variant ─────
+  'notify-lark': {
+    name: 'notify-lark',
+    displayName: 'Notify Lark',
+    description: 'Reusable child workflow — posts a structured Interactive Card to a Lark / Feishu chat. Dispatched by other workflows via sub-graph.',
+    path: join(__dirname, 'notify-lark'),
+    defaultSlug: 'alert-lark',
+    deps: { zod: '^3.23.0' },
+    features: [
+      'Single-node, no LLM',
+      'Lark Interactive Card with severity template (red/orange/yellow/grey)',
+      'Optional Sentry-flavored metadata fields',
+      'Token cache across multiple sends in one task',
+      'Returns messageId for threaded replies',
+    ],
+    marketplace: {
+      slug: 'notify-lark',
+      tagline: 'Reusable Lark / Feishu alert worker — dispatch from any workflow.',
+      iconPrompt: [
+        'A clean, modern app icon for a Lark / Feishu notification worker.',
+        '',
+        'Visual style: flat geometric vector with subtle gradient, complementary to the notify-slack icon (same family).',
+        'Subject: a stylized speech-bubble silhouette in Lark-cyan-to-blue gradient (#00D6B9 → #1664FF) with a checkmark inside. Gentle motion lines behind it.',
+        'Background: deep navy (#0B0F1A) rounded square (1024×1024).',
+        'Mood: focused, professional, signal-not-noise.',
+        'NO Lark / Feishu logo trademark, NO text, NO photo-realism.',
+      ].join('\n'),
+      category: 'Notifications',
+      tags: ['lark', 'feishu', 'notification', 'alert', 'child-workflow'],
+      capabilities: [
+        'Severity-coded Lark Interactive Card',
+        'Auto-detects receive_id_type from id prefix (chat_id / open_id / email)',
+        'Sub-graph dispatchable from any parent workflow',
+        'Per-process token cache for fan-out efficiency',
+      ],
+      conversationStarters: [
+        'Send a CRITICAL alert to the engineering Lark group',
+        'Notify the on-call group chat when Sentry issue spikes',
+        'Forward deploy notifications to our Lark channel',
+      ],
+    },
+  },
+
+  // ── sentry-triage: parent workflow that uses notify-slack/-lark ──
+  'sentry-triage': {
+    name: 'sentry-triage',
+    displayName: 'Sentry Triage Bot',
+    description: 'Hourly Sentry triage — pulls new issues, drops obvious noise with a regex pre-filter, classifies survivors with LLM (CRITICAL/HIGH/MEDIUM/LOW/NOISE), and fans out alerts to a notify-slack OR notify-lark child workflow.',
+    path: join(__dirname, 'sentry-triage'),
+    defaultSlug: 'sentry-triage',
+    deps: { zod: '^3.23.0' },
+    features: [
+      '4-node graph: fetch → filter_noise → classify → dispatch_alerts',
+      'Regex noise filter before LLM cuts ~80% of classification cost',
+      'LLM severity classifier with explicit rubric (rules 1-5)',
+      'Sub-graph fan-out to notify-slack OR notify-lark (choose at deploy)',
+      'Per-issue failure isolation — one Slack hiccup doesn\'t stall the run',
+      'Configurable severityThreshold (don\'t notify on LOW noise)',
+      'Cron-friendly: hourly schedule, default sinceMinutes=60',
+    ],
+    marketplace: {
+      slug: 'sentry-triage',
+      tagline: 'Filter noise, classify severity, ping the right channel — every hour.',
+      iconPrompt: [
+        'Hand-painted storybook illustration in a warm gouache style with soft brushwork and gentle painterly texture, featuring the friendly round lighthouse mascot character with two big smiling eyes and a rosy blush on its white-and-coral-striped tower body, perched on a tiny mint-green island and clutching a small glowing purple SHIELD BADGE in front of its body — the badge is a rounded geometric emblem in Sentry\'s signature deep violet (#362D59 / #7553FF) with a stylized white "S"-mark inside it formed from overlapping rounded parallelogram shapes, painted with the same soft gouache brushstrokes as the rest of the scene so it feels integrated rather than corporate.',
+        'The lighthouse lantern emits a soft golden beam that catches one glowing amber alert orb while three faded grey noise specks drift harmlessly past, reinforcing the "filter the signal, calm the noise" idea.',
+        'Background is a soft sunrise gradient of pale peach at the top blending through buttercream into a gentle wash of dusty lavender at the base, tying the warm scene to the violet of the badge; a few small fluffy pastel clouds float in for friendliness.',
+        'Centered composition with the purple shield badge as the immediate focal point in the lower-center, the lighthouse rising behind and slightly above it, beam angled diagonally; plenty of breathing room so the silhouette reads at 64×64 with the violet badge clearly visible at a glance.',
+        'Mood is warm, reassuring, optimistic — the friendly Sentry-flavored night-watch character, NOT tactical or corporate or alarming.',
+        'Soft rounded square 1024×1024 canvas with a subtle paper-grain texture.',
+        'NO text, NO letters, NO photo-realism, NO sleek 3D render, NO magnifying glass, NO speech bubbles, NO dark navy or near-black backgrounds, NO bug or insect imagery, NO literal Sentry wordmark.',
+      ].join('\n'),
+      category: 'Operations',
+      tags: ['sentry', 'observability', 'on-call', 'triage', 'alerting'],
+      capabilities: [
+        'Hourly scheduled triage of new Sentry issues',
+        'Deterministic regex filter drops Script error / ResizeObserver / extension noise',
+        'LLM severity classifier with auditable rubric',
+        'Dispatches to notify-slack or notify-lark (sub-graph, ~5ms in-process)',
+        'CRITICAL alerts get caller-supplied @-mentions; lower severities don\'t',
+        'Configurable severity threshold per deploy',
+      ],
+      conversationStarters: [
+        'Triage all new Sentry issues from the last hour',
+        'Notify #sentry-alerts when severity is HIGH or above',
+        'Run hourly and post a summary to our team Slack',
+        'Page on-call when a CRITICAL error appears in checkout',
+      ],
+    },
   }
 };
 

package/notify-lark/README.md

@@ -0,0 +1,88 @@
+# notify-lark
+
+A reusable **child workflow** that posts an Interactive Card alert to a Lark / Feishu chat.
+
+Companion to `notify-slack` — same provider-neutral input shape, so a parent workflow can fan out to BOTH Slack and Lark with the same `input` block (just swap `channel` → `receiveId`).
+
+## What it does
+
+- Takes a provider-neutral payload (severity, title, body, optional Sentry-flavored context)
+- Builds a Lark Interactive Card with severity-coded header template + emoji + action buttons
+- Resolves `tenant_access_token` from the app id/secret stored in your Lark integration
+- POSTs to `/open-apis/im/v1/messages` with the right `receive_id_type` inferred from the id prefix
+
+No LLM call — single deterministic API request, typically <500ms (or <1s on cold token cache).
+
+## Dispatch shape (parent workflow)
+
+```js
+graph.addNode('alert', {
+  workflow: 'notify-lark',
+  async: false,
+  input: (state) => ({
+    severity:   'critical',
+    title:      'Checkout: TypeError on session.user.id',
+    body:       '**12 users** affected in the last 1h. Likely regression from `1.42.0`.',
+    receiveId:  'oc_abc123def456...',                      // chat id, open id, or email
+    sentryLink: 'https://sentry.io/.../1234567890/',
+    affectedUsers: 12,
+    events:     47,
+    release:    '1.42.0',
+    firstSeen:  '8 min ago',
+    codeSnippet:'src/handlers/checkout.ts:142\nconst userId = session.user.id;',
+    mentions:   ['<at user_id="ou_oncall_group">@backend-oncall</at>'],
+  }),
+  output: 'notify_lark.messageId',
+});
+```
+
+## receiveId formats
+
+The `receive_id_type` query param is inferred from the prefix:
+
+| Prefix | Type | Description |
+|---|---|---|
+| `oc_` | `chat_id` | Group chat or DM (most common) |
+| `ou_` | `open_id` | Direct message to a specific user |
+| `on_` | `union_id` | Cross-app stable user id |
+| `cli_` | `app_id` | App-to-app message |
+| `<email>@…` | `email` | Send to user by email |
+
+If you don't know your chat id, DM the bot `whoami` and it'll respond with the caller's `open_id`. Group chat ids appear in the URL when you open the chat in browser.
+
+## Output
+
+```js
+{ delivered: true, receiveId: 'oc_abc...', receiveIdType: 'chat_id', messageId: 'om_xxxxx' }
+```
+
+The `messageId` lets the parent post threaded replies later (e.g. incident-commander progress updates).
+
+## Prerequisites
+
+Project must have the **Lark** integration connected with:
+- `im:message` scope (send messages)
+- `im:message.group_msg` scope (send to group chats)
+
+## Severity → header template
+
+| Severity | Lark template | Emoji |
+|---|---|---|
+| low | `grey` | ⚪ |
+| medium | `yellow` | 🟡 |
+| high | `orange` | 🟠 |
+| critical | `red` | 🚨 |
+
+## Tests
+
+```bash
+cd packages/workflow-templates/notify-lark
+npm test
+```
+
+Tests cover:
+- Card rendering for each severity
+- Conditional sections (fields/body/code/actions only when input present)
+- receive_id_type inference per prefix
+- Tenant token caching across multiple sends
+- Error mapping (invalid receive_id, scope missing, network blip)

package/notify-lark/graph.mjs

@@ -0,0 +1,43 @@
+/**
+ * notify-lark — single-node child workflow.
+ *
+ * Companion to notify-slack; same provider-neutral input shape so a
+ * parent can `dispatchSubgraph('notify-slack')` AND
+ * `dispatchSubgraph('notify-lark')` with the same input block, just
+ * swapping `channel` → `receiveId`. (See notify-slack/graph.mjs for the
+ * Slack-flavored example.)
+ *
+ * Returns `{ delivered, receiveId, receiveIdType, messageId }`. The
+ * `messageId` can be used for thread replies via Lark's reply API in
+ * follow-up dispatches.
+ */
+
+import { WorkflowAgent, WorkflowGraph } from '@zibby/core';
+import { notifyLarkNode } from './nodes/notify-lark-node.js';
+import {
+  notifyLarkInputSchema,
+  notifyLarkContextSchema,
+} from './state.js';
+
+export class NotifyLarkAgent extends WorkflowAgent {
+  buildGraph() {
+    const graph = new WorkflowGraph();
+    graph
+      .setInputSchema(notifyLarkInputSchema)
+      .setContextSchema(notifyLarkContextSchema);
+
+    graph.addNode('notify_lark', notifyLarkNode);
+    graph.setEntryPoint('notify_lark');
+    graph.addEdge('notify_lark', 'END');
+
+    return graph;
+  }
+
+  async onComplete(result) {
+    const delivered = !!result?.state?.notify_lark?.delivered;
+    const mid = result?.state?.notify_lark?.messageId || '?';
+    console.log(`[notify-lark] ${delivered ? 'delivered' : 'failed'} (messageId=${mid})`);
+  }
+}
+
+export default NotifyLarkAgent;