@synergenius/flowweaver-pack-weaver 0.3.0 → 0.4.0

package/dist/templates/weaver-template.js

@@ -8,663 +8,25 @@ export const weaverTemplate = {
 //   flow-weaver compile weaver.ts
 //   flow-weaver run weaver.ts
 // Or use the CLI directly: npx weaver weaver.ts
+//
+// Node types are provided by @synergenius/flowweaver-pack-weaver.
+// Install it: npm install @synergenius/flowweaver-pack-weaver
 
-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(process.platform === 'win32' ? 'where claude' : 'which claude', projectDir)) {
-      type = 'claude-cli';
-    } else if (runSafe(process.platform === 'win32' ? 'where copilot' : '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/executor';
-    // 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 Record<string, unknown> | null;
-    const ok = (result?.onSuccess as boolean) ?? false;
-    // Build summary from result fields, falling back gracefully
-    let summary: string;
-    if (typeof result?.summary === 'string') {
-      summary = result.summary;
-    } else if (result) {
-      const parts: string[] = [];
-      for (const [k, v] of Object.entries(result)) {
-        if (k === 'onSuccess' || k === 'onFailure' || v == null) continue;
-        const s = typeof v === 'string' ? v : JSON.stringify(v);
-        parts.push(k + ': ' + (s.length > 80 ? s.slice(0, 80) + '...' : s));
-      }
-      summary = parts.length > 0 ? parts.join(', ') : 'completed';
-    } else {
-      summary = 'completed';
-    }
-
-    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
-// ============================================================
+import { weaverLoadConfig } from '@synergenius/flowweaver-pack-weaver/node-types';
+import { weaverDetectProvider } from '@synergenius/flowweaver-pack-weaver/node-types';
+import { weaverResolveTarget } from '@synergenius/flowweaver-pack-weaver/node-types';
+import { weaverExecuteTarget } from '@synergenius/flowweaver-pack-weaver/node-types';
+import { weaverSendNotify } from '@synergenius/flowweaver-pack-weaver/node-types';
+import { weaverReport } from '@synergenius/flowweaver-pack-weaver/node-types';
 
 /**
  * @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]
+ * @node cfg weaverLoadConfig [color: "teal"] [icon: "settings"] [position: 100 0]
+ * @node detect weaverDetectProvider [color: "cyan"] [icon: "search"] [position: 250 0]
+ * @node target weaverResolveTarget [color: "blue"] [icon: "code"] [position: 400 0]
+ * @node exec weaverExecuteTarget [color: "purple"] [icon: "psychology"] [position: 550 0]
+ * @node notify weaverSendNotify [color: "yellow"] [icon: "notifications"] [position: 700 0]
+ * @node rep weaverReport [color: "green"] [icon: "description"] [position: 850 0]
  * @path Start -> cfg -> detect -> target -> exec -> notify -> rep -> Exit
  * @position Start 0 0
  * @position Exit 1000 0

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyqBV,CAAC;IACA,CAAC;CACF,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CV,CAAC;IACA,CAAC;CACF,CAAC"}

package/dist/workflows/index.d.ts

@@ -0,0 +1,2 @@
+export { weaver } from './weaver.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/workflows/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflows/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}