@synergenius/flowweaver-pack-weaver 0.1.0

package/dist/templates/weaver-template.js

@@ -0,0 +1,672 @@
+export const weaverTemplate = {
+    id: 'weaver',
+    name: 'Weaver: Autonomous workflow runner',
+    description: 'AI-powered runner that executes any Flow Weaver workflow autonomously, with auto-detected providers and notification support',
+    category: 'automation',
+    generate: (_opts) => {
+        return `import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+// ============================================================
+// Types
+// ============================================================
+
+interface WeaverConfig {
+  provider?: 'auto' | 'anthropic' | 'claude-cli' | 'copilot-cli' | { name: string; model?: string; maxTokens?: number };
+  target?: string;
+  approval?: 'auto' | 'timeout-auto' | { mode: string; timeoutSeconds?: number };
+  notify?: Array<{ channel: 'discord' | 'slack' | 'webhook'; url: string; events?: string[]; headers?: Record<string, string> }>;
+}
+
+interface ProviderInfo {
+  type: 'anthropic' | 'claude-cli' | 'copilot-cli';
+  model?: string;
+  maxTokens?: number;
+  apiKey?: string;
+}
+
+// ============================================================
+// Helpers
+// ============================================================
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim();
+}
+
+function runSafe(cmd: string, cwd: string): string {
+  try { return run(cmd, cwd); } catch { return ''; }
+}
+
+function info(msg: string): void { console.log(\`\\x1b[36m→ \${msg}\\x1b[0m\`); }
+function success(msg: string): void { console.log(\`\\x1b[32m✓ \${msg}\\x1b[0m\`); }
+function warn(msg: string): void { console.log(\`\\x1b[33m! \${msg}\\x1b[0m\`); }
+
+function callCli(provider: string, prompt: string): string {
+  if (provider === 'claude-cli') {
+    return execSync('claude -p --output-format text', {
+      input: prompt,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 120_000,
+    }).trim();
+  }
+  if (provider === 'copilot-cli') {
+    return execSync('copilot -p --silent --allow-all-tools', {
+      input: prompt,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 120_000,
+    }).trim();
+  }
+  throw new Error(\`Unknown CLI provider: \${provider}\`);
+}
+
+async function callApiAsync(
+  apiKey: string,
+  model: string,
+  maxTokens: number,
+  systemPrompt: string,
+  userPrompt: string,
+): Promise<string> {
+  const body = JSON.stringify({
+    model,
+    max_tokens: maxTokens,
+    system: systemPrompt,
+    messages: [{ role: 'user', content: userPrompt }],
+  });
+  const response = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+    },
+    body,
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(\`Anthropic API error \${response.status}: \${text.slice(0, 200)}\`);
+  }
+  const json = await response.json() as { content: Array<{ type: string; text: string }> };
+  return json.content[0]?.text ?? '';
+}
+
+function parseJsonResponse(text: string): Record<string, unknown> {
+  let cleaned = text.trim();
+  if (cleaned.startsWith('\\\`\\\`\\\`')) {
+    cleaned = cleaned.replace(/^\\\`\\\`\\\`(?:json)?\\s*\\n?/, '').replace(/\\n?\\\`\\\`\\\`\\s*$/, '');
+  }
+  try { return JSON.parse(cleaned); } catch {}
+  const match = cleaned.match(/\\{[\\s\\S]*\\}/);
+  if (match) return JSON.parse(match[0]);
+  throw new Error(\`Failed to parse AI response as JSON: \${text.slice(0, 200)}\`);
+}
+
+function sendWebhook(
+  config: { channel: string; url: string; headers?: Record<string, string> },
+  event: Record<string, unknown>,
+): void {
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+    ...config.headers,
+  };
+  let body: string;
+  if (config.channel === 'discord') {
+    const color = event.success ? 0x22c55e : 0xef4444;
+    body = JSON.stringify({
+      embeds: [{
+        title: \`Weaver: \${event.outcome ?? 'update'}\`,
+        description: String(event.summary ?? '').slice(0, 2000),
+        color,
+        fields: [
+          { name: 'Workflow', value: String(event.targetPath ?? 'unknown'), inline: true },
+          { name: 'Provider', value: String(event.providerType ?? 'unknown'), inline: true },
+        ],
+        timestamp: new Date().toISOString(),
+      }],
+    });
+  } else if (config.channel === 'slack') {
+    const emoji = event.success ? ':white_check_mark:' : ':x:';
+    body = JSON.stringify({
+      blocks: [
+        { type: 'header', text: { type: 'plain_text', text: \`\${emoji} Weaver: \${event.outcome ?? 'update'}\` } },
+        { type: 'section', text: { type: 'mrkdwn', text: String(event.summary ?? '').slice(0, 2000) } },
+      ],
+    });
+  } else {
+    body = JSON.stringify(event);
+  }
+  const headerFlags = Object.entries(headers).map(([k, v]) => \`-H "\${k}: \${v}"\`).join(' ');
+  try {
+    execSync(\`curl -sS -X POST \${headerFlags} -d @- "\${config.url}"\`, {
+      input: body,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10_000,
+    });
+  } catch { /* notification failure is non-fatal */ }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function buildWeaverPrompt(): Promise<string> {
+  const FALLBACK = 'You are Weaver, an expert AI companion for Flow Weaver workflows. Respond ONLY with valid JSON. No markdown, no code fences, no explanation outside the JSON structure.';
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const docMeta: any = await import('@synergenius/flow-weaver/doc-metadata');
+
+    const annotations: Array<{ name: string; syntax: string; description: string; category: string }> = docMeta.ALL_ANNOTATIONS ?? [];
+    const portMods: Array<{ syntax: string; description: string }> = docMeta.PORT_MODIFIERS ?? [];
+    const nodeMods: Array<{ syntax: string; description: string }> = docMeta.NODE_MODIFIERS ?? [];
+    const codes: Array<{ code: string; severity: string; title: string; description: string }> = docMeta.VALIDATION_CODES ?? [];
+    const commands: Array<{ name: string; description: string; group?: string }> = docMeta.CLI_COMMANDS ?? [];
+
+    // Format annotations grouped by category
+    const groups = new Map<string, typeof annotations>();
+    for (const a of annotations) {
+      const list = groups.get(a.category) ?? [];
+      list.push(a);
+      groups.set(a.category, list);
+    }
+    const annotationLines: string[] = [];
+    for (const [category, items] of groups) {
+      annotationLines.push('[' + category + ']');
+      for (const item of items) annotationLines.push('  ' + item.syntax + '  -- ' + item.description);
+    }
+
+    // Format modifiers
+    const modLines: string[] = [];
+    if (portMods.length > 0) {
+      modLines.push('Port modifiers (after port name):');
+      for (const m of portMods) modLines.push('  ' + m.syntax + '  -- ' + m.description);
+    }
+    if (nodeMods.length > 0) {
+      modLines.push('Node instance modifiers (in @node declaration):');
+      for (const m of nodeMods) modLines.push('  ' + m.syntax + '  -- ' + m.description);
+    }
+
+    // Format errors (top 15)
+    const errors = codes.filter(c => c.severity === 'error').slice(0, 15);
+    const errorLines = errors.map(c => '  ' + c.code + ': ' + c.title + ' -- ' + c.description);
+
+    // Format top-level CLI commands
+    const topCmds = commands.filter(c => !c.group);
+    const cmdLines = topCmds.map(c => '  flow-weaver ' + c.name + ' -- ' + c.description);
+
+    return \`You are Weaver, an expert AI companion for Flow Weaver workflows. You have deep knowledge of the entire Flow Weaver ecosystem: annotation grammar, compilation, CLI tools, node patterns, error diagnosis, and the Genesis self-evolution protocol.
+
+## Core Mental Model
+
+The code IS the workflow. Flow Weaver workflows are plain TypeScript files with JSDoc annotations above functions. The compiler reads annotations and generates deterministic execution code between @flow-weaver-body-start/end markers. Compiled code is standalone with no runtime dependency on flow-weaver.
+
+Three block types:
+- @flowWeaver nodeType: A reusable function (node) with typed inputs/outputs
+- @flowWeaver workflow: A DAG orchestration that wires node instances together
+- @flowWeaver pattern: A reusable fragment with boundary ports (IN/OUT instead of Start/Exit)
+
+## Annotation Grammar
+
+\${annotationLines.join('\\n')}
+
+\${modLines.join('\\n')}
+
+## Node Execution Model
+
+Expression nodes (@expression):
+- No execute/onSuccess/onFailure params. Just inputs and return value.
+- throw = failure path, return = success path
+- Synchronous. Use execSync for shell commands.
+- Preferred for deterministic operations.
+
+Standard nodes:
+- execute: boolean param gates execution
+- Return { onSuccess: boolean, onFailure: boolean, ...outputs }
+- Can be async for I/O operations
+
+Async agent nodes:
+- Use (globalThis as any).__fw_agent_channel__ to pause workflow
+- Call channel.request({ agentId, context, prompt }) which returns a Promise
+- Workflow suspends until agent responds
+- NOT @expression (must be async)
+
+Pass-through pattern:
+- FW auto-connects ports by matching names on adjacent nodes
+- To forward data through intermediate nodes, declare it as both @input and @output with the same name
+- For non-adjacent wiring, use @connect sourceNode.port -> targetNode.port
+
+Data flow:
+- @path A -> B -> C: Linear execution path (sugar for multiple @connect)
+- @autoConnect: Auto-wire all nodes in declaration order
+- @connect: Explicit port-to-port wiring
+- Merge strategies for fan-in: FIRST, LAST, COLLECT, MERGE, CONCAT
+
+## CLI Commands
+
+\${cmdLines.join('\\n')}
+
+Key workflows:
+  flow-weaver compile <file>  -- Generate executable code (in-place)
+  flow-weaver validate <file> -- Check for errors without compiling
+  flow-weaver modify <op> --file <f> -- Structural changes (addNode, removeNode, addConnection, removeConnection)
+  flow-weaver implement <file> -- Replace declare stubs with implementations
+  flow-weaver diff <a> <b> -- Semantic diff between two workflow versions
+  flow-weaver diagram <file> -f ascii-compact -- Generate ASCII diagram
+
+## Validation Errors
+
+\${errorLines.join('\\n')}
+
+When you encounter validation errors, suggest the specific fix. Common resolutions:
+- UNKNOWN_NODE_TYPE: Ensure the referenced function has @flowWeaver nodeType annotation
+- MISSING_REQUIRED_INPUT: Add a @connect from a source port or make the input optional with [brackets]
+- UNKNOWN_SOURCE_PORT / UNKNOWN_TARGET_PORT: Check port name spelling in @connect
+- CYCLE_DETECTED: Break the cycle; use scoped iteration (@scope, @map) instead of circular dependencies
+
+## Genesis Protocol
+
+Genesis is a 17-step self-evolving workflow engine:
+1. Load config (.genesis/config.json with intent, focus, constraints, approval thresholds)
+2. Observe project (fingerprint: files, package.json, git, CI, tests, existing FW workflows)
+3. Load task workflow (genesis-task.ts)
+4. Diff fingerprint against last cycle
+5. Check stabilize mode (3+ rollbacks/rejections = read-only, or explicit flag)
+6. Wait for agent (YOU decide what evolutions to propose)
+7. Propose evolution (map your decisions to FwModifyOperation[])
+8. Validate proposal (budget: max 3 cost units per cycle. addNode=1, removeNode=1, addConnection=1, removeConnection=1, implementNode=2)
+9. Snapshot current task workflow for rollback
+10. Apply changes via flow-weaver CLI
+11. Compile and validate (auto-rollback on failure)
+12. Diff workflow (semantic diff)
+13. Check approval threshold (CRITICAL > BREAKING > MINOR > COSMETIC)
+14. Wait for approval (if impact >= threshold)
+15. Commit or rollback based on approval
+16. Update history (.genesis/history.json)
+17. Report summary
+
+When stabilize mode is active, only fix-up operations are allowed: removeNode, removeConnection, implementNode. No new nodes or connections.
+
+## Response Format
+
+Return ONLY valid JSON. No markdown, no code fences, no explanation outside the JSON structure. Your response must parse with JSON.parse() directly.\`;
+  } catch {
+    return FALLBACK;
+  }
+}
+
+// ============================================================
+// Node Types
+// ============================================================
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Load Config
+ * @input [projectDir] [order:0] - Project root directory (defaults to cwd)
+ * @output projectDir [order:0] - Project root directory (pass-through)
+ * @output config [order:1] - Weaver configuration (JSON)
+ */
+function loadConfig(projectDir?: string): { projectDir: string; config: string } {
+  const dir = projectDir || process.cwd();
+  const configPath = path.join(dir, '.weaver.json');
+  let config: WeaverConfig = { provider: 'auto' };
+  if (fs.existsSync(configPath)) {
+    config = { ...config, ...JSON.parse(fs.readFileSync(configPath, 'utf-8')) };
+    info(\`Loaded config from \${configPath}\`);
+  } else {
+    info('No .weaver.json found, using defaults (provider: auto)');
+  }
+  return { projectDir: dir, config: JSON.stringify(config) };
+}
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Detect Provider
+ * @input projectDir [order:0] - Project root directory
+ * @input config [order:1] - Weaver configuration (JSON)
+ * @output projectDir [order:0] - Project root directory (pass-through)
+ * @output config [order:1] - Config (pass-through)
+ * @output providerType [order:2] - Resolved provider type
+ * @output providerInfo [order:3] - Provider details (JSON)
+ */
+function detectProvider(projectDir: string, config: string): {
+  projectDir: string; config: string;
+  providerType: string; providerInfo: string;
+} {
+  const cfg: WeaverConfig = JSON.parse(config);
+  let providerSetting = cfg.provider ?? 'auto';
+
+  let type: string;
+  let model: string | undefined;
+  let maxTokens: number | undefined;
+
+  if (typeof providerSetting === 'object') {
+    type = providerSetting.name;
+    model = providerSetting.model;
+    maxTokens = providerSetting.maxTokens;
+  } else if (providerSetting !== 'auto') {
+    type = providerSetting;
+  } else {
+    // Auto-detection
+    if (process.env.ANTHROPIC_API_KEY) {
+      type = 'anthropic';
+    } else if (runSafe('which claude', projectDir)) {
+      type = 'claude-cli';
+    } else if (runSafe('which copilot', projectDir)) {
+      type = 'copilot-cli';
+    } else {
+      throw new Error(
+        'No AI provider found. Options:\\n' +
+        '  1. Set ANTHROPIC_API_KEY environment variable\\n' +
+        '  2. Install Claude CLI: https://docs.anthropic.com/claude-code\\n' +
+        '  3. Install GitHub Copilot CLI: https://github.com/features/copilot'
+      );
+    }
+  }
+
+  const providerInfo: ProviderInfo = {
+    type: type as ProviderInfo['type'],
+    model: model ?? (type === 'anthropic' ? 'claude-sonnet-4-6' : undefined),
+    maxTokens: maxTokens ?? (type === 'anthropic' ? 4096 : undefined),
+    apiKey: type === 'anthropic' ? process.env.ANTHROPIC_API_KEY : undefined,
+  };
+
+  if (type === 'anthropic' && !providerInfo.apiKey) {
+    throw new Error('Provider is "anthropic" but ANTHROPIC_API_KEY is not set');
+  }
+
+  const label = providerInfo.model ? \`\${type} (\${providerInfo.model})\` : type;
+  info(\`Provider: \${label}\`);
+
+  return {
+    projectDir, config,
+    providerType: type,
+    providerInfo: JSON.stringify(providerInfo),
+  };
+}
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Resolve Target
+ * @input projectDir [order:0] - Project root directory
+ * @input config [order:1] - Config (JSON)
+ * @input providerType [order:2] - Provider type (pass-through)
+ * @input providerInfo [order:3] - Provider info (pass-through)
+ * @output projectDir [order:0] - Project root directory (pass-through)
+ * @output config [order:1] - Config (pass-through)
+ * @output providerType [order:2] - Provider type (pass-through)
+ * @output providerInfo [order:3] - Provider info (pass-through)
+ * @output targetPath [order:4] - Absolute path to target workflow
+ */
+function resolveTarget(
+  projectDir: string, config: string, providerType: string, providerInfo: string,
+): {
+  projectDir: string; config: string; providerType: string; providerInfo: string;
+  targetPath: string;
+} {
+  const cfg: WeaverConfig = JSON.parse(config);
+
+  if (cfg.target) {
+    const abs = path.resolve(projectDir, cfg.target);
+    if (!fs.existsSync(abs)) throw new Error(\`Target workflow not found: \${abs}\`);
+    info(\`Target: \${abs}\`);
+    return { projectDir, config, providerType, providerInfo, targetPath: abs };
+  }
+
+  // Scan for workflow files (depth 2)
+  const found: string[] = [];
+  const scan = (dir: string, depth: number): void => {
+    if (depth > 2) return;
+    let entries: fs.Dirent[];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) { scan(full, depth + 1); }
+      else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
+        try {
+          const content = fs.readFileSync(full, 'utf-8').slice(0, 2000);
+          if (content.includes('@flowWeaver workflow')) found.push(full);
+        } catch { /* skip */ }
+      }
+    }
+  };
+  scan(projectDir, 0);
+
+  if (found.length === 0) {
+    throw new Error(\`No workflow files found in \${projectDir}. Set "target" in .weaver.json or pass a file path.\`);
+  }
+  if (found.length > 1) {
+    throw new Error(
+      \`Multiple workflows found. Set "target" in .weaver.json to pick one:\\n\` +
+      found.map(f => \`  - \${path.relative(projectDir, f)}\`).join('\\n')
+    );
+  }
+
+  info(\`Target: \${found[0]}\`);
+  return { projectDir, config, providerType, providerInfo, targetPath: found[0]! };
+}
+
+/**
+ * @flowWeaver nodeType
+ * @label Execute Target
+ * @input projectDir [order:0] - Project root directory
+ * @input config [order:1] - Config (JSON)
+ * @input providerType [order:2] - Provider type
+ * @input providerInfo [order:3] - Provider info (JSON)
+ * @input targetPath [order:4] - Absolute path to target workflow
+ * @output projectDir [order:0] - Project root directory (pass-through)
+ * @output config [order:1] - Config (pass-through)
+ * @output targetPath [order:2] - Target path (pass-through)
+ * @output resultJson [order:3] - Workflow execution result (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] - On Failure
+ */
+async function executeTarget(
+  execute: boolean,
+  projectDir: string,
+  config: string,
+  providerType: string,
+  providerInfo: string,
+  targetPath: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  projectDir: string; config: string; targetPath: string; resultJson: string;
+}> {
+  if (!execute) {
+    return {
+      onSuccess: true, onFailure: false,
+      projectDir, config, targetPath,
+      resultJson: JSON.stringify({ success: true, summary: 'Dry run', outcome: 'skipped' }),
+    };
+  }
+
+  const pInfo: ProviderInfo = JSON.parse(providerInfo);
+  const cfg: WeaverConfig = JSON.parse(config);
+
+  // Build expert system prompt from flow-weaver's doc-metadata
+  const systemPrompt = await buildWeaverPrompt();
+
+  // Resolve approval settings
+  const approvalSetting = cfg.approval ?? 'auto';
+  const approvalMode = typeof approvalSetting === 'string' ? approvalSetting : approvalSetting.mode;
+
+  // Create agent channel
+  const agentChannel = {
+    request: async (req: { agentId: string; context: Record<string, unknown>; prompt: string }) => {
+      // Handle approval requests
+      if (req.agentId.includes('approval')) {
+        if (approvalMode === 'auto') {
+          info('Auto-approving');
+          return { approved: true, reason: 'auto-approved' };
+        }
+        if (approvalMode === 'timeout-auto') {
+          const timeout = typeof approvalSetting === 'object' ? (approvalSetting.timeoutSeconds ?? 300) : 300;
+          info(\`Waiting \${timeout}s before auto-approving...\`);
+          await new Promise(resolve => setTimeout(resolve, timeout * 1000));
+          return { approved: true, reason: 'timeout-auto-approved' };
+        }
+        return { approved: true, reason: 'default-approved' };
+      }
+
+      // Regular agent decisions
+      const contextStr = typeof req.context === 'string'
+        ? req.context
+        : JSON.stringify(req.context, null, 2);
+      const userPrompt = \`Context:\\n\${contextStr}\\n\\nInstructions:\\n\${req.prompt}\`;
+
+      let text: string;
+      if (pInfo.type === 'anthropic') {
+        text = await callApiAsync(
+          pInfo.apiKey!,
+          pInfo.model ?? 'claude-sonnet-4-6',
+          pInfo.maxTokens ?? 4096,
+          systemPrompt,
+          userPrompt,
+        );
+      } else {
+        text = callCli(pInfo.type, systemPrompt + '\\n\\n' + userPrompt);
+      }
+
+      return parseJsonResponse(text);
+    },
+    onPause: () => new Promise<never>(() => {}),
+    resume: () => {},
+    fail: () => {},
+  };
+
+  try {
+    info(\`Executing: \${targetPath}\`);
+    const startTime = Date.now();
+
+    const mod = '@synergenius/flow-weaver/dist/mcp/workflow-executor.js';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { executeWorkflowFromFile } = await (import(mod) as Promise<any>);
+    const execResult = await executeWorkflowFromFile(targetPath, {}, {
+      agentChannel,
+      includeTrace: false,
+      production: true,
+    });
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    const result = execResult.result as { onSuccess?: boolean; summary?: string } | null;
+    const ok = result?.onSuccess ?? false;
+    const summary = result?.summary ?? 'No summary';
+
+    if (ok) success(\`Completed in \${elapsed}s: \${summary}\`);
+    else warn(\`Failed after \${elapsed}s: \${summary}\`);
+
+    const resultObj = {
+      success: ok,
+      summary,
+      outcome: ok ? 'completed' : 'failed',
+      functionName: execResult.functionName,
+      executionTime: Number(elapsed),
+    };
+
+    return {
+      onSuccess: ok, onFailure: !ok,
+      projectDir, config, targetPath,
+      resultJson: JSON.stringify(resultObj),
+    };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warn(\`Error: \${msg}\`);
+    return {
+      onSuccess: false, onFailure: true,
+      projectDir, config, targetPath,
+      resultJson: JSON.stringify({ success: false, summary: msg, outcome: 'error' }),
+    };
+  }
+}
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Notify Result
+ * @input projectDir [order:0] - Project root directory
+ * @input config [order:1] - Config (JSON)
+ * @input targetPath [order:2] - Target path
+ * @input resultJson [order:3] - Result (JSON)
+ * @output projectDir [order:0] - Project root directory (pass-through)
+ * @output targetPath [order:1] - Target path (pass-through)
+ * @output resultJson [order:2] - Result (pass-through)
+ */
+function sendNotify(
+  projectDir: string, config: string, targetPath: string, resultJson: string,
+): { projectDir: string; targetPath: string; resultJson: string } {
+  const cfg: WeaverConfig = JSON.parse(config);
+  const result = JSON.parse(resultJson);
+  const channels = cfg.notify ?? [];
+
+  for (const ch of channels) {
+    const events = ch.events ?? ['workflow-complete', 'error'];
+    const eventType = result.success ? 'workflow-complete' : 'error';
+    if (!events.includes(eventType)) continue;
+    sendWebhook(ch, { ...result, targetPath, providerType: cfg.provider, projectDir });
+  }
+
+  if (channels.length > 0) info(\`Sent \${channels.length} notification(s)\`);
+  return { projectDir, targetPath, resultJson };
+}
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Report
+ * @input projectDir [order:0] - Project root directory
+ * @input targetPath [order:1] - Target workflow path
+ * @input resultJson [order:2] - Result (JSON)
+ * @output summary [order:0] - Summary string
+ */
+function report(projectDir: string, targetPath: string, resultJson: string): { summary: string } {
+  const result = JSON.parse(resultJson);
+  const relPath = path.relative(projectDir, targetPath);
+  const lines = [
+    \`Weaver: \${result.outcome} (\${relPath})\`,
+    result.summary,
+  ];
+  if (result.executionTime) lines.push(\`Time: \${result.executionTime}s\`);
+  success(lines[0]!);
+  return { summary: lines.join('\\n') };
+}
+
+// ============================================================
+// Workflow
+// ============================================================
+
+/**
+ * @flowWeaver workflow
+ * @node cfg loadConfig [color: "teal"] [icon: "settings"] [position: 100 0]
+ * @node detect detectProvider [color: "cyan"] [icon: "search"] [position: 250 0]
+ * @node target resolveTarget [color: "blue"] [icon: "code"] [position: 400 0]
+ * @node exec executeTarget [color: "purple"] [icon: "psychology"] [position: 550 0]
+ * @node notify sendNotify [color: "yellow"] [icon: "notifications"] [position: 700 0]
+ * @node rep report [color: "green"] [icon: "description"] [position: 850 0]
+ * @path Start -> cfg -> detect -> target -> exec -> notify -> rep -> Exit
+ * @position Start 0 0
+ * @position Exit 1000 0
+ * @connect rep.summary -> Exit.summary
+ * @param execute [order:-1] - Execute
+ * @param params [order:0] - Params
+ * @returns onSuccess [order:-2] - On Success
+ * @returns onFailure [order:-1] - On Failure
+ * @returns summary [order:0] - Summary text
+ */
+export async function weaver(
+  execute: boolean,
+  params: Record<string, never> = {},
+  __abortSignal__?: AbortSignal,
+): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string | null }> {
+  // @flow-weaver-body-start
+  // (auto-generated by compiler)
+  // @flow-weaver-body-end
+  return { onSuccess: false, onFailure: true, summary: null };
+}
+`;
+    },
+};
+//# sourceMappingURL=weaver-template.js.map

package/dist/templates/weaver-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weaver-template.js","sourceRoot":"","sources":["../../src/templates/weaver-template.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,MAAM,cAAc,GAAqB;IAC9C,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,oCAAoC;IAC1C,WAAW,EAAE,8HAA8H;IAC3I,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE;QAClB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAspBV,CAAC;IACA,CAAC;CACF,CAAC"}