kanna-code 0.19.0 → 0.21.0

package/src/server/codex-app-server-protocol.ts

@@ -141,6 +141,32 @@ export interface ContextCompactedNotification {
   turnId: string
 }
 
+export interface TokenUsageCounter {
+  input_tokens?: number
+  inputTokens?: number
+  cached_input_tokens?: number
+  cachedInputTokens?: number
+  output_tokens?: number
+  outputTokens?: number
+  reasoning_output_tokens?: number
+  reasoningOutputTokens?: number
+  total_tokens?: number
+  totalTokens?: number
+}
+
+export interface ThreadTokenUsageUpdatedNotification {
+  threadId: string
+  turnId: string
+  tokenUsage: {
+    total_token_usage?: TokenUsageCounter
+    total?: TokenUsageCounter
+    last_token_usage?: TokenUsageCounter
+    last?: TokenUsageCounter
+    model_context_window?: number
+    modelContextWindow?: number
+  }
+}
+
 export interface ToolRequestUserInputOption {
   label: string
   description?: string | null
@@ -406,6 +432,7 @@ export interface ErrorNotification {
 
 export type ServerNotification =
   | { method: "thread/started"; params: ThreadStartedNotification }
+  | { method: "thread/tokenUsage/updated"; params: ThreadTokenUsageUpdatedNotification }
   | { method: "turn/started"; params: TurnStartedNotification }
   | { method: "turn/completed"; params: TurnCompletedNotification }
   | { method: "turn/plan/updated"; params: TurnPlanUpdatedNotification }
@@ -436,6 +463,7 @@ export function isServerNotification(value: unknown): value is ServerNotificatio
   const candidate = value as Record<string, unknown>
   if (typeof candidate.method !== "string" || "id" in candidate) return false
   return candidate.method === "thread/started"
+    || candidate.method === "thread/tokenUsage/updated"
     || candidate.method === "turn/started"
     || candidate.method === "turn/completed"
     || candidate.method === "turn/plan/updated"

package/src/server/codex-app-server.test.ts

@@ -181,6 +181,94 @@ describe("CodexAppServerManager", () => {
     expect(turnStart?.params.collaborationMode?.settings?.reasoning_effort).toBeNull()
   })
 
+  test("maps thread token usage updates into context window transcript entries", async () => {
+    const process = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-usage" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      } else if (message.method === "turn/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { turn: { id: "turn-usage", status: "completed", error: null } },
+        })
+        child.writeServerMessage({
+          method: "thread/tokenUsage/updated",
+          params: {
+            threadId: "thread-usage",
+            turnId: "turn-usage",
+            tokenUsage: {
+              total: {
+                inputTokens: 11_833,
+                cachedInputTokens: 3456,
+                outputTokens: 6,
+                reasoningOutputTokens: 0,
+                totalTokens: 11_839,
+              },
+              last: {
+                inputTokens: 120,
+                cachedInputTokens: 0,
+                outputTokens: 6,
+                reasoningOutputTokens: 0,
+                totalTokens: 126,
+              },
+              modelContextWindow: 258_400,
+            },
+          },
+        })
+        child.writeServerMessage({
+          method: "turn/completed",
+          params: {
+            threadId: "thread-usage",
+            turn: { id: "turn-usage", status: "completed", error: null },
+          },
+        })
+      }
+    })
+
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+
+    await manager.startSession({
+      chatId: "chat-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+    })
+
+    const turn = await manager.startTurn({
+      chatId: "chat-1",
+      model: "gpt-5.4",
+      content: "Hello",
+      planMode: false,
+      onToolRequest: async () => ({}),
+    })
+
+    const events = await collectStream(turn.stream)
+    const usageEvent = events.find((event) => event.type === "transcript" && event.entry.kind === "context_window_updated")
+
+    expect(usageEvent).toBeDefined()
+    if (!usageEvent || usageEvent.type !== "transcript" || usageEvent.entry.kind !== "context_window_updated") {
+      throw new Error("missing usage event")
+    }
+
+    expect(usageEvent.entry.usage).toMatchObject({
+      usedTokens: 126,
+      totalProcessedTokens: 11_839,
+      maxTokens: 258_400,
+      inputTokens: 120,
+      cachedInputTokens: 0,
+      outputTokens: 6,
+      reasoningOutputTokens: 0,
+      lastUsedTokens: 126,
+      compactsAutomatically: true,
+    })
+  })
+
   test("generateStructured returns the final assistant JSON and stops the transient session", async () => {
     const process = new FakeCodexProcess((message, child) => {
       if (message.method === "initialize") {

package/src/server/codex-app-server.ts

@@ -2,7 +2,14 @@ import { spawn } from "node:child_process"
 import { randomUUID } from "node:crypto"
 import { createInterface } from "node:readline"
 import type { Readable, Writable } from "node:stream"
-import type { AskUserQuestionItem, CodexReasoningEffort, ServiceTier, TodoItem, TranscriptEntry } from "../shared/types"
+import type {
+  AskUserQuestionItem,
+  CodexReasoningEffort,
+  ContextWindowUsageSnapshot,
+  ServiceTier,
+  TodoItem,
+  TranscriptEntry,
+} from "../shared/types"
 import type { HarnessEvent, HarnessToolRequest, HarnessTurn } from "./harness-types"
 import {
   type CollabAgentToolCallItem,
@@ -29,6 +36,7 @@ import {
   type ThreadResumeResponse,
   type ThreadStartParams,
   type ThreadStartResponse,
+  type ThreadTokenUsageUpdatedNotification,
   type ToolRequestUserInputParams,
   type ToolRequestUserInputQuestion,
   type ToolRequestUserInputResponse,
@@ -231,6 +239,47 @@ function asRecord(value: unknown): Record<string, unknown> | null {
   return value as Record<string, unknown>
 }
 
+function asNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined
+}
+
+function normalizeCodexTokenUsage(
+  notification: ThreadTokenUsageUpdatedNotification,
+): ContextWindowUsageSnapshot | null {
+  const usage = notification.tokenUsage
+  const totalUsage = usage.total_token_usage ?? usage.total
+  const lastUsage = usage.last_token_usage ?? usage.last
+
+  const totalProcessedTokens = asNumber(totalUsage?.total_tokens) ?? asNumber(totalUsage?.totalTokens)
+  const usedTokens = asNumber(lastUsage?.total_tokens) ?? asNumber(lastUsage?.totalTokens) ?? totalProcessedTokens
+  if (usedTokens === undefined || usedTokens <= 0) {
+    return null
+  }
+
+  const inputTokens = asNumber(lastUsage?.input_tokens) ?? asNumber(lastUsage?.inputTokens)
+  const cachedInputTokens = asNumber(lastUsage?.cached_input_tokens) ?? asNumber(lastUsage?.cachedInputTokens)
+  const outputTokens = asNumber(lastUsage?.output_tokens) ?? asNumber(lastUsage?.outputTokens)
+  const reasoningOutputTokens =
+    asNumber(lastUsage?.reasoning_output_tokens) ?? asNumber(lastUsage?.reasoningOutputTokens)
+  const maxTokens = asNumber(usage.model_context_window) ?? asNumber(usage.modelContextWindow)
+
+  return {
+    usedTokens,
+    ...(totalProcessedTokens !== undefined && totalProcessedTokens > usedTokens ? { totalProcessedTokens } : {}),
+    ...(maxTokens !== undefined ? { maxTokens } : {}),
+    ...(inputTokens !== undefined ? { inputTokens } : {}),
+    ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+    ...(outputTokens !== undefined ? { outputTokens } : {}),
+    ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+    ...(inputTokens !== undefined ? { lastInputTokens: inputTokens } : {}),
+    ...(cachedInputTokens !== undefined ? { lastCachedInputTokens: cachedInputTokens } : {}),
+    ...(outputTokens !== undefined ? { lastOutputTokens: outputTokens } : {}),
+    ...(reasoningOutputTokens !== undefined ? { lastReasoningOutputTokens: reasoningOutputTokens } : {}),
+    lastUsedTokens: usedTokens,
+    compactsAutomatically: true,
+  }
+}
+
 function todoStatus(status: TurnPlanStep["status"]): TodoItem["status"] {
   if (status === "completed") return "completed"
   if (status === "inProgress") return "in_progress"
@@ -1095,6 +1144,9 @@ export class CodexAppServerManager {
     if (!pendingTurn) return
 
     switch (notification.method) {
+      case "thread/tokenUsage/updated":
+        this.handleTokenUsageUpdated(pendingTurn, notification.params)
+        return
       case "turn/plan/updated":
         this.handlePlanUpdated(pendingTurn, notification.params)
         return
@@ -1238,6 +1290,24 @@ export class CodexAppServerManager {
     })
   }
 
+  private handleTokenUsageUpdated(
+    pendingTurn: PendingTurn,
+    notification: ThreadTokenUsageUpdatedNotification,
+  ) {
+    const usage = normalizeCodexTokenUsage(notification)
+    if (!usage) {
+      return
+    }
+
+    pendingTurn.queue.push({
+      type: "transcript",
+      entry: timestamped({
+        kind: "context_window_updated",
+        usage,
+      }),
+    })
+  }
+
   private async handleTurnCompleted(context: SessionContext, notification: TurnCompletedNotification) {
     const pendingTurn = context.pendingTurn
     if (!pendingTurn) return

package/src/server/diff-store.test.ts

@@ -0,0 +1,126 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { DiffStore } from "./diff-store"
+
+async function run(command: string[], cwd: string) {
+  const process = Bun.spawn(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(process.stdout).text(),
+    new Response(process.stderr).text(),
+    process.exited,
+  ])
+
+  if (exitCode !== 0) {
+    throw new Error(stderr || stdout || `Command failed: ${command.join(" ")}`)
+  }
+
+  return stdout
+}
+
+async function createRepo() {
+  const root = await mkdtemp(path.join(tmpdir(), "kanna-diff-store-"))
+  await run(["git", "init"], root)
+  await run(["git", "config", "user.email", "kanna@example.com"], root)
+  await run(["git", "config", "user.name", "Kanna"], root)
+  return root
+}
+
+const tempDirs: string[] = []
+
+describe("DiffStore", () => {
+  afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+  })
+
+  test("returns current worktree diffs for modified files", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await writeFile(path.join(repoRoot, "app.txt"), "base\n", "utf8")
+    await run(["git", "add", "."], repoRoot)
+    await run(["git", "commit", "-m", "init"], repoRoot)
+    await writeFile(path.join(repoRoot, "app.txt"), "changed\n", "utf8")
+
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await store.refreshSnapshot("chat-1", repoRoot)
+
+    const snapshot = store.getSnapshot("chat-1")
+    expect(snapshot.status).toBe("ready")
+    expect(snapshot.files).toHaveLength(1)
+    expect(snapshot.files[0]?.path).toBe("app.txt")
+    expect(snapshot.files[0]?.patch).toContain("-base")
+    expect(snapshot.files[0]?.patch).toContain("+changed")
+  })
+
+  test("returns no_repo outside a git repository", async () => {
+    const root = await mkdtemp(path.join(tmpdir(), "kanna-no-repo-"))
+    tempDirs.push(root)
+
+    const store = new DiffStore(root)
+    await store.initialize()
+    await store.refreshSnapshot("chat-1", root)
+
+    expect(store.getSnapshot("chat-1")).toEqual({
+      status: "no_repo",
+      branchName: undefined,
+      files: [],
+    })
+  })
+
+  test("commits only the selected files and refreshes the snapshot", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await writeFile(path.join(repoRoot, "app.txt"), "base\n", "utf8")
+    await writeFile(path.join(repoRoot, "notes.txt"), "keep\n", "utf8")
+    await run(["git", "add", "."], repoRoot)
+    await run(["git", "commit", "-m", "init"], repoRoot)
+
+    await writeFile(path.join(repoRoot, "app.txt"), "changed\n", "utf8")
+    await writeFile(path.join(repoRoot, "notes.txt"), "changed too\n", "utf8")
+
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await store.refreshSnapshot("chat-1", repoRoot)
+
+    await store.commitFiles({
+      chatId: "chat-1",
+      projectPath: repoRoot,
+      paths: ["app.txt"],
+      summary: "Update app",
+      description: "Only app changes",
+    })
+
+    const snapshot = store.getSnapshot("chat-1")
+    expect(snapshot.status).toBe("ready")
+    expect(snapshot.files).toHaveLength(1)
+    expect(snapshot.files[0]?.path).toBe("notes.txt")
+
+    const lastMessage = (await run(["git", "log", "-1", "--pretty=%B"], repoRoot)).trim()
+    expect(lastMessage).toBe("Update app\n\nOnly app changes")
+  })
+
+  test("detects renamed files", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await writeFile(path.join(repoRoot, "before.txt"), "same\n", "utf8")
+    await run(["git", "add", "."], repoRoot)
+    await run(["git", "commit", "-m", "init"], repoRoot)
+    await run(["git", "mv", "before.txt", "after.txt"], repoRoot)
+
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await store.refreshSnapshot("chat-1", repoRoot)
+
+    const snapshot = store.getSnapshot("chat-1")
+    expect(snapshot.status).toBe("ready")
+    expect(snapshot.files).toHaveLength(1)
+    expect(snapshot.files[0]?.path).toBe("after.txt")
+    expect(snapshot.files[0]?.changeType).toBe("renamed")
+  })
+})