@tyvm/knowhow 0.0.159 → 0.0.161

package/src/agents/tools/execCommand.ts

@@ -1,162 +0,0 @@
-import * as fs from "fs";
-import { exec } from "child_process";
-import { promisify } from "util";
-import { services, ToolsService } from "../../services";
-import { getProcessesDir, ManagedProcess, processDirectory, spawnManaged } from "../../processes/ProcessManager";
-
-export const execAsync = promisify(exec);
-
-export interface ExecCommandOptions {
-  timeout?: number;
-  continueInBackground?: boolean;
-  maxBuffer?: number;
-  logFileName?: string;
-  parentProcessId?: string;
-}
-
-type ExecResult = {
-  stdout: string;
-  stderr: string;
-  timedOut: boolean;
-  killed: boolean;
-  pid?: number;
-  processId: string;
-  processDirectory: string;
-  logPath: string;
-};
-
-function stripTrailingAmp(command: string): string {
-  const trimmed = command.trim();
-  return trimmed.endsWith("&") ? trimmed.replace(/&\s*$/, "").trim() : trimmed;
-}
-function readOutput(managed: ManagedProcess, maxBuffer: number): { stdout: string; stderr: string } {
-  const read = (file: string) => {
-    try {
-      const value = fs.readFileSync(file, "utf8");
-      return value.length > maxBuffer
-        ? `${value.slice(0, maxBuffer)}\n[output truncated after ${maxBuffer} characters]`
-        : value;
-    } catch { return ""; }
-  };
-  return { stdout: read(managed.stdoutPath), stderr: read(managed.stderrPath) };
-}
-async function stopAfterTimeout(managed: ManagedProcess): Promise<void> {
-  try { managed.signal("SIGTERM"); } catch {}
-  try { await managed.wait(3000); return; } catch {}
-  try { managed.signal("SIGKILL"); } catch {}
-  try { await managed.wait(1000); } catch {}
-}
-
-const execWithTimeout = async (
-  command: string,
-  options: ExecCommandOptions = {}
-): Promise<ExecResult> => {
-  const timeout = options.timeout ?? 5000;
-  const maxBuffer = options.maxBuffer ?? 16 * 1024 * 1024;
-  const background = options.continueInBackground || command.trim().endsWith("&");
-  let requestedId = options.logFileName?.replace(/[^a-zA-Z0-9._-]/g, "-");
-  if (requestedId) {
-    const base = requestedId;
-    let suffix = 0;
-    while (fs.existsSync(processDirectory(requestedId, getProcessesDir()))) requestedId = `${base}-${Date.now()}-${++suffix}`;
-  }
-  const managed = await spawnManaged(stripTrailingAmp(command), [], {
-    id: requestedId,
-    shell: true,
-    background,
-    parentPid: process.pid,
-    parentProcessId: options.parentProcessId,
-  });
-  const initial = managed.status;
-  const common = {
-    pid: initial.pid || undefined,
-    processId: managed.id,
-    processDirectory: managed.directory,
-    logPath: managed.stdoutPath,
-  };
-
-  if (background) {
-    return { stdout: "", stderr: "", timedOut: false, killed: false, ...common };
-  }
-
-  let timedOut = false;
-  if (timeout === -1) {
-    await managed.wait();
-  } else {
-    try { await managed.wait(timeout); }
-    catch {
-      timedOut = true;
-      await stopAfterTimeout(managed);
-    }
-  }
-  const output = readOutput(managed, maxBuffer);
-  return { ...output, timedOut, killed: timedOut, ...common };
-};
-
-/** Execute a shell command through the durable managed-process subsystem. */
-export async function execCommand(
-  command: string,
-  timeout?: number | string,
-  continueInBackground?: boolean,
-  logFileName?: string,
-  _ctx?: { taskId?: string }
-): Promise<string> {
-  if (!command || typeof command !== "string") {
-    throw new Error("Invalid command. We received a non-string value. Please ensure you are sending strings of 4k tokens or less.");
-  }
-
-  const toolService = (this instanceof ToolsService ? this : services().Tools) as ToolsService;
-  let normalizedTimeout: number | undefined;
-  const rawTimeout = typeof timeout === "string" ? Number(timeout.trim()) : timeout;
-  if (typeof rawTimeout !== "number" || !Number.isFinite(rawTimeout)) normalizedTimeout = undefined;
-  else if (rawTimeout === -1) normalizedTimeout = -1;
-  else normalizedTimeout = Math.max(0, Math.floor(rawTimeout));
-
-  let correctedTimeout = normalizedTimeout;
-  let timeoutWarning = "";
-  if (normalizedTimeout !== undefined && normalizedTimeout !== -1 && normalizedTimeout < 100) {
-    correctedTimeout = normalizedTimeout * 1000;
-    timeoutWarning = `⚠️  Warning: timeout was ${normalizedTimeout}ms which is extremely small and likely a mistake. The timeout unit is milliseconds, not seconds. Auto-corrected to ${correctedTimeout}ms (${normalizedTimeout}s).\n\n`;
-  }
-
-  const context = toolService.getContext();
-  if (context.Events) {
-    await context.Events.emitBlocking("exec:pre-run", { command, timeout, continueInBackground, logFileName });
-  }
-
-
-  const parentProcessId = process.env.KNOWHOW_MANAGED_PROCESS_ID || _ctx?.taskId;
-  const result = await execWithTimeout(command, {
-    timeout: correctedTimeout,
-    continueInBackground,
-    logFileName,
-    parentProcessId,
-  });
-  const { stdout, stderr, timedOut, killed, pid, processId, processDirectory, logPath } = result;
-
-  let output = "";
-  if (stderr) output += stderr + (stderr.endsWith("\n") ? "" : "\n");
-  if (stdout) output += stdout;
-  const background = continueInBackground || command.trim().endsWith("&");
-  const statusMsg = background
-    ? ` (managed background process, id=${processId}, pid=${pid || "starting"})`
-    : timedOut
-      ? " (killed due to timeout)"
-      : "";
-  if (background) {
-    output += `Process directory: ${processDirectory}\nStdout: ${logPath}\nStderr: ${result.processDirectory}/stderr\n`;
-  }
-  const rendered = `$ ${command}${statusMsg}\n${output}`;
-
-  let eventResults: any[] = [];
-  if (context.Events) {
-    eventResults = await context.Events.emitBlocking("exec:post-run", {
-      command, timeout, continueInBackground, logFileName,
-      stdout, stderr, timedOut, killed, pid, logPath, processId, processDirectory, output,
-    });
-  }
-  const eventResultsText = eventResults?.length
-    ? "\n\nAdditional Information:\n" + JSON.stringify(eventResults, null, 2)
-    : "";
-  return timeoutWarning + rendered + eventResultsText;
-}

package/src/agents/tools/fileSearch.ts

@@ -1,35 +0,0 @@
-import { globSync } from "glob";
-import { getConfiguredEmbeddings } from "../../embeddings";
-import { execCommand } from "./execCommand";
-import { getIgnorePattern } from "../../config";
-import { toUniqueArray } from "../../utils";
-
-export async function fileSearch(searchTerm) {
-  const searchTermLower = searchTerm.toLowerCase();
-  const pattern = `./**/*${searchTermLower}*`;
-  const ignore = await getIgnorePattern();
-  console.log({ pattern, ignore });
-  const globFiles = globSync(pattern, {
-    ignore,
-    nocase: true,
-  });
-
-  const embeddings = await getConfiguredEmbeddings();
-  
-  // Ensure embeddings is always an array
-  const embeddingsArray = Array.isArray(embeddings) ? embeddings : [];
-  
-  const embeddingFiles = embeddingsArray.filter((embedding) =>
-    embedding.id.toLowerCase().includes(searchTermLower)
-  );
-
-  // ids are filepath.txt-part
-  const embeddingIds = embeddingFiles.map((r) => {
-    const parts = r.id.split("-");
-    return parts.slice(0, -1).join("-");
-  });
-
-  const allFiles = toUniqueArray([...globFiles, ...embeddingIds]);
-
-  return allFiles;
-}

package/src/agents/tools/finalAnswer.ts

@@ -1,4 +0,0 @@
-// Finalize the AI's task and return the answer to the user
-export function finalAnswer(answer: string): string {
-  return answer;
-}

package/src/agents/tools/googleSearch.ts

@@ -1,243 +0,0 @@
-import http from "../../utils/http";
-import { Tool } from "../../clients/types";
-
-interface GoogleSearchParams {
-  q: string;
-  cx?: string;
-  dateRestrict?: string;
-  siteSearch?: string;
-  siteSearchFilter?: "e" | "i";
-  sort?: string;
-  start?: number;
-  lr?: string;
-  num?: number;
-  [key: string]: any;
-}
-
-// Google Search API Response Types
-interface GoogleSearchUrlTemplate {
-  type: string;
-  template: string;
-}
-
-interface GoogleSearchQuery {
-  title: string;
-  totalResults: string;
-  searchTerms: string;
-  count: number;
-  startIndex: number;
-  startPage: number;
-  language: string;
-  inputEncoding: string;
-  outputEncoding: string;
-  safe: string;
-  cx: string;
-  sort: string;
-  filter: string;
-  gl: string;
-  cr: string;
-  googleHost: string;
-  disableCnTwTranslation: string;
-  hq: string;
-  hl: string;
-  siteSearch: string;
-  siteSearchFilter: string;
-  exactTerms: string;
-  excludeTerms: string;
-  linkSite: string;
-  orTerms: string;
-  relatedSite: string;
-  dateRestrict: string;
-  lowRange: string;
-  highRange: string;
-  fileType: string;
-  rights: string;
-  searchType: string;
-  imgSize: string;
-  imgType: string;
-  imgColorType: string;
-  imgDominantColor: string;
-}
-
-interface GoogleSearchQueries {
-  previousPage: GoogleSearchQuery[];
-  request: GoogleSearchQuery[];
-  nextPage: GoogleSearchQuery[];
-}
-
-interface GoogleSearchInformation {
-  searchTime: number;
-  formattedSearchTime: string;
-  totalResults: string;
-  formattedTotalResults: string;
-}
-
-interface GoogleSearchSpelling {
-  correctedQuery: string;
-  htmlCorrectedQuery: string;
-}
-
-export interface GoogleSearchResponse {
-  kind: string;
-  url: GoogleSearchUrlTemplate;
-  queries: GoogleSearchQueries;
-  promotions?: any[];
-  context?: any;
-  searchInformation: GoogleSearchInformation;
-  spelling?: GoogleSearchSpelling;
-  items?: any[];
-}
-
-interface LlmRelevantSearchResult {
-  title: string;
-  link: string;
-  snippet: string;
-  source?: string;
-}
-
-interface TransformedLlmResponse {
-  searchQuery: string;
-  totalResults?: string;
-  results: LlmRelevantSearchResult[];
-}
-
-/**
- * Transforms the Google Custom Search API response to a more LLM-relevant format.
- * It prioritizes plain text fields and extracts essential information.
- *
- * @param apiResponse The original API response from Google Custom Search.
- * @returns An object containing the search query and a list of processed search results.
- */
-function transformGoogleSearchResponseForLLM(
-  apiResponse: GoogleSearchResponse
-) {
-  const searchQuery =
-    apiResponse.queries?.request?.[0]?.searchTerms || "Unknown query";
-  const totalResults = apiResponse.searchInformation?.totalResults;
-
-  const relevantItems: LlmRelevantSearchResult[] = (
-    apiResponse.items || []
-  ).map((item) => {
-    let bestSnippet = item.snippet || ""; // Default to the item's snippet
-
-    const metaTags = item.pagemap?.metatags?.[0];
-    if (metaTags) {
-      const ogDescription = metaTags["og:description"];
-      const twitterDescription = metaTags["twitter:description"];
-      const genericDescription = metaTags?.description;
-
-      // Prefer meta descriptions if they are longer or provide more context
-      if (ogDescription && ogDescription.length > bestSnippet.length) {
-        bestSnippet = ogDescription;
-      } else if (
-        twitterDescription &&
-        twitterDescription.length > bestSnippet.length
-      ) {
-        bestSnippet = twitterDescription;
-      } else if (
-        genericDescription &&
-        genericDescription.length > bestSnippet.length
-      ) {
-        bestSnippet = genericDescription;
-      }
-    }
-
-    return {
-      title: item.title,
-      link: item.link,
-      snippet: bestSnippet,
-      source: item.displayLink,
-    };
-  });
-
-  return {
-    searchQuery,
-    totalResults,
-    results: relevantItems,
-    usd_cost: 0.005,
-  };
-}
-
-export async function googleSearch(params: GoogleSearchParams) {
-  const apiKey = process.env.GOOGLE_SEARCH_API_KEY;
-  const cx = process.env.GOOGLE_SEARCH_CX;
-  if (!apiKey) {
-    throw new Error("GOOGLE_SEARCH_API_KEY environment variable is not set");
-  }
-  if (!cx) {
-    throw new Error("GOOGLE_SEARCH_CX environment variable is not set");
-  }
-
-  const baseUrl = "https://www.googleapis.com/customsearch/v1";
-  const url = new URL(baseUrl);
-  url.searchParams.append("key", apiKey);
-  url.searchParams.append("cx", cx);
-
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== undefined) {
-      url.searchParams.append(key, value.toString());
-    }
-  }
-
-  try {
-    const response = await http.get<GoogleSearchResponse>(url.toString());
-    return transformGoogleSearchResponseForLLM(response.data);
-  } catch (error) {
-    console.error("Error performing Google search:", error);
-    throw error;
-  }
-}
-
-export const googleSearchDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "googleSearch",
-    description: "Perform a Google search using the Custom Search API",
-    parameters: {
-      type: "object",
-      properties: {
-        q: {
-          type: "string",
-          description: "The search query",
-        },
-        num: {
-          type: "number",
-          description:
-            "The number of search results to return (optional, default is 10, max is 10)",
-        },
-        start: {
-          type: "number",
-          description:
-            "The index of the first result to return (optional, default is 1)",
-        },
-        dateRestrict: {
-          type: "string",
-          description:
-            "Restricts results to URLs based on date. Format: [d|w|m|y]NUMBER. Example: 'd10' for past 10 days",
-        },
-        siteSearch: {
-          type: "string",
-          description: "Specifies a site to search within",
-        },
-        siteSearchFilter: {
-          type: "string",
-          description:
-            "Controls whether to include or exclude results from the site specified in siteSearch. 'e' to exclude, 'i' to include",
-        },
-        sort: {
-          type: "string",
-          description:
-            "The sort expression to apply to the results, e.g., 'date'",
-        },
-        lr: {
-          type: "string",
-          description:
-            "Restricts the search to documents written in a particular language (e.g., lr=lang_ja)",
-        },
-      },
-      required: ["q"],
-    },
-  },
-};
-
-export default googleSearch;

package/src/agents/tools/index.ts

@@ -1,33 +0,0 @@
-export * from "./addInternalTools";
-export * from "./agentCall";
-export * from "./callPlugin";
-export * from "./embeddingSearch";
-export * from "./execCommand";
-export * from "./finalAnswer";
-export * from "./index";
-export * from "./lintFile";
-export * from "./modifyFile";
-export * from "./patch";
-export * from "./readBlocks";
-export * from "./readFile";
-export * from "./scanFile";
-export * from "./textSearch";
-export * from "./visionTool";
-export * from "./loadImageAsBase64";
-export * from "./writeFile";
-export * from "./fileSearch";
-export * from "./language";
-export * from "./askHuman";
-export * from "./aiClient";
-export * from "./googleSearch";
-export * from "./stringReplace";
-export * from "./startAgentTask";
-export * from "./replyToParent";
-export * from "./runGenerate";
-export * from "./sendAgentMessage";
-export * from "./connectAgent";
-export * from "./waitForAgentCompleted";
-export * from "./observe";
-export * from "./ycmd";
-export * from "./mcp";
-export * from "./skills";

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

@@ -1,105 +0,0 @@
-import { services } from "../../../services";
-function getPluginNames(): string {
-  try {
-    const { Plugins } = services();
-    return Plugins.listPlugins().join(", ");
-  } catch {
-    return "";
-  }
-}
-export const definitions = [
-  {
-    type: "function",
-    function: {
-      name: "addLanguageTerm",
-      description:
-        "Add a new language term to the language config, which can help load context for given terms in the future.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          term: {
-            type: "string",
-            description:
-              "The trigger word(s) that should load the given context",
-          },
-          sources: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                kind: {
-                  type: "string",
-                  description: `The type of datasource, options are "file", "url", "text" or the name of a plugin: ${getPluginNames()}
-                  For files you must use the full relative path. For plugins you must use the name of the plugin associated with the data.
-                  Always use a plugin as the kind, if a plugin name is in the url.
-                  `,
-                },
-                data: {
-                  type: "array",
-                  items: {
-                    type: "string",
-                  },
-                  description:
-                    "An array of strings that will be loaded when a language term is used in a user prompt. If the kind was a plugin, then we'll call the plugin with each string as input. Strings of the same kind should be grouped together in one array of data.",
-                },
-              },
-              required: ["kind", "data"],
-            },
-            description: "The sources to be loaded for the given term",
-          },
-        },
-        required: ["term"],
-      },
-      returns: {
-        type: "string",
-        description: "The response from the human.",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "getAllLanguageTerms",
-      description:
-        "Retrieves all language terms from the language configuration.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {},
-        required: [],
-      },
-      returns: {
-        type: "array",
-        items: {
-          type: "string",
-        },
-        description: "An array of all language terms in the configuration.",
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "lookupLanguageTerm",
-      description:
-        "Looks up a specific language term and calls the language plugin with it.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          term: {
-            type: "string",
-            description: "The language term to look up",
-          },
-        },
-        required: ["term"],
-      },
-      returns: {
-        type: "any",
-        description:
-          "The result of calling the language plugin with the specified term.",
-      },
-    },
-  },
-];

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

@@ -1,20 +0,0 @@
-import { services } from "../../../services";
-import { getLanguageConfig, updateLanguageConfig } from "../../../config";
-import { IDatasource } from "../../../types";
-
-export async function addLanguageTerm(term: string, sources: IDatasource[]) {
-  const language = await getLanguageConfig();
-  language[term] = { events: [], sources };
-  await updateLanguageConfig(language);
-}
-
-export async function getAllLanguageTerms() {
-  const language = await getLanguageConfig();
-  return Object.keys(language);
-}
-
-export async function lookupLanguageTerm(term: string) {
-  const { Plugins } = services();
-  const language = await getLanguageConfig();
-  return Plugins.call("language", term);
-}

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

@@ -1,72 +0,0 @@
-import { Tool } from "../../../clients/types";
-
-export const listAvailableToolsDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "listAvailableTools",
-    description:
-      "List all available tools in the system, showing which are currently enabled and disabled. Use this to discover what tools exist before enabling them. Optionally filter by glob patterns to search for specific tools.",
-    parameters: {
-      type: "object",
-      positional: true,
-      properties: {
-        patterns: {
-          type: "array",
-          items: { type: "string" },
-          description:
-            "Optional array of glob patterns to filter tool names. Examples: ['read*'] finds all tools starting with 'read', ['*File'] finds all tools ending with 'File', ['mcp_*'] finds all MCP tools. If omitted, all tools are listed.",
-        },
-      },
-      required: [],
-    },
-  },
-};
-
-export const enableToolsDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "enableTools",
-    description:
-      "Enable tools matching glob patterns. Examples: ['read*'] enables all tools starting with 'read', ['mcp_*_browser_*'] enables all browser MCP tools, ['*File'] enables all tools ending with 'File'. Pass an array of pattern strings.",
-    parameters: {
-      type: "object",
-      positional: true,
-      properties: {
-        patterns: {
-          type: "array",
-          items: { type: "string" },
-          description:
-            "Array of glob patterns to match tool names.",
-        },
-      },
-      required: ["patterns"],
-    },
-  },
-};
-
-export const disableToolsDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "disableTools",
-    description:
-      "Disable tools matching glob patterns. This removes tools from the available tool list to stay within provider limits. Pass an array of pattern strings.",
-    parameters: {
-      type: "object",
-      positional: true,
-      properties: {
-        patterns: {
-          type: "array",
-          items: { type: "string" },
-          description: "Array of glob patterns to match tool names for disabling.",
-        },
-      },
-      required: ["patterns"],
-    },
-  },
-};
-
-export const definitions = [
-  listAvailableToolsDefinition,
-  enableToolsDefinition,
-  disableToolsDefinition,
-];

package/src/agents/tools/lazy/disableTools.ts

@@ -1,16 +0,0 @@
-import { LazyToolsService } from "../../../services/LazyToolsService";
-import { ToolsService } from "../../../services/Tools";
-
-export async function disableTools(
-  this: ToolsService,
-  patterns: string[]
-) {
-  if (!(this instanceof LazyToolsService)) {
-    return {
-      error: "This tool requires LazyToolsService",
-      message: "disableTools is only available when using LazyToolsService",
-    };
-  }
-
-  return this.disableTools(patterns);
-}