@tyvm/knowhow 0.0.46 → 0.0.48

package/tests/manual/agent-events/run-test.ts

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test runner for the event handler reliability test
+ * This runs the test cases manually since they're in the manual test directory
+ */
+
+import { EventEmitter } from "events";
+
+// Mock the imports that might not be available
+const mockMessage = { role: "user", content: "test" };
+const mockContext = {
+  Tools: {
+    getTools: () => [],
+    callTool: async (name: string, params: any) => ({ name, content: "mock result" })
+  },
+  Events: { registerAgent: () => {} },
+  messageProcessor: { process: async () => "processed" }
+};
+
+// Simplified BaseAgent mock
+class MockBaseAgent extends EventEmitter {
+  name = "MockAgent";
+  agentEvents = new EventEmitter();
+  eventTypes = { done: "done" };
+  
+  constructor(context: any) {
+    super();
+  }
+  
+  async call(userInput: string): Promise<string> {
+    // Simulate agent processing
+    console.log(`🤖 Agent processing: "${userInput}"`);
+    
+    // Simulate async work
+    await new Promise(resolve => setTimeout(resolve, 50));
+    
+    // Simulate finalAnswer tool call
+    const result = "Task completed successfully";
+    
+    // Emit done event (this is what we're testing)
+    setTimeout(() => {
+      console.log("📡 Emitting done event...");
+      this.agentEvents.emit(this.eventTypes.done, result);
+    }, 10);
+    
+    return result;
+  }
+}
+
+// Test cases
+async function runTests() {
+  console.log("🧪 Starting Agent Event Handler Reliability Tests\n");
+  
+  let passedTests = 0;
+  let totalTests = 0;
+  
+  // Test 1: Normal event handler
+  try {
+    totalTests++;
+    console.log("Test 1: Normal event handler flow");
+    
+    const agent = new MockBaseAgent(mockContext);
+    let eventFired = false;
+    let eventMessage = "";
+    
+    // Register event handler
+    const eventPromise = new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Event handler timeout"));
+      }, 1000);
+      
+      agent.agentEvents.once(agent.eventTypes.done, (message) => {
+        clearTimeout(timeout);
+        console.log("✅ Agent has finished."); // This should log
+        eventFired = true;
+        eventMessage = message;
+        resolve();
+      });
+    });
+    
+    const result = await agent.call("Complete normal test");
+    
+    await eventPromise;
+    
+    if (eventFired && eventMessage === result) {
+      console.log("✅ Test 1 PASSED - Event handler fired correctly\n");
+      passedTests++;
+    } else {
+      console.log("❌ Test 1 FAILED - Event handler didn't fire properly\n");
+    }
+    
+  } catch (error: any) {
+    console.log(`❌ Test 1 FAILED - ${error.message}\n`);
+  }
+  
+  // Test 2: Race condition - late event handler registration
+  try {
+    totalTests++;
+    console.log("Test 2: Race condition - late event handler");
+    
+    const agent = new MockBaseAgent(mockContext);
+    
+    // Start agent immediately
+    const agentPromise = agent.call("Race condition test");
+    
+    // Wait a bit before registering event handler (simulating race condition)
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    let eventFired = false;
+    
+    // Register event handler LATE
+    const lateEventPromise = new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Late event handler timeout - demonstrates the bug"));
+      }, 500);
+      
+      agent.agentEvents.once(agent.eventTypes.done, (message) => {
+        clearTimeout(timeout);
+        console.log("✅ Agent has finished (late handler).");
+        eventFired = true;
+        resolve();
+      });
+    });
+    
+    const result = await agentPromise;
+    
+    try {
+      await lateEventPromise;
+      console.log("✅ Test 2 PASSED - Late event handler worked (no race condition)\n");
+      passedTests++;
+    } catch (error: any) {
+      console.log("❌ Test 2 DEMONSTRATED BUG - Race condition detected!");
+      console.log("   This shows the event handler was registered too late\n");
+      // This is actually the expected failure that demonstrates the bug
+    }
+    
+  } catch (error: any) {
+    console.log(`❌ Test 2 ERROR - ${error.message}\n`);
+  }
+  
+  // Test 3: Multiple event handlers
+  try {
+    totalTests++;
+    console.log("Test 3: Multiple event handlers");
+    
+    const agent = new MockBaseAgent(mockContext);
+    let handler1Fired = false;
+    let handler2Fired = false;
+    
+    // Register multiple handlers
+    const promise1 = new Promise<void>((resolve) => {
+      agent.agentEvents.once(agent.eventTypes.done, () => {
+        console.log("✅ Handler 1: Agent has finished.");
+        handler1Fired = true;
+        resolve();
+      });
+    });
+    
+    const promise2 = new Promise<void>((resolve) => {
+      agent.agentEvents.once(agent.eventTypes.done, () => {
+        console.log("✅ Handler 2: Agent has completed the task.");
+        handler2Fired = true;
+        resolve();
+      });
+    });
+    
+    const result = await agent.call("Multiple handlers test");
+    
+    await Promise.race([
+      Promise.all([promise1, promise2]),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error("Multiple handlers timeout")), 1000)
+      )
+    ]);
+    
+    if (handler1Fired && handler2Fired) {
+      console.log("✅ Test 3 PASSED - All event handlers fired\n");
+      passedTests++;
+    } else {
+      console.log("❌ Test 3 FAILED - Not all handlers fired\n");
+    }
+    
+  } catch (error: any) {
+    console.log(`❌ Test 3 FAILED - ${error.message}\n`);
+  }
+  
+  // Summary
+  console.log("📊 Test Results:");
+  console.log(`   Passed: ${passedTests}/${totalTests} tests`);
+  
+  if (passedTests < totalTests) {
+    console.log("\n🔍 Event Handler Issues Detected:");
+    console.log("   - Race conditions when handlers are registered late");
+    console.log("   - Timing issues in event emission");
+    console.log("   - This demonstrates the reliability issues in AgentModule.ts");
+  } else {
+    console.log("\n✅ All tests passed - Event handlers are working reliably");
+  }
+}
+
+// Run the tests
+runTests().catch(console.error);

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")
+    );
+  });
+});