@tyvm/knowhow 0.0.158 → 0.0.160

package/tests/plugins/language/languagePlugin.test.ts

@@ -1,385 +0,0 @@
-jest.mock("../../../src/utils", () => ({
-  readFile: jest.fn().mockReturnValue(Buffer.from("test")),
-  fileExists: jest.fn().mockReturnValue(true),
-  fileStat: jest.fn().mockResolvedValue({
-    isDirectory: jest.fn().mockReturnValue(false),
-    isFile: jest.fn().mockReturnValue(true),
-    size: 1024,
-  }),
-}));
-
-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(),
-  })),
-}));
-
-import { LanguagePlugin } from "../../../src/plugins/language";
-import { Config } from "../../../src/types";
-import { EventService } from "../../../src/services/EventService";
-import * as utils from "../../../src/utils";
-import { getConfig, getLanguageConfig } from "../../../src/config";
-import { PluginService } from "../../../src/plugins/plugins";
-
-import { minimatch } from "minimatch";
-const mockedConfig = getConfig as jest.MockedFunction<typeof getConfig>;
-const mockedLanguageConfig = getLanguageConfig as jest.MockedFunction<
-  typeof getLanguageConfig
->;
-
-// Use minimatch for consistent pattern matching with the plugin
-const matchGlobPattern = (pattern: string, text: string) =>
-  minimatch(text, pattern);
-
-describe("matchGlobPattern", () => {
-  it("should match exact patterns", () => {
-    expect(
-      matchGlobPattern("src/components/Button.ts", "src/components/Button.ts")
-    ).toBe(true);
-  });
-
-  it("should match wildcard patterns", () => {
-    expect(matchGlobPattern("**/*.ts", "Button.ts")).toBe(true);
-    expect(matchGlobPattern("**/*.ts", "src/components/Button.ts")).toBe(true);
-    expect(matchGlobPattern("src/**", "src/components")).toBe(true);
-  });
-});
-
-const MockedPluginService = PluginService as jest.MockedClass<
-  typeof PluginService
->;
-const MockedEventService = EventService as jest.MockedClass<
-  typeof EventService
->;
-
-describe("LanguagePlugin", () => {
-  const userPrompt = "test prompt including terms";
-
-  test("should call the correct plugins based on the user prompt", async () => {
-    const mockPluginService = new MockedPluginService({} as any);
-    const mockEventService = {
-      on: jest.fn(),
-      emit: jest.fn(),
-      log: jest.fn(),
-    };
-    const mockListPlugins = jest.fn().mockReturnValue(["github", "asana"]);
-    const mockCall = jest.fn().mockResolvedValue(["mocked plugin response"]);
-
-    mockPluginService.listPlugins = mockListPlugins;
-    mockPluginService.call = mockCall;
-
-    mockedConfig.mockResolvedValue({
-      plugins: { enabled: ["github", "asana"], disabled: [] },
-    } as Config);
-    mockedLanguageConfig.mockResolvedValue({
-      test: {
-        events: [],
-        sources: [
-          { kind: "github", data: ["http://github.com/test"] },
-          { kind: "asana", data: ["http://asana.com/test"] },
-          { kind: "file", data: ["../.knowhow/knowhow.json"] },
-        ],
-      },
-    });
-
-    const languagePlugin = new LanguagePlugin({
-      Events: mockEventService,
-      Plugins: mockPluginService,
-    } as any);
-    const pluginResponse = await languagePlugin.call(userPrompt);
-
-    expect(utils.fileExists).toHaveBeenCalled();
-    expect(utils.readFile).toHaveBeenCalled();
-    expect(mockListPlugins).toHaveBeenCalled();
-    expect(mockCall).toHaveBeenCalledWith("github", expect.any(String));
-    expect(mockCall).toHaveBeenCalledWith("asana", expect.any(String));
-    expect(pluginResponse).toContain(
-      "LANGUAGE PLUGIN: The user mentioned these terms triggering contextual expansions"
-    );
-  });
-
-  describe("Event-driven context expansion", () => {
-    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((event: string, data: any) => {
-          return true;
-        }),
-      };
-
-      mockPluginService = new MockedPluginService({} as any);
-      mockPluginService.listPlugins = jest.fn().mockReturnValue(["github"]);
-      mockPluginService.call = jest
-        .fn()
-        .mockResolvedValue(["plugin context data"]);
-    });
-
-    test("should register event handlers for configured events during initialization", async () => {
-      mockedLanguageConfig.mockResolvedValue({
-        "*.ts,*.js": {
-          events: ["file:post-edit", "file:create"],
-          sources: [{ kind: "file", data: ["src/config.ts"] }],
-        },
-        "package.json": {
-          events: ["file:post-edit"],
-          sources: [{ kind: "text", data: ["Package configuration"] }],
-        },
-      });
-
-      new LanguagePlugin({
-        Events: mockEventService,
-        Plugins: mockPluginService,
-      } as any);
-
-      // Wait for async setupEventHandlers to complete
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      expect(mockEventService.on).toHaveBeenCalledWith(
-        "file:post-edit",
-        expect.any(Function)
-      );
-      expect(mockEventService.on).toHaveBeenCalledWith(
-        "file:create",
-        expect.any(Function)
-      );
-    });
-
-    test("should handle file:post-edit event and emit agent:msg when file pattern matches", async () => {
-      mockedConfig.mockResolvedValue({
-        plugins: { enabled: ["github"], disabled: [] },
-      } as Config);
-      mockedLanguageConfig.mockResolvedValue({
-        "**/*.ts": {
-          events: ["file:post-edit"],
-          sources: [
-            { kind: "file", data: ["src/types.ts"] },
-            { kind: "github", data: ["https://github.com/repo/issues/123"] },
-          ],
-        },
-      });
-
-      new LanguagePlugin({
-        Events: mockEventService,
-        Plugins: mockPluginService,
-      } as any);
-
-      // Wait for async setupEventHandlers to complete
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      // Simulate file:post-edit event
-      const fileEditHandler = eventHandlers.get("file:post-edit");
-      expect(fileEditHandler).toBeDefined();
-
-      await fileEditHandler!({
-        filePath: "src/components/Button.ts",
-        operation: "edit",
-      });
-
-      // Wait for async event processing to complete
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      expect(mockEventService.emit).toHaveBeenCalledWith(
-        "agent:msg",
-        expect.any(String)
-      );
-
-      const emitCall = mockEventService.emit.mock.calls.find(
-        (call) => call[0] === "agent:msg"
-      );
-
-      expect(emitCall).toBeDefined();
-      // Extract JSON from <Workflow> tags
-      const workflowContent = emitCall[1].match(/<Workflow>\s*(\{[\s\S]*?\})\s*<\/Workflow>/);
-      expect(workflowContent).toBeDefined();
-      const eventData = JSON.parse(workflowContent[1]);
-      expect(eventData.type).toBe("language_context_trigger");
-      expect(eventData.matchingTerms).toEqual(["**/*.ts"]);
-      expect(eventData.eventType).toBe("file:post-edit");
-      expect(eventData.resolvedSources).toBeDefined();
-    });
-
-    test("should not emit agent:msg when file pattern does not match", async () => {
-      mockedLanguageConfig.mockResolvedValue({
-        "*.ts": {
-          events: ["file:post-edit"],
-          sources: [{ kind: "file", data: ["src/types.ts"] }],
-        },
-      });
-
-      new LanguagePlugin({
-        Events: mockEventService,
-        Plugins: mockPluginService,
-      } as any);
-
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      const fileEditHandler = eventHandlers.get("file:post-edit");
-      await fileEditHandler!({
-        filePath: "README.md", // Does not match *.ts pattern
-        operation: "edit",
-      });
-
-      expect(mockEventService.emit).not.toHaveBeenCalledWith(
-        "agent:msg",
-        expect.anything()
-      );
-    });
-
-    test("should handle multiple matching patterns for a single file", async () => {
-      mockedConfig.mockResolvedValue({
-        plugins: { enabled: [], disabled: [] },
-      } as Config);
-      mockedLanguageConfig.mockResolvedValue({
-        "**/*.ts": {
-          events: ["file:post-edit"],
-          sources: [{ kind: "text", data: ["TypeScript context"] }],
-        },
-        "src/**": {
-          events: ["file:post-edit"],
-          sources: [{ kind: "text", data: ["Source directory context"] }],
-        },
-      });
-
-      new LanguagePlugin({
-        Events: mockEventService,
-        Plugins: mockPluginService,
-      } as any);
-
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      const fileEditHandler = eventHandlers.get("file:post-edit");
-      await fileEditHandler!({
-        filePath: "src/components/Button.ts",
-      });
-      // Wait for async event processing to complete
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      const emitCall = mockEventService.emit.mock.calls.find(
-        (call) => call[0] === "agent:msg"
-      );
-      // Extract JSON from <Workflow> tags
-      const workflowContent = emitCall![1].match(/<Workflow>\s*(\{[\s\S]*?\})\s*<\/Workflow>/);
-      expect(workflowContent).toBeDefined();
-      const eventData = JSON.parse(workflowContent![1]);
-      // With minimatch, *.ts doesn't match src/components/Button.ts (needs **/*.ts)
-      // Only src/** pattern matches src/components/Button.ts
-      expect(eventData.matchingTerms).toContain("src/**");
-    });
-
-    test("should only trigger on configured events for a term", async () => {
-      mockedLanguageConfig.mockResolvedValue({
-        "*.ts": {
-          events: ["file:create"], // Only configured for create, not edit
-          sources: [{ kind: "text", data: ["TypeScript context"] }],
-        },
-      });
-
-      new LanguagePlugin({
-        Events: mockEventService,
-        Plugins: mockPluginService,
-      } as any);
-
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      const fileEditHandler = eventHandlers.get("file:post-edit");
-      if (fileEditHandler) {
-        await fileEditHandler({
-          filePath: "src/Button.ts",
-        });
-      }
-
-      expect(mockEventService.emit).not.toHaveBeenCalledWith(
-        "agent:msg",
-        expect.anything()
-      );
-    });
-
-    test("should resolve different source types in event context", async () => {
-      mockedConfig.mockResolvedValue({
-        plugins: { enabled: ["github"], disabled: [] },
-      } as Config);
-      mockedLanguageConfig.mockResolvedValue({
-        "package.json": {
-          events: ["file:post-edit"],
-          sources: [
-            { kind: "file", data: ["config/settings.json"] },
-            { kind: "text", data: ["JSON configuration files"] },
-            { kind: "github", data: ["https://github.com/repo/config"] },
-          ],
-        },
-      });
-
-      new LanguagePlugin({
-        Events: mockEventService,
-        Plugins: mockPluginService,
-      } as any);
-
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      const fileEditHandler = eventHandlers.get("file:post-edit");
-      await fileEditHandler!({
-        filePath: "package.json",
-      });
-
-      expect(utils.fileExists).toHaveBeenCalledWith("config/settings.json");
-      expect(utils.readFile).toHaveBeenCalledWith(
-        "config/settings.json",
-        "utf8"
-      );
-      expect(mockPluginService.call).toHaveBeenCalledWith(
-        "github",
-        "https://github.com/repo/config"
-      );
-      expect(mockEventService.emit).toHaveBeenCalledWith(
-        "agent:msg",
-        expect.stringMatching(
-          /<Workflow>[\s\S]*language_context_trigger[\s\S]*<\/Workflow>/
-        )
-      );
-    });
-  });
-
-  test("should return a message if no matching terms found", async () => {
-    const mockEventService = {
-      on: jest.fn(),
-      emit: jest.fn(),
-      log: jest.fn(),
-    };
-    const mockPluginService = new MockedPluginService({} as any);
-    const mockListPlugins = jest.fn().mockReturnValue(["github"]);
-
-    mockPluginService.listPlugins = mockListPlugins;
-
-    mockedConfig.mockResolvedValue({
-      plugins: { enabled: ["github"], disabled: [] },
-    } as Config);
-    mockedLanguageConfig.mockResolvedValue({});
-    const languagePlugin = new LanguagePlugin({
-      Events: mockEventService,
-      Plugins: mockPluginService,
-    } as any);
-    const pluginResponse = await languagePlugin.call(userPrompt);
-
-    expect(pluginResponse).toEqual("LANGUAGE PLUGIN: No matching terms found");
-  });
-});

package/tests/processes/managedProcessShim.test.ts

@@ -1,59 +0,0 @@
-import { spawn } from "child_process";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-
-describe("managed process shim", () => {
-  const testOnPosix = process.platform === "win32" ? test.skip : test;
-
-  testOnPosix("exits after a short command instead of leaking the shim process", async () => {
-    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-shim-test-"));
-    const configPath = path.join(directory, "launch.json");
-    const shimModule = path.resolve(__dirname, "../../src/processes/managedProcessShim");
-    fs.writeFileSync(configPath, JSON.stringify({
-      id: "short-command",
-      command: process.execPath,
-      args: ["-e", "process.exit(0)"],
-      cwd: directory,
-      env: {},
-      background: true,
-      parentProcessId: null,
-      parentPid: null,
-      shell: false,
-      processesDir: path.dirname(directory),
-    }));
-
-    const script = `require(${JSON.stringify(shimModule)})`
-      + `.runManagedProcessShim(${JSON.stringify(configPath)})`
-      + `.catch(error => { console.error(error); process.exitCode = 1; });`;
-    const shim = spawn(process.execPath, ["-r", "ts-node/register/transpile-only", "-e", script], {
-      cwd: path.resolve(__dirname, "../.."),
-      stdio: ["ignore", "ignore", "pipe"],
-    });
-    let stderr = "";
-    shim.stderr!.setEncoding("utf8");
-    shim.stderr!.on("data", (chunk) => { stderr += chunk; });
-
-    try {
-      const result = await new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve, reject) => {
-        const timer = setTimeout(() => {
-          shim.kill("SIGKILL");
-          reject(new Error(`Shim PID ${shim.pid} did not exit after its command completed`));
-        }, 10000);
-        shim.once("exit", (code, signal) => {
-          clearTimeout(timer);
-          resolve({ code, signal });
-        });
-      });
-
-      expect(stderr).toBe("");
-      expect(result).toEqual({ code: 0, signal: null });
-      const status = JSON.parse(fs.readFileSync(path.join(directory, "status.json"), "utf8"));
-      expect(status).toMatchObject({ shimPid: shim.pid, state: "exited", exitCode: 0 });
-      expect(() => process.kill(shim.pid!, 0)).toThrow();
-    } finally {
-      if (shim.exitCode === null && shim.signalCode === null) shim.kill("SIGKILL");
-      fs.rmSync(directory, { recursive: true, force: true });
-    }
-  });
-});