@tyvm/knowhow 0.0.109-dev.e88af1e → 0.0.110

package/src/commands/modules.ts

@@ -4,6 +4,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import { getConfig, getGlobalConfig, updateConfig, updateGlobalConfig } from "../config";
+import * as readline from "readline";
 
 // Default built-in modules that `knowhow modules setup` adds to the config.
 export const BUILTIN_MODULES = [
@@ -49,6 +50,234 @@ function npmInstallToKnowhow(mod: string, knowhowDir: string): void {
   });
 }
 
+/**
+ * Returns true if a module package is already installed in the given knowhow dir.
+ */
+function isModuleInstalled(mod: string, knowhowDir: string): boolean {
+  try {
+    require.resolve(mod, {
+      paths: [path.join(knowhowDir, "node_modules"), knowhowDir],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+interface NpmRegistryInfo {
+  latestVersion: string;
+  publishedAt: string;
+}
+
+/**
+ * Fetch the latest version and publish time from the npm registry for a package.
+ * Returns null if the package info can't be fetched.
+ */
+async function fetchNpmRegistryInfo(mod: string): Promise<NpmRegistryInfo | null> {
+  try {
+    // npm view <pkg> version time --json returns either a single value or array
+    const output = execSync(`npm view ${mod} version time --json`, {
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    });
+    const parsed = JSON.parse(output.trim());
+    let latestVersion: string;
+    let timestamps: Record<string, string> = {};
+    if (Array.isArray(parsed)) {
+      latestVersion = parsed[0];
+      timestamps = parsed[1] || {};
+    } else if (parsed && typeof parsed === "object") {
+      latestVersion = parsed["version"] || "";
+      timestamps = parsed["time"] || {};
+    } else {
+      latestVersion = String(parsed);
+    }
+    const publishedAt = timestamps[latestVersion] || timestamps["modified"] || "";
+    return { latestVersion, publishedAt };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Simple engine range checker — handles the common cases:
+ *   ">=22"  ">=22.0.0"  "^20"  "20.x"  "*"  ""
+ * Returns true if the given nodeVersion satisfies the range.
+ * Falls back to true (permissive) for unsupported range syntax.
+ */
+function nodeSatisfiesRange(nodeVersion: string, range: string): boolean {
+  if (!range || range === "*" || range === "") return true;
+
+  // Parse "major.minor.patch" from e.g. "v20.17.0"
+  const vMatch = nodeVersion.replace(/^v/, "").match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!vMatch) return true;
+  const vMajor = parseInt(vMatch[1], 10);
+  const vMinor = parseInt(vMatch[2] ?? "0", 10);
+  const vPatch = parseInt(vMatch[3] ?? "0", 10);
+  const vNum = vMajor * 1_000_000 + vMinor * 1_000 + vPatch;
+
+  function parseVersion(s: string): number {
+    const m = s.trim().match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!m) return 0;
+    return parseInt(m[1], 10) * 1_000_000 + parseInt(m[2] ?? "0", 10) * 1_000 + parseInt(m[3] ?? "0", 10);
+  }
+
+  // Handle " || " — any segment satisfying is fine
+  if (range.includes("||")) {
+    return range.split("||").some((r) => nodeSatisfiesRange(nodeVersion, r.trim()));
+  }
+
+  // Handle space-separated AND conditions e.g. ">=14 <18"
+  const parts = range.trim().split(/\s+/);
+  for (const part of parts) {
+    const gteMatch = part.match(/^>=(.+)/);
+    const gtMatch = part.match(/^>(?!=)(.+)/);
+    const lteMatch = part.match(/^<=(.+)/);
+    const ltMatch = part.match(/^<(?!=)(.+)/);
+    const caretMatch = part.match(/^\^(\d+)/);
+    const tildeMatch = part.match(/^~(\d+)(?:\.(\d+))?/);
+    const exactMatch = part.match(/^(\d+(?:\.\d+)*)/);
+
+    if (gteMatch) {
+      if (vNum < parseVersion(gteMatch[1])) return false;
+    } else if (gtMatch) {
+      if (vNum <= parseVersion(gtMatch[1])) return false;
+    } else if (lteMatch) {
+      if (vNum > parseVersion(lteMatch[1])) return false;
+    } else if (ltMatch) {
+      if (vNum >= parseVersion(ltMatch[1])) return false;
+    } else if (caretMatch) {
+      const base = parseVersion(caretMatch[1]);
+      const baseMajor = parseInt(caretMatch[1], 10);
+      if (vNum < base || vMajor !== baseMajor) return false;
+    } else if (tildeMatch) {
+      const baseMajor = parseInt(tildeMatch[1], 10);
+      const baseMinor = parseInt(tildeMatch[2] ?? "0", 10);
+      const base = parseVersion(`${baseMajor}.${baseMinor}`);
+      const nextMinor = parseVersion(`${baseMajor}.${baseMinor + 1}`);
+      if (vNum < base || vNum >= nextMinor) return false;
+    } else if (exactMatch && !part.startsWith("v")) {
+      // e.g. "20.x" or "20"
+      const xMatch = part.match(/^(\d+)(?:\.x)?$/);
+      if (xMatch) {
+        if (vMajor !== parseInt(xMatch[1], 10)) return false;
+      }
+    }
+    // Unknown operators — fall through (permissive)
+  }
+  return true;
+}
+
+/**
+ * Fetch the latest version of a package that is compatible with the current
+ * Node.js engine. Falls back to "@latest" if no engine info is available.
+ *
+ * Uses the npm registry API to get per-version engine requirements.
+ */
+async function fetchLatestCompatibleVersion(mod: string): Promise<string> {
+  const currentNode = process.version; // e.g. "v20.17.0"
+  try {
+    // Encode scoped package names for URL (e.g. @tyvm/pkg -> @tyvm%2Fpkg)
+    const encodedMod = mod.replace(/^@/, "").replace("/", "%2F");
+    const registryUrl = mod.startsWith("@")
+      ? `https://registry.npmjs.org/@${encodedMod}`
+      : `https://registry.npmjs.org/${mod}`;
+
+    const response = await fetch(registryUrl);
+    if (!response.ok) throw new Error(`Registry returned ${response.status}`);
+    const pkgData = await response.json() as any;
+
+    // pkgData.versions is a map of version -> package metadata
+    const versionsMap: Record<string, any> = pkgData.versions ?? {};
+    const allVersions = Object.keys(versionsMap);
+
+    // Build per-version engine map from actual per-version metadata
+    const enginesByVersion: Record<string, string> = {};
+    for (const [v, meta] of Object.entries(versionsMap)) {
+      enginesByVersion[v] = (meta as any)?.engines?.node ?? "";
+    }
+
+    if (allVersions.length === 0) return `${mod}@latest`;
+
+    // Sort versions descending (simple semver numeric sort)
+    const sorted = [...allVersions].sort((a, b) => {
+      const pa = a.split(".").map(Number);
+      const pb = b.split(".").map(Number);
+      for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pb[i] ?? 0) - (pa[i] ?? 0);
+      }
+      return 0;
+    });
+
+    for (const v of sorted) {
+      const engineRange = enginesByVersion[v] ?? "";
+      if (nodeSatisfiesRange(currentNode, engineRange)) {
+        return `${mod}@${v}`;
+      }
+    }
+
+    // No compatible version found — warn and fall back to latest
+    console.warn(`⚠️  No version of ${mod} found compatible with Node ${currentNode}. Installing latest anyway.`);
+    return `${mod}@latest`;
+  } catch {
+    // Can't fetch registry info — fall back to latest
+    return `${mod}@latest`;
+  }
+}
+
+/**
+ * Get the currently installed version of a package in .knowhow/node_modules.
+ */
+function getInstalledVersion(mod: string, knowhowDir: string): string | null {
+  try {
+    const pkgJsonPath = path.join(knowhowDir, "node_modules", mod, "package.json");
+    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+    return pkgJson.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format a date string as a human-readable relative time (e.g. "2 days ago").
+ */
+function formatRelativeTime(isoDate: string): string {
+  if (!isoDate) return "unknown";
+  const then = new Date(isoDate).getTime();
+  if (isNaN(then)) return "unknown";
+  const diffMs = Date.now() - then;
+  const diffMins = Math.floor(diffMs / 60_000);
+  if (diffMins < 2) return "just now";
+  if (diffMins < 60) return `${diffMins} minutes ago`;
+  const diffHours = Math.floor(diffMins / 60);
+  if (diffHours < 24) return `${diffHours} hour${diffHours !== 1 ? "s" : ""} ago`;
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffDays < 30) return `${diffDays} day${diffDays !== 1 ? "s" : ""} ago`;
+  const diffMonths = Math.floor(diffDays / 30);
+  if (diffMonths < 12) return `${diffMonths} month${diffMonths !== 1 ? "s" : ""} ago`;
+  const diffYears = Math.floor(diffMonths / 12);
+  return `${diffYears} year${diffYears !== 1 ? "s" : ""} ago`;
+}
+
+/**
+ * Prompt the user for a yes/no confirmation.
+ */
+function promptConfirm(question: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(`${question} (y/N) `, (answer) => {
+      rl.close();
+      resolve(
+        answer.trim().toLowerCase() === "y" ||
+          answer.trim().toLowerCase() === "yes"
+      );
+    });
+  });
+}
+
 export function addModulesCommand(program: Command): void {
   const modulesCmd = program
     .command("modules")
@@ -70,39 +299,39 @@ export function addModulesCommand(program: Command): void {
 
         if (!cfg.modules) cfg.modules = [];
 
-        const toAdd = BUILTIN_MODULES.filter(
-          (m) => !cfg.modules!.includes(m)
-        );
-
-        if (toAdd.length === 0) {
-          console.log(
-            `✅ All default modules are already in ${configLabel}. Nothing to do.`
-          );
-          return;
-        }
-
         const knowhowDir = getKnowhowDir(isGlobal);
         ensureKnowhowPackageJson(knowhowDir);
 
-        // Install packages that are not local file paths
-        for (const mod of toAdd) {
+        // Even if modules are already in the config, they may not be installed.
+        // Check and install any that are missing from .knowhow/node_modules.
+        let anyChanges = false;
+        for (const mod of BUILTIN_MODULES) {
           if (!mod.startsWith(".") && !mod.startsWith("/")) {
-            console.log(`📦 Installing ${mod}...`);
-            npmInstallToKnowhow(mod, knowhowDir);
+            if (!isModuleInstalled(mod, knowhowDir)) {
+              const installTarget = await fetchLatestCompatibleVersion(mod);
+              console.log(`📦 Installing ${installTarget}...`);
+              npmInstallToKnowhow(installTarget, knowhowDir);
+              console.log(`✅ Installed ${mod}`);
+              anyChanges = true;
+            }
+          }
+          if (!cfg.modules.includes(mod)) {
+            cfg.modules.push(mod);
+            console.log(`✅ Added ${mod} to ${configLabel}`);
+            anyChanges = true;
           }
-          cfg.modules!.push(mod);
-          console.log(`✅ Added ${mod} to ${configLabel}`);
         }
 
-        if (isGlobal) {
-          await updateGlobalConfig(cfg);
+        if (!anyChanges) {
+          console.log(
+            `✅ All default modules are already in ${configLabel} and installed. Nothing to do.`
+          );
         } else {
-          await updateConfig(cfg);
+          await (isGlobal ? updateGlobalConfig(cfg) : updateConfig(cfg));
+          console.log(
+            `\n🎉 Setup complete! Modules ready in ${knowhowDir}/node_modules.`
+          );
         }
-
-        console.log(
-          `\n🎉 Setup complete! ${toAdd.length} module(s) added to ${configLabel}`
-        );
       } catch (error: any) {
         console.error("Error during modules setup:", error.message ?? error);
         process.exit(1);
@@ -116,6 +345,7 @@ export function addModulesCommand(program: Command): void {
       "If no module name is given, installs all modules already in the config."
     )
     .option("--global", "Use the global config (~/.knowhow/knowhow.json)")
+    .option("--latest", "Force install the latest version (bypasses package-lock)")
     .action(async (moduleName: string | undefined, opts) => {
       try {
         const isGlobal: boolean = opts.global ?? false;
@@ -135,9 +365,7 @@ export function addModulesCommand(program: Command): void {
             (m) => !m.startsWith(".") && !m.startsWith("/")
           );
           if (installable.length === 0) {
-            console.log(
-              `ℹ No installable modules found in ${configLabel}.`
-            );
+            console.log(`ℹ No installable modules found in ${configLabel}.`);
             return;
           }
           console.log(
@@ -145,7 +373,8 @@ export function addModulesCommand(program: Command): void {
           );
           for (const mod of installable) {
             console.log(`  📦 Installing ${mod}...`);
-            npmInstallToKnowhow(mod, knowhowDir);
+            const installTarget = opts.latest ? await fetchLatestCompatibleVersion(mod) : mod;
+            npmInstallToKnowhow(installTarget, knowhowDir);
             console.log(`  ✅ Installed ${mod}`);
           }
           console.log(`\n🎉 All modules installed!`);
@@ -153,8 +382,9 @@ export function addModulesCommand(program: Command): void {
         }
 
         // Install the specified module
-        console.log(`📦 Installing ${moduleName} into ${knowhowDir}/node_modules...`);
-        npmInstallToKnowhow(moduleName, knowhowDir);
+        const installTarget = opts.latest ? await fetchLatestCompatibleVersion(moduleName) : moduleName;
+        console.log(`📦 Installing ${installTarget} into ${knowhowDir}/node_modules...`);
+        npmInstallToKnowhow(installTarget, knowhowDir);
         console.log(`✅ Installed ${moduleName}`);
 
         // Add to config if not already there
@@ -214,4 +444,109 @@ export function addModulesCommand(program: Command): void {
         process.exit(1);
       }
     });
+
+  modulesCmd
+    .command("update")
+    .description(
+      "Check for updates to all modules in your config and update them. " +
+      "Shows installed vs latest version with publish date before updating."
+    )
+    .option("--global", "Use the global config (~/.knowhow/knowhow.json)")
+    .option("-y, --yes", "Skip confirmation prompt and update all outdated modules automatically")
+    .action(async (opts) => {
+      try {
+        const isGlobal: boolean = opts.global ?? false;
+        const skipConfirm: boolean = opts.yes ?? false;
+        const cfg = isGlobal ? await getGlobalConfig() : await getConfig();
+        const configLabel = isGlobal
+          ? "~/.knowhow/knowhow.json"
+          : ".knowhow/knowhow.json";
+
+        if (!cfg.modules || cfg.modules.length === 0) {
+          console.log(`ℹ No modules found in ${configLabel}.`);
+          return;
+        }
+
+        const knowhowDir = getKnowhowDir(isGlobal);
+        ensureKnowhowPackageJson(knowhowDir);
+
+        // Only check npm packages (not local paths)
+        const installable = cfg.modules.filter(
+          (m) => !m.startsWith(".") && !m.startsWith("/")
+        );
+
+        if (installable.length === 0) {
+          console.log(`ℹ No npm modules found in ${configLabel}.`);
+          return;
+        }
+
+        console.log(`🔍 Checking for updates to ${installable.length} module(s)...\n`);
+
+        interface UpdateInfo {
+          mod: string;
+          installed: string | null;
+          latest: string;
+          compatibleVersion: string; // e.g. "@tyvm/knowhow-module-script@0.0.4"
+          publishedAt: string;
+          needsUpdate: boolean;
+        }
+
+        const updates: UpdateInfo[] = [];
+
+        for (const mod of installable) {
+          const registryInfo = await fetchNpmRegistryInfo(mod);
+          if (!registryInfo) {
+            console.log(`  ⚠️  ${mod}: could not fetch registry info (skipping)`);
+            continue;
+          }
+          const installed = getInstalledVersion(mod, knowhowDir);
+          const { latestVersion, publishedAt } = registryInfo;
+          // Find the latest compatible version for the current Node.js engine
+          const compatibleInstallTarget = await fetchLatestCompatibleVersion(mod);
+          const compatibleVersion = compatibleInstallTarget.replace(/^[^@]+@/, ""); // strip "pkg@" prefix
+          const needsUpdate = installed !== compatibleVersion;
+          const timeAgo = formatRelativeTime(publishedAt);
+
+          if (needsUpdate) {
+            const installedStr = installed ?? "(not installed)";
+            const versionLabel = compatibleVersion !== latestVersion
+              ? `${compatibleVersion} (latest compatible with Node ${process.version}; absolute latest: ${latestVersion})`
+              : compatibleVersion;
+            console.log(`  📦 ${mod}`);
+            console.log(`     installed: ${installedStr}  →  latest: ${versionLabel} (published ${timeAgo})`);
+          } else {
+            console.log(`  ✅ ${mod}  v${compatibleVersion}  (up to date, published ${timeAgo})`);
+          }
+          updates.push({ mod, installed, latest: compatibleVersion, compatibleVersion: compatibleInstallTarget, publishedAt, needsUpdate });
+        }
+
+        const toUpdate = updates.filter((u) => u.needsUpdate);
+
+        if (toUpdate.length === 0) {
+          console.log(`\n✅ All modules are up to date!`);
+          return;
+        }
+
+        console.log(`\n${toUpdate.length} module(s) can be updated.`);
+
+        if (!skipConfirm) {
+          const confirmed = await promptConfirm(`Update ${toUpdate.length} module(s) now?`);
+          if (!confirmed) {
+            console.log("Cancelled.");
+            return;
+          }
+        }
+
+        console.log("");
+        for (const { mod, compatibleVersion } of toUpdate) {
+          console.log(`  📦 Updating ${compatibleVersion}...`);
+          npmInstallToKnowhow(compatibleVersion, knowhowDir);
+          console.log(`  ✅ Updated ${mod}`);
+        }
+        console.log(`\n🎉 Update complete! ${toUpdate.length} module(s) updated.`);
+      } catch (error: any) {
+        console.error("Error during modules update:", error.message ?? error);
+        process.exit(1);
+      }
+    });
 }

package/src/config.ts

@@ -74,7 +74,7 @@ const defaultConfig = {
       description:
         "You can define agents in the config. They will have access to all tools.",
       instructions: "Reply to the user saying 'Hello, world!'",
-      model: "gpt-4o-2024-08-06",
+      model: "gpt-5.4-nano",
       provider: "openai",
     },
   ],

package/src/hashes.ts

@@ -54,18 +54,17 @@ export async function checkNoFilesChanged(
       return false;
     }
 
-    if (
+    // Check if this file has changed (either format)
+    const matchesLegacy =
       hashes[file].promptHash === promptHash &&
-      hashes[file].fileHash === fileHash
-    ) {
-      return true;
-    }
+      hashes[file].fileHash === fileHash;
+    const matchesCurrent = hashes[file][promptHash] === fileHash;
 
-    if (hashes[file][promptHash] === fileHash) {
-      return true;
+    if (!matchesLegacy && !matchesCurrent) {
+      // This file has changed — re-generation needed
+      return false;
     }
-
-    return false;
+    // This file is unchanged — continue checking the rest
   }
 
   return true;

package/src/index.ts

@@ -184,13 +184,15 @@ export async function upload() {
  *   - Standard glob patterns (e.g. "src/**\/*.ts")
  *   - Brace expansion (e.g. "{src/a.ts,src/b.ts}")
  *   - Comma-separated file paths (e.g. "src/a.ts,src/b.ts") — auto-converted to brace expansion
+ *   - Mixed comma-separated list with globs (e.g. "src/a.ts,src/commands/**\/*.ts")
  */
 function normalizeInputPattern(input: string): string {
-  // If it already has braces or glob chars other than comma, use as-is
-  if (input.includes("{") || input.includes("*") || input.includes("?")) {
+  // If it already has braces, use as-is (already brace-expanded)
+  if (input.includes("{")) {
     return input;
   }
   // If it contains commas, treat as comma-separated list and wrap in braces
+  // This also handles the mixed case: "src/a.ts,src/commands/**/*.ts"
   if (input.includes(",")) {
     const parts = input.split(",").map((p) => p.trim());
     return `{${parts.join(",")}}`;

package/src/processors/Base64ImageDetector.ts

@@ -17,6 +17,15 @@ interface TextContent {
   text: string;
 }
 
+/**
+ * Regex that matches common image file paths (absolute, relative, or just filenames)
+ * ending in a known image extension.
+ */
+const IMAGE_PATH_REGEX =
+  /(?:^|[\s"'(,\[{])([^\s"'(,\[{]*?\.(?:png|jpe?g|gif|webp|bmp|svg))(?=$|[\s"'),\]}])/gi;
+
+const IMAGE_EXTENSIONS = ["png", "jpeg", "jpg", "gif", "webp", "bmp", "svg"];
+
 export class Base64ImageProcessor {
   private imageDetail: "auto" | "low" | "high" = "auto";
   private supportedFormats = ["png", "jpeg", "jpg", "gif", "webp"];
@@ -118,6 +127,61 @@ export class Base64ImageProcessor {
     }
   }
 
+  /**
+   * Finds all image file paths mentioned in a text string.
+   * Returns deduplicated list of paths like "/tmp/screenshot.png" or "screenshot.jpg".
+   */
+  private findImageFilePaths(text: string): string[] {
+    const found: string[] = [];
+    const seen = new Set<string>();
+    IMAGE_PATH_REGEX.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = IMAGE_PATH_REGEX.exec(text)) !== null) {
+      const filePath = match[1];
+      if (filePath && !seen.has(filePath)) {
+        seen.add(filePath);
+        found.push(filePath);
+      }
+    }
+    return found;
+  }
+
+  /**
+   * Appends a hint to a text string if image file paths are detected.
+   * The hint tells the model it can use loadImageAsBase64 to view the image.
+   */
+  private addImagePathHint(text: string): string {
+    const paths = this.findImageFilePaths(text);
+    if (paths.length === 0) return text;
+
+    const hints = paths.map(
+      (p) =>
+        `loadImageAsBase64("${p}") to view the image at ${p}`
+    );
+
+    const hintBlock =
+      paths.length === 1
+        ? `\n\n[TIP: An image file path was detected: ${paths[0]}. Use the \`loadImageAsBase64\` tool with this path to load and view the image: ${hints[0]}]`
+        : `\n\n[TIP: Image file paths were detected. Use the \`loadImageAsBase64\` tool to load and view them:\n${hints.map((h) => `  - ${h}`).join("\n")}]`;
+
+    return text + hintBlock;
+  }
+
+  /**
+   * Applies image path hints to a message's text content items.
+   */
+  private applyImagePathHintsToMessage(message: Message): void {
+    if (typeof message.content === "string") {
+      message.content = this.addImagePathHint(message.content);
+    } else if (Array.isArray(message.content)) {
+      for (const item of message.content) {
+        if (item && (item as TextContent).type === "text" && typeof (item as TextContent).text === "string") {
+          (item as TextContent).text = this.addImagePathHint((item as TextContent).text);
+        }
+      }
+    }
+  }
+
   private processToolCallArguments(message: Message): void {
     if (message.tool_calls) {
       for (const toolCall of message.tool_calls) {
@@ -209,6 +273,15 @@ export class Base64ImageProcessor {
         // and converted to proper image content before the agent sees them
         if (message.role === "tool") {
           this.processToolMessageContent(message);
+          // After processing tool content (which may not convert to image if it's plain text
+          // describing a screenshot path), add hints for any image file paths found in the text.
+          this.applyImagePathHintsToMessage(message);
+        }
+
+        // Also apply hints to assistant messages — e.g. when an assistant message
+        // contains the result of a screenshot tool that returned a file path.
+        if (message.role === "assistant") {
+          this.applyImagePathHintsToMessage(message);
         }
 
         // Process tool calls in any message