@synergenius/flow-weaver-pack-weaver 0.8.1

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@synergenius/flow-weaver-pack-weaver",
+  "version": "0.8.1",
+  "description": "AI bot for Flow Weaver. Execute tasks, run workflows, evolve autonomously.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./node-types": {
+      "types": "./dist/node-types/index.d.ts",
+      "default": "./dist/node-types/index.js"
+    },
+    "./bot": {
+      "types": "./dist/bot/index.d.ts",
+      "default": "./dist/bot/index.js"
+    }
+  },
+  "keywords": [
+    "flowweaver-marketplace-pack",
+    "flowweaver-bot-pack",
+    "flow-weaver",
+    "weaver",
+    "automation",
+    "ai-agent",
+    "bot"
+  ],
+  "flowWeaver": {
+    "type": "marketplace-pack",
+    "engineVersion": ">=0.17.0",
+    "categories": [
+      "automation",
+      "ai"
+    ]
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": ">=0.30.0",
+    "@synergenius/flow-weaver": ">=0.21.0",
+    "zod": ">=3.22.0"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "flowweaver.manifest.json",
+    "templates.js",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && cp -r src/docs dist/docs && node -e \"require('fs').writeFileSync('templates.js','export{workflowTemplates}from\\\"./dist/templates/index.js\\\";\\n')\"",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "release": "tsx scripts/release.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.5",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/synergenius-fw/flow-weaver-pack-weaver"
+  }
+}

package/src/bot/agent-provider.ts

@@ -0,0 +1,273 @@
+import { execFileSync } from 'node:child_process';
+import type { BotProviderConfig, BotConfig, BotAgentProvider, OnUsageCallback, StreamChunk, ToolDefinition, ToolUseResult } from './types.js';
+import { buildSystemPrompt } from './system-prompt.js';
+import { defaultRegistry, loadExternalProvider } from './provider-registry.js';
+import type { ProviderRegistry } from './provider-registry.js';
+
+const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
+
+export type { BotAgentProvider };
+
+export function resolveProviderConfig(
+  provider: BotConfig['provider'],
+): BotProviderConfig {
+  if (provider === 'auto') return detectProvider();
+  if (typeof provider === 'string') return { name: provider };
+  return provider;
+}
+
+export async function createProvider(
+  config: BotProviderConfig,
+  registry: ProviderRegistry = defaultRegistry,
+): Promise<BotAgentProvider> {
+  // If config.module is set, load and register it first
+  if (config.module) {
+    if (!registry.has(config.name)) {
+      const { factory, metadata } = await loadExternalProvider(config.module);
+      registry.register(config.name, factory, metadata);
+    }
+  }
+
+  // Check registry (covers built-ins + loaded externals)
+  const entry = registry.resolve(config.name);
+  if (entry) {
+    return entry.factory({
+      model: config.model,
+      maxTokens: config.maxTokens,
+      options: config.options,
+    });
+  }
+
+  // Fallback: try conventional npm package names
+  const candidates = [
+    `flowweaver-provider-${config.name}`,
+    `@synergenius/flowweaver-provider-${config.name}`,
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      const { factory, metadata } = await loadExternalProvider(candidate);
+      registry.register(config.name, factory, metadata);
+      return factory({
+        model: config.model,
+        maxTokens: config.maxTokens,
+        options: config.options,
+      });
+    } catch {
+      // Try next candidate
+    }
+  }
+
+  throw new Error(
+    `Unknown provider: ${config.name}\n` +
+    `  Install a provider package: npm install flowweaver-provider-${config.name}\n` +
+    `  Or specify a module path: { "provider": { "name": "${config.name}", "module": "./my-provider.js" } }`,
+  );
+}
+
+export function detectProvider(registry: ProviderRegistry = defaultRegistry): BotProviderConfig {
+  // Check registry metadata for env vars and CLI commands
+  for (const { name, metadata } of registry.list()) {
+    if (metadata.requiredEnvVars) {
+      const allPresent = metadata.requiredEnvVars.every((v) => process.env[v]);
+      if (allPresent) return { name };
+    }
+  }
+
+  for (const { name, metadata } of registry.list()) {
+    if (metadata.detectCliCommand) {
+      try {
+        execFileSync(WHICH_CMD, [metadata.detectCliCommand], { stdio: 'pipe' });
+        return { name };
+      } catch { /* not installed */ }
+    }
+  }
+
+  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',
+  );
+}
+
+export class AnthropicAgentProvider implements BotAgentProvider {
+  private model: string;
+  private maxTokens: number;
+  onUsage?: OnUsageCallback;
+
+  constructor(config: BotProviderConfig) {
+    this.model = config.model ?? 'claude-sonnet-4-6';
+    this.maxTokens = config.maxTokens ?? 4096;
+  }
+
+  async decide(request: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+  }): Promise<Record<string, unknown>> {
+    if (!process.env.ANTHROPIC_API_KEY) {
+      throw new Error(
+        'ANTHROPIC_API_KEY environment variable is required for the Anthropic provider',
+      );
+    }
+
+    const Anthropic = await this.loadSdk();
+    const client = new Anthropic();
+    const systemPrompt = await buildSystemPrompt();
+
+    const contextStr =
+      typeof request.context === 'string'
+        ? request.context
+        : JSON.stringify(request.context, null, 2);
+
+    const response = await client.messages.create({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: systemPrompt,
+      messages: [
+        {
+          role: 'user',
+          content: `Context:\n${contextStr}\n\nInstructions:\n${request.prompt}`,
+        },
+      ],
+    });
+
+    if (this.onUsage && response.usage) {
+      this.onUsage(request.agentId, response.model ?? this.model, {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        cacheCreationInputTokens: response.usage.cache_creation_input_tokens,
+        cacheReadInputTokens: response.usage.cache_read_input_tokens,
+      });
+    }
+
+    const text =
+      response.content[0].type === 'text' ? response.content[0].text : '';
+    return this.parseJson(text);
+  }
+
+  async *stream(request: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+  }): AsyncIterable<StreamChunk> {
+    if (!process.env.ANTHROPIC_API_KEY) {
+      throw new Error('ANTHROPIC_API_KEY environment variable is required for the Anthropic provider');
+    }
+
+    const Anthropic = await this.loadSdk();
+    const client = new Anthropic();
+    const systemPrompt = await buildSystemPrompt();
+
+    const contextStr = typeof request.context === 'string'
+      ? request.context
+      : JSON.stringify(request.context, null, 2);
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const stream = (client as any).messages.stream({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: `Context:\n${contextStr}\n\nInstructions:\n${request.prompt}` }],
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    for await (const event of stream as AsyncIterable<any>) {
+      if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+        yield { type: 'text', text: event.delta.text };
+      }
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const finalMessage = await (stream as any).finalMessage();
+    if (finalMessage?.usage) {
+      const usage = {
+        inputTokens: finalMessage.usage.input_tokens,
+        outputTokens: finalMessage.usage.output_tokens,
+        cacheCreationInputTokens: finalMessage.usage.cache_creation_input_tokens,
+        cacheReadInputTokens: finalMessage.usage.cache_read_input_tokens,
+      };
+      if (this.onUsage) this.onUsage(request.agentId, finalMessage.model ?? this.model, usage);
+      yield { type: 'usage', usage };
+    }
+    yield { type: 'done' };
+  }
+
+  async decideWithTools(request: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+    tools: ToolDefinition[];
+  }): Promise<{ result: Record<string, unknown>; toolCalls?: ToolUseResult[] }> {
+    if (!process.env.ANTHROPIC_API_KEY) {
+      throw new Error('ANTHROPIC_API_KEY environment variable is required for the Anthropic provider');
+    }
+
+    const Anthropic = await this.loadSdk();
+    const client = new Anthropic();
+    const systemPrompt = await buildSystemPrompt();
+
+    const contextStr = typeof request.context === 'string'
+      ? request.context
+      : JSON.stringify(request.context, null, 2);
+
+    const response = await client.messages.create({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: `Context:\n${contextStr}\n\nInstructions:\n${request.prompt}` }],
+      tools: request.tools,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
+    if (this.onUsage && response.usage) {
+      this.onUsage(request.agentId, response.model ?? this.model, {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        cacheCreationInputTokens: response.usage.cache_creation_input_tokens,
+        cacheReadInputTokens: response.usage.cache_read_input_tokens,
+      });
+    }
+
+    const toolCalls: ToolUseResult[] = [];
+    let text = '';
+    for (const block of response.content) {
+      if (block.type === 'text') text = block.text;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      else if (block.type === 'tool_use') toolCalls.push({ toolName: (block as any).name, toolInput: (block as any).input });
+    }
+
+    return { result: this.parseJson(text || '{}'), toolCalls: toolCalls.length > 0 ? toolCalls : undefined };
+  }
+
+  private parseJson(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)}`);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private async loadSdk(): Promise<new () => any> {
+    try {
+      // @ts-expect-error -- optional peer dep, loaded at runtime
+      const mod = await import('@anthropic-ai/sdk');
+      return mod.default ?? mod.Anthropic;
+    } catch {
+      throw new Error(
+        'Bot mode requires @anthropic-ai/sdk. Install it:\n  npm install @anthropic-ai/sdk',
+      );
+    }
+  }
+}

package/src/bot/ai-client.ts

@@ -0,0 +1,153 @@
+import { execSync, spawn } from 'node:child_process';
+import { parseStreamLine, extractTextFromChunks } from './cli-stream-parser.js';
+import type { ProviderInfo, StreamChunk } from './types.js';
+
+// Strip CLAUDECODE from child env so nested claude CLI invocations work.
+const childEnv = { ...process.env };
+delete childEnv.CLAUDECODE;
+
+export function callCli(provider: string, prompt: string, model?: string): string {
+  if (provider === 'claude-cli') {
+    const modelFlag = model ? ` --model ${model}` : '';
+    return execSync(`claude -p --output-format text${modelFlag}`, {
+      input: prompt, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 300_000, env: childEnv,
+    }).trim();
+  }
+  if (provider === 'copilot-cli') {
+    return execSync('copilot -p --silent --allow-all-tools', {
+      input: prompt, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 300_000, env: childEnv,
+    }).trim();
+  }
+  throw new Error(`Unknown CLI provider: ${provider}`);
+}
+
+export async function callCliAsync(provider: string, prompt: string, model?: string): Promise<string> {
+  if (provider === 'copilot-cli') {
+    return callCli(provider, prompt, model);
+  }
+  if (provider !== 'claude-cli') {
+    throw new Error(`Unknown CLI provider: ${provider}`);
+  }
+
+  const args = ['-p', '--output-format', 'stream-json'];
+  if (model) args.push('--model', model);
+
+  const child = spawn('claude', args, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: childEnv,
+  });
+
+  child.stdin.write(prompt);
+  child.stdin.end();
+
+  const timeout = setTimeout(() => child.kill('SIGTERM'), 300_000);
+
+  const chunks: StreamChunk[] = [];
+  let buffer = '';
+
+  try {
+    for await (const data of child.stdout) {
+      buffer += data.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop()!;
+
+      for (const line of lines) {
+        const chunk = parseStreamLine(line);
+        if (chunk) chunks.push(chunk);
+      }
+    }
+
+    if (buffer.trim()) {
+      const chunk = parseStreamLine(buffer);
+      if (chunk) chunks.push(chunk);
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code && code !== 0) reject(new Error(`claude CLI exited with code ${code}`));
+      else resolve();
+    });
+    child.on('error', reject);
+  });
+
+  return extractTextFromChunks(chunks);
+}
+
+export async function callApi(
+  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 ?? '';
+}
+
+/**
+ * Call the platform-injected AI proxy (routes through IPC to the host process).
+ * Available when running inside the Studio sandbox.
+ */
+export async function callPlatform(
+  systemPrompt: string,
+  userPrompt: string,
+  model?: string,
+  maxTokens?: number,
+): Promise<string> {
+  const provider = (globalThis as any).__fw_llm_provider__;
+  if (!provider) throw new Error('Platform AI provider not available');
+  const messages = [
+    { role: 'system', content: systemPrompt },
+    { role: 'user', content: userPrompt },
+  ];
+  const response = await provider.chat(messages, { model, maxTokens });
+  return response.content ?? '';
+}
+
+/**
+ * Unified AI call that dispatches to the right backend based on provider type.
+ */
+export async function callAI(
+  pInfo: Pick<ProviderInfo, 'type' | 'apiKey' | 'model' | 'maxTokens'>,
+  systemPrompt: string,
+  userPrompt: string,
+  defaultMaxTokens = 4096,
+): Promise<string> {
+  if (pInfo.type === 'platform') {
+    return callPlatform(systemPrompt, userPrompt, pInfo.model, pInfo.maxTokens ?? defaultMaxTokens);
+  }
+  if (pInfo.type === 'anthropic') {
+    return callApi(
+      pInfo.apiKey!,
+      pInfo.model ?? 'claude-sonnet-4-6',
+      pInfo.maxTokens ?? defaultMaxTokens,
+      systemPrompt,
+      userPrompt,
+    );
+  }
+  return callCli(pInfo.type, systemPrompt + '\n\n' + userPrompt, pInfo.model);
+}
+
+export 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 { /* fallthrough */ }
+  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)}`);
+}