airaknit 1.1.2-rc.9

package/src/server/transcript-consumer.ts

@@ -0,0 +1,162 @@
+import { jetstream, DeliverPolicy } from "@nats-io/jetstream"
+import type { ConsumerMessages } from "@nats-io/jetstream"
+import type { NatsConnection } from "@nats-io/transport-node"
+import { Kvm } from "@nats-io/kv"
+import { RUNNER_EVENTS_STREAM, type RunnerTurnEvent } from "../shared/runner-protocol"
+import type { SessionStatus, TranscriptEntry, AgentProvider } from "../shared/types"
+import { LOG_PREFIX } from "../shared/branding"
+
+const decoder = new TextDecoder()
+const encoder = new TextEncoder()
+
+// ── Store interface (subset of EventStore) ──────────────────────────
+
+export interface TranscriptConsumerStore {
+  appendMessage(chatId: string, entry: TranscriptEntry): void
+  recordTurnFinished(chatId: string): Promise<void>
+  recordTurnFailed(chatId: string, error: string): Promise<void>
+  recordTurnCancelled(chatId: string): Promise<void>
+  setSessionToken(chatId: string, token: string | null): Promise<void>
+  renameChat(chatId: string, title: string): Promise<void>
+  setChatProvider(chatId: string, provider: AgentProvider): Promise<void>
+  setPlanMode(chatId: string, planMode: boolean): Promise<void>
+}
+
+// ── Options ─────────────────────────────────────────────────────────
+
+export interface TranscriptConsumerOptions {
+  nc: NatsConnection
+  store: TranscriptConsumerStore
+  onStateChange: () => void
+  onMessageAppended?: (chatId: string, entry: TranscriptEntry) => void
+}
+
+// ── TranscriptConsumer ──────────────────────────────────────────────
+
+export class TranscriptConsumer {
+  private readonly nc: NatsConnection
+  private readonly store: TranscriptConsumerStore
+  private readonly onStateChange: () => void
+  private readonly onMessageAppended: ((chatId: string, entry: TranscriptEntry) => void) | undefined
+  private readonly activeStatuses = new Map<string, SessionStatus>()
+  private messages: ConsumerMessages | null = null
+  private running = false
+
+  constructor(options: TranscriptConsumerOptions) {
+    this.nc = options.nc
+    this.store = options.store
+    this.onStateChange = options.onStateChange
+    this.onMessageAppended = options.onMessageAppended
+  }
+
+  getActiveStatuses(): Map<string, SessionStatus> {
+    return new Map(this.activeStatuses)
+  }
+
+  hasActiveChat(chatId: string): boolean {
+    return this.activeStatuses.has(chatId)
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return
+    this.running = true
+
+    const js = jetstream(this.nc)
+
+    // Read last-processed sequence from KV for resume
+    const kvm = new Kvm(this.nc)
+    const stateBucket = await kvm.create("kanna_consumer_state")
+    const entry = await stateBucket.get("transcript_last_seq")
+    const lastSeq = entry ? Number(decoder.decode(entry.value)) : 0
+
+    const consumerOpts = lastSeq > 0
+      ? { deliver_policy: DeliverPolicy.StartSequence, opt_start_seq: lastSeq + 1 }
+      : { deliver_policy: DeliverPolicy.New }
+
+    const consumer = await js.consumers.get(RUNNER_EVENTS_STREAM, consumerOpts)
+    const messages = await consumer.consume()
+    this.messages = messages
+
+    // Process messages in the background — don't block start()
+    ;(async () => {
+      for await (const msg of messages) {
+        if (!this.running) break
+        try {
+          const event = JSON.parse(decoder.decode(msg.data)) as RunnerTurnEvent
+          await this.handleEvent(event)
+          msg.ack()
+          await stateBucket.put("transcript_last_seq", encoder.encode(String(msg.seq)))
+        } catch (err) {
+          console.warn(
+            LOG_PREFIX,
+            "TranscriptConsumer: failed to process event:",
+            err instanceof Error ? err.message : String(err),
+          )
+        }
+      }
+    })()
+  }
+
+  stop(): void {
+    this.running = false
+    if (this.messages) {
+      this.messages.close().catch(() => {})
+      this.messages = null
+    }
+  }
+
+  private async handleEvent(event: RunnerTurnEvent): Promise<void> {
+    let stateChanged = true
+
+    switch (event.type) {
+      case "transcript":
+        this.store.appendMessage(event.chatId, event.entry)
+        this.onMessageAppended?.(event.chatId, event.entry)
+        break
+      case "turn_finished":
+        await this.store.recordTurnFinished(event.chatId)
+        this.activeStatuses.delete(event.chatId)
+        break
+      case "turn_failed":
+        await this.store.recordTurnFailed(event.chatId, event.error)
+        this.activeStatuses.delete(event.chatId)
+        break
+      case "turn_cancelled":
+        await this.store.recordTurnCancelled(event.chatId)
+        this.activeStatuses.delete(event.chatId)
+        break
+      case "session_token":
+        await this.store.setSessionToken(event.chatId, event.sessionToken)
+        break
+      case "title_generated":
+        await this.store.renameChat(event.chatId, event.title)
+        break
+      case "status_change": {
+        const prev = this.activeStatuses.get(event.chatId)
+        if (prev === event.status) {
+          stateChanged = false
+        } else {
+          this.activeStatuses.set(event.chatId, event.status)
+        }
+        break
+      }
+      case "pending_tool":
+        // Trigger state change — UI needs to show pending tool
+        break
+      case "provider_set":
+        await this.store.setChatProvider(event.chatId, event.provider)
+        break
+      case "plan_mode_set":
+        await this.store.setPlanMode(event.chatId, event.planMode)
+        break
+      case "context_cleared":
+        // Already handled by session_token event — no store write needed
+        stateChanged = false
+        break
+    }
+
+    if (stateChanged) {
+      this.onStateChange()
+    }
+  }
+}

package/src/server/transcript-search.test.ts

@@ -0,0 +1,193 @@
+// src/server/transcript-search.test.ts
+import { describe, expect, test } from "bun:test"
+import { TranscriptSearchIndex } from "./transcript-search"
+import type { TranscriptEntry } from "../shared/types"
+
+function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
+  entry: T,
+): TranscriptEntry {
+  return { _id: crypto.randomUUID(), createdAt: Date.now(), ...entry } as TranscriptEntry
+}
+
+describe("TranscriptSearchIndex", () => {
+  test("indexes user_prompt entries and searches", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({ kind: "user_prompt", content: "implement auth middleware with JWT tokens" }))
+    index.addEntry("chat-2", timestamped({ kind: "user_prompt", content: "fix CSS styling on sidebar" }))
+
+    const results = index.search("auth middleware")
+    expect(results.length).toBeGreaterThanOrEqual(1)
+    expect(results[0].chatId).toBe("chat-1")
+    expect(results[0].kind).toBe("user_prompt")
+  })
+
+  test("indexes assistant_text entries", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({ kind: "assistant_text", text: "I created the users table with email and password_hash columns" }))
+
+    const results = index.search("users table")
+    expect(results.length).toBe(1)
+    expect(results[0].chatId).toBe("chat-1")
+  })
+
+  test("indexes tool_call entries with file paths", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({
+      kind: "tool_call",
+      tool: {
+        kind: "tool",
+        toolKind: "edit_file",
+        toolName: "Edit",
+        toolId: "tool-1",
+        input: { filePath: "/src/server/auth.ts", oldString: "a", newString: "b" },
+      },
+    } as Omit<TranscriptEntry, "_id" | "createdAt">))
+
+    const results = index.search("auth.ts")
+    expect(results.length).toBe(1)
+  })
+
+  test("indexes tool_call entries with bash commands", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({
+      kind: "tool_call",
+      tool: {
+        kind: "tool",
+        toolKind: "bash",
+        toolName: "Bash",
+        toolId: "tool-2",
+        input: { command: "bun test src/server/auth.test.ts" },
+      },
+    } as Omit<TranscriptEntry, "_id" | "createdAt">))
+
+    const results = index.search("bun test auth")
+    expect(results.length).toBe(1)
+  })
+
+  test("indexes tool_call entries with grep patterns", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({
+      kind: "tool_call",
+      tool: {
+        kind: "tool",
+        toolKind: "grep",
+        toolName: "Grep",
+        toolId: "tool-3",
+        input: { pattern: "handleAuth", outputMode: "content" },
+      },
+    } as Omit<TranscriptEntry, "_id" | "createdAt">))
+
+    const results = index.search("handleAuth")
+    expect(results.length).toBe(1)
+  })
+
+  test("indexes tool_result entries", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({
+      kind: "tool_result",
+      toolId: "tool-1",
+      content: "File written successfully to /src/server/auth.ts",
+    }))
+
+    const results = index.search("auth.ts written")
+    expect(results.length).toBe(1)
+  })
+
+  test("indexes tool_result with non-string content via JSON", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({
+      kind: "tool_result",
+      toolId: "tool-1",
+      content: { files: ["auth.ts", "middleware.ts"], count: 2 },
+    }))
+
+    const results = index.search("auth.ts middleware")
+    expect(results.length).toBe(1)
+  })
+
+  test("returns results with score and fragment", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({ kind: "user_prompt", content: "implement error handling for database connections" }))
+
+    const results = index.search("error handling")
+    expect(results[0].score).toBeGreaterThan(0)
+    expect(results[0].fragment.length).toBeGreaterThan(0)
+  })
+
+  test("returns empty for no matches", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({ kind: "user_prompt", content: "hello world" }))
+
+    const results = index.search("nonexistent term here")
+    expect(results).toEqual([])
+  })
+
+  test("respects limit", () => {
+    const index = new TranscriptSearchIndex()
+    for (let i = 0; i < 20; i++) {
+      index.addEntry(`chat-${i}`, timestamped({ kind: "user_prompt", content: `testing search feature ${i}` }))
+    }
+
+    const results = index.search("testing search", 5)
+    expect(results.length).toBe(5)
+  })
+
+  test("skips non-indexable entry kinds", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({ kind: "status", status: "running" }))
+    index.addEntry("chat-1", timestamped({ kind: "context_cleared" }))
+    index.addEntry("chat-1", timestamped({ kind: "interrupted" }))
+    index.addEntry("chat-1", timestamped({ kind: "compact_boundary" }))
+
+    expect(index.size).toBe(0)
+  })
+
+  test("fragment is truncated to 300 chars", () => {
+    const index = new TranscriptSearchIndex()
+    const longContent = "database ".repeat(100) // 900 chars
+    index.addEntry("chat-1", timestamped({ kind: "user_prompt", content: longContent }))
+
+    const results = index.search("database")
+    expect(results[0].fragment.length).toBeLessThanOrEqual(300)
+  })
+
+  test("tool_result content is truncated to 500 chars before indexing", () => {
+    const index = new TranscriptSearchIndex()
+    // "filler " is 7 chars; 72 repeats = 504 chars, pushing ZZZMARKER past the 500 boundary
+    const padding = "filler ".repeat(72)
+    const content = padding + "ZZZMARKER"
+    expect(content.indexOf("ZZZMARKER")).toBeGreaterThan(500)
+
+    index.addEntry("chat-1", timestamped({
+      kind: "tool_result",
+      toolId: "tool-1",
+      content,
+    }))
+
+    // ZZZMARKER sits beyond 500 chars and must not be indexed
+    const results = index.search("ZZZMARKER")
+    expect(results).toEqual([])
+  })
+
+  test("tool_result content within 500 chars is still searchable", () => {
+    const index = new TranscriptSearchIndex()
+    index.addEntry("chat-1", timestamped({
+      kind: "tool_result",
+      toolId: "tool-1",
+      content: "File written successfully to /src/server/auth.ts",
+    }))
+
+    const results = index.search("auth.ts written")
+    expect(results.length).toBe(1)
+  })
+
+  test("timestamp is ISO string derived from createdAt", () => {
+    const index = new TranscriptSearchIndex()
+    const now = Date.now()
+    const entry = { _id: "fixed-id", createdAt: now, kind: "user_prompt" as const, content: "test timestamp" } as TranscriptEntry
+    index.addEntry("chat-1", entry)
+
+    const results = index.search("timestamp")
+    expect(results[0].timestamp).toBe(new Date(now).toISOString())
+  })
+})

package/src/server/transcript-search.ts

@@ -0,0 +1,83 @@
+// src/server/transcript-search.ts
+import type { TranscriptEntry, NormalizedToolCall } from "../shared/types"
+import type { SearchResult, SearchDocumentKind } from "../shared/workspace-types"
+import { BM25Index } from "./bm25"
+
+const TOOL_RESULT_MAX_CHARS = 500
+const SEARCH_FRAGMENT_MAX_CHARS = 300
+
+interface IndexedEntry {
+  chatId: string
+  timestamp: string
+  kind: SearchDocumentKind
+  text: string
+}
+
+function extractTextFromEntry(entry: TranscriptEntry): { text: string; kind: SearchDocumentKind } | null {
+  switch (entry.kind) {
+    case "user_prompt":
+      return { text: entry.content, kind: "user_prompt" }
+    case "assistant_text":
+      return { text: entry.text, kind: "assistant_text" }
+    case "tool_call":
+      return { text: toolCallToText(entry.tool), kind: "tool_call" }
+    case "tool_result": {
+      const raw = typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
+      return { text: raw.slice(0, TOOL_RESULT_MAX_CHARS), kind: "tool_result" }
+    }
+    default:
+      return null
+  }
+}
+
+function toolCallToText(tool: NormalizedToolCall): string {
+  const parts: string[] = [tool.toolKind]
+  const input = tool.input as Record<string, unknown>
+  if (typeof input.filePath === "string") parts.push(input.filePath)
+  if (typeof input.path === "string") parts.push(input.path)
+  if (typeof input.command === "string") parts.push(input.command)
+  if (typeof input.pattern === "string") parts.push(input.pattern)
+  if (typeof input.query === "string") parts.push(input.query)
+  return parts.join(" ")
+}
+
+export class TranscriptSearchIndex {
+  private readonly bm25 = new BM25Index<string>()
+  private readonly entries = new Map<string, IndexedEntry>()
+
+  get size(): number {
+    return this.entries.size
+  }
+
+  addEntry(chatId: string, entry: TranscriptEntry): void {
+    const extracted = extractTextFromEntry(entry)
+    if (!extracted) return
+
+    const docId = entry._id
+    const indexed: IndexedEntry = {
+      chatId,
+      timestamp: new Date(entry.createdAt).toISOString(),
+      kind: extracted.kind,
+      text: extracted.text,
+    }
+    this.entries.set(docId, indexed)
+    this.bm25.add(docId, extracted.text)
+  }
+
+  search(query: string, limit = 10): SearchResult[] {
+    const bm25Results = this.bm25.search(query, limit)
+    return bm25Results
+      .map((r) => {
+        const entry = this.entries.get(r.id)
+        if (!entry) return null
+        return {
+          chatId: entry.chatId,
+          timestamp: entry.timestamp,
+          kind: entry.kind,
+          fragment: entry.text.slice(0, SEARCH_FRAGMENT_MAX_CHARS),
+          score: r.score,
+        }
+      })
+      .filter((r): r is SearchResult => r !== null)
+  }
+}

package/src/server/transcript-utils.ts

@@ -0,0 +1,52 @@
+import type { TranscriptEntry } from "../shared/types"
+
+/** Collapse whitespace and truncate a single line to `limit` characters. */
+export function truncateLine(text: string, limit: number): string {
+  const normalized = text.replace(/\s+/g, " ").trim()
+  if (normalized.length <= limit) return normalized
+  return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}…`
+}
+
+/** Convert a transcript entry into a labeled single line, or null for non-displayable kinds. */
+export function toTranscriptLine(entry: TranscriptEntry, lineCharLimit: number): string | null {
+  switch (entry.kind) {
+    case "user_prompt":
+      return `User: ${truncateLine(entry.content, lineCharLimit)}`
+    case "assistant_text":
+      return `Assistant: ${truncateLine(entry.text, lineCharLimit)}`
+    case "compact_summary":
+      return `Summary: ${truncateLine(entry.summary, lineCharLimit)}`
+    case "result":
+      return `${entry.isError ? "Result error" : "Result"}: ${truncateLine(entry.result, lineCharLimit)}`
+    default:
+      return null
+  }
+}
+
+const PROMPT_SCHEMA = {
+  type: "object",
+  properties: {
+    prompt: { type: "string" },
+  },
+  required: ["prompt"],
+  additionalProperties: false,
+} as const
+
+export { PROMPT_SCHEMA }
+
+/** Collapse whitespace and clamp intent text to 1000 characters. */
+export function normalizeIntent(intent: string): string {
+  return intent.replace(/\s+/g, " ").trim().slice(0, 1_000)
+}
+
+/** Normalize LLM-generated prompt output, clamping to maxChars. Returns null for empty/invalid. */
+export function normalizeGeneratedPrompt(value: unknown, maxChars: number): string | null {
+  if (typeof value !== "string") return null
+  const normalized = value
+    .replace(/\r\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim()
+    .slice(0, maxChars)
+    .trim()
+  return normalized || null
+}

package/src/server/update-manager.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test"
+import { UpdateManager } from "./update-manager"
+
+describe("UpdateManager", () => {
+  test("detects available updates", async () => {
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => "0.13.0",
+      installVersion: () => ({
+        ok: true,
+        errorCode: null,
+        userTitle: null,
+        userMessage: null,
+      }),
+    })
+
+    const snapshot = await manager.checkForUpdates({ force: true })
+
+    expect(snapshot.status).toBe("available")
+    expect(snapshot.updateAvailable).toBe(true)
+    expect(snapshot.latestVersion).toBe("0.13.0")
+    expect(snapshot.installAction).toBe("restart")
+  })
+
+  test("bypasses cache when force is true", async () => {
+    let calls = 0
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => {
+        calls += 1
+        return calls === 1 ? "0.12.1" : "0.13.0"
+      },
+      installVersion: () => ({
+        ok: true,
+        errorCode: null,
+        userTitle: null,
+        userMessage: null,
+      }),
+    })
+
+    await manager.checkForUpdates()
+    await manager.checkForUpdates({ force: true })
+
+    expect(calls).toBe(2)
+    expect(manager.getSnapshot().latestVersion).toBe("0.13.0")
+  })
+
+  test("surfaces install failures without clearing the running version", async () => {
+    let installedVersion: string | null = null
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => "0.13.0",
+      installVersion: (_packageName, version) => {
+        installedVersion = version
+        return {
+          ok: false,
+          errorCode: "version_not_live_yet",
+          userTitle: "Update not live yet",
+          userMessage: "This update is still propagating. Try again in a few minutes.",
+        }
+      },
+    })
+
+    const result = await manager.installUpdate()
+
+    expect(result).toEqual({
+      ok: false,
+      action: "restart",
+      errorCode: "version_not_live_yet",
+      userTitle: "Update not live yet",
+      userMessage: "This update is still propagating. Try again in a few minutes.",
+    })
+    expect(installedVersion === "0.13.0").toBe(true)
+    expect(manager.getSnapshot().status).toBe("error")
+    expect(manager.getSnapshot().currentVersion).toBe("0.12.0")
+  })
+
+  test("always exposes an available reload action in dev mode", async () => {
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => "9.9.9",
+      installVersion: () => ({
+        ok: true,
+        errorCode: null,
+        userTitle: null,
+        userMessage: null,
+      }),
+      devMode: true,
+    })
+
+    expect(manager.getSnapshot()).toMatchObject({
+      status: "available",
+      updateAvailable: true,
+      installAction: "restart",
+    })
+
+    const result = await manager.installUpdate()
+    expect(result).toEqual({
+      ok: true,
+      action: "restart",
+      errorCode: null,
+      userTitle: null,
+      userMessage: null,
+    })
+    expect(manager.getSnapshot().status).toBe("restart_pending")
+  })
+})