@tyvm/knowhow 0.0.156 → 0.0.158

package/tests/unit/commands/remote.test.ts

@@ -0,0 +1,79 @@
+import { Command } from "commander";
+
+const getConfig = jest.fn();
+const updateConfig = jest.fn();
+
+jest.mock("../../../src/config", () => ({ getConfig, updateConfig }));
+
+import { addRemoteCommand } from "../../../src/commands/remote";
+
+describe("remote command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(console, "log").mockImplementation(() => undefined);
+    program = new Command();
+    program.exitOverride();
+    addRemoteCommand(program);
+  });
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it("adds a named remote with an independent JWT path", async () => {
+    const config: any = {
+      orgIds: {
+        "http://localhost:4000": "org-local",
+      },
+    };
+    getConfig.mockResolvedValue(config);
+
+    await program.parseAsync([
+      "node",
+      "knowhow",
+      "remote",
+      "add",
+      "dev",
+      "https://api.dev.knowhow.tyvm.ai/",
+    ]);
+
+    expect(updateConfig).toHaveBeenCalledWith(config);
+    expect(config.remotes.dev).toEqual({
+      name: "dev",
+      apiUrl: "https://api.dev.knowhow.tyvm.ai",
+      jwtPath: ".knowhow/.jwt.dev",
+    });
+    expect(config.orgIds).toBeUndefined();
+    expect(config.remotes.local).toEqual({
+      name: "local",
+      apiUrl: "http://localhost:4000",
+      jwtPath: ".knowhow/.jwt.local",
+      orgId: "org-local",
+    });
+  });
+
+  it("selects a configured remote for subsequent commands", async () => {
+    const config: any = {
+      remotes: {
+        local: {
+          name: "local",
+          apiUrl: "http://localhost:4000",
+          jwtPath: ".knowhow/.jwt.local",
+          orgId: "org-local",
+        },
+      },
+    };
+    getConfig.mockResolvedValue(config);
+
+    await program.parseAsync([
+      "node",
+      "knowhow",
+      "remote",
+      "use",
+      "local",
+    ]);
+
+    expect(config.activeRemote).toBe("local");
+    expect(updateConfig).toHaveBeenCalledWith(config);
+  });
+});

package/tests/unit/login.test.ts

@@ -48,7 +48,7 @@ describe("login public-key bootstrap", () => {
     jest.spyOn(console, "warn").mockImplementation(() => undefined);
     workingDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-login-"));
     fs.mkdirSync(path.join(workingDirectory, ".knowhow"));
-    fs.writeFileSync(path.join(workingDirectory, ".knowhow", ".jwt"), "raw-jwt");
+    fs.writeFileSync(path.join(workingDirectory, ".knowhow", ".jwt.api.example"), "raw-jwt");
     process.chdir(workingDirectory);
     hasKeyPair.mockReturnValue(false);
     browserLogin.mockResolvedValue(undefined);
@@ -87,7 +87,42 @@ describe("login public-key bootstrap", () => {
       "https://api.example"
     );
     expect(updateConfig).toHaveBeenCalledWith(
-      expect.objectContaining({ orgId: "org-1", modelProviders: [{ provider: "knowhow" }] })
+      expect.objectContaining({
+        activeRemote: "api.example",
+        modelProviders: [{ provider: "knowhow" }],
+        remotes: expect.objectContaining({
+          "api.example": {
+            name: "api.example",
+            apiUrl: "https://api.example",
+            jwtPath: ".knowhow/.jwt.api.example",
+            orgId: "org-1",
+          },
+        }),
+      })
+    );
+  });
+
+  it("persists an explicit --api-url as the authenticated remote", async () => {
+    fs.writeFileSync(path.join(workingDirectory, ".knowhow", ".jwt.local"), "local-jwt");
+
+    await login(false, undefined, "http://localhost:4000/", "local");
+
+    expect(updateConfig).toHaveBeenCalledWith(
+      expect.objectContaining({
+        activeRemote: "local",
+        remotes: expect.objectContaining({
+          local: {
+            name: "local",
+            apiUrl: "http://localhost:4000",
+            jwtPath: ".knowhow/.jwt.local",
+            orgId: "org-1",
+          },
+        }),
+      })
+    );
+    expect(httpGet).toHaveBeenCalledWith(
+      "http://localhost:4000/api/users/me",
+      expect.any(Object)
     );
   });
 
@@ -119,9 +154,9 @@ describe("login public-key bootstrap", () => {
     expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/default");
     expect(updateConfig).toHaveBeenCalledWith(
       expect.objectContaining({
-        orgId: "org-1",
         cliIdentityPath: "/keys/default",
         modelProviders: [{ provider: "knowhow" }],
+        remotes: expect.objectContaining({ "api.example": expect.objectContaining({ orgId: "org-1" }) }),
       })
     );
   });
@@ -143,6 +178,32 @@ describe("login public-key bootstrap", () => {
     expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/dev");
   });
 
+  it("uses the selected API's JWT org instead of an org saved by another environment", async () => {
+    const devJwt = `${Buffer.from("{}").toString("base64url")}.${Buffer.from(
+      JSON.stringify({ org: "org-dev" })
+    ).toString("base64url")}.signature`;
+    fs.writeFileSync(
+      path.join(workingDirectory, ".knowhow", ".jwt.api.example"),
+      devJwt
+    );
+    hasKeyPair.mockReturnValue(true);
+    getConfig.mockResolvedValue({
+      orgId: "org-local",
+      orgIds: { "http://localhost:4000": "org-local" },
+      modelProviders: [],
+    });
+    authenticateWithKey.mockResolvedValueOnce(true);
+
+    await expect(login(false, "/keys/default")).resolves.toBeUndefined();
+
+    expect(authenticateWithKey).toHaveBeenCalledWith(
+      "org-dev",
+      "https://api.example",
+      "/keys/default"
+    );
+    expect(browserLogin).not.toHaveBeenCalled();
+  });
+
   it("does not attempt key authentication without a configured organization", async () => {
     hasKeyPair.mockReturnValue(true);
     getConfig.mockResolvedValue({ modelProviders: [] });

package/tests/unit/services/KnowhowClient.test.ts

@@ -54,7 +54,7 @@ describe("KnowhowSimpleClient identity renewal", () => {
       "https://api.example.test",
       "/tmp/identity"
     );
-    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt");
+    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt", "https://api.example.test");
     expect(mockGet.mock.calls[0][1].headers.Authorization).toBe("Bearer fresh-jwt");
   });
 
@@ -77,7 +77,7 @@ describe("KnowhowSimpleClient identity renewal", () => {
       "https://api.example.test",
       "/tmp/identity"
     );
-    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt");
+    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt", "https://api.example.test");
     expect(mockGet).toHaveBeenCalledTimes(1);
     expect(mockGet.mock.calls[0][1].headers.Authorization).toBe("Bearer fresh-jwt");
   });

package/tests/unit/services/Mcp.test.ts

@@ -33,11 +33,11 @@ describe("McpService JWT file transport", () => {
     fs.rmSync(temporaryDirectory, { recursive: true, force: true });
   });
 
-  it("reads the refreshed JWT when the transport is created", () => {
+  it("reads the refreshed JWT when the transport is created", async () => {
     fs.writeFileSync(tokenFile, "expired-jwt");
     fs.writeFileSync(tokenFile, "fresh-jwt");
 
-    new McpService().createTransport({
+    await new McpService().createTransport({
       name: "authenticated-remote",
       url: "https://api.example.test/mcp",
       authorization_token_file: tokenFile,

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.156",
+    "version": "0.0.158",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {

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

@@ -70,6 +70,9 @@ export declare abstract class BaseAgent implements IAgent {
     protected compressThreshold: number;
     protected compressMinMessages: number;
     protected _forceCompact: boolean;
+    private _compactionPromise;
+    private _completedCompaction;
+    private _compactionGeneration;
     private _interruptResolve;
     private _interruptToken;
     protected threads: Message[][];
@@ -147,7 +150,7 @@ export declare abstract class BaseAgent implements IAgent {
     getTurnCount(): number;
     adjustTotalCostUsd(cost: number): void;
     getTotalCostUsd(): number;
-    adjustTokenUsage(usage: any, messages?: Message[]): void;
+    adjustTokenUsage(usage: any, messages?: Message[], updateLastPromptTokens?: boolean): void;
     getTokenUsage(): {
         totalInputTokens: number;
         totalOutputTokens: number;
@@ -156,6 +159,7 @@ export declare abstract class BaseAgent implements IAgent {
     };
     protected createAgentCompletion(params: CachedChatCompletion, options?: {
         interruptValue?: CompletionResponse;
+        updateLastPromptTokens?: boolean;
     }): Promise<CompletionResponse>;
     startNewThread(messages: Message[]): void;
     updateCurrentThread(messages: Message[]): void;
@@ -192,6 +196,7 @@ export declare abstract class BaseAgent implements IAgent {
         content: string;
     } | null;
     extractContentFromMessages(messages: Message[]): string;
-    getTaskBreakdown(messages: Message[]): Promise<string>;
-    compressMessages(messages: Message[]): Promise<Message[]>;
+    private startBackgroundCompaction;
+    getTaskBreakdown(messages: Message[], cacheResult?: boolean): Promise<string>;
+    compressMessages(messages: Message[], onSummary?: (summary: string) => void, taskBreakdown?: string): Promise<Message[]>;
 }

package/ts_build/src/agents/base/base.js

@@ -44,6 +44,9 @@ let BaseAgent = class BaseAgent {
     compressThreshold = 30000;
     compressMinMessages = 30;
     _forceCompact = false;
+    _compactionPromise = null;
+    _completedCompaction = null;
+    _compactionGeneration = 0;
     _interruptResolve = null;
     _interruptToken = 0;
     threads = [];
@@ -141,6 +144,9 @@ let BaseAgent = class BaseAgent {
         this.maxRunTimeMs = maxRunTimeMs;
     }
     newTask(taskId) {
+        this._compactionGeneration++;
+        this._compactionPromise = null;
+        this._completedCompaction = null;
         this.currentThread = 0;
         this.threads = [];
         this.taskBreakdown = "";
@@ -348,7 +354,7 @@ let BaseAgent = class BaseAgent {
     getTotalCostUsd() {
         return this.totalCostUsd;
     }
-    adjustTokenUsage(usage, messages) {
+    adjustTokenUsage(usage, messages, updateLastPromptTokens = true) {
         if (!usage)
             return;
         const inputTokens = usage.input_tokens ?? usage.prompt_tokens ?? 0;
@@ -359,7 +365,7 @@ let BaseAgent = class BaseAgent {
             0;
         const cacheWriteTokens = usage.cache_creation_input_tokens ?? usage.cache_write_tokens ?? 0;
         const promptTokens = inputTokens + cacheReadTokens + cacheWriteTokens;
-        if (promptTokens > 0) {
+        if (updateLastPromptTokens && promptTokens > 0) {
             this.lastPromptTokens = promptTokens;
         }
         this.totalInputTokens += inputTokens;
@@ -388,7 +394,7 @@ let BaseAgent = class BaseAgent {
         };
     }
     async createAgentCompletion(params, options = {}) {
-        const { interruptValue } = options;
+        const { interruptValue, updateLastPromptTokens = true } = options;
         const defaultedParams = {
             model: this.getModel(),
             tools: this.getEnabledTools(),
@@ -407,7 +413,7 @@ let BaseAgent = class BaseAgent {
             ? await this.makeInterruptible(callPromise, interruptValue)
             : await callPromise;
         this.adjustTotalCostUsd(response?.usd_cost);
-        this.adjustTokenUsage(response?.usage, params.messages);
+        this.adjustTokenUsage(response?.usage, params.messages, updateLastPromptTokens);
         return response;
     }
     startNewThread(messages) {
@@ -774,25 +780,56 @@ let BaseAgent = class BaseAgent {
                 this.agentEvents.emit(this.eventTypes.done, firstMessage.content);
                 return firstMessage.content;
             }
+            const completedCompaction = this._completedCompaction;
+            this._completedCompaction = null;
+            let appliedCompaction = false;
+            if (completedCompaction) {
+                const currentPrefix = messages.slice(0, completedCompaction.compressionEnd);
+                const prefixIsUnchanged = currentPrefix.every((message, index) => message === completedCompaction.originalPrefix[index] ||
+                    JSON.stringify(message) ===
+                        JSON.stringify(completedCompaction.originalPrefix[index]));
+                if (currentPrefix.length === completedCompaction.compressionEnd &&
+                    prefixIsUnchanged) {
+                    messages = [
+                        ...completedCompaction.replacementPrefix,
+                        ...messages.slice(completedCompaction.compressionEnd),
+                    ];
+                    this.summaries.push(completedCompaction.summary);
+                    this.startNewThread(messages);
+                    this.lastPromptTokens = 0;
+                    appliedCompaction = true;
+                }
+                else {
+                    this.log("Discarding completed compaction because its source prefix changed; a later turn will retry", "warn");
+                }
+            }
             const contextTokens = this.getContextTokenCount(messages);
             const overThreshold = contextTokens > this.getCompressThreshold() &&
                 messages.length > this.compressMinMessages;
-            if (overThreshold || this._forceCompact) {
-                const taskBreakdown = await this.getTaskBreakdown(messages);
+            if (!appliedCompaction &&
+                !this._compactionPromise &&
+                (overThreshold || this._forceCompact)) {
                 this.log(this._forceCompact
-                    ? `Compacting messages (manual /compact request): ${contextTokens} tokens`
-                    : `Compressing messages: ${contextTokens} tokens exceeds ${this.getCompressThreshold()}`);
+                    ? `Starting background compaction (manual /compact request): ${contextTokens} tokens`
+                    : `Starting background compaction: ${contextTokens} tokens exceeds ${this.getCompressThreshold()}`);
                 this._forceCompact = false;
-                messages = await this.compressMessages(messages);
-                this.startNewThread(messages);
-                this.lastPromptTokens = 0;
+                this.startBackgroundCompaction(messages);
             }
             if (["assistant", "tool"].includes(messages[messages.length - 1].role)) {
                 const statusMessage = this.getStatusMessage();
                 this.logStatus();
                 const continuation = `<Workflow>
-        Task terminates after you call on of these tools: ${JSON.stringify(this.requiredToolNames)}.\n
-        User likely only sees output from the required tool call.
+        This is an automated runtime instruction, not a new user message.
+        The original user request remains active. Do not say that the user's
+        message was empty, and do not ask the user to repeat the request.
+
+        Your previous response did not terminate the task because it did not
+        call one of the required tools: ${JSON.stringify(this.requiredToolNames)}.
+        If your previous response was intended as the final response, call the
+        appropriate required tool now with that response. Otherwise, continue
+        working on the original request and call an appropriate required tool
+        when the task is complete.
+
         <TaskStatus>${statusMessage}</TaskStatus>
         </Workflow>`;
                 messages.push({
@@ -1028,12 +1065,53 @@ let BaseAgent = class BaseAgent {
             .map((t) => t.function.arguments);
         return [...content, ...finalAnswer].join("\n\n");
     }
-    async getTaskBreakdown(messages) {
+    startBackgroundCompaction(messages) {
+        const snapshot = messages.slice();
+        let resumeIndex = snapshot.length - 1;
+        while (resumeIndex >= 0 && snapshot[resumeIndex].role !== "assistant") {
+            resumeIndex--;
+        }
+        const compressionEnd = resumeIndex === -1 ? snapshot.length : resumeIndex;
+        const generation = this._compactionGeneration;
+        const promise = (async () => {
+            const taskBreakdown = await this.getTaskBreakdown(snapshot, false);
+            if (generation !== this._compactionGeneration)
+                return;
+            this.taskBreakdown = taskBreakdown;
+            let summary = "";
+            const compactedSnapshot = await this.compressMessages(snapshot, (generatedSummary) => {
+                summary = generatedSummary;
+            }, taskBreakdown);
+            if (generation !== this._compactionGeneration)
+                return;
+            const preservedSnapshotLength = snapshot.length - compressionEnd;
+            this._completedCompaction = {
+                compressionEnd,
+                originalPrefix: snapshot.slice(0, compressionEnd),
+                replacementPrefix: compactedSnapshot.slice(0, compactedSnapshot.length - preservedSnapshotLength),
+                summary,
+            };
+            this.log("Background compaction completed; it will be applied next turn");
+        })();
+        this._compactionPromise = promise;
+        promise
+            .catch((error) => {
+            if (generation === this._compactionGeneration) {
+                this.log(`Background compaction failed; a later turn will retry: ${error}`, "warn");
+            }
+        })
+            .finally(() => {
+            if (this._compactionPromise === promise) {
+                this._compactionPromise = null;
+            }
+        });
+    }
+    async getTaskBreakdown(messages, cacheResult = true) {
         if (this.taskBreakdown) {
             return this.taskBreakdown;
         }
         const taskPrompt = `
-    Analyze all previous messages.
+    TASK INTERRUPT. CONTEXT COMPACTION NEEDED. Analyze all previous messages.
 
     Generate a detailed task breakdown for this conversation, include a section for the following:
     1. Task List
@@ -1052,17 +1130,19 @@ let BaseAgent = class BaseAgent {
         const response = await this.createAgentCompletion({
             messages: taskBreakdownMessages,
             tool_choice: "none",
-        });
+        }, { updateLastPromptTokens: false });
         const breakdownContent = this.extractContentFromMessages(response.choices?.map((c) => c.message));
         if (!breakdownContent) {
             console.log(JSON.stringify(response.choices, null, 2));
             throw new Error("Compaction task-breakdown request returned no text content");
         }
-        this.taskBreakdown = breakdownContent;
+        if (cacheResult) {
+            this.taskBreakdown = breakdownContent;
+        }
         this.log(`task breakdown cost: ${response.usd_cost}`);
-        return this.taskBreakdown;
+        return breakdownContent;
     }
-    async compressMessages(messages) {
+    async compressMessages(messages, onSummary, taskBreakdown = this.taskBreakdown) {
         let resumeIndex = messages.length - 1;
         while (resumeIndex >= 0 && messages[resumeIndex].role !== "assistant") {
             resumeIndex--;
@@ -1071,7 +1151,8 @@ let BaseAgent = class BaseAgent {
         const toCompress = messages.slice(0, compressionEnd);
         const resumeMessages = messages.slice(compressionEnd);
         this.log(`Compressing messages from 0 to ${compressionEnd}, resuming from ${resumeIndex}, total messages: ${messages.length}`);
-        const toCompressPrompt = `We are compressing our conversation to save memory.
+        const toCompressPrompt = `TASK INTERRUPT. CONTEXT COMPACTION NEEDED.
+    We are compressing our conversation to save memory.
     Please summarize the conversation so far, so that we may continue the original task with a smaller context
 
     Include the following sections:
@@ -1080,8 +1161,8 @@ let BaseAgent = class BaseAgent {
     3. Next Steps - what we're about to do next to continue the user's original request.
     4. Tasks remaining - what tasks are left from the initial task breakdown.
 
-    ${this.taskBreakdown
-            ? `Our initial task breakdown: ${this.taskBreakdown}`
+    ${taskBreakdown
+            ? `Our initial task breakdown: ${taskBreakdown}`
             : ""}
 
     This summary will replace the older history. The latest agent interaction will remain verbatim:
@@ -1097,19 +1178,24 @@ let BaseAgent = class BaseAgent {
         const response = await this.createAgentCompletion({
             messages: compressMessagesPayload,
             tool_choice: "none",
-        });
+        }, { updateLastPromptTokens: false });
         const summary = this.extractContentFromMessages(response.choices?.map((c) => c.message));
         if (summary.length === 0) {
             console.log(JSON.stringify(response.choices, null, 2));
             throw new Error("Compaction summary request returned no text content");
         }
-        this.summaries.push(summary);
+        if (onSummary) {
+            onSummary(summary);
+        }
+        else {
+            this.summaries.push(summary);
+        }
         const startMessages = [
             {
                 role: "user",
                 content: `
-        ${this.taskBreakdown
-                    ? `Initial task breakdown:\n        ${this.taskBreakdown}`
+        ${taskBreakdown
+                    ? `Initial task breakdown:\n        ${taskBreakdown}`
                     : "(No task breakdown available — summarize what you know from context above)"}
 
         We have just compressed the conversation to save memory: