@tyvm/knowhow 0.0.158 → 0.0.160

package/src/plugins/LinterPlugin.ts

@@ -1,214 +0,0 @@
-import { getConfig } from "../config";
-import { PluginBase, PluginMeta } from "./PluginBase";
-import { PluginContext } from "./types";
-import { EventService } from "../services/EventService";
-import { spawn } from "child_process";
-
-export interface LintJob {
-  filePath: string;
-  extension: string;
-  command: string;
-}
-
-export interface LintRunState {
-  current: LintJob | null;
-  next: LintJob | null;
-}
-
-export class LinterPlugin extends PluginBase {
-  static readonly meta: PluginMeta = {
-    key: "linter",
-    name: "Linter Plugin",
-    requires: [],
-  };
-
-  meta = LinterPlugin.meta;
-  private eventService: EventService;
-  // Track running lint jobs per extension: current + next
-  private runState: Map<string, LintRunState> = new Map();
-  // Track average run times per extension (in ms)
-  private runTimes: Map<string, number[]> = new Map();
-
-  constructor(context: PluginContext) {
-    super(context);
-    this.eventService = context.Events;
-
-    // Subscribe to file:post-edit events
-    this.context.Events.on(
-      "file:post-edit",
-      this.handleFilePostEdit.bind(this)
-    );
-  }
-
-  async embed() {
-    return [];
-  }
-
-  async call(userPrompt: string): Promise<string> {
-    return "";
-  }
-
-  /**
-   * Handle file:post-edit events by linting the file
-   */
-  async handleFilePostEdit(payload: { filePath: string }): Promise<void> {
-    const { filePath } = payload;
-    await this.enqueueLint(filePath);
-  }
-
-  /**
-   * Enqueue a lint job for the given file path. If a lint is already running
-   * for this extension, it is queued as "next". If there's already a "next",
-   * it replaces it (so we only keep current + latest pending).
-   */
-  async enqueueLint(filePath: string): Promise<void> {
-    const config = await getConfig();
-    const extension = filePath.split(".").pop();
-
-    if (!extension || !config.lintCommands || !config.lintCommands[extension]) {
-      return;
-    }
-
-    let lintCommand = config.lintCommands[extension];
-    if (lintCommand.includes("$1")) {
-      lintCommand = lintCommand.replace("$1", filePath);
-    }
-
-    const job: LintJob = { filePath, extension, command: lintCommand };
-
-    const state = this.runState.get(extension);
-
-    if (!state || !state.current) {
-      // Nothing running, start immediately
-      this.runState.set(extension, { current: job, next: null });
-      this.runLint(job);
-    } else {
-      // Already running — queue as next (replace any existing next)
-      this.runState.set(extension, { current: state.current, next: job });
-    }
-  }
-
-  /**
-   * Get estimated time remaining for an extension based on past run times (in ms).
-   */
-  private getEstimatedTime(extension: string): number | null {
-    const times = this.runTimes.get(extension);
-    if (!times || times.length === 0) return null;
-    return Math.round(times.reduce((a, b) => a + b, 0) / times.length);
-  }
-
-  /**
-   * Record a completed run time for an extension.
-   */
-  private recordRunTime(extension: string, durationMs: number): void {
-    if (!this.runTimes.has(extension)) {
-      this.runTimes.set(extension, []);
-    }
-    const times = this.runTimes.get(extension)!;
-    times.push(durationMs);
-    // Keep only last 5 runs for rolling average
-    if (times.length > 5) {
-      times.shift();
-    }
-  }
-
-  /**
-   * Run a lint job in the background, emitting events when started and finished.
-   */
-  private runLint(job: LintJob): void {
-    const { extension, command, filePath } = job;
-    const startTime = Date.now();
-
-    // Emit linter:started event
-    this.eventService.emit("linter:started", { extension, filePath, command });
-
-    // Notify the agent that a lint is starting
-    const estimatedMs = this.getEstimatedTime(extension);
-    const estimatedMsg = estimatedMs
-      ? ` Expected completion time: ~${Math.round(estimatedMs / 1000)}s.`
-      : "";
-
-    this.eventService.emit(
-      "agent:msg",
-      `<Workflow>
-LinterPlugin: Running lint command for .${extension} files in the background.${estimatedMsg}
-Command: ${command}
-You will receive the results shortly. Continue working and the linter output will be provided when ready.
-</Workflow>`
-    );
-
-    // Spawn the lint command in background, capturing stdout and stderr separately
-    let stdout = "";
-    let stderr = "";
-
-    const child = spawn(command, { shell: true });
-
-    child.stdout?.on("data", (d: Buffer) => {
-      stdout += d.toString();
-    });
-
-    child.stderr?.on("data", (d: Buffer) => {
-      stderr += d.toString();
-    });
-
-    child.once("error", (err: Error) => {
-      const durationMs = Date.now() - startTime;
-      this.recordRunTime(extension, durationMs);
-      this.onLintFinished(job, false, `Failed to start lint command: ${err.message}`, durationMs);
-    });
-
-    child.once("exit", (code: number | null) => {
-      const durationMs = Date.now() - startTime;
-      this.recordRunTime(extension, durationMs);
-
-      // If stderr has content, treat as failure; otherwise success
-      const hasErrors = stderr.trim().length > 0;
-      this.onLintFinished(job, !hasErrors, hasErrors ? stderr : stdout, durationMs);
-    });
-  }
-
-  /**
-   * Called when a lint job finishes. Emits events and starts next queued job if any.
-   */
-  private onLintFinished(
-    job: LintJob,
-    success: boolean,
-    output: string,
-    durationMs: number
-  ): void {
-    const { extension, filePath, command } = job;
-
-    // Emit linter:finished event
-    this.eventService.emit("linter:finished", {
-      extension,
-      filePath,
-      command,
-      success,
-      output,
-      durationMs,
-    });
-
-    // Only surface failures to the agent — successes are wasted context
-    if (!success) {
-      this.eventService.emit(
-        "agent:msg",
-        `<Workflow>
-LinterPlugin: Lint finished with errors for .${extension} files (took ${Math.round(durationMs / 1000)}s).
-${output}
-Please review and fix the issues above.
-</Workflow>`
-      );
-    }
-
-    // Check for a queued next job
-    const state = this.runState.get(extension);
-    if (state?.next) {
-      const nextJob = state.next;
-      this.runState.set(extension, { current: nextJob, next: null });
-      this.runLint(nextJob);
-    } else {
-      // Nothing queued, clear state
-      this.runState.set(extension, { current: null, next: null });
-    }
-  }
-}

package/src/plugins/PluginBase.ts

@@ -1,70 +0,0 @@
-import { Plugin, PluginContext, PluginMeta } from "./types";
-
-export abstract class PluginBase implements Plugin {
-  /** Manual on/off toggle (default ON) */
-  private active = true;
-
-  abstract readonly meta: PluginMeta;
-
-  constructor(protected context: PluginContext = {}) {}
-
-  /* ------------------------------------------------------------------ */
-  /** Public helpers called by PluginService -------------------------- */
-  /* ------------------------------------------------------------------ */
-  enable(): void {
-    this.active = true;
-  }
-
-  disable(): void {
-    this.active = false;
-  }
-
-  isEnabled(): boolean {
-    if (!this.active) return false;
-
-    const envOk = this.hasRequiredEnv();
-
-    const extraOk = this.customEnableCheck();
-
-    const enabled = envOk && extraOk;
-    return enabled;
-  }
-
-  protected hasRequiredEnv(): boolean {
-    const isGood =
-      !this.meta.requires ||
-      this.meta.requires.every((k) => process.env[k] && process.env[k] !== "");
-
-    return isGood;
-  }
-
-  protected customEnableCheck(): boolean {
-    return true; // subclasses override if needed
-  }
-
-  protected log(message: string, level: "info" | "warn" | "error" = "info"): void {
-    if (this.context.Events) {
-      this.context.Events.log(this.meta.name, message, level);
-    } else {
-      // Fallback to console if no Events service
-      if (level === "error") console.error(`[${this.meta.name}] ${message}`);
-      else if (level === "warn") console.warn(`[${this.meta.name}] ${message}`);
-      else console.log(`[${this.meta.name}] ${message}`);
-    }
-  }
-
-  /* ------------------------------------------------------------------ */
-  /** 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 ---------------------------------------- */
-  /* ------------------------------------------------------------------ */
-  abstract call(input?: string): Promise<string>;
-}
-
-export { PluginMeta, Plugin } from "./types";

package/src/plugins/SkillsPlugin.ts

@@ -1,37 +0,0 @@
-import { PluginBase, PluginMeta } from "./PluginBase";
-import { Plugin, PluginContext } from "./types";
-
-export class SkillsPlugin extends PluginBase implements Plugin {
-  static readonly meta: PluginMeta = {
-    key: "skills",
-    name: "Skills Plugin",
-    description: "Lists available skills",
-    requires: [],
-  };
-
-  meta = SkillsPlugin.meta;
-
-  constructor(context: PluginContext) {
-    super(context);
-  }
-
-  /**
-   * Returns a summary list of in-memory skills (name + description).
-   * This is called by the plugin system to inject context into agent prompts.
-   * Skills must be loaded into memory first via Behaviors.initFromDisk() at startup.
-   */
-  async call(_input?: string): Promise<string> {
-    const { Behaviors } = this.context;
-    const skills = Behaviors.listSkills();
-
-    if (skills.length === 0) {
-      return "No skills available";
-    }
-
-    const lines = ["Available skills:"];
-    for (const skill of skills) {
-      lines.push(`- ${skill.name}: ${skill.description}`);
-    }
-    return lines.join("\n");
-  }
-}

package/src/plugins/embedding.ts

@@ -1,82 +0,0 @@
-import { getConfig } from "../config";
-import {
-  getConfiguredEmbeddings,
-  queryEmbedding,
-  pruneVector,
-  pruneMetadata,
-} from "../embeddings";
-
-import { PluginBase, PluginMeta } from "./PluginBase";
-import { spawn } from "child_process";
-
-export class EmbeddingPlugin extends PluginBase {
-  static readonly meta: PluginMeta = {
-    key: "embeddings",
-    name: "Embedding Plugin",
-    requires: [],
-  };
-
-  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 in a separate process
-   * @param payload The event payload containing filePath
-   * @returns Status message about embedding operation
-   */
-  async handleFilePostEdit(payload: { filePath: string }): Promise<string> {
-    const child = spawn("knowhow", ["embed"], {
-      detached: true,
-      stdio: "ignore",
-      cwd: process.cwd(),
-    });
-    child.unref();
-    this.log(`Started 'knowhow embed' in background (pid: ${child.pid})`);
-    return "Embedding started in background process";
-  }
-
-  async call(userPrompt: string): Promise<string> {
-    const count = 7;
-    const embeddings = await getConfiguredEmbeddings();
-
-    if (embeddings.length === 0) {
-      return "EMBEDDING PLUGIN: No embeddings configured. Run 'knowhow embed' to generate embeddings.";
-    }
-
-    const config = await getConfig();
-    const results = await queryEmbedding(
-      userPrompt,
-      embeddings,
-      config.embeddingModel
-    );
-    const context = results.slice(0, count);
-
-    pruneVector(context);
-    pruneMetadata(context);
-
-    for (const entry of context) {
-      this.log(`Reading entry ${entry.id}`);
-    }
-
-    const ids = context.map((entry) => entry.id);
-
-    const contextLength = JSON.stringify(ids).split(" ").length;
-    this.log(`Found ${context.length} entries. Loading ${contextLength} words`);
-
-    return `EMBEDDING PLUGIN: Our knowledgebase indicates these embedding entries may be related to the question:
-    ${JSON.stringify(ids)}`;
-  }
-}

package/src/plugins/exec.ts

@@ -1,70 +0,0 @@
-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 {
-      this.log(`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 || "";
-
-      this.log(`Command failed: ${errorMessage}`, "error");
-      if (stderr) {
-        this.log(stderr, "error");
-      }
-
-      return `EXEC PLUGIN: Command \`${command}\` failed:\n\`\`\`\n${stdout}\n${stderr}\n${errorMessage}\n\`\`\``;
-    }
-  }
-
-  async embed(input: string) {
-    return [];
-  }
-}