@tyvm/knowhow 0.0.89 → 0.0.91

package/src/agents/tools/list.ts

@@ -2,8 +2,6 @@ import { Tool } from "../../clients/types";
 import { ChatCompletionTool } from "openai/resources/chat";
 
 import { services } from "../../services";
-import * as github from "./github/definitions";
-import * as asana from "./asana/definitions";
 import * as ycmd from "./ycmd/definitions";
 import * as language from "./language/definitions";
 import * as mcp from "./mcp/definitions";
@@ -710,152 +708,7 @@ export const includedTools = [
   executeScriptDefinition,
   googleSearchDefinition,
   startAgentTaskDefinition,
-  {
-    type: "function",
-    function: {
-      name: "astListPaths",
-      description:
-        "List all available simple paths in a file using tree-sitter AST parsing. Useful for understanding the structure of a file before making targeted edits.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          filePath: {
-            type: "string",
-            description: "The path to the file to analyze",
-          },
-        },
-        required: ["filePath"],
-      },
-      returns: {
-        type: "string",
-        description:
-          "JSON object containing all available AST paths in the file",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "astEditNode",
-      description:
-        "Update a node at a specific AST path in a file using tree-sitter parsing. Use astListPaths first to find available paths.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          filePath: {
-            type: "string",
-            description: "The path to the file to edit",
-          },
-          path: {
-            type: "string",
-            description:
-              "The AST path to the node to update (from astListPaths)",
-          },
-          newContent: {
-            type: "string",
-            description: "The new content to replace the node with",
-          },
-        },
-        required: ["filePath", "path", "newContent"],
-      },
-      returns: {
-        type: "string",
-        description: "JSON object with edit result and updated file content",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "astAppendNode",
-      description:
-        "Append a child node to a specific AST path in a file using tree-sitter parsing. Use astListPaths first to find available paths.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          filePath: {
-            type: "string",
-            description: "The path to the file to edit",
-          },
-          parentPath: {
-            type: "string",
-            description: "The AST path to the parent node (from astListPaths)",
-          },
-          newContent: {
-            type: "string",
-            description: "The content of the child node to append",
-          },
-        },
-        required: ["filePath", "parentPath", "newContent"],
-      },
-      returns: {
-        type: "string",
-        description: "JSON object with append result and updated file content",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "astDeleteNode",
-      description:
-        "Delete a node at a specific AST path in a file using tree-sitter parsing. Use astListPaths first to find available paths.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          filePath: {
-            type: "string",
-            description: "The path to the file to edit",
-          },
-          path: {
-            type: "string",
-            description:
-              "The AST path to the node to delete (from astListPaths)",
-          },
-        },
-        required: ["filePath", "path"],
-      },
-      returns: {
-        type: "string",
-        description: "JSON object with delete result and updated file content",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "astGetPathForLine",
-      description:
-        "Get the AST path for a specific line of text in a file using tree-sitter parsing. Useful for finding the structural location of specific code.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          filePath: {
-            type: "string",
-            description: "The path to the file to analyze",
-          },
-          searchText: {
-            type: "string",
-            description: "The text to search for in the file",
-          },
-        },
-        required: ["filePath", "searchText"],
-      },
-      returns: {
-        type: "string",
-        description:
-          "JSON object containing AST paths and locations for the matching text",
-      },
-    },
-  },
-  ...asana.definitions,
   ...ycmd.definitions,
-  ...github.definitions,
   ...language.definitions,
   ...mcp.definitions,
 ] as Tool[];

package/src/agents/tools/loadWebpage.ts

@@ -1,6 +1,3 @@
-import { chromium } from "playwright-extra";
-import stealth from "puppeteer-extra-plugin-stealth";
-
 export interface LoadWebpageOptions {
   url: string;
   mode?: "text" | "screenshot";
@@ -14,116 +11,9 @@ export async function loadWebpage(
   waitForSelector?: string,
   timeout: number = 30000
 ): Promise<string> {
-  let browser;
-  let page;
-
-  try {
-    console.log(`Loading webpage: ${url} in ${mode} mode`);
-
-    chromium.use(stealth());
-
-    // Launch browser with stealth settings
-    browser = await chromium.launch({
-      headless: true,
-      args: [
-        "--disable-setuid-sandbox",
-        "--disable-dev-shm-usage",
-        "--disable-accelerated-2d-canvas",
-        "--no-first-run",
-        "--no-zygote",
-        "--disable-gpu",
-        "--disable-blink-features=AutomationControlled",
-        process.env.DISABLE_CHROME_SANDBOX === "true" ? "--no-sandbox" : "",
-      ],
-    });
-
-    const context = await browser.newContext({
-      userAgent:
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-      viewport: { width: 1366, height: 768 },
-      extraHTTPHeaders: {
-        "Accept-Language": "en-US,en;q=0.9",
-      },
-    });
-
-    page = await context.newPage();
-
-    // Capture console logs for text mode
-    const consoleLogs: string[] = [];
-    if (mode === "text") {
-      page.on("console", (msg) => {
-        consoleLogs.push(`[${msg.type()}] ${msg.text()}`);
-      });
-    }
-
-    // Navigate to the URL
-    await page.goto(url, {
-      waitUntil: "networkidle",
-      timeout,
-    });
-
-    // Wait for specific selector if provided
-    if (waitForSelector) {
-      await page.waitForSelector(waitForSelector, { timeout });
-    }
-
-    let result: string;
-
-    if (mode === "screenshot") {
-      // Take screenshot and return base64 encoded image
-      const screenshot = await page.screenshot({
-        fullPage: true,
-        type: "png",
-      });
-
-      const base64Screenshot = screenshot.toString("base64");
-      result = `data:image/png;base64,${base64Screenshot}`;
-    } else {
-      // Extract text content
-      const textContent = await page.evaluate(() => {
-        // Remove script and style elements
-        const scripts = document.querySelectorAll("script, style");
-        scripts.forEach((el) => el.remove());
-
-        // Get the text content
-        return document.body?.innerText || document.body?.textContent || "";
-      });
-
-      // Get page title
-      const title = await page.title();
-
-      // Format the result
-      result = `# ${title}\n\n## Page Content:\n${textContent}`;
-
-      if (consoleLogs.length > 0) {
-        result += `\n\n## Console Logs:\n${consoleLogs.join("\n")}`;
-      }
-    }
-
-    return result;
-  } catch (error) {
-    console.error("Error loading webpage:", error);
-    return `Error loading webpage: ${
-      error instanceof Error ? error.message : String(error)
-    }`;
-  } finally {
-    // Always close the browser
-    if (page) {
-      try {
-        await page.close();
-      } catch (e) {
-        console.warn("Error closing page:", e);
-      }
-    }
-
-    if (browser) {
-      try {
-        await browser.close();
-      } catch (e) {
-        console.warn("Error closing browser:", e);
-      }
-    }
-  }
+  throw new Error(
+    "loadWebpage requires @tyvm/knowhow-module-load-webpage to be installed and configured in knowhow.json modules."
+  );
 }
 
 export default loadWebpage;

package/src/ai.ts

@@ -6,6 +6,7 @@ import { Assistant } from "./types";
 import { convertToText } from "./conversion";
 import { getConfigSync } from "./config";
 import { Clients } from "./clients";
+import { getModelContextLimit } from "./clients/contextLimits";
 
 const config = getConfigSync();
 const OPENAI_KEY = process.env.OPENAI_KEY;
@@ -59,7 +60,7 @@ export async function singlePrompt(userPrompt: string, model = "", agent = "") {
   }
 
   if (!model) {
-    model = Models.openai.GPT_4o;
+    model = Models.openai.GPT_54_Nano;
   }
 
   // Assume we're using provider/model format of model
@@ -71,12 +72,43 @@ export async function singlePrompt(userPrompt: string, model = "", agent = "") {
   return resp?.choices?.[0]?.message?.content;
 }
 
+/**
+ * Rough token estimate: ~4 characters per token (common heuristic).
+ */
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
 export async function summarizeTexts(
   texts: string[],
   template: string,
   model = "",
   agent = ""
 ) {
+  const effectiveModel = model || Models.openai.GPT_54_Nano;
+
+  // Estimate total tokens if we were to combine all texts into one prompt
+  const combinedText = texts.join("\n\n");
+  const combinedContent = template.replaceAll("{text}", combinedText);
+  const estimatedTokens = estimateTokens(combinedContent);
+  const contextLimit = getModelContextLimit(effectiveModel);
+
+  console.log(
+    `summarizeTexts: ${texts.length} text(s), ~${estimatedTokens} estimated tokens, context limit: ${contextLimit}`
+  );
+
+  // If everything fits in one context window, do a single prompt
+  if (estimatedTokens < contextLimit) {
+    console.log("summarizeTexts: fits in context window, using single prompt");
+    return singlePrompt(combinedContent, model, agent).catch((err) => {
+      return `Texts of combined length ${combinedText.length} could not be summarized due to error: ${err.message}`;
+    });
+  }
+
+  // Otherwise summarize each text individually, then combine
+  console.log(
+    "summarizeTexts: exceeds context window, summarizing texts individually"
+  );
   const summaries = [];
   for (const text of texts) {
     const content = template.replaceAll("{text}", text);
@@ -94,7 +126,6 @@ export async function summarizeTexts(
   }
 
   // Otherwise form a final summary of the pieces
-
   const finalPrompt =
     `Generate a final output for this prompt ${template} with these incremental summaries: ` +
     summaries.join("\n\n");

package/src/auth/browserLogin.ts

@@ -1,4 +1,4 @@
-import axios from "axios";
+import http from "../utils/http";
 import { exec } from "child_process";
 import { promisify } from "util";
 import * as os from "os";
@@ -81,7 +81,7 @@ export class BrowserLoginService {
             );
           }
 
-          const statusResponse = await axios.get(
+          const statusResponse = await http.get(
             `${this.baseUrl}/api/cli-login/session/${sessionData.sessionId}/status`,
             { timeout: 10000 }
           );
@@ -93,7 +93,7 @@ export class BrowserLoginService {
             spinner.start("Authentication successful! Retrieving token");
 
             // Step 4: Retrieve JWT token
-            const tokenResponse = await axios.post(
+            const tokenResponse = await http.post(
               `${this.baseUrl}/api/cli-login/session/${sessionData.sessionId}/token`
             );
 
@@ -113,7 +113,7 @@ export class BrowserLoginService {
             );
           }
         } catch (error) {
-          if (axios.isAxiosError(error) && error.code !== "ECONNABORTED") {
+          if (http.isHttpError(error) && error.status !== 408) {
             throw new BrowserLoginError(
               `Network error: ${error.message}`,
               "NETWORK_ERROR"
@@ -139,23 +139,20 @@ export class BrowserLoginService {
    */
   private async createSession(): Promise<CreateSessionResponse> {
     try {
-      const response = await axios.post<CreateSessionResponse>(
+      const response = await http.post<CreateSessionResponse>(
         `${this.baseUrl}/api/cli-login/session`,
-        {},
-        { timeout: 10000 }
+        {}
       );
       return response.data;
     } catch (error) {
-      if (axios.isAxiosError(error)) {
+      if (http.isHttpError(error)) {
         throw new BrowserLoginError(
-          `Failed to create login session: ${
-            error.response?.data?.message || error.message
-          }`,
+          `Failed to create login session: ${error.message}`,
           "SESSION_CREATE_FAILED"
         );
       }
       throw new BrowserLoginError(
-        `Unexpected error creating session: ${error.message}`
+        `Unexpected error creating session: ${(error as Error).message}`
       );
     }
   }
@@ -226,7 +223,7 @@ export async function openBrowser(url: string): Promise<void> {
   } catch (error) {
     // If we can't open the browser automatically, that's not a fatal error
     // The user can still manually navigate to the URL
-    console.warn(`Could not automatically open browser: ${error.message}`);
+    console.warn(`Could not automatically open browser: ${(error as Error).message}`);
   }
 }
 

package/src/cli.ts

@@ -1,5 +1,4 @@
 #!/usr/bin/env node --no-node-snapshot
-import "source-map-support/register";
 import * as fs from "fs";
 import * as fsPromises from "fs/promises";
 import * as path from "path";
@@ -26,7 +25,6 @@ import {
 } from "./workerRegistry";
 import { agents } from "./agents";
 import { startChat } from "./chat";
-import { askAI } from "./chat-old";
 import { getConfiguredEmbeddingMap, queryEmbedding } from "./embeddings";
 import { getConfig } from "./config";
 import { getEnabledPlugins } from "./types";
@@ -42,7 +40,7 @@ import { CliChatService } from "./chat/CliChatService";
 
 async function setupServices() {
   const { Agents, Mcp, Clients, Tools: OldTools } = services();
-  const Tools = new LazyToolsService();
+  const Tools = new LazyToolsService(); // eslint-disable-line no-shadow
 
   // We need to wireup the LazyTools to be connected to the same singletons that are in services()
   Tools.setContext({
@@ -80,6 +78,9 @@ async function setupServices() {
   console.log("Connecting to clients...");
   await Clients.registerConfiguredModels();
   console.log("✓ Services are set up and ready to go!");
+
+  // Return both LazyToolsService (for agents) and OldTools (plain ToolsService with all tools for scripts)
+  return { Tools, Clients, PlainTools: OldTools };
 }
 
 // Utility function to read from stdin
@@ -488,6 +489,65 @@ async function main() {
       }
     });
 
+  program
+    .command("script")
+    .description("Run a local tool script file using the executeScript sandbox")
+    .option("--input-file <path>", "Path to a local .js/.ts script file to run")
+    .option(
+      "--allow-network",
+      "Allow fetch() calls in the script (disabled by default for security)"
+    )
+    .action(async (options) => {
+      try {
+        if (!options.inputFile) {
+          console.error(
+            "Error: Provide --input-file <path> to the script file to run"
+          );
+          process.exit(1);
+        }
+
+        // Run a local script file
+        const scriptPath = path.resolve(options.inputFile);
+        if (!fs.existsSync(scriptPath)) {
+          console.error(`Error: Script file not found: ${scriptPath}`);
+          process.exit(1);
+        }
+        const scriptContent = fs.readFileSync(scriptPath, "utf-8");
+
+        const { Tools, Clients } = await setupServices();
+
+        // Enable all tools on the LazyToolsService so scripts can access MCP tools
+        // (LazyToolsService starts with only meta-tools enabled; we need all for scripts)
+        Tools.enableTools(["*"]);
+
+        const { ScriptExecutor } = await import(
+          "./services/script-execution/ScriptExecutor"
+        );
+        const executor = new ScriptExecutor(Tools, Clients);
+        const result = await executor.execute({
+          script: scriptContent,
+          policy: {
+            allowNetworkAccess: !!options.allowNetwork,
+          },
+          quotas: {
+            maxExecutionTimeMs: 5 * 60 * 1000, // 5 minutes for CLI scripts
+          },
+        });
+
+        if (result.consoleOutput?.length) {
+          console.log(result.consoleOutput.join("\n"));
+        }
+        console.log(JSON.stringify(result.result, null, 2));
+        if (!result.success) {
+          console.error("Script error:", result.error);
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error("Error running script:", error);
+        process.exit(1);
+      }
+    });
+
   program
     .command("github-credentials [action]")
     .description(