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

package/src/bot/slash-commands.ts

@@ -0,0 +1,114 @@
+import type { ToolExecutor } from '@synergenius/flow-weaver/agent';
+import { c } from './ansi.js';
+
+export interface SlashContext {
+  executor: ToolExecutor;
+  out: (s: string) => void;
+  projectDir: string;
+  conversationId?: string;
+  onClear?: () => void;
+  onExit?: () => void;
+  onNew?: () => void;
+  onVerbose?: () => void;
+}
+
+export interface SlashCommand {
+  name: string;
+  description: string;
+  handler: (ctx: SlashContext, args: string) => Promise<void>;
+}
+
+export const SLASH_COMMANDS: SlashCommand[] = [
+  {
+    name: '/help',
+    description: 'Show available commands',
+    handler: async (ctx) => {
+      ctx.out('\n  Available commands:\n');
+      for (const cmd of SLASH_COMMANDS) {
+        ctx.out(`    ${c.cyan(cmd.name.padEnd(12))} ${c.dim(cmd.description)}\n`);
+      }
+      ctx.out('\n');
+    },
+  },
+  {
+    name: '/status',
+    description: 'Show bots, queue, and conversation summary',
+    handler: async (ctx) => {
+      const bots = await ctx.executor('bot_list', {});
+      const summary = await ctx.executor('conversation_summary', {});
+      ctx.out(`\n  ${bots.result}\n  ${summary.result}\n\n`);
+    },
+  },
+  {
+    name: '/bots',
+    description: 'List running bots',
+    handler: async (ctx) => {
+      const result = await ctx.executor('bot_list', {});
+      ctx.out(`\n  ${result.result}\n\n`);
+    },
+  },
+  {
+    name: '/clear',
+    description: 'Clear screen and start new conversation',
+    handler: async (ctx) => {
+      process.stderr.write('\x1b[2J\x1b[H');
+      ctx.onClear?.();
+    },
+  },
+  {
+    name: '/exit',
+    description: 'Exit the assistant',
+    handler: async (ctx) => {
+      ctx.onExit?.();
+    },
+  },
+  {
+    name: '/new',
+    description: 'Start a new conversation',
+    handler: async (ctx) => {
+      ctx.onNew?.();
+      ctx.out(`\n  ${c.dim('New conversation started.')}\n\n`);
+    },
+  },
+  {
+    name: '/list',
+    description: 'List saved conversations',
+    handler: async (ctx) => {
+      const result = await ctx.executor('conversation_list', {});
+      ctx.out(`\n  ${result.result}\n\n`);
+    },
+  },
+  {
+    name: '/verbose',
+    description: 'Toggle verbose mode (show AI thinking)',
+    handler: async (ctx) => {
+      ctx.onVerbose?.();
+    },
+  },
+  {
+    name: '/history',
+    description: 'Show conversation history summary',
+    handler: async (ctx) => {
+      const result = await ctx.executor('conversation_summary', {});
+      ctx.out(`\n  ${result.result}\n\n`);
+    },
+  },
+];
+
+export function getSlashCompletions(partial: string): string[] {
+  if (!partial.startsWith('/')) return [];
+  return SLASH_COMMANDS
+    .filter(cmd => cmd.name.startsWith(partial))
+    .map(cmd => cmd.name);
+}
+
+export async function handleSlashCommand(
+  input: string,
+  ctx: SlashContext,
+): Promise<boolean> {
+  const [name, ...rest] = input.split(' ');
+  const cmd = SLASH_COMMANDS.find(c => c.name === name);
+  if (!cmd) return false;
+  await cmd.handler(ctx, rest.join(' '));
+  return true;
+}

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,