@synergenius/flow-weaver-pack-weaver 0.9.59 → 0.9.77

package/src/node-types/orchestrator-load-state.ts

@@ -0,0 +1,66 @@
+import type { OrchestratorInput } from '../bot/profile-types.js';
+
+/**
+ * Loads the current swarm state for the orchestrator to make routing decisions.
+ *
+ * @flowWeaver nodeType
+ * @label Load Swarm State
+ * @input projectDir [order:0] - Project directory path
+ * @output state [order:0] - JSON OrchestratorInput snapshot
+ * @output onSuccess [order:-2] - Loaded successfully
+ * @output onFailure [order:-1] [hidden] - Load failed
+ */
+export async function orchestratorLoadState(
+  execute: boolean,
+  projectDir: string,
+): Promise<{ onSuccess: boolean; onFailure: boolean; state: string | null }> {
+  if (!execute) {
+    return { onSuccess: true, onFailure: false, state: '{"pendingTasks":[],"profiles":[],"instances":[],"budgetRemaining":{"tokens":0,"cost":0}}' };
+  }
+
+  try {
+    const { SwarmController } = await import('../bot/swarm-controller.js');
+    const controller = SwarmController.getInstance(projectDir);
+    const profileStore = controller.getProfileStore();
+    const instanceManager = controller.getInstanceManager();
+    const swarmStatus = controller.getStatus();
+
+    // Load profiles
+    const profiles = profileStore.list();
+
+    // Load instances
+    const instances = instanceManager.listAll();
+
+    // Calculate budget remaining from swarm state
+    const { workspace, session } = swarmStatus.budgets;
+    const remainingTokens: number[] = [];
+    const remainingCost: number[] = [];
+    if (session.limitTokens > 0) remainingTokens.push(session.limitTokens - session.usedTokens);
+    if (workspace.limitTokens > 0) remainingTokens.push(workspace.limitTokens - workspace.usedTokens);
+    if (session.limitCost > 0) remainingCost.push(session.limitCost - session.usedCost);
+    if (workspace.limitCost > 0) remainingCost.push(workspace.limitCost - workspace.usedCost);
+
+    const budgetRemaining = {
+      tokens: remainingTokens.length > 0 ? Math.min(...remainingTokens) : Infinity,
+      cost: remainingCost.length > 0 ? Math.min(...remainingCost) : Infinity,
+    };
+
+    // Note: pending tasks are not loaded here — the node only loads
+    // profiles, instances, and budget. Task loading requires TaskStore
+    // access which is internal to SwarmController's dispatch loop.
+    // The caller should provide tasks via the workflow or the dispatch loop
+    // builds the full OrchestratorInput itself.
+    const input: OrchestratorInput = {
+      pendingTasks: [],
+      profiles,
+      instances,
+      budgetRemaining,
+    };
+
+    return { onSuccess: true, onFailure: false, state: JSON.stringify(input) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`\x1b[31m→ Load swarm state failed: ${msg}\x1b[0m`);
+    return { onSuccess: false, onFailure: true, state: null };
+  }
+}

package/src/node-types/orchestrator-route.ts

@@ -0,0 +1,33 @@
+import { Orchestrator } from '../bot/orchestrator.js';
+import type { OrchestratorInput } from '../bot/profile-types.js';
+
+/**
+ * Routes pending tasks to appropriate bot profiles using the orchestrator brain.
+ *
+ * @flowWeaver nodeType
+ * @label Route Tasks
+ * @input state [order:0] - JSON OrchestratorInput
+ * @output decisions [order:0] - JSON OrchestratorOutput
+ * @output onSuccess [order:-2] - Routing complete
+ * @output onFailure [order:-1] [hidden] - Routing failed
+ */
+export async function orchestratorRoute(
+  execute: boolean,
+  state: string,
+): Promise<{ onSuccess: boolean; onFailure: boolean; decisions: string | null }> {
+  if (!execute) {
+    return { onSuccess: true, onFailure: false, decisions: '{"assignments":[],"scaleActions":[],"skippedTasks":[]}' };
+  }
+
+  try {
+    const input = JSON.parse(state) as OrchestratorInput;
+    const orchestrator = new Orchestrator();
+    const output = await orchestrator.route(input);
+
+    return { onSuccess: true, onFailure: false, decisions: JSON.stringify(output) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`\x1b[31m→ Route tasks failed: ${msg}\x1b[0m`);
+    return { onSuccess: false, onFailure: true, decisions: null };
+  }
+}

package/src/node-types/receive-task.ts

@@ -1,24 +1,8 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
 import type { WeaverEnv, WeaverContext } from '../bot/types.js';
-import { withFileLock } from '../bot/file-lock.js';
-
-interface QueuedTask {
-  id: string;
-  instruction: string;
-  mode?: 'create' | 'modify' | 'read' | 'batch';
-  targets?: string[];
-  options?: Record<string, unknown>;
-  priority: number;
-  addedAt: number;
-  status: string;
-}
 
 /**
- * Receives a task from CLI args, MCP tool call, or the task queue.
- * Parses the instruction into a structured BotTask. Creates the
- * WeaverContext that threads through the bot pipeline.
+ * Receives a pre-supplied task and creates the WeaverContext that
+ * threads through the bot pipeline.
  *
  * @flowWeaver nodeType
  * @label Receive Task
@@ -42,7 +26,6 @@ export async function weaverReceiveTask(
     return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
   }
 
-  // If taskJson is pre-supplied, use it directly
   if (taskJson) {
     try {
       const parsed = JSON.parse(taskJson);
@@ -52,46 +35,9 @@ export async function weaverReceiveTask(
         context.hasTask = true;
         return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
       }
-    } catch { /* fall through to queue check */ }
+    } catch { /* invalid JSON — no task */ }
   }
 
-  // Check task queue (with file locking to prevent race conditions)
-  const queuePath = path.join(os.homedir(), '.weaver', 'task-queue.ndjson');
-  try {
-    const claimed = await withFileLock(queuePath, () => {
-      if (!fs.existsSync(queuePath)) return null;
-      const content = fs.readFileSync(queuePath, 'utf-8').trim();
-      if (!content) return null;
-
-      const tasks: QueuedTask[] = content.split('\n').filter(Boolean).map(l => JSON.parse(l));
-      const pending = tasks
-        .filter(t => t.status === 'pending')
-        .sort((a, b) => b.priority - a.priority || a.addedAt - b.addedAt);
-
-      if (pending.length === 0) return null;
-
-      const task = pending[0]!;
-      // Atomically mark as running inside the lock
-      const updated = tasks.map(t => t.id === task.id ? { ...t, status: 'running' } : t);
-      fs.writeFileSync(queuePath, updated.map(t => JSON.stringify(t)).join('\n') + '\n', 'utf-8');
-      return task;
-    });
-
-    if (claimed) {
-      const botTask = {
-        instruction: claimed.instruction,
-        mode: claimed.mode ?? 'create',
-        targets: claimed.targets,
-        options: claimed.options,
-        queueId: claimed.id,
-      };
-      console.log(`\x1b[36m→ Task from queue [${claimed.id}]: ${claimed.instruction.slice(0, 80)}\x1b[0m`);
-      context.taskJson = JSON.stringify(botTask);
-      context.hasTask = true;
-      return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
-    }
-  } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[receive-task] queue error:', err); }
-
   console.log('\x1b[33m→ No task found\x1b[0m');
   return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
 }

package/src/ui/bot-activity.tsx

@@ -181,7 +181,7 @@ function BotActivity({ packName, botId }: { packName: string; botId: string }) {
   const fetchAll = useCallback(async () => {
     const [hist, q, ins, st] = await Promise.allSettled([
       callTool('fw_weaver_history', { limit: 15 }),
-      callTool('fw_weaver_queue', { action: 'list' }),
+      callTool('fw_weaver_task_list', { status: 'pending' }),
       callTool('fw_weaver_insights'),
       callTool('fw_weaver_status'),
     ]);
@@ -212,7 +212,7 @@ function BotActivity({ packName, botId }: { packName: string; botId: string }) {
   }, [botId]);
 
   const handleRemoveQueueItem = useCallback(async (id: string) => {
-    await callTool('fw_weaver_queue', { action: 'remove', id });
+    await callTool('fw_weaver_task_cancel', { id });
     setQueue((prev) => prev.filter((q) => q.id !== id));
   }, []);
 

package/src/ui/bot-constants.ts

@@ -0,0 +1,192 @@
+/**
+ * Shared constants for bot panel components: icon catalog, colors, helpers.
+ */
+
+/* ── Categorised icon catalog ──────────────────────────────────────── */
+
+export const ICON_CATALOG: { category: string; icons: string[] }[] = [
+  {
+    category: 'Actions',
+    icons: [
+      'playArrow',
+      'stop',
+      'pause',
+      'restart',
+      'send',
+      'check',
+      'edit',
+      'copy',
+      'add',
+      'reset',
+      'resume',
+    ],
+  },
+  {
+    category: 'AI & Science',
+    icons: ['smartToy', 'psychology', 'autoAwesome', 'modelTraining', 'biotech', 'science', 'ai'],
+  },
+  {
+    category: 'Data & Storage',
+    icons: ['database', 'dataObject', 'dataArray', 'tableChart', 'token', 'dns', 'cloudStorage'],
+  },
+  {
+    category: 'Logic & Flow',
+    icons: [
+      'altRoute',
+      'callSplit',
+      'callMerge',
+      'rule',
+      'filterAlt',
+      'sort',
+      'loop',
+      'repeat',
+      'compareArrows',
+      'swapHoriz',
+      'syncAlt',
+      'changeCircle',
+      'allInclusive',
+    ],
+  },
+  {
+    category: 'Cloud & Network',
+    icons: [
+      'cloudSync',
+      'cloudUpload',
+      'cloudDownload',
+      'cloudDone',
+      'api',
+      'webhook',
+      'public',
+      'router',
+    ],
+  },
+  {
+    category: 'Communication',
+    icons: ['email', 'chat', 'forum', 'notifications', 'campaign', 'rssFeed', 'sms'],
+  },
+  {
+    category: 'Security',
+    icons: [
+      'key',
+      'shield',
+      'security',
+      'vpnKey',
+      'adminPanel',
+      'policy',
+      'verified',
+      'lockClosed',
+      'lockOpened',
+    ],
+  },
+  {
+    category: 'Time',
+    icons: [
+      'timer',
+      'alarm',
+      'hourglassEmpty',
+      'pendingActions',
+      'update',
+      'watchLater',
+      'scheduled',
+    ],
+  },
+  {
+    category: 'Tasks & Workflow',
+    icons: [
+      'task',
+      'taskAlt',
+      'checklist',
+      'assignment',
+      'publish',
+      'build',
+      'construction',
+      'engineering',
+    ],
+  },
+  {
+    category: 'Analytics',
+    icons: [
+      'analytics',
+      'insights',
+      'barChart',
+      'pieChart',
+      'trendingUp',
+      'showChart',
+      'leaderboard',
+      'monitoring',
+    ],
+  },
+  {
+    category: 'Flow Nodes',
+    icons: [
+      'schema',
+      'hub',
+      'deviceHub',
+      'source',
+      'trigger',
+      'pulse',
+      'step',
+      'event',
+      'outlinedFlow',
+    ],
+  },
+  {
+    category: 'Files & Documents',
+    icons: [
+      'file',
+      'filePresent',
+      'fileCopy',
+      'textSnippet',
+      'attachFile',
+      'uploadFile',
+      'save',
+      'upload',
+      'download',
+    ],
+  },
+  {
+    category: 'General',
+    icons: [
+      'rocketLaunch',
+      'code',
+      'terminal',
+      'logs',
+      'info',
+      'help',
+      'list',
+      'category',
+      'hash',
+      'calendar',
+      'history',
+      'integration',
+      'layers',
+      'link',
+      'search',
+      'outlinedSettings',
+      'outlinedBug',
+      'collaboration',
+      'person',
+      'people',
+      'backup',
+      'healthAndSafety',
+    ],
+  },
+];
+
+export const BOT_COLORS = [
+  { label: 'Blue', token: 'color-node-blue-icon' },
+  { label: 'Purple', token: 'color-node-purple-icon' },
+  { label: 'Cyan', token: 'color-node-cyan-icon' },
+  { label: 'Orange', token: 'color-node-orange-icon' },
+  { label: 'Pink', token: 'color-node-pink-icon' },
+  { label: 'Green', token: 'color-node-green-icon' },
+  { label: 'Brand', token: 'color-brand-main' },
+  { label: 'Accent', token: 'color-brand-alt' },
+  { label: 'Positive', token: 'color-status-positive' },
+  { label: 'Info', token: 'color-status-info' },
+];
+
+/** Convert camelCase icon name to searchable words: "cloudSync" -> "cloud sync" */
+export function iconToWords(name: string): string {
+  return name.replace(/([A-Z])/g, ' $1').toLowerCase();
+}