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

package/src/bot/assistant-core.ts

@@ -8,7 +8,8 @@
  * - API provider: tools collected and executed manually (tool_use_start/end events)
  */
 
-import * as readline from 'node:readline';
+import * as path from 'node:path';
+import * as os from 'node:os';
 import {
   runAgentLoop,
   type AgentProvider,
@@ -30,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 */
@@ -70,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;
@@ -83,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();
@@ -116,31 +152,53 @@ 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.')}\n\n`);
-
-  // Input source
-  const rl = opts.inputMessages
-    ? null
-    : readline.createInterface({ input: process.stdin, output: process.stderr, prompt: `${c.cyan('❯')} ` });
+  out(`  ${c.dim('Type your request. Ctrl+C to exit. /help for commands.')}\n\n`);
+
+  // Rich input with history, arrows, tab completion, slash commands
+  const { RichInput } = await import('./rich-input.js');
+  const { getSlashCompletions, handleSlashCommand } = await import('./slash-commands.js');
+  const { formatResponse } = await import('./response-formatter.js');
+
+  const richInput = opts.inputMessages ? null : new RichInput({
+    historyFile: path.join(os.homedir(), '.weaver', 'input-history.txt'),
+    prompt: `${c.cyan('❯')} `,
+    completionProvider: (partial) => {
+      if (partial.startsWith('/')) return getSlashCompletions(partial);
+      return [];
+    },
+  });
 
   const getNextInput = opts.inputMessages
     ? (() => {
         let i = 0;
         return (): Promise<string | null> => Promise.resolve(opts.inputMessages![i++] ?? null);
       })()
-    : (): Promise<string | null> => new Promise<string | null>((resolve) => {
-        rl!.prompt();
-        rl!.once('line', (line) => resolve(line.trim() || null));
-        rl!.once('close', () => resolve(null));
-      });
+    : (): Promise<string | null> => richInput!.getInput();
 
   const onStreamEvent = (event: StreamEvent) => {
     if (event.type === 'text_delta') {
@@ -169,14 +227,64 @@ export async function runAssistant(opts: AssistantOptions): Promise<void> {
     }
   };
 
+  // Slash command context
+  let shouldExit = false;
+  const slashCtx = {
+    executor,
+    out,
+    projectDir,
+    conversationId: conversation.id,
+    onClear: () => { history.length = 0; },
+    onExit: () => { shouldExit = true; },
+    onNew: () => { history.length = 0; conversation = store.create(projectDir); },
+    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 (true) {
+  while (!shouldExit) {
     const input = await getNextInput();
     if (input === null) break;
     if (!input.trim()) continue;
 
+    // Handle slash commands
+    if (input.startsWith('/')) {
+      const handled = await handleSlashCommand(input, slashCtx);
+      if (handled) continue;
+      // Unknown slash command — tell user
+      out(`  ${c.dim('Unknown command. Type /help for available commands.')}\n\n`);
+      continue;
+    }
+
     out('\n');
 
+    // Reset Ctrl+C counter after successful input
+    richInput?.resetCtrlC();
+
     // Add user message to history
     history.push({ role: 'user', content: input });
 
@@ -208,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');
@@ -234,7 +345,8 @@ export async function runAssistant(opts: AssistantOptions): Promise<void> {
     out('\n');
   }
 
-  rl?.close();
+  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/bot/response-formatter.ts

@@ -0,0 +1,42 @@
+import * as path from 'node:path';
+import { c } from './ansi.js';
+
+/**
+ * Highlight code blocks in streamed text.
+ * Detects ```lang ... ``` patterns and applies dim styling.
+ */
+export function highlightCodeBlocks(text: string): string {
+  return text.replace(/```(\w+)?\n([\s\S]*?)```/g, (_, lang, code) => {
+    const header = lang ? `  ${c.cyan(`[${lang}]`)}\n` : '';
+    return `${header}${c.dim(code)}`;
+  });
+}
+
+/**
+ * Make file paths clickable using OSC 8 terminal hyperlinks.
+ * Only active when terminal supports it.
+ */
+export function linkifyPaths(text: string, cwd: string): string {
+  if (!supportsHyperlinks()) return text;
+  return text.replace(/\b((?:src|tests|lib|dist)\/[\w/.-]+\.(?:ts|js|json|md))\b/g, (match) => {
+    const abs = path.resolve(cwd, match);
+    return `\x1b]8;;file://${abs}\x07${match}\x1b]8;;\x07`;
+  });
+}
+
+/**
+ * Format a full response — apply all formatting passes.
+ */
+export function formatResponse(text: string, cwd: string): string {
+  let result = text;
+  result = highlightCodeBlocks(result);
+  result = linkifyPaths(result, cwd);
+  return result;
+}
+
+function supportsHyperlinks(): boolean {
+  const term = process.env.TERM_PROGRAM ?? '';
+  // Known terminals that support OSC 8
+  return ['iTerm.app', 'WezTerm', 'vscode', 'Hyper'].includes(term)
+    || !!process.env.TERM_PROGRAM_VERSION; // Most modern terminals
+}

package/src/bot/rich-input.ts

@@ -0,0 +1,307 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as readline from 'node:readline';
+
+export interface RichInputOptions {
+  historyFile?: string;
+  prompt?: string;
+  completionProvider?: (partial: string) => string[];
+  maxHistorySize?: number;
+}
+
+export class RichInput {
+  private history: string[] = [];
+  private historyIndex = -1;
+  private currentLine = '';
+  private cursorPos = 0;
+  private multiLineBuffer: string[] = [];
+  private searchMode = false;
+  private searchQuery = '';
+  private ctrlCCount = 0;
+  private prompt: string;
+  private historyFile: string;
+  private completionProvider?: (partial: string) => string[];
+  private maxHistory: number;
+
+  constructor(opts: RichInputOptions = {}) {
+    this.prompt = opts.prompt ?? '❯ ';
+    this.historyFile = opts.historyFile ?? path.join(os.homedir(), '.weaver', 'input-history.txt');
+    this.completionProvider = opts.completionProvider;
+    this.maxHistory = opts.maxHistorySize ?? 500;
+    this.loadHistory();
+  }
+
+  async getInput(): Promise<string | null> {
+    // Non-TTY fallback
+    if (!process.stdin.isTTY) {
+      return this.getInputReadline();
+    }
+
+    return new Promise((resolve) => {
+      this.ctrlCCount = 0;
+      this.historyIndex = -1;
+      this.currentLine = '';
+      this.cursorPos = 0;
+      this.searchMode = false;
+
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+
+      const handler = (key: Buffer) => {
+        this.handleKey(key, (result) => {
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener('data', handler);
+          resolve(result);
+        });
+      };
+
+      process.stdin.on('data', handler);
+      this.renderPrompt();
+    });
+  }
+
+  resetCtrlC(): void {
+    this.ctrlCCount = 0;
+  }
+
+  private handleKey(key: Buffer, resolve: (value: string | null) => void): void {
+    const s = key.toString();
+
+    // Handle search mode separately
+    if (this.searchMode) {
+      this.handleSearchKey(s, resolve);
+      return;
+    }
+
+    if (s === '\r' || s === '\n') {
+      this.handleEnter(resolve);
+    } else if (s === '\x03') { // Ctrl+C
+      this.ctrlCCount++;
+      if (this.ctrlCCount >= 2 || this.currentLine === '') {
+        process.stderr.write('\n');
+        resolve(null);
+      } else {
+        this.currentLine = '';
+        this.cursorPos = 0;
+        process.stderr.write('\n');
+        this.renderPrompt();
+      }
+    } else if (s === '\x0c') { // Ctrl+L
+      process.stderr.write('\x1b[2J\x1b[H'); // clear screen + move to top
+      this.renderPrompt();
+    } else if (s === '\x12') { // Ctrl+R
+      this.searchMode = true;
+      this.searchQuery = '';
+      this.renderSearchPrompt();
+    } else if (s === '\x09') { // Tab
+      this.handleTab();
+    } else if (s === '\x1b[A') { // Arrow Up
+      this.historyUp();
+    } else if (s === '\x1b[B') { // Arrow Down
+      this.historyDown();
+    } else if (s === '\x1b[C') { // Arrow Right
+      if (this.cursorPos < this.currentLine.length) {
+        this.cursorPos++;
+        process.stderr.write('\x1b[C');
+      }
+    } else if (s === '\x1b[D') { // Arrow Left
+      if (this.cursorPos > 0) {
+        this.cursorPos--;
+        process.stderr.write('\x1b[D');
+      }
+    } else if (s === '\x7f' || s === '\b') { // Backspace
+      if (this.cursorPos > 0) {
+        this.currentLine = this.currentLine.slice(0, this.cursorPos - 1) + this.currentLine.slice(this.cursorPos);
+        this.cursorPos--;
+        this.renderPrompt();
+      }
+    } else if (s === '\x1b[3~') { // Delete
+      if (this.cursorPos < this.currentLine.length) {
+        this.currentLine = this.currentLine.slice(0, this.cursorPos) + this.currentLine.slice(this.cursorPos + 1);
+        this.renderPrompt();
+      }
+    } else if (s === '\x01') { // Ctrl+A (home)
+      this.cursorPos = 0;
+      this.renderPrompt();
+    } else if (s === '\x05') { // Ctrl+E (end)
+      this.cursorPos = this.currentLine.length;
+      this.renderPrompt();
+    } else if (s === '\x15') { // Ctrl+U (clear line)
+      this.currentLine = '';
+      this.cursorPos = 0;
+      this.renderPrompt();
+    } else if (s >= ' ' && s.length === 1) { // Printable
+      this.ctrlCCount = 0;
+      this.currentLine = this.currentLine.slice(0, this.cursorPos) + s + this.currentLine.slice(this.cursorPos);
+      this.cursorPos++;
+      this.renderPrompt();
+    } else if (s.length > 1 && !s.startsWith('\x1b')) {
+      // Pasted text (multiple chars at once)
+      this.ctrlCCount = 0;
+      this.currentLine = this.currentLine.slice(0, this.cursorPos) + s + this.currentLine.slice(this.cursorPos);
+      this.cursorPos += s.length;
+      this.renderPrompt();
+    }
+  }
+
+  private handleEnter(resolve: (value: string | null) => void): void {
+    const fullLine = this.multiLineBuffer.length > 0
+      ? [...this.multiLineBuffer, this.currentLine].join('\n')
+      : this.currentLine;
+
+    // Check for multi-line continuation
+    if (this.isIncomplete(fullLine)) {
+      this.multiLineBuffer.push(this.currentLine);
+      this.currentLine = '';
+      this.cursorPos = 0;
+      process.stderr.write('\n');
+      process.stderr.write('  ... ');
+      return;
+    }
+
+    process.stderr.write('\n');
+
+    const trimmed = fullLine.trim();
+    if (trimmed) {
+      this.addToHistory(trimmed);
+    }
+
+    this.multiLineBuffer = [];
+    this.currentLine = '';
+    this.cursorPos = 0;
+
+    resolve(trimmed || null);
+  }
+
+  private isIncomplete(text: string): boolean {
+    const backticks = (text.match(/```/g) || []).length;
+    if (backticks % 2 !== 0) return true;
+    if (text.endsWith('\\')) return true;
+    return false;
+  }
+
+  private historyUp(): void {
+    if (this.history.length === 0) return;
+    if (this.historyIndex < this.history.length - 1) {
+      this.historyIndex++;
+      this.currentLine = this.history[this.history.length - 1 - this.historyIndex];
+      this.cursorPos = this.currentLine.length;
+      this.renderPrompt();
+    }
+  }
+
+  private historyDown(): void {
+    if (this.historyIndex > 0) {
+      this.historyIndex--;
+      this.currentLine = this.history[this.history.length - 1 - this.historyIndex];
+      this.cursorPos = this.currentLine.length;
+      this.renderPrompt();
+    } else if (this.historyIndex === 0) {
+      this.historyIndex = -1;
+      this.currentLine = '';
+      this.cursorPos = 0;
+      this.renderPrompt();
+    }
+  }
+
+  private handleTab(): void {
+    if (!this.completionProvider) return;
+    const candidates = this.completionProvider(this.currentLine);
+    if (candidates.length === 0) return;
+    if (candidates.length === 1) {
+      this.currentLine = candidates[0];
+      this.cursorPos = this.currentLine.length;
+      this.renderPrompt();
+    } else {
+      // Show candidates below, then redraw prompt
+      process.stderr.write('\n  ' + candidates.join('  ') + '\n');
+      this.renderPrompt();
+    }
+  }
+
+  private handleSearchKey(s: string, resolve: (value: string | null) => void): void {
+    if (s === '\x1b' || s === '\x03') { // Esc or Ctrl+C — cancel search
+      this.searchMode = false;
+      this.renderPrompt();
+    } else if (s === '\r' || s === '\n') { // Enter — accept match
+      this.searchMode = false;
+      const match = this.searchHistory(this.searchQuery);
+      if (match) {
+        this.currentLine = match;
+        this.cursorPos = this.currentLine.length;
+      }
+      this.renderPrompt();
+    } else if (s === '\x7f' || s === '\b') { // Backspace
+      this.searchQuery = this.searchQuery.slice(0, -1);
+      this.renderSearchPrompt();
+    } else if (s >= ' ' && s.length === 1) {
+      this.searchQuery += s;
+      this.renderSearchPrompt();
+    }
+  }
+
+  private searchHistory(query: string): string | null {
+    if (!query) return null;
+    const lower = query.toLowerCase();
+    for (let i = this.history.length - 1; i >= 0; i--) {
+      if (this.history[i].toLowerCase().includes(lower)) return this.history[i];
+    }
+    return null;
+  }
+
+  private renderPrompt(): void {
+    process.stderr.write(`\r\x1b[K${this.prompt}${this.currentLine}`);
+    // Move cursor to correct position
+    const offset = this.currentLine.length - this.cursorPos;
+    if (offset > 0) process.stderr.write(`\x1b[${offset}D`);
+  }
+
+  private renderSearchPrompt(): void {
+    const match = this.searchHistory(this.searchQuery) ?? '';
+    process.stderr.write(`\r\x1b[K\x1b[2m(search): ${this.searchQuery}\x1b[0m  ${match}`);
+  }
+
+  private addToHistory(line: string): void {
+    // Don't add duplicates of the last entry
+    if (this.history.length > 0 && this.history[this.history.length - 1] === line) return;
+    this.history.push(line);
+    if (this.history.length > this.maxHistory) this.history.shift();
+    this.saveHistory();
+  }
+
+  private loadHistory(): void {
+    try {
+      if (fs.existsSync(this.historyFile)) {
+        this.history = fs.readFileSync(this.historyFile, 'utf-8')
+          .split('\n')
+          .filter(Boolean)
+          .slice(-this.maxHistory);
+      }
+    } catch { /* history not available */ }
+  }
+
+  private saveHistory(): void {
+    try {
+      const dir = path.dirname(this.historyFile);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(this.historyFile, this.history.join('\n') + '\n');
+    } catch { /* non-fatal */ }
+  }
+
+  private async getInputReadline(): Promise<string | null> {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr, prompt: this.prompt });
+    return new Promise<string | null>((resolve) => {
+      rl.prompt();
+      rl.once('line', (line) => { rl.close(); resolve(line.trim() || null); });
+      rl.once('close', () => resolve(null));
+    });
+  }
+
+  destroy(): void {
+    if (process.stdin.isTTY) {
+      try { process.stdin.setRawMode(false); } catch {}
+    }
+  }
+}