@tyvm/knowhow 0.0.69 → 0.0.70

package/src/plugins/AgentsMdPlugin.ts

@@ -0,0 +1,118 @@
+import * as fs from "fs";
+import * as path from "path";
+import { PluginBase, PluginMeta } from "./PluginBase";
+import { Plugin, PluginContext } from "./types";
+import { MinimalEmbedding } from "../types";
+
+/**
+ * AgentsMdPlugin - Traverses directory tree upward from edited files to find
+ * agents.md files and alerts the agent about their presence.
+ */
+export class AgentsMdPlugin extends PluginBase implements Plugin {
+  static readonly meta: PluginMeta = {
+    key: "agents-md",
+    name: "AgentsMd Plugin",
+    description:
+      "Alerts the agent when an agents.md file is found near an edited file",
+    requires: [],
+  };
+
+  meta = AgentsMdPlugin.meta;
+
+  constructor(context: PluginContext) {
+    super(context);
+    this.setupEventHandlers();
+  }
+
+  private setupEventHandlers() {
+    const events = this.context?.Events;
+    if (!events) return;
+
+    const fileEvents = [
+      "file:pre-write",
+      "file:post-write",
+      "file:write",
+      "file:edit",
+    ];
+
+    fileEvents.forEach((eventType) => {
+      events.on(eventType, async (eventData: any) => {
+        await this.handleFileEvent(eventData);
+      });
+    });
+  }
+
+  private findAgentsMd(startPath: string): string | null {
+    // Resolve to absolute path
+    const absoluteStart = path.isAbsolute(startPath)
+      ? startPath
+      : path.resolve(startPath);
+
+    // Start from the directory of the file
+    let currentDir = fs.existsSync(absoluteStart)
+      ? fs.statSync(absoluteStart).isDirectory()
+        ? absoluteStart
+        : path.dirname(absoluteStart)
+      : path.dirname(absoluteStart);
+
+    const root = path.parse(currentDir).root;
+
+    while (true) {
+      const agentsMdPath = path.join(currentDir, "agents.md");
+      if (fs.existsSync(agentsMdPath)) {
+        return agentsMdPath;
+      }
+
+      // Stop at filesystem root
+      if (currentDir === root) {
+        break;
+      }
+
+      const parentDir = path.dirname(currentDir);
+      // If we can't go up anymore, stop
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+    }
+
+    return null;
+  }
+
+  private async handleFileEvent(eventData: any) {
+    try {
+      const filePath = eventData?.filePath || eventData?.path || eventData;
+      if (!filePath || typeof filePath !== "string") {
+        return;
+      }
+
+      const agentsMdPath = this.findAgentsMd(filePath);
+      if (!agentsMdPath) {
+        return;
+      }
+
+      const events = this.context?.Events;
+      if (!events) return;
+
+      const alertMessage = `There is an agents.md file detected near the edited file at \`${agentsMdPath}\`. You should read it if you haven't already.`;
+
+      events.emit("agent:msg", alertMessage);
+    } catch (error) {
+      console.error("AGENTS-MD PLUGIN: Error handling file event:", error);
+    }
+  }
+
+  async call(input?: string): Promise<string> {
+    if (input) {
+      const agentsMdPath = this.findAgentsMd(input);
+      if (agentsMdPath) {
+        return `There is an agents.md file detected near \`${input}\` at \`${agentsMdPath}\`. You should read it if you haven't already.`;
+      }
+    }
+    return "";
+  }
+
+  async embed(input: string): Promise<MinimalEmbedding[]> {
+    return [];
+  }
+}

package/src/plugins/PluginBase.ts

@@ -43,6 +43,14 @@ export abstract class PluginBase implements Plugin {
     return true; // subclasses override if needed
   }
 
+  /* ------------------------------------------------------------------ */
+  /** Default callMany implementation - delegates to call ------------ */
+  /* ------------------------------------------------------------------ */
+  async callMany(input?: string): Promise<string> {
+    // Default behavior: callMany just calls call
+    return this.call(input);
+  }
+
   /* ------------------------------------------------------------------ */
   /** Mandatory plugin actions ---------------------------------------- */
   /* ------------------------------------------------------------------ */

package/src/plugins/downloader/downloader.ts

@@ -5,10 +5,8 @@ import Logger from "progress-estimator";
 import { DownloadInfo, KeyframeInfo, TranscriptChunk } from "./types";
 import { visionTool } from "../../agents/tools/visionTool";
 import { execAsync, fileExists, readFile, mkdir } from "../../utils";
-import OpenAI from "openai";
 import { Clients } from "../../clients";
 import { Models } from "../../types";
-import { openai } from "../../ai";
 
 const logger = Logger();
 
@@ -132,7 +130,6 @@ export class DownloaderService {
     }
 
     const allTranscripts = [];
-    const openAi = openai();
     for (const file of files) {
       const chunkName = path.parse(file).name;
       const chunkTranscriptPath = path.join(
@@ -159,9 +156,11 @@ export class DownloaderService {
       }
 
       console.log("Transcribing", file);
-      const transcript = await openAi.audio.transcriptions
-        .create({
-          file: fs.createReadStream(file),
+      const fileBuffer = fs.readFileSync(file);
+      const transcript = await this.clients
+        .createAudioTranscription("openai", {
+          file: fileBuffer,
+          fileName: path.basename(file),
           model: "whisper-1",
         })
         .catch((e) => {

package/src/plugins/embedding.ts

@@ -7,7 +7,7 @@ import {
 } from "../embeddings";
 
 import { PluginBase, PluginMeta } from "./PluginBase";
-import { embed as embedFunction } from "../index";
+import { spawn } from "child_process";
 
 export class EmbeddingPlugin extends PluginBase {
   static readonly meta: PluginMeta = {
@@ -30,17 +30,19 @@ export class EmbeddingPlugin extends PluginBase {
   }
 
   /**
-   * Handle file:post-edit events by triggering embedding
+   * Handle file:post-edit events by triggering embedding in a separate process
    * @param payload The event payload containing filePath
    * @returns Status message about embedding operation
    */
   async handleFilePostEdit(payload: { filePath: string }): Promise<string> {
-    try {
-      await embedFunction();
-      return "Embedding completed successfully";
-    } catch (error) {
-      return `Embedding failed: ${error.message}`;
-    }
+    const child = spawn("knowhow", ["embed"], {
+      detached: true,
+      stdio: "ignore",
+      cwd: process.cwd(),
+    });
+    child.unref();
+    console.log(`EMBEDDING PLUGIN: Started 'knowhow embed' in background (pid: ${child.pid})`);
+    return "Embedding started in background process";
   }
 
   async call(userPrompt: string): Promise<string> {

package/src/plugins/exec.ts

@@ -0,0 +1,70 @@
+import { PluginBase, PluginMeta } from "./PluginBase";
+import { PluginContext } from "./types";
+import { execSync } from "child_process";
+
+/**
+ * Exec Plugin - Execute shell commands from language config
+ * This allows language config entries to trigger shell commands
+ */
+export class ExecPlugin extends PluginBase {
+  static readonly meta: PluginMeta = {
+    key: "exec",
+    name: "Exec Plugin",
+    requires: [],
+  };
+
+  meta = ExecPlugin.meta;
+
+  constructor(context: PluginContext) {
+    super(context);
+  }
+
+  async callMany(input?: string): Promise<string> {
+    // Only execute during callMany if input starts with ! or /!
+    if (!input) {
+      return "";
+    }
+    const trimmed = input.trim();
+    if (trimmed.startsWith("!") || trimmed.startsWith("/!")) {
+      return this.call(input);
+    }
+    return "";
+  }
+
+  async call(input: string): Promise<string> {
+    // Input should be the command to execute
+    const command = input.trim();
+
+    if (!command) {
+      return "EXEC PLUGIN: No command provided";
+    }
+
+    try {
+      console.log(`EXEC PLUGIN: Executing: ${command}`);
+
+      // Execute the command
+      const result = execSync(command, {
+        encoding: "utf8",
+        cwd: process.cwd(),
+        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+      });
+
+      return `EXEC PLUGIN: Command output from \`${command}\`:\n\`\`\`\n${result}\n\`\`\``;
+    } catch (error: any) {
+      const errorMessage = error.message;
+      const stderr = error.stderr || "";
+      const stdout = error.stdout || "";
+
+      console.error(`EXEC PLUGIN: Command failed: ${errorMessage}`);
+      if (stderr) {
+        console.error(stderr);
+      }
+
+      return `EXEC PLUGIN: Command \`${command}\` failed:\n\`\`\`\n${stdout}\n${stderr}\n${errorMessage}\n\`\`\``;
+    }
+  }
+
+  async embed(input: string) {
+    return [];
+  }
+}

package/src/plugins/github.ts

@@ -74,29 +74,45 @@ export class GitHubPlugin extends PluginBase {
   }
 
   async getDiff(url: string) {
-    const { owner, repo, pullNumber } = this.parseUrl(url);
-    console.log(
-      `GITHUB PLUGIN: Loading diff for ${owner}/${repo}#${pullNumber}`
-    );
-    const { data: diff } = await this.octokit.rest.pulls.get({
-      owner,
-      repo,
-      pull_number: parseInt(pullNumber, 10),
-      mediaType: {
-        format: "diff",
-      },
-    });
+    try {
+      const { owner, repo, pullNumber } = this.parseUrl(url);
+      console.log(
+        `GITHUB PLUGIN: Loading diff for ${owner}/${repo}#${pullNumber}`
+      );
+      const { data: diff } = await this.octokit.rest.pulls.get({
+        owner,
+        repo,
+        pull_number: parseInt(pullNumber, 10),
+        mediaType: {
+          format: "diff",
+        },
+      });
 
-    return diff;
+      return diff;
+    } catch (error) {
+      console.error(`GITHUB PLUGIN: Failed to get diff for ${url}:`, error.message);
+      if (error.status === 401) {
+        console.error("GITHUB PLUGIN: Authentication failed. Please check your GITHUB_TOKEN.");
+      }
+      return null;
+    }
   }
 
-  getPR(url: string) {
-    const { owner, repo, pullNumber } = this.parseUrl(url);
-    return this.octokit.rest.pulls.get({
-      owner,
-      repo,
-      pull_number: parseInt(pullNumber, 10),
-    });
+  async getPR(url: string) {
+    try {
+      const { owner, repo, pullNumber } = this.parseUrl(url);
+      return await this.octokit.rest.pulls.get({
+        owner,
+        repo,
+        pull_number: parseInt(pullNumber, 10),
+      });
+    } catch (error) {
+      console.error(`GITHUB PLUGIN: Failed to get PR for ${url}:`, error.message);
+      if (error.status === 401) {
+        console.error("GITHUB PLUGIN: Authentication failed. Please check your GITHUB_TOKEN.");
+      }
+      return null;
+    }
   }
 
   getLengthOfHunks(hunks: ReturnType<typeof parseHunks>) {
@@ -110,37 +126,49 @@ export class GitHubPlugin extends PluginBase {
   async getParsedDiffs(urls: string[]) {
     return Promise.all(
       urls.map(async (url) => {
-        const diff = await this.getDiff(url);
-        let parsed = parseHunks(diff.toString());
-
-        console.log(`GITHUB PLUGIN: Parsed ${parsed.length} hunks`);
-
-        const averageHunkSize =
-          parsed.reduce((acc, hunk) => acc + hunk.lines.length, 0) /
-          parsed.length;
-
-        const totalCharacters = parsed
-          .flatMap((hunk) => [...hunk.additions, ...hunk.subtractions])
-          .reduce((acc, line) => acc + line.length, 0);
-
-        console.log(
-          `GITHUB PLUGIN: Average hunk size: ${averageHunkSize}, total characters: ${totalCharacters}`
-        );
-
-        const MAX_CHARACTERS = 10000;
-        const average = MAX_CHARACTERS / averageHunkSize;
-        const PER_HUNK_LIMIT = Math.max(average, 2000);
-
-        parsed = parsed.filter((hunk) => {
-          return this.getLengthOfHunks([hunk]) <= PER_HUNK_LIMIT;
-        });
-
-        console.log(
-          `GITHUB PLUGIN: Filtered to ${
-            parsed.length
-          } hunks. ${this.getLengthOfHunks(parsed)} characters`
-        );
-        return parsed;
+        try {
+          const diff = await this.getDiff(url);
+          
+          // If getDiff returned null (auth error), skip this URL
+          if (!diff) {
+            console.log(`GITHUB PLUGIN: Skipping ${url} due to error`);
+            return null;
+          }
+          
+          let parsed = parseHunks(diff.toString());
+
+          console.log(`GITHUB PLUGIN: Parsed ${parsed.length} hunks`);
+
+          const averageHunkSize =
+            parsed.reduce((acc, hunk) => acc + hunk.lines.length, 0) /
+            parsed.length;
+
+          const totalCharacters = parsed
+            .flatMap((hunk) => [...hunk.additions, ...hunk.subtractions])
+            .reduce((acc, line) => acc + line.length, 0);
+
+          console.log(
+            `GITHUB PLUGIN: Average hunk size: ${averageHunkSize}, total characters: ${totalCharacters}`
+          );
+
+          const MAX_CHARACTERS = 10000;
+          const average = MAX_CHARACTERS / averageHunkSize;
+          const PER_HUNK_LIMIT = Math.max(average, 2000);
+
+          parsed = parsed.filter((hunk) => {
+            return this.getLengthOfHunks([hunk]) <= PER_HUNK_LIMIT;
+          });
+
+          console.log(
+            `GITHUB PLUGIN: Filtered to ${
+              parsed.length
+            } hunks. ${this.getLengthOfHunks(parsed)} characters`
+          );
+          return parsed;
+        } catch (error) {
+          console.error(`GITHUB PLUGIN: Error parsing diff for ${url}:`, error.message);
+          return null;
+        }
       })
     );
   }
@@ -153,30 +181,48 @@ export class GitHubPlugin extends PluginBase {
     const urls = this.extractUrls(userPrompt);
 
     if (urls) {
-      const prs = [];
-      for (const url of urls) {
-        const { owner, repo, pullNumber } = this.parseUrl(url);
-        const { data: pr } = await this.getPR(url);
-        const responses = await this.getParsedDiffs(urls);
-        // Format the diffs in Markdown
-        const diffStrings = responses.map(hunksToPatch);
-
-        prs.push({
-          description: pr.title,
-          url: pr.html_url,
-          body: pr.body,
-          author: pr.user.login,
-          diff: diffStrings,
-        });
+      try {
+        const prs = [];
+        for (const url of urls) {
+          const prResponse = await this.getPR(url);
+          
+          // Skip this PR if we couldn't get its data
+          if (!prResponse) {
+            console.log(`GITHUB PLUGIN: Skipping ${url} - could not fetch PR data`);
+            continue;
+          }
+          
+          const { data: pr } = prResponse;
+          const responses = await this.getParsedDiffs([url]);
+          
+          // Format the diffs in Markdown
+          const diffStrings = responses
+            .filter(response => response !== null)
+            .map(hunksToPatch);
+
+          prs.push({
+            description: pr.title,
+            url: pr.html_url,
+            body: pr.body,
+            author: pr.user.login,
+            diff: diffStrings,
+          });
+        }
+
+        if (prs.length === 0) {
+          return "GITHUB PLUGIN: Could not fetch any pull request data. Please check your GITHUB_TOKEN and permissions.";
+        }
+
+        const context = `GITHUB PLUGIN: These ${urls} have automatically been expanded to include the changes:\n\n${JSON.stringify(
+          prs,
+          null,
+          2
+        )}`;
+        console.log(context);
+        return context;
+      } catch (error) {
+        return `GITHUB PLUGIN: Error fetching pull request data: ${error.message}`;
       }
-
-      const context = `GITHUB PLUGIN: These ${urls} have automatically been expanded to include the changes:\n\n${JSON.stringify(
-        prs,
-        null,
-        2
-      )}`;
-      console.log(context);
-      return context;
     }
 
     return "GITHUB PLUGIN: No pull request URLs detected.";

package/src/plugins/language.ts

@@ -3,6 +3,7 @@ import { minimatch } from "minimatch";
 import { EventService } from "../services/EventService";
 import { Language } from "../types";
 import { getConfig, getLanguageConfig } from "../config";
+import { getEnabledPlugins } from "../types";
 import { PluginBase, PluginMeta } from "./PluginBase";
 import { Plugin, PluginContext } from "./types";
 import { GitHubPlugin } from "./github";
@@ -115,7 +116,7 @@ export class LanguagePlugin extends PluginBase implements Plugin {
 
     const plugins = this.context.Plugins.listPlugins();
     for (const plugin of plugins) {
-      if (config.plugins.includes(plugin)) {
+      if (getEnabledPlugins(config.plugins).includes(plugin)) {
         const matchingSources = sources.filter((s) => s.kind === plugin);
         if (matchingSources.length === 0) {
           continue;
@@ -258,15 +259,15 @@ export class LanguagePlugin extends PluginBase implements Plugin {
     const terms = Object.keys(languageConfig);
 
     // Find all matching terms in the userPrompt using glob patterns
-    const matchingTerms = terms.filter((term) =>
-      term.split(",").some((pattern) => {
+    const matchingTerms = terms.filter((term) => {
+      return term.split(",").some((pattern) => {
         const trimmedPattern = pattern.trim();
-        // Use minimatch for file patterns, fallback to string contains for non-glob patterns
+        // Use minimatch for glob patterns, fallback to string contains for simple patterns
         return trimmedPattern.includes("*")
           ? minimatch(userPrompt, trimmedPattern)
           : userPrompt.toLowerCase().includes(trimmedPattern.toLowerCase());
-      })
-    );
+      });
+    });
     return matchingTerms;
   }
 
@@ -281,16 +282,13 @@ export class LanguagePlugin extends PluginBase implements Plugin {
     // Use the extracted resolveSources method
     const contexts = await this.resolveSources(matchingTerms);
 
-    if (!matchingTerms || !matchingTerms.length) {
-      return "LANGUAGE PLUGIN: No matching terms found";
-    }
-
     console.log("LANGUAGE PLUGIN: Matching terms found:", matchingTerms);
 
+    const output = contexts.every((c) => typeof c === "string")
+      ? contexts.join("")
+      : JSON.stringify(contexts, null, 2);
     // Return the file contents in a format that can be added to the prompt context
-    return `LANGUAGE PLUGIN: The user mentioned these terms triggering contextual expansions ${matchingTerms} expanded to: ${JSON.stringify(
-      contexts
-    )}
+    return `LANGUAGE PLUGIN: The user mentioned these terms triggering contextual expansions ${matchingTerms} expanded to: ${output}
     These terms are directly related to what the user is asking about so be sure to contextualize your response to this information.
     `;
   }

package/src/plugins/plugins.ts

@@ -12,6 +12,11 @@ import { DownloaderPlugin } from "./downloader/plugin";
 import { FigmaPlugin } from "./figma";
 import { UrlPlugin } from "./url";
 import { GitPlugin } from "./GitPlugin";
+import { TmuxPlugin } from "./tmux";
+import { AgentsMdPlugin } from "./AgentsMdPlugin";
+import { ExecPlugin } from "./exec";
+import { getConfig } from "../config";
+import { getDisabledPlugins } from "../types";
 
 export class PluginService {
   private pluginMap = new Map<string, Plugin>();
@@ -33,9 +38,9 @@ export class PluginService {
     this.pluginMap.set("language", new LanguagePlugin(context));
     this.pluginMap.set("url", new UrlPlugin(context));
     this.pluginMap.set("git", new GitPlugin(context));
-
-    // Keep legacy plugins for backward compatibility
-    // These will be removed once all consumers are updated
+    this.pluginMap.set("tmux", new TmuxPlugin(context));
+    this.pluginMap.set("agents-md", new AgentsMdPlugin(context));
+    this.pluginMap.set("exec", new ExecPlugin(context));
   }
 
   /* -------- lifecycle helpers ------------------------------------ */
@@ -96,7 +101,7 @@ export class PluginService {
       return "";
     }
     const calls = plugins.map(async (p) => {
-      return this.call(p, userInput);
+      return this.callManyForPlugin(p, userInput).catch();
     });
 
     const results = await Promise.all(calls);
@@ -119,6 +124,22 @@ export class PluginService {
     return newPlugin.call(userInput);
   }
 
+  async callManyForPlugin(kind: string, userInput?: string) {
+    // Check new plugin system first
+    const newPlugin = this.pluginMap.get(kind);
+
+    if (!newPlugin) {
+      throw new Error(`Plugin ${kind} not found`);
+    }
+
+    const enabled = await newPlugin.isEnabled();
+    if (!enabled) {
+      console.log(`Plugin ${kind} is disabled, skipping`);
+      return "";
+    }
+    return newPlugin.callMany(userInput);
+  }
+
   async embed(kind: string, userInput: string) {
     // Check new plugin system first
     const newPlugin = this.pluginMap.get(kind);