@tyvm/knowhow 0.0.54 → 0.0.56

package/src/services/index.ts

@@ -9,6 +9,7 @@ import { McpService } from "./Mcp";
 import { S3Service } from "./S3";
 import { ToolsService } from "./Tools";
 import { PluginService } from "../plugins/plugins";
+import { DockerService } from "./DockerService";
 
 export * from "./AgentService";
 export * from "./EventService";
@@ -18,6 +19,7 @@ export * from "./S3";
 export * from "./Tools";
 export * as MCP from "./Mcp";
 export * from "./EmbeddingService";
+export * from "./DockerService";
 export { Clients } from "../clients";
 
 let Singletons = {} as {
@@ -28,6 +30,7 @@ let Singletons = {} as {
   GitHub: GitHubService;
   Mcp: McpService;
   AwsS3: S3Service;
+  Docker: DockerService;
   knowhowApiClient: KnowhowSimpleClient;
   Plugins: PluginService;
   Clients: AIClient;
@@ -51,6 +54,7 @@ export const services = (): typeof Singletons => {
       Agents,
       AwsS3: new S3Service(),
       Clients,
+      Docker: new DockerService(),
       Downloader,
       Events,
       Flags: new FlagsService(),
@@ -58,7 +62,7 @@ export const services = (): typeof Singletons => {
       Mcp: new McpService(),
       Plugins,
       Tools,
-      knowhowApiClient: new KnowhowSimpleClient(process.env.KNOWHOW_API_URL),
+      knowhowApiClient: new KnowhowSimpleClient(),
     };
 
     Singletons.Tools.setContext({

package/src/types.ts

@@ -63,6 +63,9 @@ export type Config = {
 
   worker?: {
     allowedTools?: string[];
+    sandbox?: boolean;
+    volumes?: string[];
+    envFile?: string;
   };
 };
 
@@ -138,6 +141,7 @@ export type ChatInteraction = {
 
 export const Models = {
   anthropic: {
+    Opus4_5: "claude-opus-4-5-20251101",
     Opus4: "claude-opus-4-20250514",
     Opus4_1: "claude-opus-4-1-20250805",
     Sonnet4_5: "claude-sonnet-4-5-20250929",
@@ -162,6 +166,7 @@ export const Models = {
     Grok2Vision1212: "grok-2-vision-1212",
   },
   openai: {
+    GPT_5_2: "gpt-5.2",
     GPT_5_1: "gpt-5.1",
     GPT_5: "gpt-5",
     GPT_5_Mini: "gpt-5-mini",
@@ -231,6 +236,8 @@ export const OpenAiReasoningModels = [
   Models.openai.GPT_5,
   Models.openai.GPT_5_Mini,
   Models.openai.GPT_5_Nano,
+  Models.openai.GPT_5_1,
+  Models.openai.GPT_5_2,
 ];
 
 export const OpenAiEmbeddingModels = [

package/src/utils/InputQueueManager.ts

@@ -0,0 +1,324 @@
+import readline from "node:readline";
+
+export const askHistory: string[] = [];
+
+type AskOptions = {
+  question: string;
+  options?: string[];
+  history?: string[];
+  resolve: (value: string) => void;
+};
+
+export class InputQueueManager {
+  private stack: AskOptions[] = [];
+  private rl: readline.Interface | null = null;
+
+  // We keep one “live” buffer shared across stacked questions
+  // (so typing is preserved when questions change)
+  private currentLine = "";
+
+  // History navigation state (custom: global askHistory + per-question history)
+  private historyIndex = -1;
+  private savedLineBeforeHistory = "";
+
+  private ensureRl(): readline.Interface {
+    if (this.rl) return this.rl;
+
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+      historySize: 500,
+
+      /**
+       * Use readline's built-in completion system so Tab does NOT insert a literal tab.
+       */
+      completer: (line: string) => {
+        const current = this.peek();
+        const opts = current?.options ?? [];
+        if (opts.length === 0) return [[], line];
+
+        // Identify the "word" at the end of the line that we want to complete
+        // (default readline behavior is word-based completion)
+        const lastSpace = Math.max(
+          line.lastIndexOf(" "),
+          line.lastIndexOf("\t")
+        );
+        const word = line.slice(lastSpace + 1); // the token to complete
+
+        const hits = opts.filter((c) => c.startsWith(word));
+
+        // Return [matches, wordToReplace]
+        // Readline will replace `word` with the selected match (or extend if unique)
+        return [hits, word];
+      },
+    });
+
+    // When user presses Enter, resolve ONLY the top question
+    this.rl.on("line", (line) => {
+      const current = this.peek();
+      if (!current) return;
+
+      // IMPORTANT: do not allow embedded newlines in history / answers
+      const answer = this.sanitizeHistoryEntry(line);
+
+      // Pop & resolve current question
+      const resolved = this.stack.pop();
+      resolved?.resolve(answer);
+
+      // Add to global history
+      if (answer && !askHistory.includes(answer)) {
+        askHistory.push(answer);
+      }
+
+      // Reset preserved buffer + history nav state for the next question
+      this.currentLine = "";
+      this.historyIndex = -1;
+      this.savedLineBeforeHistory = "";
+
+      // Update prompt for next stacked question (if any)
+      this.renderTopOrClose();
+    });
+
+    // Handle Ctrl+C (readline SIGINT)
+    this.rl.on("SIGINT", () => {
+      // If there’s an active question, cancel it (like Esc)
+      if (this.stack.length > 0) {
+        const cancelled = this.stack.pop();
+        cancelled?.resolve("");
+        this.currentLine = "";
+        this.historyIndex = -1;
+        this.savedLineBeforeHistory = "";
+        this.renderTopOrClose();
+        return;
+      }
+      // Otherwise exit
+      this.close();
+      process.exit(0);
+    });
+
+    // Capture keypresses for ESC + history nav while still using readline.
+    // Tab is handled by rl completer.
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+    process.stdin.on("keypress", (_str, key) => {
+      // Handle Ctrl+C in raw mode (some terminals deliver this here instead of SIGINT)
+      if (key?.ctrl && key?.name === "c") {
+        if (this.stack.length > 0) {
+          const cancelled = this.stack.pop();
+          cancelled?.resolve("");
+          this.currentLine = "";
+        }
+        this.close();
+        process.exit(0);
+      }
+
+      // If RL is closed or nothing to ask, ignore
+      if (!this.rl || this.stack.length === 0) return;
+
+      // Keep our buffer in sync with readline’s live line
+      this.syncFromReadline();
+
+      // Any "real typing" should exit history mode
+      // (we'll treat left/right as not exiting; you can tweak)
+      const exitsHistoryMode =
+        key &&
+        (key.name === "return" ||
+          key.name === "enter" ||
+          key.name === "backspace" ||
+          (key.sequence &&
+            key.sequence.length === 1 &&
+            !key.ctrl &&
+            !key.meta));
+      if (exitsHistoryMode && this.historyIndex !== -1) {
+        this.historyIndex = -1;
+        this.savedLineBeforeHistory = "";
+      }
+
+      if (key?.name === "escape") {
+        // Cancel only the current (top) question
+        const cancelled = this.stack.pop();
+        cancelled?.resolve("");
+
+        this.currentLine = "";
+        this.historyIndex = -1;
+        this.savedLineBeforeHistory = "";
+
+        // clear the current input in readline and redraw
+        this.replaceLine("");
+        this.renderTopOrClose();
+        return;
+      }
+
+      // Custom Up/Down history: global askHistory + per-question history
+      if (key?.name === "up") {
+        const fullHistory = this.getFullHistory();
+        if (fullHistory.length === 0) return;
+
+        if (this.historyIndex === -1) {
+          // entering history mode: remember current typed text
+          this.savedLineBeforeHistory = this.currentLine;
+        }
+
+        if (this.historyIndex < fullHistory.length - 1) {
+          this.historyIndex++;
+          const next =
+            fullHistory[fullHistory.length - 1 - this.historyIndex] ?? "";
+          this.replaceLine(next);
+          this.currentLine = next;
+        }
+        return;
+      }
+
+      if (key?.name === "down") {
+        const fullHistory = this.getFullHistory();
+        if (fullHistory.length === 0) return;
+
+        if (this.historyIndex > 0) {
+          this.historyIndex--;
+          const next =
+            fullHistory[fullHistory.length - 1 - this.historyIndex] ?? "";
+          this.replaceLine(next);
+          this.currentLine = next;
+          return;
+        }
+
+        if (this.historyIndex === 0) {
+          // leave history mode, restore what user was typing
+          this.historyIndex = -1;
+          const restore = this.savedLineBeforeHistory ?? "";
+          this.savedLineBeforeHistory = "";
+          this.replaceLine(restore);
+          this.currentLine = restore;
+          return;
+        }
+
+        return;
+      }
+    });
+
+    return this.rl;
+  }
+
+  async ask(question: string, options: string[] = [], history: string[] = []) {
+    return new Promise<string>((resolve) => {
+      this.stack.push({ question, options, history, resolve });
+
+      const rl = this.ensureRl();
+
+      // IMPORTANT: snapshot readline's current buffer before we redraw/switch prompts.
+      // This prevents us from clobbering tab-completed text with a stale currentLine.
+      this.syncFromReadline();
+
+      // Update prompt to top-of-stack
+      this.render();
+
+      // Preserve what user typed so far
+      this.replaceLine(this.currentLine);
+
+      rl.prompt(true);
+    });
+  }
+
+  private peek(): AskOptions | undefined {
+    return this.stack[this.stack.length - 1];
+  }
+
+  private syncFromReadline(): void {
+    if (!this.rl) return;
+    this.currentLine = (this.rl as any).line ?? "";
+  }
+
+  private sanitizeHistoryEntry(value: string): string {
+    // Prevent embedded newlines from triggering readline's "line" event
+    return value.replace(/[\r\n]+/g, " ").trim();
+  }
+
+  private getFullHistory(): string[] {
+    const current = this.peek();
+    const local = current?.history ?? [];
+
+    // De-dup while preserving order preference (older -> newer)
+    const merged = [...askHistory, ...local];
+    const seen = new Set<string>();
+    const out: string[] = [];
+
+    for (const item of merged) {
+      const clean = this.sanitizeHistoryEntry(item);
+      if (!clean) continue;
+      if (seen.has(clean)) continue;
+      seen.add(clean);
+      out.push(clean);
+    }
+
+    return out;
+  }
+
+  private render(): void {
+    if (!this.rl) return;
+    const current = this.peek();
+    if (!current) return;
+
+    // Make prompt be the question (readline manages wrapping/cursor)
+    this.rl.setPrompt(current.question);
+    this.rl.prompt(true);
+  }
+
+  private renderTopOrClose(): void {
+    if (this.stack.length === 0) {
+      this.close();
+      return;
+    }
+
+    // IMPORTANT: snapshot readline's current buffer before we redraw/switch prompts.
+    // This prevents us from clobbering tab-completed text with a stale currentLine.
+    this.syncFromReadline();
+
+    this.render();
+    this.replaceLine(this.currentLine);
+    this.rl?.prompt(true);
+  }
+
+  private replaceLine(next: string): void {
+    if (!this.rl) return;
+
+    const safe = this.sanitizeHistoryEntry(next);
+
+    // Clear current line and write next input without affecting terminal scrollback
+    this.rl.write(null, { ctrl: true, name: "u" }); // Ctrl+U clears the line
+    if (safe) this.rl.write(safe);
+  }
+
+  /**
+   * Returns the longest common prefix of all strings in the array.
+   */
+  private longestCommonPrefix(items: string[]): string {
+    if (items.length === 0) return "";
+    let prefix = items[0];
+
+    for (let i = 1; i < items.length; i++) {
+      const s = items[i];
+      let j = 0;
+      while (j < prefix.length && j < s.length && prefix[j] === s[j]) j++;
+      prefix = prefix.slice(0, j);
+      if (!prefix) break;
+    }
+
+    return prefix;
+  }
+
+  private close(): void {
+    if (!this.rl) return;
+    this.rl.close();
+    this.rl = null;
+
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+        // ignore
+      }
+    }
+  }
+}

package/src/utils/index.ts

@@ -5,6 +5,7 @@ import { exec } from "child_process";
 import * as fs from "fs";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
+import { InputQueueManager } from "./InputQueueManager";
 
 marked.use(markedTerminal());
 
@@ -16,164 +17,16 @@ export const execAsync = util.promisify(exec);
 export const fileStat = promisify(fs.stat);
 export const wait = promisify(setTimeout);
 
-export const askHistory = [];
+
+// Create singleton instance
+const inputQueue = new InputQueueManager();
 
 export const ask = async (
   question: string,
   options: string[] = [],
   history = []
-) => {
-  const fullHistory = [...askHistory, ...history];
-  const readline = require("readline").createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    history: fullHistory,
-    completer: (line) => {
-      const hits = options.filter((c) => c?.startsWith(line));
-      return [hits.length ? hits : options, line];
-    },
-    terminal: true,
-  });
-
-  const _ask = util.promisify(readline.question).bind(readline);
-  const answer = await _ask(question);
-  readline.close();
-
-  return answer;
-};
-
-/**
- * Enhanced ask function that handles paste operations with newlines
- * and provides a better multi-line input experience
- */
-export const askWithPaste = async (
-  question: string,
-  options: string[] = [],
-  history: string[] = [],
-  submitKeys: string[] = ["ctrl+d", "ctrl+enter"]
 ): Promise<string> => {
-  const readline = require("readline");
-  const fullHistory = [...askHistory, ...history];
-
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      history: fullHistory,
-      completer: (line: string) => {
-        const hits = options.filter((c) => c?.startsWith(line));
-        return [hits.length ? hits : options, line];
-      },
-      terminal: true,
-    });
-
-    let buffer = "";
-    let currentLine = "";
-    let cursorPos = 0;
-    const historyIndex = -1;
-
-    // Display the question
-    process.stdout.write(question);
-
-    // Handle raw input to detect paste operations and special keys
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-
-    const cleanup = () => {
-      process.stdin.setRawMode(false);
-      process.stdin.pause();
-      rl.close();
-    };
-
-    process.stdin.on("data", (data) => {
-      const input = data.toString();
-
-      // Handle Ctrl+C
-      if (input === "\u0003") {
-        cleanup();
-        process.exit(0);
-        return;
-      }
-
-      // Handle Ctrl+D (submit)
-      if (input === "\u0004") {
-        process.stdout.write("\n");
-        cleanup();
-        resolve(buffer.trim());
-        return;
-      }
-
-      // Handle Ctrl+Enter (submit)
-      if (input === "\r\n" || input === "\n\r") {
-        process.stdout.write("\n");
-        cleanup();
-        resolve(buffer.trim());
-        return;
-      }
-
-      // Handle regular Enter (add newline to buffer)
-      if (input === "\r" || input === "\n") {
-        buffer += currentLine + "\n";
-        currentLine = "";
-        cursorPos = 0;
-        process.stdout.write("\n");
-        return;
-      }
-
-      // Handle Backspace
-      if (input === "\u007f" || input === "\b") {
-        if (cursorPos > 0) {
-          currentLine =
-            currentLine.slice(0, cursorPos - 1) + currentLine.slice(cursorPos);
-          cursorPos--;
-          // Redraw current line
-          process.stdout.write(
-            "\r" +
-              " ".repeat(question.length + currentLine.length + 1) +
-              "\r" +
-              question +
-              currentLine
-          );
-          process.stdout.write("\u001b[" + (question.length + cursorPos) + "G");
-        }
-        return;
-      }
-
-      // Handle Tab (autocomplete)
-      if (input === "\t" && options.length > 0) {
-        const hits = options.filter((c) => c?.startsWith(currentLine));
-        if (hits.length === 1) {
-          currentLine = hits[0];
-          cursorPos = currentLine.length;
-          process.stdout.write("\r" + question + currentLine);
-        }
-        return;
-      }
-
-      // Handle regular characters (including pasted content)
-      if (input.length > 1) {
-        // This is likely a paste operation
-        currentLine =
-          currentLine.slice(0, cursorPos) +
-          input +
-          currentLine.slice(cursorPos);
-        cursorPos += input.length;
-      } else if (input >= " ") {
-        // Single printable character
-        currentLine =
-          currentLine.slice(0, cursorPos) +
-          input +
-          currentLine.slice(cursorPos);
-        cursorPos++;
-      }
-
-      // Redraw current line
-      process.stdout.write("\r" + question + currentLine);
-      if (cursorPos < currentLine.length) {
-        process.stdout.write("\u001b[" + (question.length + cursorPos) + "G");
-      }
-    });
-  });
+  return inputQueue.ask(question, options, history);
 };
 
 export const Marked = marked;