@tyvm/knowhow 0.0.56 → 0.0.59

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

@@ -119,7 +119,9 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
     // Verify that the content-based trigger was activated
     expect(mockEventService.emit).toHaveBeenCalledWith(
       "agent:msg",
-      expect.stringContaining("language_context_trigger")
+      expect.stringMatching(
+        /<Workflow>[\s\S]*language_context_trigger[\s\S]*<\/Workflow>/
+      )
     );
 
     const emitCall = mockEventService.emit.mock.calls.find(
@@ -127,9 +129,11 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
     );
     expect(emitCall).toBeDefined();
 
-    const eventData = JSON.parse(emitCall![1]);
+    // 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.filePath).toBe("src/components/MyComponent.spec.ts");
     expect(eventData.matchingTerms).toContain("test(");
     expect(eventData.contextMessage).toContain("Jest testing best practices");
   });
@@ -275,7 +279,9 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
     // Verify that case-insensitive matching worked
     expect(mockEventService.emit).toHaveBeenCalledWith(
       "agent:msg",
-      expect.stringContaining("language_context_trigger")
+      expect.stringMatching(
+        /<Workflow>[\s\S]*language_context_trigger[\s\S]*<\/Workflow>/
+      )
     );
   });
 
@@ -326,7 +332,9 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
     // Verify that edit events also trigger content analysis
     expect(mockEventService.emit).toHaveBeenCalledWith(
       "agent:msg",
-      expect.stringContaining("language_context_trigger")
+      expect.stringMatching(
+        /<Workflow>[\s\S]*language_context_trigger[\s\S]*<\/Workflow>/
+      )
     );
   });
 });

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

@@ -146,7 +146,9 @@ test("should calculate sum correctly", () => {
     // Verify agent:msg was emitted
     expect(mockEventService.emit).toHaveBeenCalledWith(
       "agent:msg",
-      expect.stringContaining("language_context_trigger")
+      expect.stringMatching(
+        /<Workflow>[\s\S]*language_context_trigger[\s\S]*<\/Workflow>/
+      )
     );
   });
 
@@ -198,7 +200,9 @@ describe('User service', () => {
     // Should trigger on 'test(' pattern
     expect(mockEventService.emit).toHaveBeenCalledWith(
       "agent:msg",
-      expect.stringContaining("Testing context")
+      expect.stringMatching(
+        /<Workflow>[\s\S]*Testing context[\s\S]*<\/Workflow>/
+      )
     );
   });
 
@@ -267,7 +271,9 @@ test('should get user data', () => {
     // Should now trigger on the edited content
     expect(mockEventService.emit).toHaveBeenCalledWith(
       "agent:msg",
-      expect.stringContaining("Testing context")
+      expect.stringMatching(
+        /<Workflow>[\s\S]*Testing context[\s\S]*<\/Workflow>/
+      )
     );
   });
 
@@ -336,7 +342,9 @@ test('should query database correctly', async () => {
     // Should emit agent:msg for the triggered terms
     expect(mockEventService.emit).toHaveBeenCalledWith(
       "agent:msg",
-      expect.stringContaining("language_context_trigger")
+      expect.stringMatching(
+        /<Workflow>[\s\S]*language_context_trigger[\s\S]*<\/Workflow>/
+      )
     );
 
     // Check that the emitted message contains both contexts
@@ -345,7 +353,10 @@ test('should query database correctly', async () => {
     );
     expect(emitCalls.length).toBeGreaterThan(0);
 
-    const eventData = JSON.parse(emitCalls[0][1]);
+    // Extract JSON from <Workflow> tags
+    const workflowContent = emitCalls[0][1].match(/<Workflow>\s*(\{[\s\S]*?\})\s*<\/Workflow>/);
+    expect(workflowContent).toBeDefined();
+    const eventData = JSON.parse(workflowContent[1]);
     expect(eventData.matchingTerms).toEqual(
       expect.arrayContaining(["test(", "database"])
     );
@@ -393,7 +404,9 @@ test('sum function works', () => {
 
     expect(mockEventService.emit).toHaveBeenCalledWith(
       "agent:msg",
-      expect.stringContaining("Testing context")
+      expect.stringMatching(
+        /<Workflow>[\s\S]*Testing context[\s\S]*<\/Workflow>/
+      )
     );
 
     // Clean up
@@ -447,7 +460,9 @@ test('performance test', () => {
     // Should still trigger correctly
     expect(mockEventService.emit).toHaveBeenCalledWith(
       "agent:msg",
-      expect.stringContaining("Testing context")
+      expect.stringMatching(
+        /<Workflow>[\s\S]*Testing context[\s\S]*<\/Workflow>/
+      )
     );
 
     // Should process reasonably quickly (less than 1 second)

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

@@ -199,9 +199,11 @@ describe("LanguagePlugin", () => {
       );
 
       expect(emitCall).toBeDefined();
-      const eventData = JSON.parse(emitCall[1]);
+      // 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.filePath).toBe("src/components/Button.ts");
       expect(eventData.matchingTerms).toEqual(["**/*.ts"]);
       expect(eventData.eventType).toBe("file:post-edit");
       expect(eventData.resolvedSources).toBeDefined();
@@ -264,7 +266,10 @@ describe("LanguagePlugin", () => {
       const emitCall = mockEventService.emit.mock.calls.find(
         (call) => call[0] === "agent:msg"
       );
-      const eventData = JSON.parse(emitCall![1]);
+      // 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/**");
@@ -334,7 +339,9 @@ describe("LanguagePlugin", () => {
       );
       expect(mockEventService.emit).toHaveBeenCalledWith(
         "agent:msg",
-        expect.stringContaining("language_context_trigger")
+        expect.stringMatching(
+          /<Workflow>[\s\S]*language_context_trigger[\s\S]*<\/Workflow>/
+        )
       );
     });
   });

package/tests/processors/ToolResponseCache.test.ts

@@ -2,6 +2,9 @@ import { Message } from "../../src/clients/types";
 import {
   ToolResponseCache,
   jqToolResponseDefinition,
+  grepToolResponseDefinition,
+  tailToolResponseDefinition,
+  listStoredToolResponsesDefinition,
 } from "../../src/processors/ToolResponseCache";
 import { ToolsService } from "../../src/services";
 
@@ -170,9 +173,15 @@ describe("ToolResponseCache", () => {
       expect(cache).toBeInstanceOf(ToolResponseCache);
       expect(mockToolsService.addTools).toHaveBeenCalledWith([
         jqToolResponseDefinition,
+        grepToolResponseDefinition,
+        tailToolResponseDefinition,
+        listStoredToolResponsesDefinition,
       ]);
       expect(mockToolsService.addFunctions).toHaveBeenCalledWith({
         jqToolResponse: expect.any(Function),
+        grepToolResponse: expect.any(Function),
+        tailToolResponse: expect.any(Function),
+        listStoredToolResponses: expect.any(Function),
       });
     });
 
@@ -549,9 +558,30 @@ describe("ToolResponseCache", () => {
             name: "jqToolResponse",
           }),
         },
+        {
+          type: "function",
+          function: expect.objectContaining({
+            name: "grepToolResponse",
+          }),
+        },
+        {
+          type: "function",
+          function: expect.objectContaining({
+            name: "tailToolResponse",
+          }),
+        },
+        {
+          type: "function",
+          function: expect.objectContaining({
+            name: "listStoredToolResponses",
+          }),
+        },
       ]);
       expect(mockToolsService.addFunctions).toHaveBeenCalledWith({
         jqToolResponse: expect.any(Function),
+        grepToolResponse: expect.any(Function),
+        tailToolResponse: expect.any(Function),
+        listStoredToolResponses: expect.any(Function),
       });
     });
 
@@ -581,6 +611,104 @@ describe("ToolResponseCache", () => {
     });
   });
 
+  describe("tailToolResponse", () => {
+    beforeEach(() => {
+      // Store test data with multiple lines
+      const multiLineContent = Array(50)
+        .fill(0)
+        .map((_, i) => `Line ${i + 1}: This is line number ${i + 1}`)
+        .join("\n");
+      cache.storeToolResponse(multiLineContent, "call_multiline");
+
+      // Store short content
+      cache.storeToolResponse("Line 1\nLine 2\nLine 3", "call_short");
+
+      // Store single line
+      cache.storeToolResponse("Single line content", "call_single");
+
+      // Store empty content
+      cache.storeToolResponse("", "call_empty");
+    });
+
+    it("should return last 10 lines by default", async () => {
+      const result = await cache.tailToolResponse("call_multiline");
+      const lines = result.split("\n");
+      expect(lines).toHaveLength(10);
+      expect(lines[0]).toContain("41: Line 41");
+      expect(lines[9]).toContain("50: Line 50");
+    });
+
+    it("should return last n lines when specified", async () => {
+      const result = await cache.tailToolResponse("call_multiline", {
+        lines: 5,
+      });
+      const lines = result.split("\n");
+      expect(lines).toHaveLength(5);
+      expect(lines[0]).toContain("46: Line 46");
+      expect(lines[4]).toContain("50: Line 50");
+    });
+
+    it("should return all lines if n is greater than total lines", async () => {
+      const result = await cache.tailToolResponse("call_short", { lines: 10 });
+      const lines = result.split("\n");
+      expect(lines).toHaveLength(3);
+      expect(lines[0]).toContain("1: Line 1");
+      expect(lines[1]).toContain("2: Line 2");
+      expect(lines[2]).toContain("3: Line 3");
+    });
+
+    it("should handle single line content", async () => {
+      const result = await cache.tailToolResponse("call_single", { lines: 5 });
+      expect(result).toBe("1: Single line content");
+    });
+
+    it("should handle empty content", async () => {
+      const result = await cache.tailToolResponse("call_empty", { lines: 10 });
+      expect(result).toBe("1: ");
+    });
+
+    it("should return last 1 line when lines is 1", async () => {
+      const result = await cache.tailToolResponse("call_multiline", {
+        lines: 1,
+      });
+      expect(result).toBe("50: Line 50: This is line number 50");
+    });
+
+    it("should return last 20 lines", async () => {
+      const result = await cache.tailToolResponse("call_multiline", {
+        lines: 20,
+      });
+      const lines = result.split("\n");
+      expect(lines).toHaveLength(20);
+      expect(lines[0]).toContain("31: Line 31");
+      expect(lines[19]).toContain("50: Line 50");
+    });
+
+    it("should format line numbers correctly", async () => {
+      const result = await cache.tailToolResponse("call_multiline", {
+        lines: 3,
+      });
+      const lines = result.split("\n");
+      expect(lines[0]).toMatch(/^48:/);
+      expect(lines[1]).toMatch(/^49:/);
+      expect(lines[2]).toMatch(/^50:/);
+    });
+
+    it("should return error for missing tool call ID", async () => {
+      const result = await cache.tailToolResponse("missing_id");
+      expect(result).toContain("Error: No tool response found");
+      expect(result).toContain("missing_id");
+      expect(result).toContain("Available IDs:");
+    });
+
+    it("should handle lines option of 0", async () => {
+      const result = await cache.tailToolResponse("call_multiline", {
+        lines: 0,
+      });
+      expect(result).toBe("");
+    });
+  });
+
   describe("Edge Cases and Error Handling", () => {
     it("should handle very large JSON objects", async () => {
       const largeObject = {

package/tests/unit/InputQueueManager.test.ts

@@ -0,0 +1,174 @@
+import { InputQueueManager } from "../../src/utils/InputQueueManager";
+
+describe("InputQueueManager history ordering", () => {
+  test("should use only passed-in history for navigation", () => {
+    const manager = new InputQueueManager();
+    
+    // Simulate history passed to ask() (oldest -> newest)
+    const history = ["old1", "old2", "old3"];
+    
+    // Access the private getHistory method via reflection for testing
+    const getHistory = (manager as any).getHistory.bind(manager);
+    
+    // Simulate having a current question with history
+    (manager as any).stack = [{
+      question: "test",
+      options: [],
+      history: history,
+      resolve: () => {}
+    }];
+    
+    const result = getHistory();
+    
+    // Should return history in oldest->newest order (same as passed in)
+    expect(result).toEqual(["old1", "old2", "old3"]);
+  });
+
+  test("should sanitize history entries", () => {
+    const manager = new InputQueueManager();
+    
+    // History with entries that need sanitization
+    const history = ["normal", "has\nnewline", "  spaces  ", ""];
+    
+    const getHistory = (manager as any).getHistory.bind(manager);
+    
+    (manager as any).stack = [{
+      question: "test",
+      options: [],
+      history: history,
+      resolve: () => {}
+    }];
+    
+    const result = getHistory();
+    
+    // Should sanitize: remove newlines, trim whitespace, filter empty
+    expect(result).toEqual(["normal", "has newline", "spaces"]);
+  });
+
+  test("should return empty array when no history provided", () => {
+    const manager = new InputQueueManager();
+    
+    const getHistory = (manager as any).getHistory.bind(manager);
+    
+    // No history in stack
+    (manager as any).stack = [{
+      question: "test",
+      options: [],
+      history: undefined,
+      resolve: () => {}
+    }];
+    
+    const result = getHistory();
+    
+    expect(result).toEqual([]);
+  });
+
+  test("should return empty array when stack is empty", () => {
+    const manager = new InputQueueManager();
+    
+    const getHistory = (manager as any).getHistory.bind(manager);
+    
+    // Empty stack
+    (manager as any).stack = [];
+    
+    const result = getHistory();
+    
+    expect(result).toEqual([]);
+  });
+
+  test("Verify historyIndex math for first Up press", () => {
+    // History array: ["old1", "old2", "recent"]
+    // length = 3
+    // First Up: historyIndex becomes 0
+    // Index to access: length - 1 - historyIndex = 3 - 1 - 0 = 2
+    // history[2] = "recent" ✓
+    
+    const history = ["old1", "old2", "recent"];
+    const historyIndex = 0; // After first Up press
+    const accessIndex = history.length - 1 - historyIndex;
+    
+    expect(accessIndex).toBe(2);
+    expect(history[accessIndex]).toBe("recent");
+  });
+
+  test("Verify historyIndex math for multiple Up presses", () => {
+    // History array: ["old1", "old2", "recent"]
+    // length = 3
+    const history = ["old1", "old2", "recent"];
+    
+    // First Up: historyIndex = 0
+    expect(history[history.length - 1 - 0]).toBe("recent");
+    
+    // Second Up: historyIndex = 1
+    expect(history[history.length - 1 - 1]).toBe("old2");
+    
+    // Third Up: historyIndex = 2
+    expect(history[history.length - 1 - 2]).toBe("old1");
+  });
+
+  test("onNewEntry callback is called when set", () => {
+    const manager = new InputQueueManager();
+    const entries: string[] = [];
+    
+    manager.setOnNewEntry((entry) => {
+      entries.push(entry);
+    });
+    
+    // Verify callback is stored (we can't easily test the actual Enter key behavior without mocking readline)
+    expect((manager as any).onNewEntry).toBeDefined();
+  });
+});
+
+describe("InputQueueManager with CliChatService integration pattern", () => {
+  test("new entries should appear in history for next ask() call", () => {
+    // This test verifies the pattern used by CliChatService:
+    // 1. ask() is called with current inputHistory
+    // 2. User types and presses Enter
+    // 3. onNewEntry callback adds entry to inputHistory
+    // 4. Next ask() call includes the new entry
+    
+    const inputHistory: string[] = ["old1", "old2"];
+    const manager = new InputQueueManager();
+    
+    // Set up callback (like CliChatService does)
+    manager.setOnNewEntry((entry) => {
+      if (!entry.startsWith("/") && entry.trim() !== "") {
+        inputHistory.push(entry);
+      }
+    });
+    
+    // Simulate: first ask() call with current history
+    const getHistory = (manager as any).getHistory.bind(manager);
+    (manager as any).stack = [{
+      question: "test",
+      options: [],
+      history: [...inputHistory], // snapshot at time of ask()
+      resolve: () => {}
+    }];
+    
+    let result = getHistory();
+    expect(result).toEqual(["old1", "old2"]);
+    
+    // Simulate: user presses Enter with "new message"
+    // The callback fires (in real code this happens in the 'line' event)
+    (manager as any).onNewEntry("new message");
+    
+    // inputHistory is now updated
+    expect(inputHistory).toEqual(["old1", "old2", "new message"]);
+    
+    // Simulate: next ask() call with updated history
+    (manager as any).stack = [{
+      question: "test2",
+      options: [],
+      history: [...inputHistory], // new snapshot includes "new message"
+      resolve: () => {}
+    }];
+    
+    result = getHistory();
+    expect(result).toEqual(["old1", "old2", "new message"]);
+    
+    // Press Up: should get "new message" (the most recent)
+    const historyIndex = 0;
+    expect(result[result.length - 1 - historyIndex]).toBe("new message");
+  });
+});

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.56",
+    "version": "0.0.59",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {
@@ -10,7 +10,7 @@
         "test": "jest --testTimeout 300000",
         "test:debug": "node --inspect-brk ../../node_modules/jest/bin/jest.js --detectOpenHandles --forceExit --testTimeout 300000",
         "compile": "tsc",
-        "start": "npm run compile && node ts_build/src/server/index.js",
+        "start": "npm run compile && node --no-node-snapshot ts_build/src/server/index.js",
         "dataset:diffs:generate": "ts-node src/dataset/diffs/generate.ts",
         "dataset:diffs:jsonl": "ts-node src/dataset/diffs/jsonl.ts",
         "prepublishOnly": "npm run compile",
@@ -62,7 +62,7 @@
         "jira-client": "^8.2.2",
         "marked": "^10.0.0",
         "marked-terminal": "^6.2.0",
-        "minimatch": "^10.0.3",
+        "minimatch": "^10.1.2",
         "morgan": "^1.10.0",
         "node-fetch": "^3.2.3",
         "node-jq": "^6.0.1",

package/ts_build/src/agents/base/base.d.ts

@@ -52,10 +52,17 @@ export declare abstract class BaseAgent implements IAgent {
         costUpdate: string;
         toolCall: string;
         toolUsed: string;
+        notStarted: string;
+        inProgress: string;
         done: string;
         pause: string;
         kill: string;
         unpause: string;
+        agentMsg: string;
+        userSay: string;
+        agentSay: string;
+        agentNewTask: string;
+        agentTaskComplete: string;
     };
     tools: ToolsService;
     events: EventService;
@@ -108,6 +115,9 @@ export declare abstract class BaseAgent implements IAgent {
     unpaused(): Promise<unknown>;
     kill(): Promise<void>;
     call(userInput: string, _messages?: Message[]): any;
+    getStatusMessage(): string;
+    logStatus(): void;
+    addPendingMessage(message: Message): void;
     addPendingUserMessage(message: Message): void;
     getMessagesLength(messages: Message[]): number;
     getTaskBreakdown(messages: Message[]): Promise<string>;