@tyvm/knowhow 0.0.47 → 0.0.49

package/src/plugins/embedding.ts

@@ -7,22 +7,42 @@ import {
 } from "../embeddings";
 
 import { PluginBase, PluginMeta } from "./PluginBase";
+import { embed as embedFunction } from "../index";
 
 export class EmbeddingPlugin extends PluginBase {
   static readonly meta: PluginMeta = {
     key: "embeddings",
     name: "Embedding Plugin",
-    requires: []
+    requires: [],
   };
 
-  constructor() {
-    super(EmbeddingPlugin.meta);
+  meta = EmbeddingPlugin.meta;
+
+  constructor(context) {
+    super(context);
+    
+    // Subscribe to file:post-edit events
+    this.context.Events.on("file:post-edit", this.handleFilePostEdit.bind(this));
   }
 
   async embed() {
     return [];
   }
 
+  /**
+   * Handle file:post-edit events by triggering embedding
+   * @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}`;
+    }
+  }
+
   async call(userPrompt: string): Promise<string> {
     const count = 7;
     const embeddings = await getConfiguredEmbeddings();
@@ -49,4 +69,4 @@ export class EmbeddingPlugin extends PluginBase {
     return `EMBEDDING PLUGIN: Our knowledgebase contains this information which can be used to answer the question:
     ${JSON.stringify(context)}`;
   }
-}
+}

package/src/plugins/figma.ts

@@ -1,9 +1,9 @@
 import { Client } from "figma-js";
 import qs from "qs"; // Assumed to be installed
 import { PluginBase, PluginMeta } from "./PluginBase";
+import { PluginContext } from "./types";
 import { Plugin } from "./types";
 import { MinimalEmbedding } from "../types";
-import { askGptVision } from "../ai";
 
 interface Node {}
 
@@ -41,8 +41,10 @@ export class FigmaPlugin extends PluginBase implements Plugin {
     requires: ["FIGMA_API_KEY"],
   };
 
-  constructor() {
-    super(FigmaPlugin.meta);
+  meta = FigmaPlugin.meta;
+
+  constructor(context: PluginContext = {}) {
+    super(context);
     if (!this.isEnabled()) return;
 
     this.figmaToken = process.env.FIGMA_API_KEY;
@@ -138,6 +140,8 @@ export class FigmaPlugin extends PluginBase implements Plugin {
         if (!data.images.hasOwnProperty(nodeId)) continue;
 
         const imageUrl = data.images[nodeId];
+        // Lazy import to break circular dependency
+        const { askGptVision } = await import("../ai");
         const imageDescription = await askGptVision(
           imageUrl,
           `Describe the image with relavant information for this user question: ${userPrompt}`

package/src/plugins/github.ts

@@ -1,5 +1,6 @@
 import { Octokit } from "@octokit/rest";
 import { PluginBase, PluginMeta } from "./PluginBase";
+import { PluginContext } from "./types";
 import { parseHunks, hunksToPatch } from "../agents/tools/patch";
 import { MinimalEmbedding } from "../types";
 
@@ -10,10 +11,11 @@ export class GitHubPlugin extends PluginBase {
     requires: ["GITHUB_TOKEN"],
   };
 
+  meta = GitHubPlugin.meta;
   octokit: Octokit;
 
-  constructor() {
-    super(GitHubPlugin.meta);
+  constructor(context: PluginContext) {
+    super(context);
 
     const key = process.env.GITHUB_TOKEN;
     if (key && this.isEnabled()) {

package/src/plugins/jira.ts

@@ -1,5 +1,6 @@
 import JiraClient from "jira-client";
 import { PluginBase, PluginMeta } from "./PluginBase";
+import { PluginContext } from "./types";
 import { MinimalEmbedding } from "../types";
 
 export class JiraPlugin extends PluginBase {
@@ -9,10 +10,11 @@ export class JiraPlugin extends PluginBase {
     requires: ["JIRA_HOST", "JIRA_USER", "JIRA_PASSWORD"]
   };
 
+  meta = JiraPlugin.meta;
   jiraClient: JiraClient;
 
-  constructor() {
-    super(JiraPlugin.meta);
+  constructor(context: PluginContext) {
+    super(context);
     
     if (!this.isEnabled()) return;
     this.jiraClient = new JiraClient({

package/src/plugins/language.ts

@@ -1,44 +1,67 @@
 import { readFile, fileExists, fileStat } from "../utils";
+import { minimatch } from "minimatch";
+import { EventService } from "../services/EventService";
 import { Language } from "../types";
 import { getConfig, getLanguageConfig } from "../config";
 import { PluginBase, PluginMeta } from "./PluginBase";
-import { Plugin } from "./types";
+import { Plugin, PluginContext } from "./types";
 import { GitHubPlugin } from "./github";
 import { AsanaPlugin } from "./asana";
 import { JiraPlugin } from "./jira";
 import { LinearPlugin } from "./linear";
 import { PluginService } from "./plugins";
 
+/**
+ * Language Plugin with event-driven context loading
+ */
 export class LanguagePlugin extends PluginBase implements Plugin {
   static readonly meta: PluginMeta = {
     key: "language",
     name: "Language Plugin",
-    requires: []
+    requires: [],
   };
 
-  constructor(private pluginService: PluginService) {
-    super(LanguagePlugin.meta);
+  meta = LanguagePlugin.meta;
+  private eventService: EventService;
+
+  constructor(context: PluginContext) {
+    super(context);
+    this.eventService = context.Events;
+    this.setupEventHandlers();
   }
 
-  async embed(userPrompt: string) {
-    return [];
+  /**
+   * Register event handlers based on language configuration
+   */
+  private async setupEventHandlers() {
+    try {
+      const languageConfig = await getLanguageConfig();
+
+      // Collect all unique events from all language terms
+      const allEvents = new Set<string>();
+      Object.values(languageConfig).forEach((termConfig) => {
+        if (termConfig.events) {
+          termConfig.events.forEach((event) => allEvents.add(event));
+        }
+      });
+
+      // Register handlers for each event
+      allEvents.forEach((eventType) => {
+        this.eventService.on(eventType, async (eventData) => {
+          await this.handleFileEvent(eventType, eventData);
+        });
+      });
+    } catch (error) {
+      console.error("LANGUAGE PLUGIN: Error setting up event handlers:", error);
+    }
   }
 
-  async call(userPrompt: string): Promise<string> {
-    const config = await getConfig();
+  /**
+   * Resolve sources for given terms and return loaded contexts
+   */
+  private async resolveSources(matchingTerms: string[]): Promise<any[]> {
     const languageConfig = await getLanguageConfig();
-    // Extract terms from the language configuration
-    const terms = Object.keys(languageConfig);
-
-    // Find all matching terms in the userPrompt
-    const matchingTerms = terms.filter((term) =>
-      term
-        .split(",")
-        .some((w) => userPrompt.toLowerCase().includes(w.toLowerCase()))
-    );
-    if (matchingTerms.length > 0) {
-      console.log("LANGUAGE PLUGIN: Found matching terms", matchingTerms);
-    }
+    const config = await getConfig();
 
     const sources = matchingTerms.flatMap(
       (term) => languageConfig[term].sources
@@ -60,7 +83,6 @@ export class LanguagePlugin extends PluginBase implements Plugin {
           return { filePath, content: `File ${filePath} does not exist` };
         }
         const content = (await readFile(filePath, "utf8")).toString();
-        console.log("LANGUAGE PLUGIN: Read file", filePath);
         return { filePath, content };
       })
     );
@@ -73,7 +95,7 @@ export class LanguagePlugin extends PluginBase implements Plugin {
       .map((s) => s.data);
     contexts.push(...textContexts);
 
-    const plugins = this.pluginService.listPlugins();
+    const plugins = this.context.Plugins.listPlugins();
     for (const plugin of plugins) {
       if (config.plugins.includes(plugin)) {
         const matchingSources = sources.filter((s) => s.kind === plugin);
@@ -85,13 +107,101 @@ export class LanguagePlugin extends PluginBase implements Plugin {
           .map((s) => s.data)
           .flat()
           .join("\n");
-        console.log("LANGUAGE PLUGIN: Calling plugin", plugin, data);
-        const pluginContext = await this.pluginService.call(plugin, data);
+        const pluginContext = await this.context.Plugins.call(plugin, data);
 
         contexts.push(...pluginContext);
       }
     }
 
+    return contexts;
+  }
+
+  /**
+   * Handle file operation events and emit agent messages when patterns match
+   */
+  private async handleFileEvent(eventType: string, eventData: any) {
+    try {
+      const languageConfig = await getLanguageConfig();
+      const filePath = eventData?.filePath || eventData?.path;
+      const fileContent = await readFile(filePath, "utf8");
+
+      if (!filePath) {
+        return;
+      }
+
+      // Find matching language terms based on file patterns
+      const matchingFileTerms = Object.entries(languageConfig)
+        .filter(([term, config]) => {
+          // Check if this event type is configured for this term
+          if (!config.events || !config.events.includes(eventType)) {
+            return false;
+          }
+
+          // Check if file path matches any of the term patterns
+          // Or if the file content includes any of the term patterns
+          const patterns = term.split(",").map((p) => p.trim());
+          const matches = patterns.some(
+            (pattern) =>
+              minimatch(filePath, pattern) ||
+              fileContent.toString().toLowerCase().includes(pattern.toLowerCase())
+          );
+          return matches;
+        })
+        .map(([term]) => term);
+
+      if (matchingFileTerms.length > 0) {
+        // Resolve sources for matching terms
+        const resolvedSources = await this.resolveSources(matchingFileTerms);
+
+        // Emit agent message event with resolved context
+        this.eventService.emit(
+          "agent:msg",
+          JSON.stringify({
+            type: "language_context_trigger",
+            filePath,
+            matchingTerms: matchingFileTerms,
+            eventType,
+            resolvedSources,
+            contextMessage: `LANGUAGE PLUGIN: File event ${eventType} on ${filePath} triggered contextual expansions for terms: ${matchingFileTerms.join(
+              ", "
+            )}.
+            Expanded context: ${JSON.stringify(resolvedSources)}
+            These terms are directly related to the file operation so be sure to contextualize your response to this information.`,
+          })
+        );
+      }
+    } catch (error) {
+      console.error("LANGUAGE PLUGIN: Error handling file event:", error);
+    }
+  }
+
+  async embed(userPrompt: string) {
+    return [];
+  }
+
+  async call(userPrompt: string) {
+    // Get language configuration
+    const languageConfig = await getLanguageConfig();
+    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 trimmedPattern = pattern.trim();
+        // Use minimatch for file patterns, fallback to string contains for non-glob patterns
+        return trimmedPattern.includes("*")
+          ? minimatch(userPrompt, trimmedPattern)
+          : userPrompt.toLowerCase().includes(trimmedPattern.toLowerCase());
+      })
+    );
+
+    if (matchingTerms.length === 0) {
+      return "LANGUAGE PLUGIN: No matching terms found";
+    }
+
+    // Use the extracted resolveSources method
+    const contexts = await this.resolveSources(matchingTerms);
+
     if (!matchingTerms || !matchingTerms.length) {
       return "LANGUAGE PLUGIN: No matching terms found";
     }
@@ -104,6 +214,3 @@ export class LanguagePlugin extends PluginBase implements Plugin {
     `;
   }
 }
-
-// Since this uses other plugins, it needs to be registered
-// Plugins.registerPlugin("language", new LanguagePlugin());

package/src/plugins/linear.ts

@@ -1,5 +1,6 @@
 import { LinearClient } from "@linear/sdk";
 import { PluginBase, PluginMeta } from "./PluginBase";
+import { PluginContext } from "./types";
 import { MinimalEmbedding } from "../types";
 
 export class LinearPlugin extends PluginBase {
@@ -9,10 +10,11 @@ export class LinearPlugin extends PluginBase {
     requires: ["LINEAR_API_KEY"],
   };
 
+  meta = LinearPlugin.meta;
   linearClient: LinearClient;
 
-  constructor() {
-    super(LinearPlugin.meta);
+  constructor(context: PluginContext) {
+    super(context);
 
     if (!this.isEnabled()) return;
     this.linearClient = new LinearClient({

package/src/plugins/notion.ts

@@ -1,5 +1,6 @@
 import { Client } from "@notionhq/client";
 import { PluginBase, PluginMeta } from "./PluginBase";
+import { PluginContext } from "./types";
 import { PageObjectResponse } from "@notionhq/client/build/src/api-endpoints";
 import { Embeddable, MinimalEmbedding } from "../types";
 
@@ -10,10 +11,11 @@ export class NotionPlugin extends PluginBase {
     requires: ["NOTION_TOKEN"]
   };
 
+  meta = NotionPlugin.meta;
   notionClient: Client;
 
-  constructor() {
-    super(NotionPlugin.meta);
+  constructor(context: PluginContext) {
+    super(context);
     
     if (!this.isEnabled()) return;
     this.notionClient = new Client({

package/src/plugins/plugins.ts

@@ -1,6 +1,6 @@
-import glob from "glob";
-import { Plugin } from "./types";
+import { Plugin, PluginContext } from "./types";
 import { VimPlugin } from "./vim";
+import { LinterPlugin } from "./LinterPlugin";
 import { LanguagePlugin } from "./language";
 import { EmbeddingPlugin } from "./embedding";
 import { GitHubPlugin } from "./github";
@@ -11,23 +11,28 @@ import { NotionPlugin } from "./notion";
 import { DownloaderPlugin } from "./downloader/plugin";
 import { FigmaPlugin } from "./figma";
 import { UrlPlugin } from "./url";
+import { GitPlugin } from "./GitPlugin";
 
 export class PluginService {
   private pluginMap = new Map<string, Plugin>();
 
-  constructor() {
+  constructor(context: PluginContext) {
+    context.Plugins = this;
+
     // Register migrated PluginBase plugins
-    this.pluginMap.set("embeddings", new EmbeddingPlugin());
-    this.pluginMap.set("vim", new VimPlugin());
-    this.pluginMap.set("github", new GitHubPlugin());
-    this.pluginMap.set("asana", new AsanaPlugin());
-    this.pluginMap.set("linear", new LinearPlugin());
-    this.pluginMap.set("jira", new JiraPlugin());
-    this.pluginMap.set("notion", new NotionPlugin());
-    this.pluginMap.set("download", new DownloaderPlugin());
-    this.pluginMap.set("figma", new FigmaPlugin());
-    this.pluginMap.set("language", new LanguagePlugin(this));
-    this.pluginMap.set("url", new UrlPlugin());
+    this.pluginMap.set("embeddings", new EmbeddingPlugin(context));
+    this.pluginMap.set("vim", new VimPlugin(context));
+    this.pluginMap.set("linter", new LinterPlugin(context));
+    this.pluginMap.set("github", new GitHubPlugin(context));
+    this.pluginMap.set("asana", new AsanaPlugin(context));
+    this.pluginMap.set("linear", new LinearPlugin(context));
+    this.pluginMap.set("jira", new JiraPlugin(context));
+    this.pluginMap.set("notion", new NotionPlugin(context));
+    this.pluginMap.set("download", new DownloaderPlugin(context));
+    this.pluginMap.set("figma", new FigmaPlugin(context));
+    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
@@ -78,6 +83,14 @@ export class PluginService {
     this.pluginMap.set(name, plugin);
   }
 
+  getPlugin(name: string): Plugin | undefined {
+    return this.pluginMap.get(name);
+  }
+
+  getPlugins(): Plugin[] {
+    return Array.from(this.pluginMap.values());
+  }
+
   async callMany(plugins: string[], userInput?: string) {
     if (!plugins || plugins.length === 0) {
       return "";
@@ -121,5 +134,3 @@ export class PluginService {
     return newPlugin.embed ? newPlugin.embed(userInput) : [];
   }
 }
-
-export const Plugins = new PluginService();