@tyvm/knowhow 0.0.47 → 0.0.48

package/src/agents/tools/ast/astListPaths.ts

@@ -0,0 +1,66 @@
+import * as fs from "fs";
+import { fileExists } from "../../../utils";
+import { services, ToolsService } from "../../../services";
+import { LanguageAgnosticParser } from "../../../plugins/tree-sitter/parser";
+import { TreeEditor } from "../../../plugins/tree-sitter/editor";
+
+/**
+ * List all available simple paths in a file using tree-sitter AST parsing
+ */
+export async function astListPaths(filePath: string): Promise<string> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const context = toolService.getContext();
+
+  if (context.Events) {
+    await context.Events.emitBlocking("file:pre-read", {
+      filePath,
+    });
+    await context.Events.emitNonBlocking("ast:pre-list-paths", {
+      filePath,
+    });
+  }
+
+  const exists = await fileExists(filePath);
+  if (!exists) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+
+    if (!LanguageAgnosticParser.supportsFile(filePath)) {
+      throw new Error(`Unsupported file type for AST parsing: ${filePath}`);
+    }
+
+    const parser = LanguageAgnosticParser.createParserForFile(filePath);
+    const editor = new TreeEditor(parser, content);
+    const paths = editor.getAllSimplePaths();
+
+    // Emit post-action event
+    if (context.Events) {
+      await context.Events.emitNonBlocking("file:post-read", {
+        filePath,
+        content,
+      });
+      await context.Events.emitNonBlocking("ast:post-list-paths", {
+        filePath,
+        paths,
+      });
+    }
+
+    const result = {
+      file: filePath,
+      language: parser.getLanguage(),
+      totalPaths: paths.length,
+      paths: paths.sort(),
+    };
+
+    return JSON.stringify(result, null, 2);
+  } catch (error: any) {
+    throw new Error(`Failed to parse file ${filePath}: ${error.message}`);
+  }
+}

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

@@ -0,0 +1,7 @@
+// AST Tools - Tree-sitter based tools for parsing and modifying code structure
+
+export { astEditNode } from "./astEditNode";
+export { astAppendNode } from "./astAppendNode";
+export { astDeleteNode } from "./astDeleteNode";
+export { astListPaths } from "./astListPaths";
+export { astGetPathForLine } from "./astGetPathForLine";

package/src/agents/tools/callPlugin.ts

@@ -1,4 +1,10 @@
-import { Plugins } from "../../plugins/plugins";
+import { services } from "../../services";
+import { ToolsService } from "../../services";
 export async function callPlugin(pluginName: string, userInput: string) {
-  return Plugins.call(pluginName, userInput);
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  return toolService.getContext().Plugins.call(pluginName, userInput);
 }

package/src/agents/tools/embeddingSearch.ts

@@ -1,5 +1,6 @@
 // Tool to search for files related to the user's goal
-import { Plugins } from "../../plugins/plugins";
+import { services } from "../../services";
 export async function embeddingSearch(keyword: string): Promise<string> {
+  const { Plugins } = services();
   return Plugins.call("embeddings", keyword);
 }

package/src/agents/tools/execCommand.ts

@@ -1,135 +1,280 @@
-import { exec } from "child_process";
+import { exec, spawn, ExecException } from "child_process";
 import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
 
 const execAsync = promisify(exec);
 
 export interface ExecCommandOptions {
-  timeout?: number; // Timeout in milliseconds (default: 5000)
-  continueInBackground?: boolean; // Whether to let command continue in background on timeout (default: false)
-  waitForCompletion?: boolean; // Whether to wait for full completion regardless of timeout (default: false)
+  timeout?: number; // ms; -1 = wait indefinitely
+  continueInBackground?: boolean; // allow to keep running on timeout
+  maxBuffer?: number; // for exec()
 }
 
-// Enhanced exec function with timeout support
-const execWithTimeout = async (
-  command: string,
-  options: ExecCommandOptions = {}
-): Promise<{
+type ExecResult = {
   stdout: string;
   stderr: string;
   timedOut: boolean;
   killed: boolean;
-}> => {
-  const { timeout = 5000, continueInBackground = false, waitForCompletion = false } = options;
+  pid?: number;
+  logPath?: string;
+};
 
-  // If waitForCompletion is explicitly true, ignore timeout and wait indefinitely
-  if (waitForCompletion === true) {
-    try {
-      const result = await execAsync(command);
-      return { ...result, timedOut: false, killed: false };
-    } catch (error) {
-      return {
-        stdout: error.stdout || "",
-        stderr: error.stderr || error.message,
-        timedOut: false,
-        killed: false,
-      };
+const PROCESSES_DIR = path.join(process.cwd(), ".knowhow", "processes");
+fs.mkdirSync(PROCESSES_DIR, { recursive: true });
+
+const STARTED_PIDS = new Set<number>();
+setupProcessCleanup();
+
+// ---------- utils ----------
+function stripTrailingAmp(cmd: string) {
+  const t = cmd.trim();
+  return t.endsWith("&") ? t.replace(/&\s*$/, "").trim() : t;
+}
+
+function commandNameFrom(cmd: string) {
+  const cleaned = stripTrailingAmp(cmd);
+  const first = cleaned.split(/\s+/)[0] || "command";
+  return first.replace(/[^\w.-]+/g, "_");
+}
+
+function makeLogPath(cmd: string) {
+  const name = commandNameFrom(cmd);
+  return path.join(PROCESSES_DIR, `${name}.txt`);
+}
+
+function setupProcessCleanup() {
+  const killAll = () => {
+    for (const pid of STARTED_PIDS) {
+      try {
+        if (os.platform() === "win32") {
+          spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            detached: true,
+          }).unref();
+        } else {
+          try {
+            process.kill(-pid, "SIGTERM");
+          } catch {
+            try {
+              process.kill(pid, "SIGTERM");
+            } catch {}
+          }
+        }
+      } catch {}
     }
-  }
+  };
+  process.once("exit", killAll);
+  process.once("SIGINT", () => {
+    killAll();
+    process.exit(130);
+  });
+  process.once("SIGTERM", () => {
+    killAll();
+    process.exit(143);
+  });
+  process.once("uncaughtException", (e) => {
+    console.error(e);
+    killAll();
+    process.exit(1);
+  });
+  process.once("unhandledRejection", (e: any) => {
+    console.error(e);
+    killAll();
+    process.exit(1);
+  });
+}
+
+// ---------- core ----------
+const execWithTimeout = async (
+  command: string,
+  opts: ExecCommandOptions = {}
+): Promise<ExecResult> => {
+  const {
+    timeout = 5000,
+    continueInBackground = false,
+    maxBuffer = 1024 * 1024 * 16,
+  } = opts;
 
-  // Timeout behavior when waitForCompletion is false
-  return new Promise((resolve) => {
-    const childProcess = exec(command, (error, stdout, stderr) => {
-      if (error && !error.killed) {
+  const cleaned = stripTrailingAmp(command);
+  const shouldBg = continueInBackground || command.trim().endsWith("&");
+
+  // Foreground, indefinite wait → stream with spawn
+  if (timeout === -1 && !shouldBg) {
+    return new Promise<ExecResult>((resolve) => {
+      let out = "";
+      let err = "";
+      const child = spawn(cleaned, { shell: true });
+      child.stdout?.on("data", (d) => (out += d.toString()));
+      child.stderr?.on("data", (d) => (err += d.toString()));
+      child.once("error", (e) =>
         resolve({
-          stdout,
-          stderr: stderr || error.message,
+          stdout: out,
+          stderr: err || String(e),
           timedOut: false,
           killed: false,
-        });
-      } else {
+          pid: child.pid ?? undefined,
+        })
+      );
+      child.once("exit", () =>
         resolve({
-          stdout,
-          stderr,
+          stdout: out,
+          stderr: err,
           timedOut: false,
-          killed: error?.killed || false,
-        });
-      }
+          killed: false,
+          pid: child.pid ?? undefined,
+        })
+      );
     });
+  }
 
-    const timeoutId = setTimeout(() => {
-      if (!continueInBackground) {
-        // Kill the process if continueInBackground is false (default behavior)
-        childProcess.kill("SIGTERM");
-        // Force kill after additional 5 seconds if still running
-        setTimeout(() => {
-          if (!childProcess.killed) {
-            childProcess.kill("SIGKILL");
-          }
-        }, 5000);
-        resolve({
+  if (shouldBg) {
+    // --- BACKGROUND MODE WITH CHILD-OWNED LOG FD ---
+    const logPath = makeLogPath(cleaned);
+
+    // Open the log file now; we'll pass this FD to the child so it writes directly.
+    // Use 'w' to truncate old logs and guarantee our header goes first.
+    const fd = fs.openSync(logPath, "w");
+
+    // Spawn detached; bind stdout/stderr to the same file.
+    const child = spawn(cleaned, {
+      shell: true,
+      detached: true,
+      stdio: ["ignore", fd, fd], // child writes directly to file for its entire lifetime
+    });
+
+    // Immediately write header (first line includes PID), then close *our* fd.
+    // The child keeps its own duplicated handle open.
+    const pid = child.pid!;
+    const header =
+      `PID: ${pid}\n` +
+      `CMD: ${cleaned}\n` +
+      `START: ${new Date().toISOString()}\n` +
+      `---\n`;
+    fs.writeSync(fd, header);
+    fs.fsyncSync(fd); // flush header before we let go
+    try {
+      fs.closeSync(fd);
+    } catch {}
+
+    // We only wait 'timeout' ms to return; process keeps running/logging after that.
+    return await new Promise<ExecResult>((resolve) => {
+      let settled = false;
+
+      const done = (res: ExecResult) => {
+        if (settled) return;
+        settled = true;
+        resolve({ ...res, pid, logPath });
+      };
+
+      child.once("error", (e) =>
+        done({
           stdout: "",
-          stderr: `Command timed out after ${timeout}ms and was killed`,
-          timedOut: true,
-          killed: true,
-        });
-      } else {
-        // Let command continue in background
-        resolve({
+          stderr: `Failed to start command: ${String(e)}`,
+          timedOut: false,
+          killed: false,
+        })
+      );
+
+      const tid = setTimeout(() => {
+        // fully detach from our side
+        try {
+          child.unref();
+        } catch {}
+        STARTED_PIDS.add(pid);
+        done({
           stdout: "",
-          stderr: `Command timed out after ${timeout}ms but is still running in background`,
+          stderr:
+            `Command timed out after ${timeout}ms but continues in background\n` +
+            `Logs: ${logPath}\n` +
+            `Tip: read first line for PID; kill by PID for cleanup.\n`,
           timedOut: true,
           killed: false,
         });
-      }
-    }, timeout);
+      }, timeout);
 
-    // Clear timeout if command completes before timeout
-    childProcess.on("exit", () => {
-      clearTimeout(timeoutId);
+      // If it finishes early, report success and avoid “timed out” messaging
+      child.once("exit", () => {
+        clearTimeout(tid);
+        done({
+          stdout: "",
+          stderr: `Process finished before timeout. Logs: ${logPath}\n`,
+          timedOut: false,
+          killed: false,
+        });
+      });
     });
+  }
+
+  // Foreground with timeout → use exec (buffered) or switch to spawn+manual timer if you prefer
+  return new Promise<ExecResult>((resolve) => {
+    let out = "";
+    let err = "";
+    const child = exec(
+      cleaned,
+      { timeout, maxBuffer },
+      (error: ExecException | null, stdout: string, stderr: string) => {
+        out = out || stdout;
+        err = err || stderr;
+        if (error) {
+          resolve({
+            stdout: out,
+            stderr: err || error.message,
+            timedOut: (error as any).killed ?? false,
+            killed: !!(error as any).killed,
+            pid: (child as any).pid ?? undefined,
+          });
+        } else {
+          resolve({
+            stdout: out,
+            stderr: err,
+            timedOut: false,
+            killed: false,
+            pid: (child as any).pid ?? undefined,
+          });
+        }
+      }
+    );
+    child.stdout?.on("data", (d) => (out += d.toString()));
+    child.stderr?.on("data", (d) => (err += d.toString()));
   });
 };
 
-// Tool to execute a command in the system's command line interface
+// Public tool
 export const execCommand = async (
   command: string,
   timeout?: number,
-  continueInBackground?: boolean,
-  waitForCompletion?: boolean
+  continueInBackground?: boolean
 ): Promise<string> => {
-  let output = "";
-  console.log("execCommand:", command);
-
-  const { stdout, stderr, timedOut, killed } = await execWithTimeout(command, {
-    timeout,
-    continueInBackground,
-    waitForCompletion,
-  });
+  const { stdout, stderr, timedOut, killed, pid, logPath } =
+    await execWithTimeout(command, {
+      timeout,
+      continueInBackground,
+    });
 
-  if (stderr) {
-    output += stderr + "\n";
-  }
-  output += stdout;
+  let output = "";
+  if (stderr) output += stderr + "\n";
+  if (stdout) output += stdout;
 
-  if (timedOut) {
-    const statusMsg = killed
+  const statusMsg = timedOut
+    ? killed
       ? " (killed due to timeout)"
-      : " (timed out, still running)";
-    console.log(`$ ${command}${statusMsg}:\n${output}`);
-  } else {
-    console.log(`$ ${command}:\n${output}`);
-  }
-
-  const fullOutput = output.split("\n");
+      : ` (timed out, still running${pid ? `, pid=${pid}` : ""}${
+          logPath ? `, logs=${logPath}` : ""
+        })`
+    : "";
 
+  const lines = output.split("\n");
   const maxLines = 1000;
-  const maxCharacters = 40000;
-  const shouldTrim = fullOutput.length > maxLines;
-  const trimmedOutput = shouldTrim ? fullOutput.slice(0, maxLines) : fullOutput;
-
-  const trimmedMessage = shouldTrim
-    ? ` (${fullOutput.length - maxLines} results trimmed)`
-    : "";
+  const maxChars = 40000;
+  const trimmed = (lines.length > maxLines ? lines.slice(0, maxLines) : lines)
+    .join("\n")
+    .slice(0, maxChars);
+  const trimmedMsg =
+    lines.length > maxLines
+      ? ` (${lines.length - maxLines} results trimmed)`
+      : "";
 
-  return trimmedOutput.join("\n").slice(0, maxCharacters) + trimmedMessage;
-};
+  return `$ ${command}${statusMsg}\n${trimmed}${trimmedMsg}`;
+};

package/src/agents/tools/fileSearch.ts

@@ -1,4 +1,4 @@
-import glob from "glob";
+import { globSync } from "glob";
 import { getConfiguredEmbeddings } from "../../embeddings";
 import { execCommand } from "./execCommand";
 import { getIgnorePattern } from "../../config";
@@ -9,25 +9,23 @@ export async function fileSearch(searchTerm) {
   const pattern = `./**/*${searchTermLower}*`;
   const ignore = await getIgnorePattern();
   console.log({ pattern, ignore });
-  const files = await glob.sync(pattern, {
+  const globFiles = globSync(pattern, {
     ignore,
+    nocase: true,
   });
 
-  if (files.length === 0) {
-    const embeddings = await getConfiguredEmbeddings();
-    const results = embeddings.filter((embedding) =>
-      embedding.id.toLowerCase().includes(searchTermLower)
-    );
+  const embeddings = await getConfiguredEmbeddings();
+  const embeddingFiles = embeddings.filter((embedding) =>
+    embedding.id.toLowerCase().includes(searchTermLower)
+  );
 
-    // ids are filepath.txt-part
-    const ids = toUniqueArray(
-      results.map((r) => {
-        const parts = r.id.split("-");
-        return parts.slice(0, -1).join("-");
-      })
-    );
-    files.push(...ids);
-  }
+  // 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 JSON.stringify(files);
+  return allFiles;
 }

package/src/agents/tools/index.ts

@@ -24,5 +24,6 @@ export * from "./googleSearch";
 export * from "./loadWebpage";
 export * from "./stringReplace";
 export * from "./executeScript";
+export * from "./ast";
 export * from "./startAgentTask";
 export * from "./ycmd";

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

@@ -1,4 +1,12 @@
-import { Plugins } from "../../../plugins/plugins";
+import { services } from "../../../services";
+function getPluginNames(): string {
+  try {
+    const { Plugins } = services();
+    return Plugins.listPlugins().join(", ");
+  } catch {
+    return "";
+  }
+}
 export const definitions = [
   {
     type: "function",
@@ -22,7 +30,7 @@ export const definitions = [
               properties: {
                 kind: {
                   type: "string",
-                  description: `The type of datasource, options are "file", "url", "text" or the name of a plugin: ${Plugins.listPlugins()}
+                  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.
                   `,

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

@@ -1,10 +1,10 @@
-import { Plugins } from "../../../plugins/plugins";
+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] = { sources };
+  language[term] = { events: [], sources };
   await updateLanguageConfig(language);
 }
 
@@ -14,6 +14,7 @@ export async function getAllLanguageTerms() {
 }
 
 export async function lookupLanguageTerm(term: string) {
+  const { Plugins } = services();
   const language = await getLanguageConfig();
   return Plugins.call("language", term);
 }

package/src/agents/tools/lintFile.ts

@@ -9,8 +9,10 @@ export async function lintFile(filePath: string) {
     if (lintCommand.includes("$1")) {
       lintCommand = lintCommand.replace("$1", filePath);
     }
-    lintResult = await execCommand(`${lintCommand}`, 0, false, true);
-    console.log("Lint Result:", lintResult);
+    lintResult = await execCommand(`${lintCommand}`, -1);
+    if (lintResult) {
+      console.log("Lint Result:", lintResult);
+    }
     return lintResult;
   }
   return "";