@tyvm/knowhow 0.0.159 → 0.0.161

package/src/agents/tools/loadImageAsBase64.ts

@@ -1,83 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Tool } from "../../clients/types";
-
-const MAX_IMAGE_BYTES = 15 * 1024 * 1024;
-
-const MIME_TYPES: Record<string, string> = {
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  webp: "image/webp",
-  bmp: "image/bmp",
-  svg: "image/svg+xml",
-  avif: "image/avif",
-  ico: "image/x-icon",
-};
-
-function detectMimeType(buffer: Buffer, fallback: string): string {
-  if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
-    return "image/jpeg";
-  }
-  if (buffer.length >= 4 && buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) {
-    return "image/png";
-  }
-  if (buffer.length >= 4 && buffer.subarray(0, 4).toString("ascii") === "GIF8") {
-    return "image/gif";
-  }
-  if (
-    buffer.length >= 12 &&
-    buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
-    buffer.subarray(8, 12).toString("ascii") === "WEBP"
-  ) {
-    return "image/webp";
-  }
-  return fallback;
-}
-
-/** Load a reasonably sized image from the worker filesystem for UI/AI preview. */
-export async function loadImageAsBase64(
-  filePath: string,
-  detail: "auto" | "low" | "high" = "auto"
-): Promise<string> {
-  const stats = await fs.promises.stat(filePath).catch(() => null);
-  if (!stats) throw new Error(`File not found: ${filePath}`);
-  if (!stats.isFile()) throw new Error(`Path is not a file: ${filePath}`);
-  if (stats.size > MAX_IMAGE_BYTES) {
-    throw new Error(`Image is too large to preview (${Math.ceil(stats.size / 1024 / 1024)} MB; maximum 15 MB)`);
-  }
-
-  const extension = path.extname(filePath).slice(1).toLowerCase();
-  const extensionMimeType = MIME_TYPES[extension];
-  if (!extensionMimeType) {
-    throw new Error(`Unsupported image format: ${extension || "unknown"}`);
-  }
-
-  const image = await fs.promises.readFile(filePath);
-  const mimeType = detectMimeType(image, extensionMimeType);
-  return JSON.stringify({
-    type: "image_url",
-    image_url: {
-      url: `data:${mimeType};base64,${image.toString("base64")}`,
-      detail,
-    },
-  });
-}
-
-export const loadImageAsBase64Definition: Tool = {
-  type: "function",
-  function: {
-    name: "loadImageAsBase64",
-    description: "Load an image from the worker filesystem and return it as a base64 data URL for previewing.",
-    parameters: {
-      type: "object",
-      positional: true,
-      properties: {
-        filePath: { type: "string", description: "Absolute or workspace-relative image path" },
-        detail: { type: "string", enum: ["auto", "low", "high"], description: "Image detail hint" },
-      },
-      required: ["filePath"],
-    },
-  },
-};

package/src/agents/tools/loadWebpage.ts

@@ -1,19 +0,0 @@
-export interface LoadWebpageOptions {
-  url: string;
-  mode?: "text" | "screenshot";
-  waitForSelector?: string;
-  timeout?: number;
-}
-
-export async function loadWebpage(
-  url: string,
-  mode: "text" | "screenshot" = "text",
-  waitForSelector?: string,
-  timeout: number = 30000
-): Promise<string> {
-  throw new Error(
-    "loadWebpage requires @tyvm/knowhow-module-load-webpage to be installed and configured in knowhow.json modules."
-  );
-}
-
-export default loadWebpage;

package/src/agents/tools/mcp/connectMcpServer.ts

@@ -1,40 +0,0 @@
-import { services } from "../../../services";
-import { McpService } from "../../../services/Mcp";
-import { ToolsService } from "../../../services/Tools";
-
-export async function connectMcpServer(
-  serverName: string,
-  timeout: number = 30000
-) {
-  const toolService = (
-    this instanceof ToolsService ? this : services().Tools
-  ) as ToolsService;
-
-  const context = toolService.getContext();
-  const Mcp = context.Mcp;
-
-  if (!Mcp) {
-    return {
-      success: false,
-      error: "MCP service not available in context",
-      toolsAdded: [],
-    };
-  }
-
-  if (!serverName) {
-    return {
-      success: false,
-      error: "serverName parameter is required",
-      toolsAdded: [],
-    };
-  }
-
-  const result = await Mcp.connectSingle(serverName, timeout);
-
-  // If connection was successful and tools were added, register them with the ToolsService
-  if (result.success && result.toolsAdded.length > 0) {
-    await Mcp.addTools(toolService);
-  }
-
-  return result;
-}

package/src/agents/tools/mcp/definitions.ts

@@ -1,67 +0,0 @@
-import { Tool } from "../../../clients/types";
-
-const listAvailableMcpServersDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "listAvailableMcpServers",
-    description:
-      "List all configured MCP servers and their connection status. Shows which servers are connected, which are disconnected, and how many tools each provides.",
-    parameters: {
-      type: "object",
-      positional: true,
-      properties: {},
-      required: [],
-    },
-  },
-};
-
-const connectMcpServerDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "connectMcpServer",
-    description:
-      "Connect to a specific MCP server on-demand. This is useful for servers configured with autoConnect: false, or to reconnect a disconnected server. Once connected, the server's tools will be available for use.",
-    parameters: {
-      type: "object",
-      positional: true,
-      properties: {
-        serverName: {
-          type: "string",
-          description: "The name of the MCP server to connect to",
-        },
-        timeout: {
-          type: "number",
-          description:
-            "Connection timeout in milliseconds (optional, default: 30000)",
-        },
-      },
-      required: ["serverName"],
-    },
-  },
-};
-
-const disconnectMcpServerDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "disconnectMcpServer",
-    description:
-      "Disconnect from a specific MCP server. This will close the connection and remove the server's tools from the available tools list.",
-    parameters: {
-      type: "object",
-      positional: true,
-      properties: {
-        serverName: {
-          type: "string",
-          description: "The name of the MCP server to disconnect from",
-        },
-      },
-      required: ["serverName"],
-    },
-  },
-};
-
-export const definitions = [
-  listAvailableMcpServersDefinition,
-  connectMcpServerDefinition,
-  disconnectMcpServerDefinition,
-];

package/src/agents/tools/mcp/disconnectMcpServer.ts

@@ -1,40 +0,0 @@
-import { services } from "../../../services";
-import { McpService } from "../../../services/Mcp";
-import { ToolsService } from "../../../services/Tools";
-
-export async function disconnectMcpServer(serverName: string) {
-  const toolService = (
-    this instanceof ToolsService ? this : services().Tools
-  ) as ToolsService;
-
-  const context = toolService.getContext();
-  const Mcp = context.Mcp;
-
-  if (!Mcp) {
-    return {
-      success: false,
-      error: "MCP service not available in context",
-      toolsRemoved: [],
-    };
-  }
-
-  if (!serverName) {
-    return {
-      success: false,
-      error: "serverName parameter is required",
-      toolsRemoved: [],
-    };
-  }
-
-  const result = await Mcp.disconnectSingle(serverName);
-
-  // If disconnection was successful and tools were removed, update the ToolsService
-  if (result.success && result.toolsRemoved.length > 0) {
-    // Remove tools from the current ToolsService instance
-    toolService.tools = toolService.tools.filter(
-      (tool) => !result.toolsRemoved.includes(tool.function.name)
-    );
-  }
-
-  return result;
-}

package/src/agents/tools/mcp/index.ts

@@ -1,3 +0,0 @@
-export { listAvailableMcpServers } from "./listAvailableMcpServers";
-export { connectMcpServer } from "./connectMcpServer";
-export { disconnectMcpServer } from "./disconnectMcpServer";

package/src/agents/tools/mcp/listAvailableMcpServers.ts

@@ -1,28 +0,0 @@
-import { services } from "../../../services";
-import { McpService } from "../../../services/Mcp";
-import { ToolsService } from "../../../services/Tools";
-
-export async function listAvailableMcpServers() {
-  const toolService = (
-    this instanceof ToolsService ? this : services().Tools
-  ) as ToolsService;
-
-  const context = toolService.getContext();
-  const Mcp = context.Mcp;
-
-  if (!Mcp) {
-    return {
-      error: "MCP service not available in context",
-      servers: [],
-    };
-  }
-
-  const servers = Mcp.getAvailableServers();
-
-  return {
-    servers,
-    summary: `Found ${servers.length} configured MCP server(s). ${
-      servers.filter((s) => s.connected).length
-    } connected, ${servers.filter((s) => !s.connected).length} disconnected.`,
-  };
-}

package/src/agents/tools/minimal/callTool.ts

@@ -1,45 +0,0 @@
-import { minimatch } from "minimatch";
-import { MinimalToolsService } from "../../../services/MinimalToolsService";
-import { ToolsService } from "../../../services/Tools";
-
-/**
- * Calls any tool by name with the given args.
- * This is the escape hatch that lets agents call tools outside the base tool set
- * without changing the `tools:` array sent to the AI (preserving cache stability).
- */
-export async function callTool(
-  this: ToolsService,
-  args: { name: string; args: Record<string, any> }
-): Promise<any> {
-  const service = this as unknown as MinimalToolsService;
-  const { name, args: toolArgs } = args;
-
-  const allTools = service.getAllTools ? service.getAllTools() : service.getTools();
-
-  // Fuzzy match: exact, endsWith, or glob
-  const matchedTool =
-    allTools.find((t) => t.function.name === name) ||
-    allTools.find((t) => t.function.name.endsWith(name)) ||
-    allTools.find((t) => minimatch(t.function.name, name, { nocase: true }));
-
-  if (!matchedTool) {
-    const available = allTools.map((t) => t.function.name).join(", ");
-    return `Error: Tool "${name}" not found. Use inspectTools() to browse available tools. Available: ${available}`;
-  }
-
-  const toolName = matchedTool.function.name;
-
-  // Build a synthetic ToolCall object and delegate to the base callTool
-  const syntheticToolCall = {
-    id: `call_minimal_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
-    type: "function" as const,
-    function: {
-      name: toolName,
-      arguments: JSON.stringify(toolArgs),
-    },
-  };
-
-  // Use base ToolsService.callTool with the matched tool name allowed
-  const result = await service.callToolByName(syntheticToolCall, toolName);
-  return result;
-}

package/src/agents/tools/minimal/definitions.ts

@@ -1,50 +0,0 @@
-import { Tool } from "../../../clients/types";
-
-export const callToolDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "callTool",
-    description:
-      "Call any available tool by name with the given arguments. Use listStoredToolResponses + inspectTools to discover available tools and their argument schemas before calling. This is the primary way to call tools that are not in the base tool set.",
-    parameters: {
-      type: "object",
-      positional: false,
-      properties: {
-        name: {
-          type: "string",
-          description: "The name of the tool to call.",
-        },
-        args: {
-          type: "object",
-          description:
-            "The arguments to pass to the tool. Should match the tool's parameter schema.",
-        },
-      },
-      required: ["name", "args"],
-    },
-  },
-};
-
-export const inspectToolsDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "inspectTools",
-    description:
-      "Get the full schema/definition for tools matching the given glob patterns. Use this to discover what arguments a tool needs before calling it via callTool. Example patterns: ['read*'] finds tools starting with 'read', ['*File'] finds tools ending with 'File'.",
-    parameters: {
-      type: "object",
-      positional: true,
-      properties: {
-        patterns: {
-          type: "array",
-          items: { type: "string" },
-          description:
-            "Array of glob patterns to filter tool names. If omitted, returns all available tools.",
-        },
-      },
-      required: [],
-    },
-  },
-};
-
-export const minimalDefinitions = [callToolDefinition, inspectToolsDefinition];

package/src/agents/tools/minimal/index.ts

@@ -1,3 +0,0 @@
-export * from "./callTool";
-export * from "./inspectTools";
-export * from "./definitions";

package/src/agents/tools/minimal/inspectTools.ts

@@ -1,27 +0,0 @@
-import { minimatch } from "minimatch";
-import { MinimalToolsService } from "../../../services/MinimalToolsService";
-import { ToolsService } from "../../../services/Tools";
-
-/**
- * Returns the full tool definitions (schema) for all tools matching the given patterns.
- * Used by agents to discover argument shapes before calling via callTool.
- */
-export function inspectTools(
-  this: ToolsService,
-  patterns?: string[]
-): object[] {
-  const service = this as unknown as MinimalToolsService;
-  const allTools = service.getAllTools ? service.getAllTools() : service.getTools();
-
-  if (!patterns || patterns.length === 0) {
-    return allTools.map((t) => t.function);
-  }
-
-  return allTools
-    .filter((t) =>
-      patterns.some((pattern) =>
-        minimatch(t.function.name, pattern, { nocase: true })
-      )
-    )
-    .map((t) => t.function);
-}

package/src/agents/tools/modifyFile.ts

@@ -1,53 +0,0 @@
-import * as fs from "fs";
-import { createPatch } from "diff";
-
-import { FileBlock } from "./types/fileblock";
-import { readFile } from "./readFile";
-import { getConfig } from "../../config";
-import { lintFile, readBlocks } from ".";
-export async function modifyFile(fileBlocks: FileBlock[], filePath: string) {
-  try {
-    const exists = fs.existsSync(filePath);
-    const contentToUpdate = exists ? await readBlocks(filePath) : [];
-    const edits = {};
-    const before = [...contentToUpdate];
-    const beforeContent = before.map((b) => b.content).join("");
-
-    for (const block of fileBlocks) {
-      if (!contentToUpdate[block.blockNumber]) {
-        contentToUpdate[block.blockNumber] = {
-          blockNumber: block.blockNumber,
-          content: "",
-        };
-      }
-
-      contentToUpdate[block.blockNumber].content = block.content;
-      edits[block.blockNumber] = contentToUpdate[block.blockNumber];
-    }
-
-    const newContent = contentToUpdate.map((b) => b.content).join("");
-    fs.writeFileSync(filePath, newContent);
-    const newBlocks = await readFile(filePath);
-
-    console.log("====BEFORE====");
-    console.log(beforeContent);
-    console.log("====AFTER====");
-    console.log(newContent);
-
-    const config = await getConfig();
-    const extension = filePath.split(".").pop();
-    const lintResult = await lintFile(filePath);
-
-    return `
-    Your changes generated this diff:
-    ${createPatch(filePath, beforeContent, newContent)}
-
-    ${lintResult && "Linting Result"}
-    ${lintResult || ""}
-
-    Are you sure that was correct? .
-    `;
-  } catch (e) {
-    return e.message;
-  }
-}