@tyvm/knowhow 0.0.32 → 0.0.34

package/src/services/script-execution/ScriptExecutor.ts

@@ -37,7 +37,40 @@ export class ScriptExecutor {
     allowFileSystemAccess: false,
   };
 
-  constructor(private toolsService: ToolsService, private clients: AIClient) {}
+  constructor(private toolsService: ToolsService, private clients: AIClient) {
+    this.validateNodejsEnvironment();
+  }
+
+  /**
+   * Validate that Node.js environment is properly configured for isolated-vm
+   */
+  private validateNodejsEnvironment(): void {
+    // Get Node.js version
+    const nodeVersion = process.version;
+    const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+    
+    // Check if Node.js 20+ and --no-node-snapshot flag is required
+    if (majorVersion >= 20) {
+      const hasNoNodeSnapshot = process.execArgv.includes('--no-node-snapshot');
+      
+      if (!hasNoNodeSnapshot) {
+        const errorMessage = [
+          `Node.js ${nodeVersion} detected. The --no-node-snapshot flag is required for isolated-vm compatibility.`,
+          '',
+          'To fix this issue:',
+          '1. Restart your application with: node --no-node-snapshot your-app.js',
+          '2. Or update your package.json scripts:',
+          '   "scripts": {',
+          '     "start": "node --no-node-snapshot dist/index.js"',
+          '   }',
+          '',
+          'This flag is necessary for the executeScript tool to function properly with isolated-vm.'
+        ].join('\n');
+        
+        throw new Error(errorMessage);
+      }
+    }
+  }
 
   /**
    * Execute a TypeScript script in sandbox

package/src/services/types.ts

@@ -1,8 +1,9 @@
 import { Tool } from "../clients/types";
 
-export interface ToolOverrideFunction {
-  (originalArgs: any[], originalTool: Tool): Promise<any> | any;
-}
+export type ToolOverrideFunction = (
+  originalArgs: any[],
+  originalTool: Tool
+) => Promise<any> | any;
 
 export interface ToolOverrideRegistration {
   pattern: string | RegExp;
@@ -10,9 +11,11 @@ export interface ToolOverrideRegistration {
   priority: number;
 }
 
-export interface ToolWrapper {
-  (originalFunction: (...args: any[]) => any, originalArgs: any[], originalTool: Tool): Promise<any> | any;
-}
+export type ToolWrapper = (
+  originalFunction: (...args: any[]) => any,
+  originalArgs: any[],
+  originalTool: Tool
+) => Promise<any> | any;
 
 export interface ToolWrapperRegistration {
   pattern: string | RegExp;
@@ -27,14 +30,14 @@ export interface PatternMatcher {
 
 export class StringPatternMatcher implements PatternMatcher {
   constructor(public pattern: string) {}
-  
+
   matches(toolName: string): boolean {
     // Convert glob pattern to regex
     const regexPattern = this.pattern
-      .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // Escape special regex chars
-      .replace(/\\\*/g, '.*') // Convert * to .*
-      .replace(/\\\?/g, '.'); // Convert ? to .
-    
+      .replace(/[.*+?^${}()|[\]\\]/g, "\\$&") // Escape special regex chars
+      .replace(/\\\*/g, ".*") // Convert * to .*
+      .replace(/\\\?/g, "."); // Convert ? to .
+
     const regex = new RegExp(`^${regexPattern}$`);
     return regex.test(toolName);
   }
@@ -42,16 +45,16 @@ export class StringPatternMatcher implements PatternMatcher {
 
 export class RegexPatternMatcher implements PatternMatcher {
   constructor(public pattern: RegExp) {}
-  
+
   matches(toolName: string): boolean {
     return this.pattern.test(toolName);
   }
 }
 
 export function createPatternMatcher(pattern: string | RegExp): PatternMatcher {
-  if (typeof pattern === 'string') {
+  if (typeof pattern === "string") {
     return new StringPatternMatcher(pattern);
   } else {
     return new RegexPatternMatcher(pattern);
   }
-}
+}

package/src/types.ts

@@ -53,6 +53,14 @@ export type Config = {
   mcps: McpConfig[];
   modelProviders: ModelProvider[];
 
+  ycmd?: {
+    enabled?: boolean;
+    installPath?: string;
+    port?: number;
+    logLevel?: 'debug' | 'info' | 'warning' | 'error';
+    completionTimeout?: number;
+  };
+
   worker?: {
     allowedTools?: string[];
   };
@@ -146,6 +154,9 @@ export const Models = {
     Grok2Vision1212: "grok-2-vision-1212",
   },
   openai: {
+    GPT_5: "gpt-5",
+    GPT_5_Mini: "gpt-5-mini",
+    GPT_5_Nano: "gpt-5-nano",
     GPT_41: "gpt-4.1-2025-04-14",
     GPT_41_Mini: "gpt-4.1-mini-2025-04-14",
     GPT_41_Nano: "gpt-4.1-nano-2025-04-14",
@@ -159,6 +170,7 @@ export const Models = {
     o1: "o1-2024-12-17",
     o1_Pro: "o1-pro-2025-03-19",
     o3: "o3-2025-04-16",
+    o3_Pro: "o3-pro-2025-01-31",
     o4_Mini: "o4-mini-2025-04-16",
     o3_Mini: "o3-mini-2025-01-31",
     o1_Mini: "o1-mini-2024-09-12",
@@ -204,7 +216,11 @@ export const OpenAiReasoningModels = [
   Models.openai.o1_Mini,
   Models.openai.o3_Mini,
   Models.openai.o3,
+  Models.openai.o3_Pro,
   Models.openai.o4_Mini,
+  Models.openai.GPT_5,
+  Models.openai.GPT_5_Mini,
+  Models.openai.GPT_5_Nano,
 ];
 
 export const OpenAiEmbeddingModels = [
@@ -232,3 +248,4 @@ export const GoogleImageModels = [
 export const GoogleVideoModels = [Models.google.Veo_2];
 
 export const GoogleEmbeddingModels = [EmbeddingModels.google.Gemini_Embedding];
+

package/src/utils/index.ts

@@ -42,6 +42,140 @@ export const ask = async (
   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");
+      }
+    });
+  });
+};
+
 export const Marked = marked;
 
 export function dotp(x, y) {
@@ -66,6 +200,10 @@ export function replaceEscapedNewLines(str: string): string {
   return str;
 }
 
+export function escapeNewLines(str: string): string {
+  return str.replace(/\\n/g, "\\n");
+}
+
 export function restoreEscapedNewLines(str: string): string {
   const escaped = [NEWLINE_REPLACE, "<ESCAPE_NEWLINE>"];
   let replacedStr = str;