@tyvm/knowhow 0.0.159 → 0.0.161

package/src/chat/renderer/FancyRenderer.ts

@@ -1,440 +0,0 @@
-/**
- * FancyRenderer - A visually rich terminal renderer using box-drawing characters and ANSI colors.
- *
- * Features:
- * - Colored agent messages with agent name badges
- * - Tool calls displayed in bordered boxes
- * - Tool results with syntax-aware truncation
- * - Timing displayed inline
- * - Cost/status line with spinner animation
- */
-
-import {
-  AgentRenderer,
-  LogEvent,
-  AgentStatusEvent,
-  ToolCallEvent,
-  ToolResultEvent,
-  AgentMessageEvent,
-  AgentDoneEvent,
-  RenderEvent,
-} from "./types";
-import { EventEmitter } from "events";
-
-// ANSI color/style codes
-const c = {
-  reset: "\x1b[0m",
-  bold: "\x1b[1m",
-  dim: "\x1b[2m",
-  italic: "\x1b[3m",
-  underline: "\x1b[4m",
-
-  black: "\x1b[30m",
-  red: "\x1b[31m",
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  blue: "\x1b[34m",
-  magenta: "\x1b[35m",
-  cyan: "\x1b[36m",
-  white: "\x1b[37m",
-  gray: "\x1b[90m",
-
-  bgBlack: "\x1b[40m",
-  bgRed: "\x1b[41m",
-  bgGreen: "\x1b[42m",
-  bgYellow: "\x1b[43m",
-  bgBlue: "\x1b[44m",
-  bgMagenta: "\x1b[45m",
-  bgCyan: "\x1b[46m",
-  bgWhite: "\x1b[47m",
-  bgGray: "\x1b[100m",
-
-  brightBlue: "\x1b[94m",
-  brightCyan: "\x1b[96m",
-  brightGreen: "\x1b[92m",
-  brightYellow: "\x1b[93m",
-  brightMagenta: "\x1b[95m",
-  brightWhite: "\x1b[97m",
-};
-
-// Box drawing characters
-const box = {
-  tl: "╭", tr: "╮",
-  bl: "╰", br: "╯",
-  h: "─", v: "│",
-  ml: "├", mr: "┤",
-  cross: "┼",
-};
-
-const toolBox = {
-  tl: "┌", tr: "┐",
-  bl: "└", br: "┘",
-  h: "─", v: "│",
-  ml: "├", mr: "┤",
-};
-
-// Terminal width helper
-function termWidth(): number {
-  return process.stdout.columns || 80;
-}
-
-function pad(str: string, len: number, char = " "): string {
-  while (str.length < len) str += char;
-  return str;
-}
-
-function truncate(str: string, maxLen: number): string {
-  if (str.length <= maxLen) return str;
-  return str.slice(0, maxLen - 3) + "...";
-}
-
-function stripAnsi(str: string): string {
-  return str.replace(/\x1b\[[0-9;]*m/g, "");
-}
-
-function visibleLength(str: string): string {
-  return stripAnsi(str);
-}
-
-/** Draw a horizontal rule with optional label */
-function hRule(label = "", color = c.gray, width = termWidth()): string {
-  if (!label) {
-    return color + box.h.repeat(width) + c.reset;
-  }
-  const labelStr = ` ${label} `;
-  const side = Math.floor((width - labelStr.length) / 2);
-  const left = box.h.repeat(Math.max(0, side));
-  const right = box.h.repeat(Math.max(0, width - side - labelStr.length));
-  return color + left + c.reset + c.bold + color + labelStr + c.reset + color + right + c.reset;
-}
-
-/** Draw a box around content lines */
-function drawBox(
-  lines: string[],
-  headerLabel: string,
-  headerColor: string,
-  width: number
-): string {
-  const innerWidth = width - 2;
-  const headerText = ` ${headerLabel} `;
-  const headerPad = Math.max(0, innerWidth - stripAnsi(headerText).length);
-  const topLine =
-    headerColor + toolBox.tl + toolBox.h +
-    c.bold + headerColor + headerText + c.reset +
-    headerColor + toolBox.h.repeat(headerPad) +
-    toolBox.tr + c.reset;
-
-  const contentLines = lines.map((line) => {
-    const visible = stripAnsi(line);
-    const padLen = Math.max(0, innerWidth - visible.length);
-    return headerColor + toolBox.v + c.reset + " " + line + " ".repeat(Math.max(0, padLen - 1)) + headerColor + toolBox.v + c.reset;
-  });
-
-  const bottomLine = headerColor + toolBox.bl + toolBox.h.repeat(innerWidth) + toolBox.br + c.reset;
-
-  return [topLine, ...contentLines, bottomLine].join("\n");
-}
-
-/** Format JSON for display, with line limit */
-function formatResult(result: any, maxLines = 20): string[] {
-  let str: string;
-  try {
-    str = typeof result === "string" ? result : JSON.stringify(result, null, 2);
-  } catch {
-    str = String(result);
-  }
-
-  const lines = str.split("\n");
-  if (lines.length <= maxLines) return lines;
-
-  const head = lines.slice(0, Math.floor(maxLines * 0.7));
-  const tail = lines.slice(lines.length - Math.floor(maxLines * 0.2));
-  const omitted = lines.length - head.length - tail.length;
-  return [
-    ...head,
-    c.dim + `  ... (${omitted} lines omitted) ...` + c.reset,
-    ...tail,
-  ];
-}
-
-/** Colorize JSON string with basic syntax highlighting */
-function colorizeJson(lines: string[]): string[] {
-  return lines.map((line) => {
-    // Already has ansi (dim omitted line)
-    if (line.includes("\x1b[")) return line;
-
-    return line
-      // Keys
-      .replace(/"([^"]+)":/g, `${c.cyan}"$1"${c.reset}:`)
-      // String values
-      .replace(/: "([^"]*)"/g, `: ${c.brightGreen}"$1"${c.reset}`)
-      // Numbers
-      .replace(/: (-?\d+\.?\d*)/g, `: ${c.brightYellow}$1${c.reset}`)
-      // Booleans
-      .replace(/: (true|false)/g, `: ${c.brightMagenta}$1${c.reset}`)
-      // Null
-      .replace(/: null/g, `: ${c.dim}null${c.reset}`);
-  });
-}
-
-/** Agent name → deterministic color */
-const agentColors = [c.brightCyan, c.brightMagenta, c.brightGreen, c.brightYellow, c.brightBlue];
-const agentColorMap = new Map<string, string>();
-let agentColorIdx = 0;
-function agentColor(name: string): string {
-  if (!agentColorMap.has(name)) {
-    agentColorMap.set(name, agentColors[agentColorIdx++ % agentColors.length]);
-  }
-  return agentColorMap.get(name)!;
-}
-
-/** Keep track of tool call start times */
-const toolTimers = new Map<string, number>();
-
-export class FancyRenderer implements AgentRenderer {
-  private activeTaskId: string | undefined;
-  private emitter = new EventEmitter();
-  private paused = false;
-  private bufferedEvents: RenderEvent[] = [];
-
-  setActiveTaskId(taskId: string | undefined): void {
-    this.activeTaskId = taskId;
-  }
-
-  getActiveTaskId(): string | undefined {
-    return this.activeTaskId;
-  }
-
-  private isActiveTask(taskId: string): boolean {
-    if (!this.activeTaskId) return true;
-    return taskId === this.activeTaskId;
-  }
-
-  onLog(handler: (event: LogEvent) => void): void {
-    this.emitter.on("log", handler);
-  }
-  onAgentStatus(handler: (event: AgentStatusEvent) => void): void {
-    this.emitter.on("agentStatus", handler);
-  }
-  onToolCall(handler: (event: ToolCallEvent) => void): void {
-    this.emitter.on("toolCall", handler);
-  }
-  onToolResult(handler: (event: ToolResultEvent) => void): void {
-    this.emitter.on("toolResult", handler);
-  }
-  onAgentMessage(handler: (event: AgentMessageEvent) => void): void {
-    this.emitter.on("agentMessage", handler);
-  }
-  onAgentDone(handler: (event: AgentDoneEvent) => void): void {
-    this.emitter.on("agentDone", handler);
-  }
-
-  pause(): void {
-    this.paused = true;
-  }
-
-  resume(): void {
-    this.paused = false;
-    const buffered = this.bufferedEvents.splice(0);
-    for (const event of buffered) {
-      this.render(event);
-    }
-  }
-
-  render(event: RenderEvent): void {
-    if (!this.isActiveTask(event.taskId)) return;
-
-    if (this.paused) {
-      this.bufferedEvents.push(event);
-      return;
-    }
-
-    switch (event.type) {
-      case "log":
-        this.emitter.emit("log", event);
-        this.renderLog(event);
-        break;
-      case "agentStatus":
-        this.emitter.emit("agentStatus", event);
-        this.renderAgentStatus(event);
-        break;
-      case "toolCall":
-        this.emitter.emit("toolCall", event);
-        this.renderToolCall(event);
-        break;
-      case "toolResult":
-        this.emitter.emit("toolResult", event);
-        this.renderToolResult(event);
-        break;
-      case "agentMessage":
-        this.emitter.emit("agentMessage", event);
-        this.renderAgentMessage(event);
-        break;
-      case "agentDone":
-        this.emitter.emit("agentDone", event);
-        this.renderAgentDone(event);
-        break;
-    }
-  }
-
-  private renderLog(event: LogEvent): void {
-    const width = termWidth();
-    const levelColors: Record<string, string> = {
-      info: c.brightBlue,
-      warn: c.brightYellow,
-      error: c.red,
-    };
-    const icons: Record<string, string> = {
-      info: "ℹ",
-      warn: "⚠",
-      error: "✖",
-    };
-    const col = levelColors[event.level] || c.gray;
-    const icon = icons[event.level] || "·";
-    const prefix = col + icon + c.reset + " " + c.dim + `[${event.agentName}]` + c.reset + " ";
-    const msg = event.message;
-    console.log(prefix + msg);
-  }
-
-  private renderAgentStatus(event: AgentStatusEvent): void {
-    const agentCol = agentColor(event.agentName);
-    const cost = c.brightGreen + `$${event.details.totalCostUsd.toFixed(3)}` + c.reset;
-    const elapsed = c.brightYellow + `${Math.floor(event.details.elapsedMs / 1000)}s` + c.reset;
-    
-    let extras = "";
-    if (event.details.remainingTimeMs !== undefined) {
-      extras += c.dim + ` ~${Math.floor(event.details.remainingTimeMs / 1000)}s left` + c.reset;
-    }
-    if (event.details.remainingTurns !== undefined) {
-      extras += c.dim + ` ${event.details.remainingTurns} turns` + c.reset;
-    }
-
-    const badge = `${c.dim}●${c.reset} ${agentCol}${event.agentName}${c.reset}`;
-    console.log(`\n${badge} ${cost} ${elapsed}${extras}`);
-  }
-
-  private renderToolCall(event: ToolCallEvent): void {
-    const width = termWidth();
-    const toolName = event.toolCall.function.name;
-    const timerKey = `${event.taskId}:${toolName}:${Date.now()}`;
-    // Store start time under a stable key (last one wins per tool name per task)
-    toolTimers.set(`${event.taskId}:${toolName}`, Date.now());
-
-    let args: any;
-    try {
-      args = JSON.parse(event.toolCall.function.arguments || "{}");
-    } catch {
-      args = event.toolCall.function.arguments;
-    }
-
-    const agentCol = agentColor(event.agentName);
-    const headerLabel = `⚡ ${c.bold}${toolName}${c.reset}${c.brightYellow}`;
-
-    // Format args
-    const argsLines = colorizeJson(formatResult(args, 10));
-
-    const boxStr = drawBox(argsLines, `⚡ ${toolName}`, c.brightYellow, Math.min(width, 100));
-    console.log("");
-    console.log(
-      c.dim + agentCol + `[${event.agentName}]` + c.reset +
-      c.dim + " called tool:" + c.reset
-    );
-    console.log(boxStr);
-  }
-
-  private renderToolResult(event: ToolResultEvent): void {
-    const width = termWidth();
-    const toolName = event.toolCall.function.name;
-
-    // Calculate elapsed time
-    const startTime = toolTimers.get(`${event.taskId}:${toolName}`);
-    const elapsed = startTime ? ((Date.now() - startTime) / 1000).toFixed(3) + "s" : "";
-    toolTimers.delete(`${event.taskId}:${toolName}`);
-
-    const resultLines = colorizeJson(formatResult(event.result, 25));
-    const elapsedStr = elapsed ? c.dim + ` ⏱ ${elapsed}` + c.reset : "";
-    const headerLabel = `✓ ${toolName}${elapsedStr}`;
-
-    const boxStr = drawBox(resultLines, `✓ ${toolName} ${elapsed}`, c.brightGreen, Math.min(width, 100));
-    console.log(boxStr);
-  }
-
-  private renderAgentMessage(event: AgentMessageEvent): void {
-    const width = termWidth();
-    const agentCol = agentColor(event.agentName);
-
-    if (event.role === "assistant") {
-      // Decorative separator with agent badge
-      const badge = ` ${agentCol}${c.bold} ${event.agentName} ${c.reset} `;
-      const badgeLen = stripAnsi(badge).length;
-      const lineLen = Math.min(width, 80);
-      const leftPad = 2;
-      const rightPad = Math.max(0, lineLen - leftPad - badgeLen);
-
-      const separator =
-        c.gray + box.tl + box.h.repeat(leftPad) + c.reset +
-        badge +
-        c.gray + box.h.repeat(rightPad) + box.tr + c.reset;
-
-      console.log("\n" + separator);
-
-      // Word-wrap the message at width - 4
-      const wrapWidth = Math.min(width - 4, 76);
-      const words = event.message.split(" ");
-      const wrappedLines: string[] = [];
-      let currentLine = "";
-
-      for (const word of words) {
-        if (currentLine.length + word.length + 1 > wrapWidth) {
-          if (currentLine) wrappedLines.push(currentLine);
-          currentLine = word;
-        } else {
-          currentLine = currentLine ? currentLine + " " + word : word;
-        }
-      }
-      if (currentLine) wrappedLines.push(currentLine);
-
-      for (const line of wrappedLines) {
-        console.log(c.gray + box.v + c.reset + "  " + c.brightWhite + line + c.reset);
-      }
-
-      const bottomSep = c.gray + box.bl + box.h.repeat(lineLen - 2) + box.br + c.reset;
-      console.log(bottomSep);
-    } else {
-      // User message (less common to render, but support it)
-      console.log(c.dim + "  › " + c.reset + event.message);
-    }
-  }
-
-  private renderAgentDone(event: AgentDoneEvent): void {
-    const width = termWidth();
-    const agentCol = agentColor(event.agentName);
-
-    const costStr = event.totalCost
-      ? c.brightGreen + `$${event.totalCost.toFixed(4)}` + c.reset
-      : "";
-
-    const label = ` ${agentCol}${c.bold}✔ ${event.agentName} done${c.reset}${costStr ? "  " + costStr : ""} `;
-    console.log("\n" + hRule(stripAnsi(label), agentCol, Math.min(width, 80)));
-    if (event.totalCost) {
-      console.log(
-        c.dim + "  Total cost: " + c.reset +
-        c.brightGreen + `$${event.totalCost.toFixed(4)}` + c.reset
-      );
-    }
-    console.log("");
-  }
-
-  logMessages(events: RenderEvent[], count: number = 10): void {
-    const recent = events.slice(-count);
-    process.stdout.write(`\n[logs] Last ${recent.length} messages:\n`);
-    process.stdout.write("-".repeat(60) + "\n");
-    for (const event of recent) {
-      this.render(event);
-    }
-    process.stdout.write("-".repeat(60) + "\n");
-  }
-
-}
-
-export default FancyRenderer;

package/src/chat/renderer/PlainRenderer.ts

@@ -1,218 +0,0 @@
-/**
- * PlainRenderer - A plain-text, append-only renderer for non-TTY environments.
- *
- * Used automatically when stdout is not a TTY (e.g. redirected to a file,
- * piped, or run in background). Emits simple timestamped log lines with no
- * ANSI codes, no cursor movement, and no spinner — safe for logfiles.
- *
- * Activate explicitly via:
- *   knowhow agent --renderer plain ...
- * or it is selected automatically when !process.stdout.isTTY and no renderer
- * is configured.
- */
-
-import {
-  AgentRenderer,
-  LogEvent,
-  AgentStatusEvent,
-  ToolCallEvent,
-  ToolResultEvent,
-  AgentMessageEvent,
-  AgentDoneEvent,
-  RenderEvent,
-} from "./types";
-import { EventEmitter } from "events";
-
-function ts(): string {
-  return new Date().toISOString();
-}
-
-function truncate(s: string, n: number): string {
-  return s.length > n ? s.slice(0, n - 1) + "…" : s;
-}
-
-function formatArgs(raw: string): string {
-  try {
-    const obj = JSON.parse(raw || "{}");
-    const entries = Object.entries(obj);
-    if (!entries.length) return "{}";
-    return entries
-      .map(([k, v]) => {
-        const val = typeof v === "string" ? v : JSON.stringify(v);
-        return `${k}=${truncate(val, 80)}`;
-      })
-      .join(", ");
-  } catch {
-    return truncate(raw || "", 120);
-  }
-}
-
-function formatResult(result: any): string {
-  try {
-    const s = typeof result === "string" ? result : JSON.stringify(result);
-    return truncate(s.replace(/\s+/g, " "), 200);
-  } catch {
-    return truncate(String(result), 200);
-  }
-}
-
-export class PlainRenderer implements AgentRenderer {
-  private activeTaskId: string | undefined;
-  private emitter = new EventEmitter();
-  private paused = false;
-  private bufferedEvents: RenderEvent[] = [];
-
-  setActiveTaskId(taskId: string | undefined): void {
-    this.activeTaskId = taskId;
-  }
-
-  getActiveTaskId(): string | undefined {
-    return this.activeTaskId;
-  }
-
-  private isActiveTask(taskId: string): boolean {
-    if (!this.activeTaskId) return true;
-    return taskId === this.activeTaskId;
-  }
-
-  onLog(handler: (event: LogEvent) => void): void {
-    this.emitter.on("log", handler);
-  }
-
-  onAgentStatus(handler: (event: AgentStatusEvent) => void): void {
-    this.emitter.on("agentStatus", handler);
-  }
-
-  onToolCall(handler: (event: ToolCallEvent) => void): void {
-    this.emitter.on("toolCall", handler);
-  }
-
-  onToolResult(handler: (event: ToolResultEvent) => void): void {
-    this.emitter.on("toolResult", handler);
-  }
-
-  onAgentMessage(handler: (event: AgentMessageEvent) => void): void {
-    this.emitter.on("agentMessage", handler);
-  }
-
-  onAgentDone(handler: (event: AgentDoneEvent) => void): void {
-    this.emitter.on("agentDone", handler);
-  }
-
-  pause(): void {
-    this.paused = true;
-  }
-
-  resume(): void {
-    this.paused = false;
-    const buffered = this.bufferedEvents.splice(0);
-    for (const event of buffered) {
-      this.render(event);
-    }
-  }
-
-  render(event: RenderEvent): void {
-    if (!this.isActiveTask(event.taskId)) return;
-
-    if (this.paused) {
-      this.bufferedEvents.push(event);
-      return;
-    }
-
-    this.emitter.emit(event.type, event);
-
-    switch (event.type) {
-      case "log":
-        this._log(event);
-        break;
-      case "agentStatus":
-        this._status(event);
-        break;
-      case "toolCall":
-        this._toolCall(event);
-        break;
-      case "toolResult":
-        this._toolResult(event);
-        break;
-      case "agentMessage":
-        this._message(event);
-        break;
-      case "agentDone":
-        this._done(event);
-        break;
-    }
-  }
-
-  private _write(line: string): void {
-    process.stdout.write(line + "\n");
-  }
-
-  private _log(e: LogEvent): void {
-    const level = e.level.toUpperCase().padEnd(5);
-    this._write(`${ts()} [${level}] [${e.agentName}] ${e.message}`);
-  }
-
-  private _status(e: AgentStatusEvent): void {
-    const cost = `$${e.details.totalCostUsd.toFixed(3)}`;
-    const elapsed = `${Math.floor(e.details.elapsedMs / 1000)}s`;
-    const parts = [`cost=${cost}`, `elapsed=${elapsed}`];
-    if (e.details.remainingTurns !== undefined) {
-      parts.push(`turns_left=${e.details.remainingTurns}`);
-    }
-    if (e.details.remainingTimeMs !== undefined) {
-      parts.push(`time_left=${Math.floor(e.details.remainingTimeMs / 1000)}s`);
-    }
-    this._write(
-      `${ts()} [STATUS] [${e.agentName}] ${e.statusMessage} | ${parts.join(" | ")}`
-    );
-  }
-
-  private _toolCall(e: ToolCallEvent): void {
-    const args = formatArgs(e.toolCall.function.arguments);
-    this._write(
-      `${ts()} [TOOL->] [${e.agentName}] ${e.toolCall.function.name}(${args})`
-    );
-  }
-
-  private _toolResult(e: ToolResultEvent): void {
-    const result = formatResult(e.result);
-    this._write(
-      `${ts()} [TOOL<-] [${e.agentName}] ${e.toolCall.function.name} => ${result}`
-    );
-  }
-
-  private _message(e: AgentMessageEvent): void {
-    if (e.role !== "assistant") return;
-    // Print the message with line-by-line prefix
-    const lines = e.message.split("\n");
-    for (const line of lines) {
-      if (line.trim()) {
-        this._write(`${ts()} [MSG  ] [${e.agentName}] ${line}`);
-      }
-    }
-  }
-
-  private _done(e: AgentDoneEvent): void {
-    const cost = e.totalCost ? ` | total_cost=$${e.totalCost.toFixed(4)}` : "";
-    this._write(`${ts()} [DONE ] [${e.agentName}] Agent finished${cost}`);
-    // Print final output lines
-    const lines = e.output.split("\n");
-    for (const line of lines) {
-      if (line.trim()) {
-        this._write(`${ts()} [OUT  ] [${e.agentName}] ${line}`);
-      }
-    }
-  }
-
-  logMessages(events: RenderEvent[], count: number = 20): void {
-    const recent = events.slice(-count);
-    this._write(`\n[LOGS ] Last ${recent.length} events:`);
-    this._write("-".repeat(80));
-    for (const event of recent) {
-      this.render(event);
-    }
-    this._write("-".repeat(80));
-  }
-}
-
-export default PlainRenderer;

package/src/chat/renderer/index.ts

@@ -1,6 +0,0 @@
-export * from "./types";
-export { ConsoleRenderer } from "./ConsoleRenderer";
-export { FancyRenderer } from "./FancyRenderer";
-export { PlainRenderer } from "./PlainRenderer";
-export { CompactRenderer } from "./CompactRenderer";
-export { loadRenderer, loadRootModule, loadChatModule } from "./loadRenderer";