@tyvm/knowhow 0.0.47 → 0.0.49

package/tests/{integration → manual/file-edits}/figma.test.ts

@@ -1,4 +1,4 @@
-import { FigmaPlugin } from "../../src/plugins/figma";
+import { FigmaPlugin } from "../../../src/plugins/figma";
 
 const figmaToken = "test_token"; // This should be the actual testing token
 const figmaPlugin = new FigmaPlugin();

package/tests/{integration → manual/file-edits}/fileblocks/readwrite.test.ts

@@ -1,11 +1,15 @@
 import * as fs from "fs";
-import { readFile, writeFile } from "../../../src/utils";
-import { agents } from "../../../src/agents";
-import { FlagsService } from "../../../src/services/flags";
+import { readFile, writeFile } from "../../../../src/utils";
+import { agents } from "../../../../src/agents";
+import { services } from "../../../../src/services";
+import { includedTools } from "../../../../src/agents/tools/list";
+import { FlagsService } from "../../../../src/services/flags";
 
 describe("Developer", () => {
   const { Patcher } = agents();
   beforeAll(() => {
+    const { Tools } = services();
+    Tools.addTools(includedTools);
     Patcher.disableTool("searchFiles");
     Patcher.disableTool("execCommand");
     Patcher.enableTool("modifyFile");

package/tests/{integration → manual/file-edits}/patching.test.ts

@@ -1,11 +1,11 @@
-import { readFile, writeFile } from "../../src/utils";
+import { readFile, writeFile } from "../../../src/utils";
 import { createPatch, applyPatch } from "diff";
-import { scanFile } from "../../src/agents/tools";
-import { patchFile } from "../../src/agents/tools/patch";
-import { agents } from "../../src/agents";
-import { services } from "../../src/services";
-import { includedTools } from "../../src/agents/tools/list";
-import * as allTools from "../../src/agents/tools";
+import { scanFile } from "../../../src/agents/tools";
+import { patchFile } from "../../../src/agents/tools/patch";
+import { agents } from "../../../src/agents";
+import { services } from "../../../src/services";
+import { includedTools } from "../../../src/agents/tools/list";
+import * as allTools from "../../../src/agents/tools";
 
 const inputPath = "tests/integration/patching/input.txt";
 const outputPath = "tests/integration/patching/output.txt";
@@ -28,8 +28,11 @@ const brokenPatch = `Index: tests/integration/patching/input.txt
        }\n`;
 
 describe("Patcher", () => {
-  const { Agents, Tools } = beforeAll(async () => {
+  let Agents: any, Tools: any;
+  
+  beforeAll(async () => {
     const { Patcher } = agents();
+    ({ Agents, Tools } = services());
     Agents.registerAgent(Patcher);
     Tools.addTools(includedTools);
     const toolFunctions = Object.entries(allTools)

package/tests/plugins/language/languagePlugin-content-triggers.test.ts

@@ -0,0 +1,332 @@
+import { LanguagePlugin } from "../../../src/plugins/language";
+import { EventService } from "../../../src/services/EventService";
+import { PluginService } from "../../../src/plugins/plugins";
+import * as utils from "../../../src/utils";
+import { getConfig, getLanguageConfig } from "../../../src/config";
+
+jest.mock("../../../src/utils", () => ({
+  readFile: jest.fn(),
+  fileExists: jest.fn().mockReturnValue(true),
+  fileStat: jest.fn(),
+}));
+
+jest.mock("../../../src/services/EventService", () => ({
+  EventService: jest.fn().mockImplementation(() => ({
+    on: jest.fn(),
+    emit: jest.fn(),
+  })),
+}));
+
+jest.mock("../../../src/config", () => ({
+  getConfig: jest.fn(),
+  getConfigSync: jest.fn(),
+  getLanguageConfig: jest.fn(),
+}));
+
+jest.mock("../../../src/plugins/plugins", () => ({
+  PluginService: jest.fn().mockImplementation(() => ({
+    listPlugins: jest.fn(),
+    call: jest.fn(),
+  })),
+}));
+
+const mockedConfig = getConfig as jest.MockedFunction<typeof getConfig>;
+const mockedLanguageConfig = getLanguageConfig as jest.MockedFunction<
+  typeof getLanguageConfig
+>;
+const mockedReadFile = utils.readFile as jest.MockedFunction<
+  typeof utils.readFile
+>;
+
+describe("LanguagePlugin - Content-Based Triggering", () => {
+  let mockEventService: any;
+  let mockPluginService: any;
+  let eventHandlers: Map<string, Function>;
+
+  beforeEach(() => {
+    eventHandlers = new Map();
+    mockEventService = {
+      on: jest.fn((event: string, handler: Function) => {
+        eventHandlers.set(event, handler);
+      }),
+      emit: jest.fn(),
+    };
+
+    mockPluginService = {
+      listPlugins: jest.fn().mockReturnValue(["github"]),
+      call: jest.fn().mockResolvedValue(["plugin context data"]),
+    };
+
+    jest.clearAllMocks();
+  });
+
+  test("should trigger on file content containing test functions", async () => {
+    // Mock file content that contains test functions
+    const fileContentWithTests = `
+      import { expect } from 'jest';
+
+      describe('MyComponent', () => {
+        test('should render correctly', () => {
+          expect(component).toBeTruthy();
+        });
+
+        it('should handle click events', () => {
+          // test implementation
+        });
+      });
+    `;
+
+    mockedReadFile.mockResolvedValue(Buffer.from(fileContentWithTests));
+    mockedConfig.mockResolvedValue({
+      plugins: [],
+      modules: [],
+      promptsDir: ".knowhow/prompts",
+      sources: [],
+      embedSources: [],
+      embeddingModel: "text-embedding-ada-002",
+      agents: [],
+      mcps: [],
+      modelProviders: [],
+    });
+    mockedLanguageConfig.mockResolvedValue({
+      "test(": {
+        events: ["file:post-read"],
+        sources: [
+          { kind: "text", data: ["Jest testing best practices"] },
+          { kind: "file", data: ["docs/testing-guidelines.md"] },
+        ],
+      },
+    });
+
+    new LanguagePlugin({
+      Events: mockEventService,
+      Plugins: mockPluginService,
+    } as any);
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    // Trigger file:post-read event
+    const fileReadHandler = eventHandlers.get("file:post-read");
+    expect(fileReadHandler).toBeDefined();
+
+    await fileReadHandler!({
+      filePath: "src/components/MyComponent.spec.ts",
+      operation: "read",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Verify that the content-based trigger was activated
+    expect(mockEventService.emit).toHaveBeenCalledWith(
+      "agent:msg",
+      expect.stringContaining("language_context_trigger")
+    );
+
+    const emitCall = mockEventService.emit.mock.calls.find(
+      (call) => call[0] === "agent:msg"
+    );
+    expect(emitCall).toBeDefined();
+
+    const eventData = JSON.parse(emitCall![1]);
+    expect(eventData.type).toBe("language_context_trigger");
+    expect(eventData.filePath).toBe("src/components/MyComponent.spec.ts");
+    expect(eventData.matchingTerms).toContain("test(");
+    expect(eventData.contextMessage).toContain("Jest testing best practices");
+  });
+
+  test("should not trigger when file content doesn't match", async () => {
+    // Mock file content without trigger terms
+    const fileContent = `
+      const config = {
+        database: 'postgresql',
+        port: 5432
+      };
+    `;
+
+    mockedReadFile.mockResolvedValue(Buffer.from(fileContent));
+    mockedConfig.mockResolvedValue({
+      plugins: [],
+      modules: [],
+      promptsDir: ".knowhow/prompts",
+      sources: [],
+      embedSources: [],
+      embeddingModel: "text-embedding-ada-002",
+      agents: [],
+      mcps: [],
+      modelProviders: [],
+    });
+    mockedLanguageConfig.mockResolvedValue({
+      "test(": {
+        events: ["file:post-read"],
+        sources: [{ kind: "text", data: ["Jest testing best practices"] }],
+      },
+    });
+
+    new LanguagePlugin({
+      Events: mockEventService,
+      Plugins: mockPluginService,
+    } as any);
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    // Trigger file:post-read event
+    const fileReadHandler = eventHandlers.get("file:post-read");
+    expect(fileReadHandler).toBeDefined();
+
+    await fileReadHandler!({
+      filePath: "src/config.js",
+      operation: "read",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Verify no trigger was activated
+    expect(mockEventService.emit).not.toHaveBeenCalled();
+  });
+
+  test("should handle file read errors gracefully", async () => {
+    // Mock readFile to throw an error
+    mockedReadFile.mockRejectedValue(new Error("File not found"));
+    mockedConfig.mockResolvedValue({
+      plugins: [],
+      modules: [],
+      promptsDir: ".knowhow/prompts",
+      sources: [],
+      embedSources: [],
+      embeddingModel: "text-embedding-ada-002",
+      agents: [],
+      mcps: [],
+      modelProviders: [],
+    });
+    mockedLanguageConfig.mockResolvedValue({
+      "test(": {
+        events: ["file:post-read"],
+        sources: [{ kind: "text", data: ["Jest testing best practices"] }],
+      },
+    });
+
+    new LanguagePlugin({
+      Events: mockEventService,
+      Plugins: mockPluginService,
+    } as any);
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    // Trigger file:post-read event
+    const fileReadHandler = eventHandlers.get("file:post-read");
+    expect(fileReadHandler).toBeDefined();
+
+    await fileReadHandler!({
+      filePath: "src/nonexistent.test.js",
+      operation: "read",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Verify no crash occurred and no trigger was activated
+    expect(mockEventService.emit).not.toHaveBeenCalled();
+  });
+
+  test("should work with case-insensitive matching", async () => {
+    // Mock file content with uppercase TEST
+    const fileContent = `
+      function myTEST() {
+        return true;
+      }
+    `;
+
+    mockedReadFile.mockResolvedValue(Buffer.from(fileContent));
+    mockedConfig.mockResolvedValue({
+      plugins: [],
+      modules: [],
+      promptsDir: ".knowhow/prompts",
+      sources: [],
+      embedSources: [],
+      embeddingModel: "text-embedding-ada-002",
+      agents: [],
+      mcps: [],
+      modelProviders: [],
+    });
+    mockedLanguageConfig.mockResolvedValue({
+      "test(": {
+        events: ["file:post-read"],
+        sources: [{ kind: "text", data: ["Jest testing best practices"] }],
+      },
+    });
+
+    new LanguagePlugin({
+      Events: mockEventService,
+      Plugins: mockPluginService,
+    } as any);
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    // Trigger file:post-read event
+    const fileReadHandler = eventHandlers.get("file:post-read");
+    expect(fileReadHandler).toBeDefined();
+
+    await fileReadHandler!({
+      filePath: "src/utils.js",
+      operation: "read",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Verify that case-insensitive matching worked
+    expect(mockEventService.emit).toHaveBeenCalledWith(
+      "agent:msg",
+      expect.stringContaining("language_context_trigger")
+    );
+  });
+
+  test("should trigger on file:post-edit events", async () => {
+    const fileContent = `
+      test('new test case', () => {
+        expect(true).toBe(true);
+      });
+    `;
+
+    mockedReadFile.mockResolvedValue(Buffer.from(fileContent));
+    mockedConfig.mockResolvedValue({
+      plugins: [],
+      modules: [],
+      promptsDir: ".knowhow/prompts",
+      sources: [],
+      embedSources: [],
+      embeddingModel: "text-embedding-ada-002",
+      agents: [],
+      mcps: [],
+      modelProviders: [],
+    });
+    mockedLanguageConfig.mockResolvedValue({
+      "test(": {
+        events: ["file:post-read", "file:post-edit"],
+        sources: [{ kind: "text", data: ["Jest testing best practices"] }],
+      },
+    });
+
+    new LanguagePlugin({
+      Events: mockEventService,
+      Plugins: mockPluginService,
+    } as any);
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    // Trigger file:post-edit event instead of read
+    const fileEditHandler = eventHandlers.get("file:post-edit");
+    expect(fileEditHandler).toBeDefined();
+
+    await fileEditHandler!({
+      filePath: "src/newFeature.test.js",
+      operation: "edit",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Verify that edit events also trigger content analysis
+    expect(mockEventService.emit).toHaveBeenCalledWith(
+      "agent:msg",
+      expect.stringContaining("language_context_trigger")
+    );
+  });
+});