@tyvm/knowhow 0.0.158 → 0.0.160

package/src/agents/tools/textSearch.ts

@@ -1,128 +0,0 @@
-import { getConfiguredEmbeddings } from "../../embeddings";
-import { execAsync } from "./execCommand";
-
-// Max number of matching lines (with full text) we show per file before we
-// summarize the rest as a list of line numbers.
-const PER_FILE_LINE_LIMIT = 5;
-
-interface FileMatches {
-  file: string;
-  // [lineNumber, lineText]
-  lines: Array<[number, string]>;
-}
-
-/**
- * Parse `ag --group --numbers` style output into per-file match groups.
- * With --group, ag prints the file path on its own line, followed by
- * `<lineNumber>:<text>` lines, then a blank line between files.
- */
-function parseAgGroupedOutput(stdout: string): FileMatches[] {
-  const results: FileMatches[] = [];
-  let current: FileMatches | null = null;
-
-  for (const rawLine of stdout.split("\n")) {
-    if (rawLine === "") {
-      // Blank line separates file groups
-      current = null;
-      continue;
-    }
-
-    const numberMatch = rawLine.match(/^(\d+):([\s\S]*)$/);
-    if (numberMatch && current) {
-      current.lines.push([Number(numberMatch[1]), numberMatch[2]]);
-    } else {
-      // Treat as a file header line
-      current = { file: rawLine, lines: [] };
-      results.push(current);
-    }
-  }
-
-  return results;
-}
-
-/**
- * Format the parsed matches into a helpful, readable report. Instead of ag's
- * "Too many matches ... Skipping" error, we report the total match count, the
- * line numbers, and cap the displayed lines at PER_FILE_LINE_LIMIT.
- */
-function formatMatches(files: FileMatches[]): string {
-  if (files.length === 0) return "No matches found.";
-
-  const sections: string[] = [];
-
-  for (const { file, lines } of files) {
-    const total = lines.length;
-    const shown = lines.slice(0, PER_FILE_LINE_LIMIT);
-
-    const header = `${file} (${total} match${total === 1 ? "" : "es"})`;
-    const body = shown
-      .map(([num, text]) => `${num}:${text}`)
-      .join("\n");
-
-    let section = `${header}\n${body}`;
-
-    if (total > PER_FILE_LINE_LIMIT) {
-      const remaining = lines.slice(PER_FILE_LINE_LIMIT);
-      const remainingLineNumbers = remaining.map(([num]) => num);
-      section +=
-        `\n... ${remaining.length} more match${
-          remaining.length === 1 ? "" : "es"
-        } (showing first ${PER_FILE_LINE_LIMIT} lines). ` +
-        `Remaining matches on lines: [${remainingLineNumbers.join(", ")}]`;
-    }
-
-    sections.push(section);
-  }
-
-  return sections.join("\n\n");
-}
-
-export async function textSearch(searchTerm) {
-  try {
-    // Escape the search term for safe shell usage
-    // 1) Normalize whitespace (turn newlines/tabs into spaces)
-    const normalized = String(searchTerm)
-      .replace(/\r\n?/g, "\n") // normalize CRLF/CR → LF
-      .replace(/\n/g, " ") // kill newlines
-      .replace(/\t/g, " ") // kill tabs
-      .replace(/\s+/g, " ") // collapse
-      .trim();
-
-    // 2) Escape single quotes for safe single-quoted shell arg
-    const escapedTerm = normalized.replace(/'/g, "'\\''");
-
-    // Use --group + --numbers so we can parse per-file matches ourselves and
-    // produce a richer summary (counts + line numbers) instead of ag's
-    // unhelpful "Too many matches" error. We intentionally do NOT pass -m here.
-    const command = `ag --group --numbers -Q '${escapedTerm}'`;
-    const { stdout, stderr } = await execAsync(command);
-
-    const files = parseAgGroupedOutput(stdout || "");
-    const formatted = formatMatches(files);
-
-    // Preserve any non-"too many matches" stderr (real warnings/errors), but
-    // drop ag's per-file "Too many matches ... Skipping" noise since we now
-    // handle match limits ourselves.
-    const filteredStderr = (stderr || "")
-      .split("\n")
-      .filter((line) => !/Too many matches/i.test(line))
-      .join("\n")
-      .trim();
-
-    return {
-      stdout: formatted,
-      stderr: filteredStderr,
-    };
-  } catch (err) {
-    console.log(
-      "Falling back to embeddings text search since ag was not available"
-    );
-    const searchTermLower = searchTerm.toLowerCase();
-    const embeddings = await getConfiguredEmbeddings();
-    const results = embeddings.filter((embedding) =>
-      embedding.text.toLowerCase().includes(searchTermLower)
-    );
-    results.forEach((r) => delete r.vector);
-    return results;
-  }
-}

package/src/agents/tools/types/fileblock.ts

@@ -1,5 +0,0 @@
-export interface FileBlock {
-  blockNumber: number;
-  startLine?: number;
-  content: string;
-}

package/src/agents/tools/visionTool.ts

@@ -1,35 +0,0 @@
-import { services, ToolsService } from "../../services";
-import { askGptVision } from "../../ai";
-import { Models } from "../../types";
-
-export async function visionTool(
-  imageUrl: string,
-  question: string,
-  provider = "openai",
-  model = Models.openai.GPT_4o
-) {
-  const toolService =
-    this instanceof ToolsService ? (this as ToolsService) : services().Tools;
-
-  const { Clients } = toolService.getContext();
-
-  const response = await Clients.createCompletion(provider, {
-    model,
-    max_tokens: 2500,
-    messages: [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: question },
-          {
-            type: "image_url",
-            image_url: {
-              url: imageUrl,
-            },
-          },
-        ],
-      },
-    ],
-  });
-  return response.choices[0].message.content;
-}

package/src/agents/tools/waitForAgentCompleted.ts

@@ -1,270 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { Tool } from "../../clients/types";
-import { ToolCallContext } from "../../services/Tools";
-
-/** Resolve the agents dir lazily so tests (and cwd changes) are respected. */
-function agentsDir(): string {
-  return path.join(process.cwd(), ".knowhow", "processes", "agents");
-}
-
-const TERMINAL_STATUSES = new Set([
-  "completed",
-  "failed",
-  "killed",
-  "error",
-  "done",
-]);
-
-interface AgentTaskResult {
-  taskId: string;
-  status: string;
-  costUsd: number;
-  finalAnswer?: string;
-  artifacts?: string[];
-  elapsedMs?: number;
-  timedOut?: boolean;
-  error?: string;
-}
-
-function readMeta(taskId: string): any | null {
-  try {
-    const metaPath = path.join(agentsDir(), taskId, "metadata.json");
-    if (!fs.existsSync(metaPath)) return null;
-    return JSON.parse(fs.readFileSync(metaPath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-
-function readStatusFile(taskId: string): string | null {
-  try {
-    const statusPath = path.join(agentsDir(), taskId, "status.txt");
-    if (!fs.existsSync(statusPath)) return null;
-    return fs.readFileSync(statusPath, "utf8").trim();
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Consolidated status read. metadata.status is the live/canonical value; the
- * status.txt file is a fallback signal. If metadata says the task is no longer
- * inProgress but has no explicit terminal status, treat it as completed.
- */
-function resolveStatus(meta: any | null, statusFile: string | null): string {
-  if (meta?.status) return meta.status;
-  if (statusFile) return statusFile;
-  if (meta && meta.inProgress === false) return "completed";
-  return "unknown";
-}
-
-/** Extract the last assistant message from a thread as a fallback finalAnswer. */
-function lastAssistantText(threads: any): string | undefined {
-  if (!threads) return undefined;
-  // threads may be an array of message arrays, or a flat message array.
-  let messages: any[] = [];
-  if (Array.isArray(threads)) {
-    if (threads.length && Array.isArray(threads[0])) {
-      // array of threads — flatten
-      messages = threads.flat();
-    } else {
-      messages = threads;
-    }
-  }
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg?.role === "assistant") {
-      if (typeof msg.content === "string" && msg.content.trim()) {
-        return msg.content.trim();
-      }
-      if (Array.isArray(msg.content)) {
-        const text = msg.content
-          .filter((c: any) => c?.type === "text")
-          .map((c: any) => c.text)
-          .join("\n")
-          .trim();
-        if (text) return text;
-      }
-    }
-  }
-  return undefined;
-}
-
-/**
- * Check whether a process id is still alive. Used as a fallback liveness check
- * so we don't wait forever on a task whose process crashed without writing a
- * terminal status.
- */
-function pidAlive(pid: number): boolean {
-  try {
-    // signal 0 doesn't kill — it only checks for existence/permission.
-    process.kill(pid, 0);
-    return true;
-  } catch (e: any) {
-    // ESRCH = no such process. EPERM = exists but not ours (still alive).
-    return e?.code === "EPERM";
-  }
-}
-
-/**
- * Discover the pid of a spawned agent task. AgentSyncFs.createTask records the
- * agent subprocess's own `process.pid` into metadata.json, so we read the
- * `pid` (or legacy `processId`) field from there. If it's absent (e.g. an older
- * task created before this was persisted), we skip the liveness check.
- */
-function metaPid(meta: any | null): number | undefined {
-  const pid = meta?.pid ?? meta?.processId;
-  return typeof pid === "number" ? pid : undefined;
-}
-
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-export interface WaitForAgentCompletedParams {
-  /** The taskId of the agent to wait for. */
-  taskId: string;
-  /** Max time to wait in milliseconds before returning timedOut. Default 30 min. */
-  timeoutMs?: number;
-  /** How often to poll status in milliseconds. Default 2000ms. */
-  pollIntervalMs?: number;
-  _ctx?: ToolCallContext;
-}
-
-/**
- * Block until a spawned agent task reaches a terminal status, then return a
- * structured result: { status, costUsd, finalAnswer, artifacts }.
- *
- * This is the native "join" primitive for orchestration — it must be a real
- * tool (not a script polling loop) because the script sandbox caps `sleep` and
- * burns a tool call per poll. It reads the consolidated status from
- * metadata.json / status.txt and falls back to a process-liveness check so a
- * crashed child doesn't hang the parent forever.
- */
-export async function waitForAgentCompleted(
-  params: WaitForAgentCompletedParams
-): Promise<string> {
-  const {
-    taskId,
-    timeoutMs = 30 * 60 * 1000,
-    pollIntervalMs = 2000,
-  } = params;
-
-  if (!taskId) {
-    return JSON.stringify({
-      taskId,
-      status: "error",
-      costUsd: 0,
-      error: "taskId is required for waitForAgentCompleted",
-    } as AgentTaskResult);
-  }
-
-  const taskDir = path.join(agentsDir(), taskId);
-  if (!fs.existsSync(taskDir)) {
-    return JSON.stringify({
-      taskId,
-      status: "error",
-      costUsd: 0,
-      error: `No agent task directory found for taskId: ${taskId}`,
-    } as AgentTaskResult);
-  }
-
-  const start = Date.now();
-  const interval = Math.max(250, pollIntervalMs);
-  let missingProcessPolls = 0;
-
-  while (true) {
-    const meta = readMeta(taskId);
-    const statusFile = readStatusFile(taskId);
-    const status = resolveStatus(meta, statusFile);
-
-    if (TERMINAL_STATUSES.has(status)) {
-      const finalAnswer =
-        meta?.result ?? lastAssistantText(meta?.threads);
-      const result: AgentTaskResult = {
-        taskId,
-        status,
-        costUsd: meta?.totalCostUsd ?? 0,
-        finalAnswer,
-        artifacts: meta?.artifacts,
-        elapsedMs: Date.now() - start,
-      };
-      return JSON.stringify(result);
-    }
-
-    // Liveness fallback: if metadata exposes a pid and it is no longer alive,
-    // but no terminal status was written, treat the task as failed after a
-    // couple of confirming polls (avoids a race where the process just exited
-    // but hasn't flushed its final status yet).
-    const pid = metaPid(meta);
-    if (pid !== undefined && !pidAlive(pid)) {
-      missingProcessPolls++;
-      if (missingProcessPolls >= 2) {
-        const finalAnswer =
-          meta?.result ?? lastAssistantText(meta?.threads);
-        return JSON.stringify({
-          taskId,
-          status: meta?.result ? "completed" : "failed",
-          costUsd: meta?.totalCostUsd ?? 0,
-          finalAnswer,
-          artifacts: meta?.artifacts,
-          elapsedMs: Date.now() - start,
-          error: meta?.result
-            ? undefined
-            : "Agent process exited without writing a terminal status",
-        } as AgentTaskResult);
-      }
-    } else {
-      missingProcessPolls = 0;
-    }
-
-    if (Date.now() - start >= timeoutMs) {
-      return JSON.stringify({
-        taskId,
-        status,
-        costUsd: meta?.totalCostUsd ?? 0,
-        finalAnswer: meta?.result ?? lastAssistantText(meta?.threads),
-        artifacts: meta?.artifacts,
-        elapsedMs: Date.now() - start,
-        timedOut: true,
-      } as AgentTaskResult);
-    }
-
-    await sleep(interval);
-  }
-}
-
-export const waitForAgentCompletedDefinition: Tool = {
-  type: "function",
-  function: {
-    name: "waitForAgentCompleted",
-    description:
-      "Block until a spawned agent task (started via startAgentTask or runGenerate) reaches a " +
-      "terminal status (completed/failed/killed), then return a structured JSON result with " +
-      "{ status, costUsd, finalAnswer, artifacts, elapsedMs }. This is the native way to 'join' a " +
-      "subagent — prefer it over shell polling loops with sleep. Returns immediately if the task is " +
-      "already finished, and gives up with timedOut:true after timeoutMs.",
-    parameters: {
-      type: "object",
-      positional: false,
-      usesContext: true,
-      properties: {
-        taskId: {
-          type: "string",
-          description:
-            "The taskId of the agent task to wait for (as returned/used by startAgentTask).",
-        },
-        timeoutMs: {
-          type: "number",
-          description:
-            "Maximum time to wait in milliseconds before returning with timedOut:true. Default: 1800000 (30 min).",
-        },
-        pollIntervalMs: {
-          type: "number",
-          description:
-            "How often to poll the task status in milliseconds. Default: 2000.",
-        },
-      },
-      required: ["taskId"],
-    },
-  },
-};

package/src/agents/tools/writeFile.ts

@@ -1,106 +0,0 @@
-import * as fs from "fs";
-import { services, ToolsService } from "../../services";
-
-// Tool to write the full contents of a file
-export function writeFile(filePath: string, content: string): string {
-  try {
-    fs.writeFileSync(filePath, content);
-    return `File ${filePath} written`;
-  } catch (e) {
-    return e.message;
-  }
-}
-
-export async function writeFileChunk(
-  filePath: string,
-  content: string,
-  isContinuing: boolean,
-  isDone: boolean
-) {
-  // Get context from bound ToolsService
-  const toolService = (
-    this instanceof ToolsService ? this : services().Tools
-  ) as ToolsService;
-  const context = toolService.getContext();
-
-  if (!filePath || content === undefined) {
-    throw new Error(
-      `File path and content are both required. We received: ${JSON.stringify({
-        filePath,
-        content,
-      })}. Make sure you write small chunks of content (4k tokens), otherwise you will hit output limits, resulting in content being empty.`
-    );
-  }
-
-  // Read original content for event emission
-  let originalContent = "";
-  try {
-    if (fs.existsSync(filePath)) {
-      originalContent = fs.readFileSync(filePath, "utf8");
-    }
-  } catch (error) {
-    // If we can't read the original file, continue with empty string
-    originalContent = "";
-  }
-
-  // Emit pre-edit blocking event
-  if (context.Events) {
-    await context.Events.emitBlocking("file:pre-edit", {
-      filePath,
-      operation: isContinuing ? "append" : "write",
-      content,
-      originalContent,
-    });
-  }
-
-  if (!isContinuing) {
-    fs.writeFileSync(filePath, content);
-  }
-
-  if (isContinuing) {
-    fs.appendFileSync(filePath, "\n" + content);
-  }
-
-  let message = "";
-
-  if (isContinuing) {
-    message = "Appended content to file.";
-  }
-
-  if (!isDone) {
-    message += " Continue calling this tool until file is done.";
-  }
-
-  if (isDone) {
-    message = " File write complete. Use readFile to verify";
-
-    // Emit post-edit blocking event to get event results
-    let eventResults: any[] = [];
-    if (context.Events) {
-      // Read updated content for event emission
-      const updatedContent = fs.readFileSync(filePath, "utf8");
-
-      eventResults = await context.Events.emitBlocking("file:post-edit", {
-        filePath,
-        operation: "write",
-        content,
-        originalContent,
-        updatedContent,
-      });
-    }
-
-    // Format event results
-    let eventResultsText = "";
-    if (eventResults && eventResults.length > 0) {
-      if (eventResults.length > 0) {
-        eventResultsText =
-          "\n\nAdditional Information:\n" +
-          JSON.stringify(eventResults, null, 2);
-      }
-    }
-
-    message += eventResultsText;
-  }
-
-  return message;
-}