@tyvm/knowhow 0.0.158 → 0.0.160

package/src/plugins/language.ts

@@ -1,290 +0,0 @@
-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 { getEnabledPlugins } from "../types";
-import { PluginBase, PluginMeta } from "./PluginBase";
-import { Plugin, PluginContext } from "./types";
-
-/**
- * Language Plugin with event-driven context loading
- */
-export class LanguagePlugin extends PluginBase implements Plugin {
-  static readonly meta: PluginMeta = {
-    key: "language",
-    name: "Language Plugin",
-    requires: [],
-  };
-
-  meta = LanguagePlugin.meta;
-  private eventService: EventService;
-
-  constructor(context: PluginContext) {
-    super(context);
-    this.eventService = context.Events;
-    this.setupEventHandlers();
-  }
-
-  /**
-   * 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
-      const fileEvents = Array.from(allEvents).filter((e: string) =>
-        e.startsWith("file")
-      );
-
-      const otherEvents = Array.from(allEvents).filter(
-        (e: string) => !e.startsWith("file")
-      );
-
-      fileEvents.forEach((eventType) => {
-        this.eventService.on(eventType, async (eventData) => {
-          await this.handleFileEvent(eventType, eventData);
-        });
-      });
-
-      otherEvents.forEach((eventType) => {
-        this.eventService.on(eventType, async (eventData) => {
-          await this.handleGenericEvent(eventType, eventData);
-        });
-      });
-    } catch (error) {
-      this.log("LANGUAGE PLUGIN: Error setting up event handlers: " + error, "error");
-    }
-  }
-
-  /**
-   * Resolve sources for given terms and return loaded contexts
-   */
-  private async resolveSources(matchingTerms: string[]): Promise<any[]> {
-    const languageConfig = await getLanguageConfig();
-    const config = await getConfig();
-
-    const sources = matchingTerms.flatMap(
-      (term) => languageConfig[term].sources
-    );
-
-    const contexts = [];
-
-    // Load the files for the matching terms
-    const filesToLoad = sources
-      .filter((f) => f.kind === "file")
-      .map((f) => f.data)
-      .flat();
-
-    // Read the contents of the files
-    const fileContents = await Promise.all(
-      filesToLoad.map(async (filePath) => {
-        const exists = await fileExists(filePath);
-        if (!exists) {
-          return { filePath, content: `File ${filePath} does not exist` };
-        }
-        const stat = await fileStat(filePath);
-        if (stat.isDirectory()) {
-          throw new Error(`Cannot read directories: ${filePath}`);
-        }
-        const content = (await readFile(filePath, "utf8")).toString();
-        return { filePath, content };
-      })
-    );
-    contexts.push(...fileContents);
-
-    const textContexts = matchingTerms
-      .flatMap((term) =>
-        languageConfig[term].sources.filter((s) => s.kind === "text")
-      )
-      .map((s) => s.data);
-    contexts.push(...textContexts);
-
-    const plugins = this.context.Plugins.listPlugins();
-    for (const plugin of plugins) {
-      if (getEnabledPlugins(config.plugins).includes(plugin)) {
-        const matchingSources = sources.filter((s) => s.kind === plugin);
-        if (matchingSources.length === 0) {
-          continue;
-        }
-
-        const data = matchingSources
-          .map((s) => s.data)
-          .flat()
-          .join("\n");
-        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);
-
-        const message = `These terms are directly related to the file operation so be sure to contextualize your response to this information.`;
-        this.emitAgentMessage(
-          eventType,
-          matchingFileTerms,
-          resolvedSources,
-          message
-        );
-      }
-    } catch (error) {
-      this.log("LANGUAGE PLUGIN: Error handling file event: " + error, "error");
-    }
-  }
-
-  private emitAgentMessage(
-    eventType: string,
-    matchingTerms: string[],
-    resolvedSources: any[],
-    context: string
-  ) {
-    this.eventService.emit(
-      "agent:msg",
-
-      `<Workflow>
-      ${JSON.stringify({
-        type: "language_context_trigger",
-        eventType,
-        matchingTerms,
-        resolvedSources,
-        contextMessage: `LANGUAGE PLUGIN: Agent event ${eventType} triggered contextual expansions for terms: ${matchingTerms.join(
-          ", "
-        )}.
-            Expanded context: ${JSON.stringify(resolvedSources)}
-            These terms are directly related to what the agent is discussing so be sure to contextualize your response to this information.
-            ${context}
-        `,
-      })}
-      </Workflow>
-      `
-    );
-  }
-
-  /**
-   * Handle agent message and say events and emit agent messages when patterns match
-   */
-  private async handleGenericEvent(eventType: string, eventData: any) {
-    try {
-      const languageConfig = await getLanguageConfig();
-      const userPrompt = JSON.stringify(eventData);
-      const isJsonObj = userPrompt.startsWith("{") && userPrompt.endsWith("}");
-
-      // Skip if this is probably a language_context_trigger to avoid loops
-      if (userPrompt.includes("language_context_trigger")) {
-        return;
-      }
-
-      const matchingTerms = await this.getMatchingTerms(userPrompt);
-
-      if (matchingTerms.length > 0) {
-        // Resolve sources for matching terms
-        const resolvedSources = await this.resolveSources(matchingTerms);
-
-        const message = `These terms are directly related to the agent's message so be sure to contextualize your response to this information.`;
-        this.emitAgentMessage(
-          eventType,
-          matchingTerms,
-          resolvedSources,
-          message
-        );
-      }
-    } catch (error) {
-      this.log("LANGUAGE PLUGIN: Error handling agent event: " + error, "error");
-    }
-  }
-
-  async embed(userPrompt: string) {
-    return [];
-  }
-
-  async getMatchingTerms(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) => {
-      return term.split(",").some((pattern) => {
-        const trimmedPattern = pattern.trim();
-        // 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;
-  }
-
-  async call(userPrompt: string) {
-    // Get language configuration
-    const matchingTerms = await this.getMatchingTerms(userPrompt);
-
-    if (matchingTerms.length === 0) {
-      return "LANGUAGE PLUGIN: No matching terms found";
-    }
-
-    // Use the extracted resolveSources method
-    const contexts = await this.resolveSources(matchingTerms);
-
-    this.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: ${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

@@ -1,175 +0,0 @@
-import { Plugin, PluginContext } from "./types";
-import { VimPlugin } from "./vim";
-import { LinterPlugin } from "./LinterPlugin";
-import { LanguagePlugin } from "./language";
-import { EmbeddingPlugin } from "./embedding";
-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";
-import { SkillsPlugin } from "./SkillsPlugin";
-import { EventService } from "../services/EventService";
-
-export class PluginService {
-  protected pluginMap = new Map<string, Plugin>();
-  private events?: EventService;
-
-  constructor(context: PluginContext) {
-    this.events = context.Events;
-    context.Plugins = this;
-  }
-
-  /* -------- lifecycle helpers ------------------------------------ */
-
-  /**
-   * Dynamically import a package / file and register it.
-   * @param spec ESM import specifier, e.g. "my-linear-plugin" or "./plugins/foo"
-   * @returns the key under which it was stored
-   */
-  async loadPlugin(spec: string): Promise<string> {
-    const { default: PluginCtor } = await import(spec);
-    const instance: Plugin = new PluginCtor(this); // assumes default export
-    this.pluginMap.set(instance.meta.key, instance);
-    return instance.meta.key;
-  }
-
-  /** Disable a plugin by its key; returns `true` if found. */
-  disablePlugin(key: string): boolean {
-    const p = this.pluginMap.get(key);
-    if (!p) return false;
-    p.disable();
-    return true;
-  }
-
-  /** Enable a plugin by its key; returns `true` if found. */
-  enablePlugin(key: string): boolean {
-    const p = this.pluginMap.get(key);
-    if (!p) return false;
-    p.enable();
-    return true;
-  }
-
-  /** Apply the enabled/disabled state from the current Knowhow config. */
-  async refreshConfiguredState(): Promise<void> {
-    const config = await getConfig();
-    const disabled = new Set(getDisabledPlugins(config.plugins));
-
-    for (const [key, plugin] of this.pluginMap) {
-      if (disabled.has(key)) {
-        plugin.disable();
-      } else {
-        // Configuration is authoritative when services start or reload. This
-        // also re-enables a plugin after it is removed from `disabled`.
-        plugin.enable();
-      }
-    }
-  }
-
-  /* -------- existing public API (updated for compatibility) ---------------------- */
-
-  listPlugins() {
-    const newPlugins = [...this.pluginMap.keys()];
-    return newPlugins;
-  }
-
-  isPlugin(name: string) {
-    return this.pluginMap.has(name);
-  }
-
-  registerPlugin(name: string, plugin: Plugin) {
-    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 "";
-    }
-    const calls = plugins.map(async (p) => {
-      return this.callManyForPlugin(p, userInput).catch(() => "");
-    });
-
-    const results = await Promise.all(calls);
-    return results.filter((result) => result !== "").join("\n\n");
-  }
-
-  async call(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) {
-      this.events?.log("PluginService", `Plugin ${kind} is disabled, skipping`);
-      return "";
-    }
-    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) {
-      this.events?.log("PluginService", `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);
-    if (!newPlugin) {
-      throw new Error(`Plugin ${kind} not found`);
-    }
-
-    const enabled = await newPlugin.isEnabled();
-    if (!enabled) {
-      this.events?.log("PluginService", `Plugin ${kind} is disabled, skipping`);
-      return [];
-    }
-    return newPlugin.embed ? newPlugin.embed(userInput) : [];
-  }
-}
-
-/**
- * CliPluginService extends PluginService with the full set of default plugins
- * used by the Knowhow CLI. Use this class when setting up agents for CLI usage.
- * Use the base PluginService when you want a clean slate to register your own plugins.
- */
-export class CliPluginService extends PluginService {
-  constructor(context: PluginContext) {
-    super(context);
-
-    // Register CLI default plugins
-    this.pluginMap.set("embeddings", new EmbeddingPlugin(context));
-    this.pluginMap.set("vim", new VimPlugin(context));
-    this.pluginMap.set("linter", new LinterPlugin(context));
-    this.pluginMap.set("language", new LanguagePlugin(context));
-    this.pluginMap.set("url", new UrlPlugin(context));
-    this.pluginMap.set("git", new GitPlugin(context));
-    this.pluginMap.set("tmux", new TmuxPlugin(context));
-    this.pluginMap.set("agents-md", new AgentsMdPlugin(context));
-    this.pluginMap.set("exec", new ExecPlugin(context));
-    this.pluginMap.set("skills", new SkillsPlugin(context));
-  }
-}

package/src/plugins/tmux.ts

@@ -1,132 +0,0 @@
-import { PluginBase, PluginMeta } from "./PluginBase";
-import { PluginContext } from "./types";
-import { execAsync } from "../utils";
-
-export class TmuxPlugin extends PluginBase {
-  static readonly meta: PluginMeta = {
-    key: "tmux",
-    name: "Tmux Plugin",
-    requires: [],
-  };
-
-  meta = TmuxPlugin.meta;
-
-  constructor(context: PluginContext) {
-    super(context);
-  }
-
-  async embed(userPrompt: string) {
-    return [];
-  }
-
-  /**
-   * Check if we're currently in a tmux session
-   */
-  async isInTmux(): Promise<boolean> {
-    try {
-      const { stdout } = await execAsync("echo $TMUX");
-      return stdout.trim().length > 0;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get current session information
-   */
-  async getCurrentSession(): Promise<string> {
-    try {
-      const { stdout } = await execAsync(
-        "tmux display-message -p '#{session_name}:#{window_index}:#{window_name}'"
-      );
-      return stdout.trim();
-    } catch (error) {
-      return "";
-    }
-  }
-
-  /**
-   * Get all tmux sessions
-   */
-  async getSessions(): Promise<string[]> {
-    try {
-      const { stdout } = await execAsync("tmux list-sessions");
-      return stdout
-        .trim()
-        .split("\n")
-        .filter((line) => line.length > 0);
-    } catch {
-      return [];
-    }
-  }
-
-  /**
-   * Get all windows in current session
-   */
-  async getWindows(): Promise<string[]> {
-    try {
-      const { stdout } = await execAsync("tmux list-windows");
-      return stdout
-        .trim()
-        .split("\n")
-        .filter((line) => line.length > 0);
-    } catch {
-      return [];
-    }
-  }
-
-  /**
-   * Get all panes across all sessions
-   */
-  async getPanes(): Promise<string[]> {
-    try {
-      const { stdout } = await execAsync(
-        "tmux list-panes -a -F '#{session_name}:#{window_index}.#{pane_index} #{pane_title} #{pane_current_command} #{pane_current_path}'"
-      );
-      return stdout
-        .trim()
-        .split("\n")
-        .filter((line) => line.length > 0);
-    } catch {
-      return [];
-    }
-  }
-
-  async call(): Promise<string> {
-    const inTmux = await this.isInTmux();
-
-    if (!inTmux) {
-      return "TMUX PLUGIN: Not currently in a tmux session";
-    }
-
-    const currentSession = await this.getCurrentSession();
-    const sessions = await this.getSessions();
-    const windows = await this.getWindows();
-    const panes = await this.getPanes();
-
-    const output = `TMUX PLUGIN: You are currently in a tmux session. This means you can use tmux commands to help debug and navigate.
-
-**Current Session/Window**: ${currentSession}
-
-**Available Sessions**:
-${sessions.map((s) => `  - ${s}`).join("\n")}
-
-**Windows in Current Session**:
-${windows.map((w) => `  - ${w}`).join("\n")}
-
-**All Panes** (showing running commands and paths):
-${panes.map((p) => `  - ${p}`).join("\n")}
-
-**Useful tmux commands for debugging**:
-- \`tmux send-keys -t <session>:<window>.<pane> "command" Enter\` - Send a command to a specific pane
-- \`tmux capture-pane -t <session>:<window>.<pane> -p\` - Capture output from a pane
-- \`tmux list-panes -a\` - List all panes
-- \`tmux switch-client -t <session>\` - Switch to another session
-- \`tmux select-window -t <window>\` - Switch to another window
-- \`tmux select-pane -t <pane>\` - Switch to another pane
-
-You can use execCommand to run these tmux commands to inspect running processes, send commands to other panes, or capture output for debugging.`;
-
-    return output;
-  }
-}

package/src/plugins/types.ts

@@ -1,36 +0,0 @@
-import { Embeddable, MinimalEmbedding } from "../types";
-import {
-  AgentService,
-  BehaviorsService,
-  EventService,
-  ToolsService,
-} from "../services";
-import { AIClient } from "../clients";
-import { PluginService } from "./plugins";
-
-export interface PluginMeta {
-  key: string;
-  name: string;
-  description?: string;
-  requires?: string[]; // Environment variables required
-}
-
-export interface Plugin {
-  callMany(userInput?: string): Promise<string>;
-  call(userInput?: string): Promise<string>;
-  embed?(userInput?: string): Promise<MinimalEmbedding[]>;
-  enable(): void;
-  disable(): void;
-  isEnabled(): boolean;
-
-  meta: PluginMeta;
-}
-
-export interface PluginContext {
-  Agents?: AgentService;
-  Events?: EventService;
-  Clients?: AIClient;
-  Tools?: ToolsService;
-  Plugins?: PluginService;
-  Behaviors?: BehaviorsService;
-}