@tyvm/knowhow 0.0.159 → 0.0.161

package/src/plugins/url.ts

@@ -1,101 +0,0 @@
-import { PluginBase, PluginMeta } from "./PluginBase";
-import { Plugin, PluginContext } from "./types";
-import { MinimalEmbedding } from "../types";
-
-export class UrlPlugin extends PluginBase implements Plugin {
-  static readonly meta: PluginMeta = {
-    key: "url",
-    name: "URL Plugin",
-    requires: [],
-  };
-
-  meta = UrlPlugin.meta;
-
-  constructor(context: PluginContext) {
-    super(context);
-  }
-
-  async embed(userPrompt: string): Promise<MinimalEmbedding[]> {
-    const urls = this.extractUrls(userPrompt);
-    const embeddings = await Promise.all(urls.map((url) => this.fetchAndParseUrl(url)));
-    return embeddings.filter((e): e is MinimalEmbedding => e !== null);
-  }
-
-  extractUrls(userPrompt: string): string[] {
-    const urlRegex = /(https?:\/\/[^\s]+)/g;
-    const urls = userPrompt.match(urlRegex) || [];
-    return Array.from(new Set(urls));
-  }
-
-  async fetchAndParseUrl(url: string): Promise<MinimalEmbedding | null> {
-    try {
-      const response = await fetch(url, {
-        headers: {
-          "User-Agent": "Mozilla/5.0 (compatible; KnowhowBot/1.0)",
-          "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        },
-      });
-
-      if (!response.ok) {
-        this.log(`URL PLUGIN: Failed to fetch ${url}: ${response.status}`, "warn");
-        return null;
-      }
-
-      const contentType = response.headers.get("content-type") || "";
-      let text = "";
-
-      if (contentType.includes("text/html") || contentType.includes("text/plain")) {
-        const html = await response.text();
-        // Simple HTML to text: strip tags
-        text = html
-          .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
-          .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
-          .replace(/<[^>]+>/g, " ")
-          .replace(/\s+/g, " ")
-          .trim();
-      } else {
-        text = await response.text();
-      }
-
-      this.log(`URL PLUGIN: Fetched content from ${url}: ${text.substring(0, 100)}`);
-
-      return {
-        id: url + "-url",
-        text,
-        metadata: { url },
-      };
-    } catch (error) {
-      this.log(`Error fetching or parsing URL ${url}: ${error}`, "error");
-      return null;
-    }
-  }
-
-  async call(userPrompt: string): Promise<string> {
-    const urls = this.extractUrls(userPrompt);
-    if (urls.length === 0) {
-      return "URL PLUGIN: No URLs detected.";
-    }
-
-    if (urls.length > 10) {
-      return "URL PLUGIN: Too many URLs detected. Skipping like unintentional bulk browse.";
-    }
-
-    const results = await Promise.all(urls.map((url) => this.fetchAndParseUrl(url)));
-    const validResults = results.filter(
-      (r): r is MinimalEmbedding => r !== null
-    );
-
-    if (validResults.length === 0) {
-      return "URL PLUGIN: Failed to fetch or parse any URLs.";
-    }
-
-    const formattedResults = validResults
-      .map(
-        (result) =>
-          `URL: ${result.metadata.url}\n\nContent:\n${result.text.substring(0, 500)}...`
-      )
-      .join("\n\n---\n\n");
-
-    return `URL PLUGIN: Successfully fetched and parsed the following URLs:\n\n${formattedResults}`;
-  }
-}

package/src/plugins/vim.ts

@@ -1,89 +0,0 @@
-import { globSync } from "glob";
-import { readFile, fileExists, fileStat } from "../utils";
-import { PluginBase, PluginMeta } from "./PluginBase";
-import { PluginContext } from "./types";
-
-export class VimPlugin extends PluginBase {
-  static readonly meta: PluginMeta = {
-    key: "vim",
-    name: "Vim Plugin",
-    requires: [],
-  };
-
-  meta = VimPlugin.meta;
-
-  constructor(context: PluginContext) {
-    super(context);
-  }
-
-  async embed(userPrompt: string) {
-    return [];
-  }
-
-  async getVimFiles() {
-    const vimFiles = globSync("./**/*.swp", { dot: true });
-    return vimFiles;
-  }
-
-  async getSourcePath(vimPath: string, dotFile = false) {
-    const pathParts = vimPath.split("/");
-    const fileName = pathParts[pathParts.length - 1];
-    const cleanedFileName = fileName.slice(1, fileName.length - 4);
-    const sourcePath = pathParts.slice(0, pathParts.length - 1).join("/");
-    const finalPath = sourcePath + "/" + cleanedFileName;
-    const dotFilePath = sourcePath + "/." + cleanedFileName;
-
-    const finalFileExists = await fileExists(finalPath);
-
-    if (finalFileExists) {
-      return finalPath;
-    }
-
-    const dotFileExists = await fileExists(dotFilePath);
-    if (dotFileExists) {
-      return dotFilePath;
-    }
-
-    return finalPath;
-  }
-
-  async getFileContents(swapFile: string) {
-    const filePath = await this.getSourcePath(swapFile);
-    const exists = await fileExists(filePath);
-    if (!exists) {
-      return { filePath, content: "FILE DOES NOT EXIST" };
-    }
-
-    const stat = await fileStat(filePath);
-    if (stat.isDirectory()) {
-      return { filePath, content: "DIRECTORY" };
-    }
-    if (stat.size > 32000) {
-      this.log(
-        `VIM PLUGIN: File ${filePath} is too large with size ${stat.size}`,
-        "error"
-      );
-      return { filePath, content: "FILE TOO LARGE" };
-    }
-
-    this.log(`VIM PLUGIN: Reading file ${filePath}`);
-    const content = await readFile(filePath, "utf8");
-    return { filePath, content };
-  }
-
-  async call() {
-    const vimFiles = await this.getVimFiles();
-    const fileContents = vimFiles.map((f) => {
-      return {
-        sourceFile: f,
-      };
-    });
-    if (fileContents.length === 0) {
-      return "VIM PLUGIN: No files open in vim";
-    }
-    return (
-      "VIM PLUGIN: The following files are open in vim: " +
-      JSON.stringify(fileContents)
-    );
-  }
-}

package/src/processes/ProcessManager.ts

@@ -1,96 +0,0 @@
-import { spawn } from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-import { randomBytes } from "crypto";
-
-export type ManagedProcessState = "starting" | "running" | "exited" | "failed" | "stopped";
-export interface ManagedProcessStatus {
-  id: string; pid: number | null; shimPid: number | null; state: ManagedProcessState;
-  command: string; args: string[]; cwd: string; parentProcessId: string | null;
-  parentPid: number | null; background: boolean; startedAt: string; endedAt: string | null;
-  exitCode: number | null; signal: string | null; error?: string;
-}
-export interface SpawnManagedOptions {
-  id?: string; cwd?: string; env?: NodeJS.ProcessEnv; background?: boolean;
-  parentProcessId?: string; parentPid?: number; shell?: boolean; processesDir?: string;
-}
-export interface ManagedProcessInfo { id: string; directory: string; status: ManagedProcessStatus; }
-
-export function getProcessesDir(cwd = process.cwd()): string {
-  return process.env.KNOWHOW_PROCESSES_DIR || path.join(cwd, ".knowhow", "processes");
-}
-export function processDirectory(id: string, processesDir = getProcessesDir()): string {
-  if (!/^[a-zA-Z0-9._-]+$/.test(id)) throw new Error(`Invalid process id: ${id}`);
-  return path.join(processesDir, id);
-}
-export function readManagedStatus(id: string, processesDir = getProcessesDir()): ManagedProcessStatus {
-  return JSON.parse(fs.readFileSync(path.join(processDirectory(id, processesDir), "status.json"), "utf8"));
-}
-export function listManagedProcesses(processesDir = getProcessesDir()): ManagedProcessInfo[] {
-  if (!fs.existsSync(processesDir)) return [];
-  return fs.readdirSync(processesDir, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(processesDir, entry.name, "status.json")))
-    .flatMap((entry) => { try { return [{ id: entry.name, directory: path.join(processesDir, entry.name), status: readManagedStatus(entry.name, processesDir) }]; } catch { return []; } })
-    .sort((a, b) => b.status.startedAt.localeCompare(a.status.startedAt));
-}
-function makeId(command: string): string {
-  const ts = Date.now();
-  const name = path.basename(command).replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 28) || "process";
-  return `${ts}-${name}-${randomBytes(3).toString("hex")}`;
-}
-function waitForFile(file: string, timeoutMs: number): Promise<void> {
-  const started = Date.now();
-  return new Promise((resolve, reject) => { const check = () => {
-    if (fs.existsSync(file)) return resolve();
-    if (Date.now() - started >= timeoutMs) return reject(new Error(`Managed process did not initialize: ${file}`));
-    setTimeout(check, 20);
-  }; check(); });
-}
-export class ManagedProcess {
-  constructor(public readonly id: string, public readonly directory: string) {}
-  get status(): ManagedProcessStatus { return readManagedStatus(this.id, path.dirname(this.directory)); }
-  get stdoutPath(): string { return path.join(this.directory, "stdout"); }
-  get stderrPath(): string { return path.join(this.directory, "stderr"); }
-  get inputLogPath(): string { return path.join(this.directory, "input.log"); }
-  get stdinPath(): string { return path.join(this.directory, "stdin"); }
-  async write(input: string): Promise<void> {
-    if (process.platform === "win32") {
-      await fs.promises.appendFile(this.stdinPath, input);
-      return;
-    }
-    // A non-blocking open fails promptly with ENXIO if the shim is gone instead
-    // of leaving callers hung forever waiting for a FIFO reader.
-    const handle = await fs.promises.open(this.stdinPath, fs.constants.O_WRONLY | fs.constants.O_NONBLOCK);
-    try { await handle.writeFile(input); } finally { await handle.close(); }
-  }
-  signal(signal: NodeJS.Signals = "SIGTERM"): void {
-    const status = this.status;
-    if (!status.pid) throw new Error(`Process ${this.id} has no active pid`);
-    try { process.kill(-status.pid, signal); } catch { process.kill(status.pid, signal); }
-  }
-  async wait(timeoutMs?: number): Promise<ManagedProcessStatus> {
-    const started = Date.now();
-    while (true) {
-      const status = this.status;
-      if (!["starting", "running"].includes(status.state)) return status;
-      if (timeoutMs !== undefined && Date.now() - started >= timeoutMs) throw new Error(`Timed out waiting for managed process ${this.id} after ${timeoutMs}ms`);
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  }
-}
-export async function spawnManaged(command: string, args: string[] = [], options: SpawnManagedOptions = {}): Promise<ManagedProcess> {
-  const cwd = path.resolve(options.cwd || process.cwd());
-  const processesDir = options.processesDir || getProcessesDir(cwd);
-  const id = options.id || makeId(command);
-  const directory = processDirectory(id, processesDir);
-  fs.mkdirSync(processesDir, { recursive: true });
-  fs.mkdirSync(directory);
-  const configPath = path.join(directory, "launch.json");
-  fs.writeFileSync(configPath, JSON.stringify({ id, command, args, cwd, env: options.env || {}, background: options.background === true, parentProcessId: options.parentProcessId || null, parentPid: options.parentPid ?? process.pid, shell: options.shell === true, processesDir }, null, 2));
-  const shimPath = path.resolve(__dirname, "managedProcessShim.js");
-  const shim = spawn(process.execPath, [shimPath, configPath], { cwd, detached: true, stdio: "ignore", env: process.env });
-  shim.unref();
-  try { await waitForFile(path.join(directory, "status.json"), 5000); }
-  catch (error) { try { fs.rmSync(directory, { recursive: true, force: true }); } catch {} throw error; }
-  return new ManagedProcess(id, directory);
-}

package/src/processes/managedProcessShim.ts

@@ -1,138 +0,0 @@
-import { spawn, spawnSync, ChildProcess } from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-import type { ManagedProcessStatus } from "./ProcessManager";
-
-interface LaunchConfig {
-  id: string; command: string; args: string[]; cwd: string; env: NodeJS.ProcessEnv;
-  background: boolean; parentProcessId: string | null; parentPid: number | null;
-  shell: boolean; processesDir: string;
-}
-
-function atomicJson(file: string, value: unknown): void {
-  const tmp = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(tmp, JSON.stringify(value, null, 2));
-  fs.renameSync(tmp, file);
-}
-function alive(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch (error: any) { return error?.code === "EPERM"; }
-}
-function terminateGroup(child: ChildProcess, signal: NodeJS.Signals): void {
-  if (!child.pid) return;
-  try { process.kill(-child.pid, signal); } catch { try { child.kill(signal); } catch {} }
-}
-
-export async function runManagedProcessShim(configPath: string): Promise<void> {
-  const config: LaunchConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
-  const dir = path.dirname(configPath);
-  const startedAt = new Date().toISOString();
-  const statusPath = path.join(dir, "status.json");
-  const stdoutPath = path.join(dir, "stdout");
-  const stderrPath = path.join(dir, "stderr");
-  const inputLogPath = path.join(dir, "input.log");
-  const fifoPath = path.join(dir, "stdin");
-  fs.closeSync(fs.openSync(stdoutPath, "a"));
-  fs.closeSync(fs.openSync(stderrPath, "a"));
-  fs.closeSync(fs.openSync(inputLogPath, "a"));
-
-  if (process.platform !== "win32") {
-    const result = spawnSync("mkfifo", [fifoPath]);
-    if (result.status !== 0 && !fs.existsSync(fifoPath)) throw new Error(`Unable to create stdin FIFO: ${result.stderr?.toString()}`);
-  } else {
-    // Windows has no POSIX FIFO. Keep the same path as an append-only inbox fallback.
-    fs.closeSync(fs.openSync(fifoPath, "a"));
-  }
-
-  let status: ManagedProcessStatus = {
-    id: config.id, pid: null, shimPid: process.pid, state: "starting", command: config.command,
-    args: config.args, cwd: config.cwd, parentProcessId: config.parentProcessId,
-    parentPid: config.parentPid, background: config.background, startedAt, endedAt: null,
-    exitCode: null, signal: null,
-  };
-  const writeStatus = () => atomicJson(statusPath, status);
-  atomicJson(path.join(dir, "metadata.json"), {
-    id: config.id, command: config.command, args: config.args, cwd: config.cwd,
-    parentProcessId: config.parentProcessId, parentPid: config.parentPid,
-    background: config.background, createdAt: startedAt, shimPid: process.pid,
-  });
-  fs.writeFileSync(path.join(dir, "pid"), "");
-  writeStatus();
-
-  const stdoutFd = fs.openSync(stdoutPath, "a");
-  const stderrFd = fs.openSync(stderrPath, "a");
-  const child = spawn(config.command, config.args, {
-    cwd: config.cwd, shell: config.shell, detached: process.platform !== "win32",
-    stdio: ["pipe", stdoutFd, stderrFd],
-    env: { ...process.env, ...config.env, KNOWHOW_MANAGED_PROCESS_ID: config.id, KNOWHOW_MANAGED_PROCESS_DIR: dir },
-  });
-  fs.closeSync(stdoutFd); fs.closeSync(stderrFd);
-  status = { ...status, pid: child.pid || null, state: "running" };
-  fs.writeFileSync(path.join(dir, "pid"), child.pid ? `${child.pid}\n` : "");
-  writeStatus();
-
-  let fifoStream: fs.ReadStream | undefined;
-  if (process.platform !== "win32") {
-    // O_RDWR prevents transient writers disconnecting from delivering EOF to the shim.
-    const fifoFd = fs.openSync(fifoPath, fs.constants.O_RDWR);
-    fifoStream = fs.createReadStream("", { fd: fifoFd, autoClose: true });
-    fifoStream.on("data", (chunk) => {
-      fs.appendFileSync(inputLogPath, chunk);
-      if (child.stdin?.writable) child.stdin.write(chunk);
-    });
-  }
-
-  let stoppingForParent = false;
-  const parentTimer = !config.background && config.parentPid
-    ? setInterval(() => {
-        if (!alive(config.parentPid!)) {
-          stoppingForParent = true;
-          terminateGroup(child, "SIGTERM");
-          setTimeout(() => { if (alive(child.pid || -1)) terminateGroup(child, "SIGKILL"); }, 3000).unref();
-        }
-      }, 500)
-    : undefined;
-  parentTimer?.unref();
-
-  const forward = (signal: NodeJS.Signals) => terminateGroup(child, signal);
-  process.once("SIGINT", () => forward("SIGINT"));
-  process.once("SIGTERM", () => forward("SIGTERM"));
-  process.once("SIGHUP", () => forward("SIGHUP"));
-
-  await new Promise<void>((resolve) => {
-    child.once("error", (error) => {
-      status = { ...status, state: "failed", error: error.message, endedAt: new Date().toISOString() };
-      writeStatus(); resolve();
-    });
-    child.once("exit", (code, signal) => {
-      status = { ...status, state: stoppingForParent || signal ? "stopped" : code === 0 ? "exited" : "failed", endedAt: new Date().toISOString(), exitCode: code, signal };
-      writeStatus(); resolve();
-    });
-  });
-  if (parentTimer) clearInterval(parentTimer);
-  if (fifoStream && !fifoStream.closed) {
-    // A FIFO read cannot always be cancelled by closing its descriptor (notably
-    // on macOS). Wake the pending read before asking ReadStream to close it;
-    // otherwise each completed command can leave its shim wedged in close(2).
-    const wakeFd = fs.openSync(fifoPath, fs.constants.O_WRONLY | fs.constants.O_NONBLOCK);
-    try {
-      fs.writeSync(wakeFd, Buffer.from([0]));
-    } finally {
-      fs.closeSync(wakeFd);
-    }
-    await new Promise<void>((resolve) => {
-      fifoStream!.once("close", resolve);
-      fifoStream!.destroy();
-    });
-  }
-}
-
-// Managed processes invoke this module directly. Keeping this entry point here
-// avoids booting the full CLI (config, chat services, command modules, and
-// plugins) before every command can write its initial status.
-if (require.main === module) {
-  runManagedProcessShim(path.resolve(process.argv[2]))
-    .catch((error) => {
-      console.error(error);
-      process.exitCode = 1;
-    });
-}