@synergenius/flow-weaver-pack-weaver 0.9.5 → 0.9.6

package/src/bot/assistant-core.ts

@@ -31,6 +31,8 @@ export interface AssistantOptions {
   systemPrompt?: string;
   /** Override for testing — provide messages instead of reading stdin */
   inputMessages?: string[];
+  /** Watch a directory for file changes and auto-suggest fixes */
+  watchDir?: string;
   /** Resume a specific conversation by ID */
   resumeId?: string;
   /** Always start a fresh conversation */
@@ -71,6 +73,41 @@ For those: you may summarize or explain the result as needed.`;
 
 export async function runAssistant(opts: AssistantOptions): Promise<void> {
   const { provider, tools, executor, projectDir } = opts;
+  const out = (s: string) => process.stderr.write(s);
+
+  // Pipe mode: if stdin is not a TTY, read all input as one message
+  if (!process.stdin.isTTY && !opts.inputMessages) {
+    const chunks: string[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(typeof chunk === 'string' ? chunk : chunk.toString());
+    }
+    const pipeInput = chunks.join('').trim();
+    if (!pipeInput) return;
+
+    // Build system prompt for pipe mode
+    let systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    try {
+      const fsMod = await import('node:fs');
+      const pathMod = await import('node:path');
+      const planPath = pathMod.resolve(projectDir, '.weaver-plan.md');
+      if (fsMod.existsSync(planPath)) {
+        const plan = fsMod.readFileSync(planPath, 'utf-8').trim();
+        systemPrompt += '\n\n## Project Plan & Vision\n\nAll bots you spawn and tasks you queue MUST align with this plan.\n\n' + plan;
+      }
+    } catch { /* plan not available */ }
+
+    // Run single message, print result, exit
+    await runAgentLoop(provider, tools, executor, [{ role: 'user', content: pipeInput }], {
+      systemPrompt, maxIterations: 20,
+      onStreamEvent: (e) => { if (e.type === 'text_delta') out(e.text); },
+      onToolEvent: (e) => {
+        if (e.type === 'tool_call_start') out(`\n  ${c.cyan('◆')} ${e.name}\n`);
+        if (e.type === 'tool_call_result') out(`  ${c.dim('→')} ${(e.result ?? '').slice(0, 200)}\n`);
+      },
+    });
+    out('\n');
+    return;
+  }
 
   // Build system prompt — include project plan if it exists
   let systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
@@ -84,8 +121,6 @@ export async function runAssistant(opts: AssistantOptions): Promise<void> {
     }
   } catch { /* plan not available */ }
 
-  const out = (s: string) => process.stderr.write(s);
-
   // Persistent conversation store
   const { ConversationStore } = await import('./conversation-store.js');
   const store = new ConversationStore();
@@ -117,13 +152,30 @@ export async function runAssistant(opts: AssistantOptions): Promise<void> {
     }
   }
 
+  // Resolve versions
+  let fwVersion = '?';
+  let weaverVersion = '?';
+  try {
+    const { execFileSync: vExec } = await import('node:child_process');
+    fwVersion = vExec('npx', ['flow-weaver', '--version'], { encoding: 'utf-8', cwd: projectDir, timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim().replace(/^flow-weaver\s+v?/i, '');
+  } catch { /* not available */ }
+  try {
+    const fsMod = await import('node:fs');
+    const url = await import('node:url');
+    const packPkg = JSON.parse(fsMod.readFileSync(new url.URL('../package.json', import.meta.url), 'utf-8'));
+    weaverVersion = packPkg.version;
+  } catch { /* not available */ }
+
   // Welcome
-  out(`\n  ${c.bold('weaver assistant')}\n`);
-  out(`  ${c.dim(`Project: ${projectDir}`)}\n`);
+  out(`\n  ${c.bold('weaver assistant')} ${c.dim(`v${weaverVersion}`)}  ${c.dim(`· flow-weaver v${fwVersion}`)}\n`);
+  if (process.env.FW_PLATFORM_TOKEN) {
+    out(`  ${c.dim('AI: Platform credits (no API key needed)')}\n`);
+  }
+  out(`  ${c.dim(`Project: ${path.basename(projectDir)}`)}\n`);
   if (conversation.title) {
     out(`  ${c.dim(`Resuming: "${conversation.title}" (${conversation.messageCount} messages)`)}\n`);
   } else {
-    out(`  ${c.dim(`Conversation: ${conversation.id}`)}\n`);
+    out(`  ${c.dim(`New conversation`)}\n`);
   }
   out(`  ${c.dim('Type your request. Ctrl+C to exit. /help for commands.')}\n\n`);
 
@@ -188,6 +240,31 @@ export async function runAssistant(opts: AssistantOptions): Promise<void> {
     onVerbose: () => { out(`  ${c.dim('Verbose toggling not yet wired to streaming.')}\n`); },
   };
 
+  // Watch mode: monitor directory for file changes, auto-validate
+  let watcher: import('node:fs').FSWatcher | null = null;
+  if (opts.watchDir) {
+    try {
+      const fsMod = await import('node:fs');
+      const { execFileSync } = await import('node:child_process');
+      watcher = fsMod.watch(opts.watchDir, { recursive: true }, (_event, filename) => {
+        if (!filename || !filename.endsWith('.ts')) return;
+        const filePath = `${opts.watchDir}/${filename}`;
+        try {
+          const result = execFileSync('npx', ['flow-weaver', 'validate', filePath, '--json'], {
+            encoding: 'utf-8', cwd: projectDir, timeout: 15_000, stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          const parsed = JSON.parse(result);
+          const errorCount = parsed.errorCount ?? parsed.errors?.length ?? 0;
+          if (errorCount > 0) {
+            out(`\n  ${c.yellow('⚠')} ${filename} changed: ${errorCount} validation error(s)\n`);
+            out(`  ${c.dim('Type a message to fix, or ignore.')}\n`);
+          }
+        } catch { /* validation failed or not a workflow — ignore */ }
+      });
+      out(`  ${c.dim(`Watching: ${opts.watchDir}`)}\n\n`);
+    } catch { /* watch not available */ }
+  }
+
   // Main conversation loop
   while (!shouldExit) {
     const input = await getNextInput();
@@ -239,6 +316,9 @@ export async function runAssistant(opts: AssistantOptions): Promise<void> {
       store.appendMessages(conversation.id, [{ role: 'user', content: input }, ...newMessages]);
       store.updateAfterTurn(conversation.id, [{ role: 'user', content: input }, ...newMessages], tokensUsed);
 
+      // Sync to cloud if logged in (fire-and-forget)
+      store.syncToCloud(conversation.id, [{ role: 'user', content: input }, ...newMessages]).catch(() => {});
+
       // Auto-title from first assistant response
       if (!conversation.title) {
         const firstAssistant = newMessages.find(m => m.role === 'assistant');
@@ -265,6 +345,7 @@ export async function runAssistant(opts: AssistantOptions): Promise<void> {
     out('\n');
   }
 
+  watcher?.close();
   richInput?.destroy();
   out(`\n  ${c.dim('Goodbye.')}\n\n`);
 }

package/src/bot/conversation-store.ts

@@ -176,6 +176,38 @@ export class ConversationStore {
     });
   }
 
+  async syncToCloud(id: string, newMessages: AgentMessage[]): Promise<void> {
+    try {
+      const credPath = path.join(os.homedir(), '.fw', 'credentials.json');
+      if (!fs.existsSync(credPath)) return;
+      const creds = JSON.parse(fs.readFileSync(credPath, 'utf-8'));
+      if (!creds.token || !creds.platformUrl || creds.expiresAt <= Date.now()) return;
+
+      const conversation = this.get(id);
+      if (!conversation) return;
+
+      // Fire-and-forget sync — don't block the conversation
+      const lastMessage = newMessages.find(m => m.role === 'user');
+      if (!lastMessage) return;
+
+      const message = typeof lastMessage.content === 'string' ? lastMessage.content : JSON.stringify(lastMessage.content);
+
+      fetch(`${creds.platformUrl}/ai-chat/stream`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(creds.token.startsWith('fw_')
+            ? { 'X-API-Key': creds.token }
+            : { Authorization: `Bearer ${creds.token}` }),
+        },
+        body: JSON.stringify({
+          message: `[Synced from CLI] ${message}`,
+          conversationId: (conversation as any).cloudConversationId,
+        }),
+      }).catch(() => {}); // fire-and-forget
+    } catch { /* sync not available */ }
+  }
+
   async setTitle(id: string, title: string): Promise<void> {
     await withFileLock(this.indexPath, () => {
       const index = this.readIndex();

package/src/cli-handlers.ts

@@ -1,5 +1,6 @@
 import * as path from 'node:path';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { runWorkflow } from './bot/runner.js';
 import { RunStore } from './bot/run-store.js';
@@ -67,6 +68,7 @@ export interface ParsedArgs {
   assistantResume?: string;
   assistantList?: boolean;
   assistantDelete?: string;
+  assistantWatch?: string;
 }
 
 export function parseArgs(argv: string[]): ParsedArgs {
@@ -261,6 +263,9 @@ export function parseArgs(argv: string[]): ParsedArgs {
       result.genesisInit = true;
     } else if (arg === '--watch') {
       result.genesisWatch = true;
+    } else if (arg === '--watch-dir' && i + 1 < args.length) {
+      i++;
+      result.assistantWatch = args[i];
     } else if (arg === '--new') {
       result.assistantNew = true;
     } else if (arg === '--resume' && i + 1 < args.length) {
@@ -1093,6 +1098,43 @@ export async function handleEject(opts: ParsedArgs): Promise<void> {
   console.log(`[weaver] Metadata written to ${metaPath}`);
   console.log('[weaver] You can now customize the ejected workflow(s) freely.');
   console.log('[weaver] The bot will use local files when available.');
+
+  // Generate CUSTOMIZATION.md guide
+  const customizationGuide = `# Customizing Your Weaver Bot
+
+## What You Got
+${results.map(r => `- ${r.file} — ${r.workflow} workflow (${r.nodeTypes.length} node types)`).join('\n')}
+
+You can edit these files freely. Weaver will use your local versions.
+
+## Safe Changes
+- Add a notification node (Slack, Discord, email) after git-ops
+- Change approval mode: edit the @node approve line
+- Add custom validation: insert a node between agent and gitOps
+- Modify the system prompt: edit system-prompt.ts
+- Add new tools: create a node type and wire it in
+
+## How to Add a Node
+1. Create a new file: my-node.ts with @flowWeaver nodeType annotation
+2. Import it in the workflow file
+3. Add: @node myNode myNodeType [color: "blue"] [icon: "star"]
+4. Wire it: @connect existingNode.output -> myNode.input
+5. Compile: flow-weaver compile <workflow-file>
+
+## How to Test
+  flow-weaver validate <workflow-file>    # check for errors
+  flow-weaver diagram <workflow-file>     # visualize the DAG
+  weaver bot "test task" --auto-approve   # run a test task
+
+## Learn More
+  weaver examples                         # see what's possible
+  weaver doctor                           # check your setup
+  flow-weaver docs concepts               # Flow Weaver documentation
+`;
+
+  const customPath = path.resolve(destDir, 'CUSTOMIZATION.md');
+  fs.writeFileSync(customPath, customizationGuide, 'utf-8');
+  console.log(`[weaver] Generated ${customPath}`);
 }
 
 export async function handleRun(opts: ParsedArgs): Promise<void> {
@@ -1525,6 +1567,32 @@ export async function handleSession(opts: ParsedArgs): Promise<void> {
       sendDesktopNotification('Weaver Session Complete', `${sessionCompleted} done, ${sessionFailed} failed, ${sessionNoOp} no-op`);
     } catch { /* non-fatal */ }
   }
+
+  // Webhook notification if configured
+  if (config?.notify) {
+    try {
+      const webhookUrl = typeof config.notify === 'string' ? config.notify
+        : typeof config.notify === 'object' && 'webhook' in config.notify ? (config.notify as { webhook: string }).webhook
+        : null;
+      if (webhookUrl) {
+        fetch(webhookUrl, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            event: 'session.completed',
+            timestamp: new Date().toISOString(),
+            tasks: taskCount,
+            completed: sessionCompleted,
+            failed: sessionFailed,
+            noOp: sessionNoOp,
+            tokens: sessionInputTokens + sessionOutputTokens,
+            cost: sessionCost,
+            elapsed: Date.now() - sessionStartTime,
+          }),
+        }).catch(() => {}); // fire-and-forget
+      }
+    } catch { /* non-fatal */ }
+  }
 }
 
 export async function handleAssistant(opts: ParsedArgs): Promise<void> {
@@ -1559,13 +1627,37 @@ export async function handleAssistant(opts: ParsedArgs): Promise<void> {
 
   const config = await loadConfig(opts.configPath);
 
+  // Check platform login — override provider if logged in
+  let providerOverride: string | undefined;
+  try {
+    const credPath = path.join(os.homedir(), '.fw', 'credentials.json');
+    if (fs.existsSync(credPath)) {
+      const creds = JSON.parse(fs.readFileSync(credPath, 'utf-8'));
+      if (creds.token && creds.platformUrl && creds.expiresAt > Date.now()) {
+        providerOverride = 'platform';
+        // Make credentials available to the provider
+        process.env.FW_PLATFORM_TOKEN = creds.token;
+        process.env.FW_PLATFORM_URL = creds.platformUrl;
+      }
+    }
+  } catch { /* not available */ }
+
   // Create provider
-  const { createAnthropicProvider, createClaudeCliProvider } = await import('@synergenius/flow-weaver/agent');
+  const agentMod = await import('@synergenius/flow-weaver/agent');
+  const { createAnthropicProvider, createClaudeCliProvider } = agentMod;
+  const createPlatformProvider = 'createPlatformProvider' in agentMod
+    ? (agentMod as Record<string, unknown>).createPlatformProvider as (opts: { token: string; platformUrl: string }) => unknown
+    : null;
   const providerSetting = config?.provider ?? 'auto';
   const providerType = typeof providerSetting === 'object' ? providerSetting.name : String(providerSetting);
 
-  let provider;
-  if (providerType === 'anthropic' || (providerType === 'auto' && process.env.ANTHROPIC_API_KEY)) {
+  let provider: import('@synergenius/flow-weaver/agent').AgentProvider;
+  if ((providerOverride === 'platform' || providerType === 'platform') && createPlatformProvider) {
+    provider = createPlatformProvider({
+      token: process.env.FW_PLATFORM_TOKEN!,
+      platformUrl: process.env.FW_PLATFORM_URL!,
+    }) as import('@synergenius/flow-weaver/agent').AgentProvider;
+  } else if (providerType === 'anthropic' || (providerType === 'auto' && process.env.ANTHROPIC_API_KEY)) {
     const apiKey = process.env.ANTHROPIC_API_KEY ?? (typeof providerSetting === 'object' ? (providerSetting as { apiKey?: string }).apiKey : undefined);
     if (!apiKey) { console.error('ANTHROPIC_API_KEY required for anthropic provider'); process.exit(1); }
     provider = createAnthropicProvider({ apiKey, model: typeof providerSetting === 'object' ? providerSetting.model : undefined });
@@ -1584,6 +1676,7 @@ export async function handleAssistant(opts: ParsedArgs): Promise<void> {
     projectDir,
     resumeId: opts.assistantResume,
     newConversation: opts.assistantNew,
+    watchDir: opts.assistantWatch,
   });
 }
 
@@ -2125,6 +2218,15 @@ export async function handleDoctor(opts: ParsedArgs): Promise<void> {
     checks.push({ label: 'Connection', status: 'warn', detail: 'Not tested' });
   }
 
+  // Weaver version (this pack)
+  try {
+    const url = await import('node:url');
+    const packPkg = JSON.parse(fs.readFileSync(new url.URL('../package.json', import.meta.url) as unknown as string, 'utf-8'));
+    checks.push({ label: 'Weaver', status: 'ok', detail: `v${packPkg.version}` });
+  } catch {
+    checks.push({ label: 'Weaver', status: 'ok', detail: 'unknown version' });
+  }
+
   // Flow Weaver version
   try {
     const { execFileSync: fwCheck } = await import('node:child_process');

package/src/node-types/agent-execute.ts

@@ -140,7 +140,7 @@ export async function weaverAgentExecute(
   auditEmit('run-start', { task: task.instruction });
 
   try {
-    const provider = createProvider(pInfo, projectDir);
+    const provider = await createProvider(pInfo, projectDir);
     const executor = createWeaverExecutor(projectDir);
 
     const filesModified: string[] = [];
@@ -253,10 +253,10 @@ export async function weaverAgentExecute(
 /**
  * Create an AgentProvider from pack-weaver's ProviderInfo.
  */
-function createProvider(
+async function createProvider(
   pInfo: { type: string; apiKey?: string; model?: string; maxTokens?: number },
   projectDir?: string,
-): AgentProvider {
+): Promise<AgentProvider> {
   const type = pInfo.type ?? 'auto';
 
   // Explicit Anthropic API
@@ -273,8 +273,21 @@ function createProvider(
     return createSessionProvider(pInfo.model, projectDir);
   }
 
-  // Auto mode: try Anthropic API key from env, then fall back to Claude CLI
+  // Auto mode: try platform login, then Anthropic API key, then Claude CLI
   if (type === 'auto') {
+    // Check platform login first (no local key needed)
+    // Uses env vars set by handleSession/handleAssistant, or reads credentials directly
+    if (process.env.FW_PLATFORM_TOKEN && process.env.FW_PLATFORM_URL) {
+      try {
+        const agentMod = await import('@synergenius/flow-weaver/agent');
+        if ('createPlatformProvider' in agentMod) {
+          const factory = (agentMod as Record<string, unknown>).createPlatformProvider as
+            (opts: { token: string; platformUrl: string }) => AgentProvider;
+          return factory({ token: process.env.FW_PLATFORM_TOKEN, platformUrl: process.env.FW_PLATFORM_URL });
+        }
+      } catch { /* platform provider not available in this fw version */ }
+    }
+
     if (process.env.ANTHROPIC_API_KEY) {
       return createAnthropicProvider({
         apiKey: process.env.ANTHROPIC_API_KEY,