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

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/bot/steering.ts

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as os from 'node:os';
 import { withFileLock } from './file-lock.js';
+import { resolveWeaverDir } from './paths.js';
 
 export interface SteeringCommand {
   command: 'pause' | 'resume' | 'cancel' | 'redirect' | 'queue';
@@ -13,7 +13,7 @@ export class SteeringController {
   private controlPath: string;
 
   constructor(controlDir?: string) {
-    const dir = controlDir ?? process.env.WEAVER_STEERING_DIR ?? path.join(os.homedir(), '.weaver');
+    const dir = controlDir ?? resolveWeaverDir();
     this.controlPath = path.join(dir, 'control.json');
   }
 

package/src/bot/task-queue.ts

@@ -1,9 +1,9 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as os from 'node:os';
 import * as crypto from 'node:crypto';
 import { withFileLock } from './file-lock.js';
 import { parseNdjson } from './safe-json.js';
+import { resolveWeaverDir } from './paths.js';
 
 export interface QueuedTask {
   id: string;
@@ -28,25 +28,11 @@ const MAX_PENDING = 200;
 /** Don't re-queue tasks completed within this window (ms). */
 const CYCLE_DEDUP_WINDOW = 3600_000; // 1 hour
 
-/**
- * Hash a project directory path into a short filesystem-safe string.
- * Used for per-project queue isolation.
- */
-function hashDir(dir: string): string {
-  return crypto.createHash('sha256').update(dir).digest('hex').slice(0, 8);
-}
-
 export class TaskQueue {
   readonly filePath: string;
 
   constructor(dir?: string) {
-    // Priority: explicit dir > env var > project-scoped > global fallback
-    const projectDir = process.env.WEAVER_PROJECT_DIR;
-    const base = dir
-      ?? process.env.WEAVER_QUEUE_DIR
-      ?? (projectDir
-        ? path.join(os.homedir(), '.weaver', 'projects', hashDir(projectDir))
-        : path.join(os.homedir(), '.weaver'));
+    const base = dir ?? resolveWeaverDir();
     this.filePath = path.join(base, 'task-queue.ndjson');
   }
 

package/src/bot/terminal-renderer.ts

@@ -7,18 +7,8 @@
  */
 
 import type { StreamEvent, ToolEvent } from '@synergenius/flow-weaver/agent';
-
-// ANSI helpers
-const isTTY = process.stderr.isTTY ?? false;
-const c = {
-  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
-  red: (s: string) => `\x1b[31m${s}\x1b[0m`,
-  yellow: (s: string) => `\x1b[33m${s}\x1b[0m`,
-  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
-  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
-  bold: (s: string) => `\x1b[1m${s}\x1b[0m`,
-  redBold: (s: string) => `\x1b[1;31m${s}\x1b[0m`,
-};
+import { c } from './ansi.js';
+import { VERBOSE_TOOL_NAMES } from './tool-registry.js';
 
 export interface RendererOptions {
   verbose?: boolean;
@@ -180,9 +170,16 @@ export class TerminalRenderer {
 
     if (event.type === 'tool_call_result') {
       const elapsed = Date.now() - this.lastToolStartTime;
-      const result = (event.result ?? '').replace(/\n/g, ' ').slice(0, 120);
+      const raw = event.result ?? '';
       const icon = event.isError ? c.red('✗') : c.dim('→');
-      this.out(`  ${icon} ${result} ${c.dim(formatElapsed(elapsed))}\n`);
+      // Show full multiline output for verbose tools; one-line summary for others
+      const isVerboseTool = VERBOSE_TOOL_NAMES.has(event.name);
+      if (isVerboseTool && raw.includes('\n') && raw.length > 120) {
+        this.out(`  ${icon} ${c.dim(formatElapsed(elapsed))}\n${raw}\n`);
+      } else {
+        const result = raw.replace(/\n/g, ' ').slice(0, 200);
+        this.out(`  ${icon} ${result} ${c.dim(formatElapsed(elapsed))}\n`);
+      }
     }
   }
 

package/src/bot/tool-registry.ts

@@ -0,0 +1,477 @@
+/**
+ * Unified tool registry — single source of truth for all weaver tool definitions.
+ * Merges assistant-tools.ts ASSISTANT_TOOLS and weaver-tools.ts WEAVER_TOOLS
+ * into one registry with metadata (category, contexts, verboseOutput).
+ */
+
+import type { ToolDefinition } from '@synergenius/flow-weaver/agent';
+
+export interface WeaverTool extends ToolDefinition {
+  verboseOutput?: boolean;
+  category: 'bot-management' | 'queue' | 'flow-weaver' | 'project' | 'knowledge' | 'conversation' | 'ci' | 'web';
+  contexts: Array<'bot' | 'assistant'>;
+}
+
+export const ALL_TOOLS: WeaverTool[] = [
+  // ── Bot management (assistant only) ──────────────────────────────
+  {
+    name: 'bot_spawn',
+    description: 'Start a new bot session. Returns the bot name and status.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Unique name for this bot (e.g. "fix-templates")' },
+        project_dir: { type: 'string', description: 'Project directory for the bot to work in' },
+        parallel: { type: 'number', description: 'Number of parallel tasks (1-5, default 1)' },
+        deadline: { type: 'string', description: 'Stop time in HH:MM format (optional)' },
+        branch: { type: 'string', description: 'Git branch for commits (keeps main clean, good for overnight runs)' },
+      },
+      required: ['name'],
+    },
+    category: 'bot-management',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'bot_list',
+    description: 'List all bot sessions with their status, task counts, and cost.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'bot-management',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'bot_status',
+    description: 'Get detailed status of a specific bot including queue and recent activity.',
+    inputSchema: {
+      type: 'object',
+      properties: { name: { type: 'string', description: 'Bot name' } },
+      required: ['name'],
+    },
+    category: 'bot-management',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'bot_pause',
+    description: 'Pause a running bot. It will finish its current task then wait.',
+    inputSchema: {
+      type: 'object',
+      properties: { name: { type: 'string', description: 'Bot name' } },
+      required: ['name'],
+    },
+    category: 'bot-management',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'bot_resume',
+    description: 'Resume a paused bot.',
+    inputSchema: {
+      type: 'object',
+      properties: { name: { type: 'string', description: 'Bot name' } },
+      required: ['name'],
+    },
+    category: 'bot-management',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'bot_stop',
+    description: 'Gracefully stop a bot (finishes current task, then exits).',
+    inputSchema: {
+      type: 'object',
+      properties: { name: { type: 'string', description: 'Bot name' } },
+      required: ['name'],
+    },
+    category: 'bot-management',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'bot_logs',
+    description: 'Get recent output log from a bot.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Bot name' },
+        lines: { type: 'number', description: 'Number of lines to return (default 30)' },
+      },
+      required: ['name'],
+    },
+    verboseOutput: true,
+    category: 'bot-management',
+    contexts: ['assistant'],
+  },
+
+  // ── Queue management (assistant only) ────────────────────────────
+  {
+    name: 'queue_add',
+    description: 'Add a task to a bot\'s queue.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        bot: { type: 'string', description: 'Bot name' },
+        instruction: { type: 'string', description: 'Task instruction' },
+        targets: { type: 'array', items: { type: 'string' }, description: 'Target files (optional)' },
+      },
+      required: ['bot', 'instruction'],
+    },
+    category: 'queue',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'queue_add_batch',
+    description: 'Add multiple tasks to a bot\'s queue at once.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        bot: { type: 'string', description: 'Bot name' },
+        tasks: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              instruction: { type: 'string' },
+              targets: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['instruction'],
+          },
+          description: 'Array of tasks to add',
+        },
+      },
+      required: ['bot', 'tasks'],
+    },
+    category: 'queue',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'queue_list',
+    description: 'List all tasks in a bot\'s queue with their status.',
+    inputSchema: {
+      type: 'object',
+      properties: { bot: { type: 'string', description: 'Bot name' } },
+      required: ['bot'],
+    },
+    category: 'queue',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'queue_retry',
+    description: 'Reset all failed tasks in a bot\'s queue to pending.',
+    inputSchema: {
+      type: 'object',
+      properties: { bot: { type: 'string', description: 'Bot name' } },
+      required: ['bot'],
+    },
+    category: 'queue',
+    contexts: ['assistant'],
+  },
+
+  // ── Flow-weaver tools ────────────────────────────────────────────
+  {
+    name: 'validate',
+    description: 'Run flow-weaver validate on a workflow file. Returns JSON with errors and warnings. Use this FIRST to discover issues, and AFTER patching to confirm fixes.',
+    inputSchema: { type: 'object', properties: { file: { type: 'string', description: 'Path to the workflow file to validate' } }, required: ['file'] },
+    category: 'flow-weaver',
+    contexts: ['bot'],
+  },
+  {
+    name: 'fw_validate',
+    description: 'Validate a workflow or directory of workflows. Returns errors and warnings.',
+    inputSchema: {
+      type: 'object',
+      properties: { path: { type: 'string', description: 'File or directory path' } },
+      required: ['path'],
+    },
+    category: 'flow-weaver',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'fw_diagram',
+    description: 'Generate a text diagram of a workflow.',
+    inputSchema: {
+      type: 'object',
+      properties: { file: { type: 'string', description: 'Workflow file path' } },
+      required: ['file'],
+    },
+    verboseOutput: true,
+    category: 'flow-weaver',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'fw_describe',
+    description: 'Get a natural language description of a workflow.',
+    inputSchema: {
+      type: 'object',
+      properties: { file: { type: 'string', description: 'Workflow file path' } },
+      required: ['file'],
+    },
+    verboseOutput: true,
+    category: 'flow-weaver',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'fw_docs',
+    description: 'Look up Flow Weaver documentation by topic. Topics: concepts, jsdoc-grammar, advanced-annotations, built-in-nodes, scaffold, node-conversion, patterns, error-codes, debugging, export-interface.',
+    inputSchema: {
+      type: 'object',
+      properties: { topic: { type: 'string', description: 'Documentation topic slug' } },
+      required: ['topic'],
+    },
+    verboseOutput: true,
+    category: 'flow-weaver',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'fw_diagram_mermaid',
+    description: 'Generate a Mermaid diagram of a workflow (can be rendered in any Mermaid viewer).',
+    inputSchema: {
+      type: 'object',
+      properties: { file: { type: 'string', description: 'Workflow file path' } },
+      required: ['file'],
+    },
+    verboseOutput: true,
+    category: 'flow-weaver',
+    contexts: ['assistant'],
+  },
+
+  // ── Project tools (shared or context-specific) ───────────────────
+  {
+    name: 'read_file',
+    description: 'Read a file and return its contents.',
+    inputSchema: {
+      type: 'object',
+      properties: { file: { type: 'string', description: 'File path' } },
+      required: ['file'],
+    },
+    category: 'project',
+    contexts: ['bot', 'assistant'],
+  },
+  {
+    name: 'list_files',
+    description: 'List files in a directory, optionally filtered by regex pattern.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Directory to list' },
+        pattern: { type: 'string', description: 'Optional regex filter pattern' },
+      },
+      required: ['directory'],
+    },
+    category: 'project',
+    contexts: ['bot', 'assistant'],
+  },
+  {
+    name: 'run_shell',
+    description: 'Run a shell command (read-only operations recommended). Blocked: rm -rf, git push, sudo.',
+    inputSchema: {
+      type: 'object',
+      properties: { command: { type: 'string', description: 'Shell command to execute' } },
+      required: ['command'],
+    },
+    category: 'project',
+    contexts: ['bot', 'assistant'],
+  },
+  {
+    name: 'patch_file',
+    description: 'Apply surgical find-and-replace patches to a file. Each patch must have exact "find" and "replace" strings. Preferred over write_file for modifications.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'Path to the file to patch' },
+        patches: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              find: { type: 'string', description: 'Exact string to find' },
+              replace: { type: 'string', description: 'String to replace with' },
+            },
+            required: ['find', 'replace'],
+          },
+          description: 'Array of find/replace patches',
+        },
+      },
+      required: ['file', 'patches'],
+    },
+    category: 'project',
+    contexts: ['bot'],
+  },
+  {
+    name: 'write_file',
+    description: 'Write content to a file (creates or overwrites). Use patch_file instead for modifications to existing files.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'Path to the file to write' },
+        content: { type: 'string', description: 'Complete file content' },
+      },
+      required: ['file', 'content'],
+    },
+    category: 'project',
+    contexts: ['bot'],
+  },
+  {
+    name: 'tsc_check',
+    description: 'Run TypeScript compiler check (no emit). Returns errors if any.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    verboseOutput: true,
+    category: 'project',
+    contexts: ['bot'],
+  },
+  {
+    name: 'run_tests',
+    description: 'Run project tests. Returns structured results with pass/fail counts.',
+    inputSchema: { type: 'object', properties: { pattern: { type: 'string', description: 'Test file pattern (optional)' } }, required: [] },
+    verboseOutput: true,
+    category: 'project',
+    contexts: ['bot'],
+  },
+  {
+    name: 'project_list',
+    description: 'List known project directories that have been used with weaver.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'project',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'project_context',
+    description: 'Read package.json and .weaver-plan.md from a project directory to understand its context.',
+    inputSchema: {
+      type: 'object',
+      properties: { directory: { type: 'string', description: 'Absolute path to project directory' } },
+      required: ['directory'],
+    },
+    category: 'project',
+    contexts: ['assistant'],
+  },
+
+  // ── Knowledge tools ──────────────────────────────────────────────
+  {
+    name: 'knowledge_list',
+    description: 'List all stored knowledge entries for the current project.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'knowledge',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'knowledge_search',
+    description: 'Search stored knowledge by keyword.',
+    inputSchema: {
+      type: 'object',
+      properties: { query: { type: 'string', description: 'Search query' } },
+      required: ['query'],
+    },
+    category: 'knowledge',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'learn',
+    description: 'Store a fact for future tasks. Key should be descriptive (e.g. "file:src/agent.ts:port-issue").',
+    inputSchema: { type: 'object', properties: { key: { type: 'string' }, value: { type: 'string' } }, required: ['key', 'value'] },
+    category: 'knowledge',
+    contexts: ['bot'],
+  },
+  {
+    name: 'recall',
+    description: 'Look up stored knowledge. Returns matching entries.',
+    inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },
+    category: 'knowledge',
+    contexts: ['bot'],
+  },
+
+  // ── Conversation management (assistant only) ─────────────────────
+  {
+    name: 'conversation_list',
+    description: 'List saved assistant conversations with message counts and timestamps.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'conversation',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'conversation_delete',
+    description: 'Delete a saved conversation by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Conversation ID to delete' } },
+      required: ['id'],
+    },
+    category: 'conversation',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'conversation_summary',
+    description: 'Get a summary of the current conversation (message count, tokens, bots spawned).',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'conversation',
+    contexts: ['assistant'],
+  },
+
+  // ── CI/CD (assistant only) ───────────────────────────────────────
+  {
+    name: 'github_status',
+    description: 'Check GitHub Actions status for a branch or PR. Requires gh CLI installed.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        branch: { type: 'string', description: 'Branch name (optional, defaults to current)' },
+        pr: { type: 'number', description: 'PR number (optional, checks PR status instead of branch)' },
+      },
+      required: [],
+    },
+    category: 'ci',
+    contexts: ['assistant'],
+  },
+
+  // ── Web access (shared) ──────────────────────────────────────────
+  {
+    name: 'web_fetch',
+    description: 'Fetch HTTP content from a URL. Returns text body (max 10KB).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to fetch' },
+        method: { type: 'string', description: 'HTTP method (default GET)', enum: ['GET', 'POST'] },
+      },
+      required: ['url'],
+    },
+    category: 'web',
+    contexts: ['bot', 'assistant'],
+  },
+
+  // ── Bot-only interactive ─────────────────────────────────────────
+  {
+    name: 'ask_user',
+    description: 'Ask the user a question and wait for response. Use when you need a decision.',
+    inputSchema: { type: 'object', properties: { question: { type: 'string' } }, required: ['question'] },
+    category: 'project',
+    contexts: ['bot'],
+  },
+];
+
+// ── Derived exports ──────────────────────────────────────────────────
+
+export const BOT_TOOLS: ToolDefinition[] = ALL_TOOLS.filter(t => t.contexts.includes('bot'));
+export const ASSISTANT_TOOLS: ToolDefinition[] = ALL_TOOLS.filter(t => t.contexts.includes('assistant'));
+export const VERBOSE_TOOL_NAMES = new Set(ALL_TOOLS.filter(t => t.verboseOutput).map(t => t.name));
+
+/**
+ * Generate a prompt section grouping assistant tools by category.
+ */
+export function generateToolPromptSection(): string {
+  const groups = new Map<string, WeaverTool[]>();
+  for (const t of ALL_TOOLS.filter(t => t.contexts.includes('assistant'))) {
+    const list = groups.get(t.category) ?? [];
+    list.push(t);
+    groups.set(t.category, list);
+  }
+  const lines: string[] = [];
+  for (const [cat, tools] of groups) {
+    lines.push(`${cat}:`);
+    for (const t of tools) lines.push(`  - ${t.name}: ${t.description}`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Generate a comma-separated list of tools that produce verbose output.
+ */
+export function generateVerboseToolList(): string {
+  return [...VERBOSE_TOOL_NAMES].join(', ');
+}