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

package/src/bot/error-classifier.ts

@@ -0,0 +1,90 @@
+/**
+ * Unified error classification — merges error-guide.ts and retry-utils.ts
+ * into a single source of truth for error handling.
+ */
+
+export interface ErrorClassification {
+  isTransient: boolean;
+  guidance: string | null;
+  category: 'auth' | 'network' | 'rate-limit' | 'timeout' | 'parse' | 'system' | 'unknown';
+}
+
+const PATTERNS: Array<{ pattern: RegExp; isTransient: boolean; guidance: string; category: ErrorClassification['category'] }> = [
+  { pattern: /ETIMEDOUT/i, isTransient: true, guidance: 'Network timeout. Check internet or increase timeout.', category: 'timeout' },
+  { pattern: /ECONNRESET/i, isTransient: true, guidance: 'Connection reset. Retry in a few seconds.', category: 'network' },
+  { pattern: /ECONNREFUSED/i, isTransient: true, guidance: 'Connection refused. Is the service running?', category: 'network' },
+  { pattern: /EPIPE|ENOTFOUND/i, isTransient: true, guidance: 'Network error.', category: 'network' },
+  { pattern: /401|authentication|invalid.*key/i, isTransient: false, guidance: 'Authentication failed. Check API key or run "weaver init".', category: 'auth' },
+  { pattern: /403|forbidden/i, isTransient: false, guidance: 'Access denied. API key may lack permissions.', category: 'auth' },
+  { pattern: /429|rate.?limit|too many requests/i, isTransient: true, guidance: 'Rate limited. Wait a few minutes or reduce --parallel.', category: 'rate-limit' },
+  { pattern: /502|bad gateway/i, isTransient: true, guidance: 'Server error (502). Will auto-retry.', category: 'network' },
+  { pattern: /503|service unavailable|overloaded/i, isTransient: true, guidance: 'Service overloaded. Will auto-retry.', category: 'network' },
+  { pattern: /504|gateway timeout/i, isTransient: true, guidance: 'Gateway timeout (504). Will auto-retry.', category: 'timeout' },
+  { pattern: /exit(?:ed with)? code 143/i, isTransient: true, guidance: 'Process killed (SIGTERM). Likely timeout or Ctrl+C.', category: 'timeout' },
+  { pattern: /exit code 137/i, isTransient: false, guidance: 'Process killed (OOM). System may be low on memory.', category: 'system' },
+  { pattern: /ENOMEM/i, isTransient: false, guidance: 'Out of memory.', category: 'system' },
+  { pattern: /ENOSPC/i, isTransient: false, guidance: 'Disk full.', category: 'system' },
+  { pattern: /lock.*retries|failed to acquire.*lock/i, isTransient: true, guidance: 'File lock contention. Another weaver process may be running.', category: 'system' },
+  { pattern: /not a workflow|No @flowWeaver/i, isTransient: false, guidance: 'Not a Flow Weaver workflow. Ensure @flowWeaver annotations exist.', category: 'parse' },
+  { pattern: /parse.*json|unexpected token/i, isTransient: false, guidance: 'JSON parse error. AI may have returned malformed output.', category: 'parse' },
+  { pattern: /Queue full/i, isTransient: false, guidance: 'Too many pending tasks (200 max). Process or clear first.', category: 'system' },
+];
+
+/**
+ * Classify an error into transient/permanent with guidance and category.
+ */
+export function classifyError(err: unknown): ErrorClassification {
+  const msg = err instanceof Error ? err.message : String(err);
+  // Also check Node.js error codes
+  const code = err instanceof Error && 'code' in err ? (err as NodeJS.ErrnoException).code : undefined;
+  const fullMsg = code ? `${msg} ${code}` : msg;
+
+  for (const p of PATTERNS) {
+    if (p.pattern.test(fullMsg)) {
+      return { isTransient: p.isTransient, guidance: p.guidance, category: p.category };
+    }
+  }
+  return { isTransient: false, guidance: null, category: 'unknown' };
+}
+
+/** Convenience: check if an error is transient (retriable). */
+export function isTransientError(err: unknown): boolean {
+  return classifyError(err).isTransient;
+}
+
+/** Convenience: get actionable guidance for an error message. */
+export function getErrorGuidance(msg: string): string | null {
+  return classifyError(new Error(msg)).guidance;
+}
+
+/**
+ * Run a function with exponential backoff retry on transient errors.
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options?: {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    multiplier?: number;
+    onRetry?: (attempt: number, delay: number, err: Error) => void;
+  },
+): Promise<T> {
+  const maxRetries = options?.maxRetries ?? 3;
+  const baseDelay = options?.baseDelayMs ?? 5_000;
+  const multiplier = options?.multiplier ?? 3;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err: unknown) {
+      const isLast = attempt >= maxRetries;
+      if (isLast || !isTransientError(err)) throw err;
+      const delay = baseDelay * Math.pow(multiplier, attempt);
+      options?.onRetry?.(attempt + 1, delay, err instanceof Error ? err : new Error(String(err)));
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+
+  // Unreachable, but TypeScript needs it
+  throw new Error('withRetry: exhausted retries');
+}

package/src/bot/error-guide.ts

@@ -1,34 +1,4 @@
 /**
- * Actionable error guidance — maps cryptic error messages
- * to human-readable explanations with fix suggestions.
+ * @deprecated Use error-classifier.ts instead. This file re-exports for backward compatibility.
  */
-
-const GUIDES: Array<{ pattern: RegExp; guidance: string }> = [
-  { pattern: /ETIMEDOUT/i, guidance: 'Network timeout. Check internet connection or increase timeout with --timeout.' },
-  { pattern: /ECONNRESET/i, guidance: 'Connection reset. The server closed the connection. Retry in a few seconds.' },
-  { pattern: /ECONNREFUSED/i, guidance: 'Connection refused. Is the service running? Check the provider URL.' },
-  { pattern: /401|authentication|invalid.*key/i, guidance: 'Authentication failed. Check ANTHROPIC_API_KEY or run "weaver init" to reconfigure.' },
-  { pattern: /403|forbidden/i, guidance: 'Access denied. Your API key may not have permission for this model.' },
-  { pattern: /429|rate.?limit|too many requests/i, guidance: 'Rate limited. Wait a few minutes or reduce --parallel.' },
-  { pattern: /502|bad gateway/i, guidance: 'Server error (502). The API is temporarily unavailable. Will auto-retry.' },
-  { pattern: /503|service unavailable|overloaded/i, guidance: 'Service overloaded. Will auto-retry with backoff.' },
-  { pattern: /exit code 143/i, guidance: 'Process was killed (SIGTERM). Likely our timeout or Ctrl+C.' },
-  { pattern: /exit code 137/i, guidance: 'Process was killed (OOM or SIGKILL). System may be low on memory.' },
-  { pattern: /ENOMEM/i, guidance: 'Out of memory. Close other applications or increase available RAM.' },
-  { pattern: /ENOSPC/i, guidance: 'Disk full. Free up disk space.' },
-  { pattern: /lock.*retries|failed to acquire.*lock/i, guidance: 'File lock contention. Another weaver process may be running. Check with "ps aux | grep weaver".' },
-  { pattern: /not a workflow|No @flowWeaver/i, guidance: 'File is not a Flow Weaver workflow. Ensure it has @flowWeaver annotations.' },
-  { pattern: /parse.*json|unexpected token/i, guidance: 'JSON parse error. The AI may have returned malformed output. Retry the task.' },
-  { pattern: /Queue full/i, guidance: 'Too many pending tasks (200 max). Process or clear existing tasks first.' },
-];
-
-/**
- * Get actionable guidance for an error message.
- * Returns null if no guidance is available.
- */
-export function getErrorGuidance(msg: string): string | null {
-  for (const { pattern, guidance } of GUIDES) {
-    if (pattern.test(msg)) return guidance;
-  }
-  return null;
-}
+export { getErrorGuidance } from './error-classifier.js';

package/src/bot/paths.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared path resolution — single source of truth for .weaver directory layout.
+ */
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as crypto from 'node:crypto';
+
+/**
+ * Hash a directory path into a short filesystem-safe string.
+ * Used for per-project isolation under ~/.weaver/projects/.
+ */
+export function hashDir(dir: string): string {
+  return crypto.createHash('sha256').update(dir).digest('hex').slice(0, 8);
+}
+
+/**
+ * Resolve the weaver working directory.
+ * Priority: explicit > WEAVER_QUEUE_DIR > WEAVER_STEERING_DIR > project-scoped > global fallback.
+ */
+export function resolveWeaverDir(explicit?: string): string {
+  return explicit
+    ?? process.env.WEAVER_QUEUE_DIR
+    ?? process.env.WEAVER_STEERING_DIR
+    ?? (process.env.WEAVER_PROJECT_DIR
+      ? path.join(os.homedir(), '.weaver', 'projects', hashDir(process.env.WEAVER_PROJECT_DIR))
+      : path.join(os.homedir(), '.weaver'));
+}

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/retry-utils.ts

@@ -1,76 +1,4 @@
 /**
- * Retry utilities for transient error handling with exponential backoff.
+ * @deprecated Use error-classifier.ts instead. This file re-exports for backward compatibility.
  */
-
-const TRANSIENT_STATUS_CODES = [429, 502, 503, 504];
-const TRANSIENT_ERROR_CODES = ['ETIMEDOUT', 'ECONNRESET', 'ECONNREFUSED', 'EPIPE', 'ENOTFOUND'];
-const TRANSIENT_MESSAGES = ['rate limit', 'too many requests', 'overloaded', 'bad gateway', 'service unavailable'];
-
-/**
- * Check if an error is transient (retriable) vs permanent.
- * Transient: network issues, rate limits, server errors.
- * Permanent: auth failures, parse errors, validation errors.
- */
-export function isTransientError(err: unknown): boolean {
-  const msg = err instanceof Error ? err.message : String(err);
-  const lower = msg.toLowerCase();
-
-  // Check for HTTP status codes in message
-  for (const code of TRANSIENT_STATUS_CODES) {
-    if (msg.includes(String(code))) return true;
-  }
-
-  // Check for Node.js error codes
-  if (err instanceof Error && 'code' in err) {
-    const code = (err as NodeJS.ErrnoException).code;
-    if (code && TRANSIENT_ERROR_CODES.includes(code)) return true;
-  }
-
-  // Also check message for error code strings (e.g. "ETIMEDOUT" in message)
-  for (const code of TRANSIENT_ERROR_CODES) {
-    if (msg.includes(code)) return true;
-  }
-
-  // Check for rate limit / overload messages
-  for (const phrase of TRANSIENT_MESSAGES) {
-    if (lower.includes(phrase)) return true;
-  }
-
-  // Check for exit code 143 (SIGTERM — likely our timeout killed the process)
-  if (msg.includes('exit code 143') || msg.includes('exited with code 143')) return true;
-
-  return false;
-}
-
-/**
- * Run a function with exponential backoff retry on transient errors.
- */
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  options?: {
-    maxRetries?: number;
-    baseDelayMs?: number;
-    multiplier?: number;
-    onRetry?: (attempt: number, delay: number, err: Error) => void;
-  },
-): Promise<T> {
-  const maxRetries = options?.maxRetries ?? 3;
-  const baseDelay = options?.baseDelayMs ?? 5_000;
-  const multiplier = options?.multiplier ?? 3;
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (err: unknown) {
-      const isLast = attempt >= maxRetries;
-      if (isLast || !isTransientError(err)) throw err;
-
-      const delay = baseDelay * Math.pow(multiplier, attempt);
-      options?.onRetry?.(attempt + 1, delay, err instanceof Error ? err : new Error(String(err)));
-      await new Promise((r) => setTimeout(r, delay));
-    }
-  }
-
-  // Unreachable, but TypeScript needs it
-  throw new Error('withRetry: exhausted retries');
-}
+export { isTransientError, withRetry } from './error-classifier.js';

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 {}
+    }
+  }
+}

package/src/bot/safety.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared safety constants and checks — single source of truth.
+ */
+
+export const BLOCKED_COMMANDS = ['rm -rf', 'git push', 'npm publish', 'sudo', 'curl|sh', 'wget|sh'];
+export const BLOCKED_URL_PATTERN = /localhost|127\.0\.0\.1|0\.0\.0\.0|10\.\d|172\.(1[6-9]|2\d|3[01])\.|192\.168\./i;
+export const MAX_READ_SIZE = 1_048_576;
+export const CHARS_PER_TOKEN = 4;
+
+export function isBlockedCommand(cmd: string): boolean {
+  return BLOCKED_COMMANDS.some(b => cmd.includes(b));
+}
+
+export function isBlockedUrl(url: string): boolean {
+  return BLOCKED_URL_PATTERN.test(url);
+}