airaknit 1.1.2-rc.9

package/src/server/generate-merge-context.test.ts

@@ -0,0 +1,290 @@
+import { describe, expect, test } from "bun:test"
+import type { TranscriptEntry } from "../shared/types"
+import {
+  allocateSessionBudgets,
+  buildBudgetedTranscriptExcerpt,
+  generateMergePromptForChats,
+  MERGE_FLOOR_PER_SESSION_CHARS,
+  MAX_MERGE_TOTAL_CHARS,
+} from "./generate-merge-context"
+import { MAX_MERGE_SESSIONS } from "../shared/merge-presets"
+import type { QuickResponseAdapter, StructuredQuickResponseArgs } from "./quick-response"
+
+const entryBase = () => ({ _id: crypto.randomUUID(), createdAt: Date.now() })
+
+function userPrompt(content: string): TranscriptEntry {
+  return { ...entryBase(), kind: "user_prompt" as const, content }
+}
+
+function assistantText(text: string): TranscriptEntry {
+  return { ...entryBase(), kind: "assistant_text" as const, text }
+}
+
+function compactSummary(summary: string): TranscriptEntry {
+  return { ...entryBase(), kind: "compact_summary" as const, summary }
+}
+
+function resultEntry(result: string, isError = false): TranscriptEntry {
+  return { ...entryBase(), kind: "result" as const, result, isError, subtype: isError ? "error" : "success", durationMs: 100 }
+}
+
+function contextCleared(): TranscriptEntry {
+  return { ...entryBase(), kind: "context_cleared" as const }
+}
+
+function statusEntry(status: string): TranscriptEntry {
+  return { ...entryBase(), kind: "status" as const, status }
+}
+
+// ── allocateSessionBudgets ──────────────────────────────────────────────
+
+describe("allocateSessionBudgets", () => {
+  test("gives floor + proportional remainder", () => {
+    const sessions = [
+      { entries: [userPrompt("short")] },
+      { entries: [userPrompt("a".repeat(200)), assistantText("b".repeat(300))] },
+    ]
+
+    const budgets = allocateSessionBudgets(sessions)
+
+    expect(budgets).toHaveLength(2)
+    // Both should get at least the floor
+    expect(budgets[0]!).toBeGreaterThanOrEqual(MERGE_FLOOR_PER_SESSION_CHARS)
+    expect(budgets[1]!).toBeGreaterThanOrEqual(MERGE_FLOOR_PER_SESSION_CHARS)
+    // Total should not exceed the max
+    const total = budgets.reduce((sum, b) => sum + b, 0)
+    expect(total).toBeLessThanOrEqual(MAX_MERGE_TOTAL_CHARS)
+    // Session with more content should get a larger budget
+    expect(budgets[1]!).toBeGreaterThan(budgets[0]!)
+  })
+
+  test("skips empty sessions (returns 0 for them)", () => {
+    const sessions = [
+      { entries: [userPrompt("hello")] },
+      { entries: [] },
+      { entries: [userPrompt("world"), assistantText("reply")] },
+    ]
+
+    const budgets = allocateSessionBudgets(sessions)
+
+    expect(budgets).toHaveLength(3)
+    expect(budgets[1]).toBe(0)
+    expect(budgets[0]!).toBeGreaterThan(0)
+    expect(budgets[2]!).toBeGreaterThan(0)
+  })
+
+  test("throws if more than MAX_MERGE_SESSIONS sessions", () => {
+    const sessions = Array.from({ length: MAX_MERGE_SESSIONS + 1 }, () => ({
+      entries: [userPrompt("x")],
+    }))
+
+    expect(() => allocateSessionBudgets(sessions)).toThrow()
+  })
+})
+
+// ── buildBudgetedTranscriptExcerpt ──────────────────────────────────────
+
+describe("buildBudgetedTranscriptExcerpt", () => {
+  test("respects char budget", () => {
+    const entries = [
+      userPrompt("a".repeat(500)),
+      assistantText("b".repeat(500)),
+      userPrompt("c".repeat(500)),
+    ]
+
+    const budget = 800
+    const result = buildBudgetedTranscriptExcerpt(entries, budget)
+
+    expect(result.length).toBeLessThanOrEqual(budget)
+  })
+
+  test("prefers entries after context_cleared", () => {
+    const entries = [
+      userPrompt("old context before clear"),
+      assistantText("old response"),
+      contextCleared(),
+      userPrompt("new context after clear"),
+      assistantText("new response"),
+    ]
+
+    const result = buildBudgetedTranscriptExcerpt(entries, 5000)
+
+    expect(result).toContain("new context after clear")
+    expect(result).toContain("new response")
+    expect(result).not.toContain("old context before clear")
+    expect(result).not.toContain("old response")
+  })
+
+  test("returns fallback message for empty entries", () => {
+    const result = buildBudgetedTranscriptExcerpt([], 5000)
+
+    expect(result).toContain("No prior transcript")
+  })
+
+  test("filters out non-transcript entry kinds", () => {
+    const entries = [
+      statusEntry("thinking"),
+      userPrompt("visible"),
+      statusEntry("more thinking"),
+    ]
+
+    const result = buildBudgetedTranscriptExcerpt(entries, 5000)
+
+    expect(result).toContain("visible")
+    expect(result).not.toContain("thinking")
+  })
+
+  test("includes compact_summary entries", () => {
+    const entries = [compactSummary("This is a compact summary of prior work.")]
+
+    const result = buildBudgetedTranscriptExcerpt(entries, 5000)
+
+    expect(result).toContain("compact summary of prior work")
+  })
+
+  test("includes result entries with error flag", () => {
+    const entries = [resultEntry("something failed", true)]
+
+    const result = buildBudgetedTranscriptExcerpt(entries, 5000)
+
+    expect(result).toContain("something failed")
+    expect(result).toContain("error")
+  })
+})
+
+// ── generateMergePromptForChats ─────────────────────────────────────────
+
+describe("generateMergePromptForChats", () => {
+  function createMockAdapter(
+    respond?: (args: StructuredQuickResponseArgs<unknown>) => unknown | null,
+  ) {
+    const capturedArgs: StructuredQuickResponseArgs<unknown>[] = []
+
+    const adapter = {
+      generateStructured: async <T>(args: StructuredQuickResponseArgs<T>): Promise<T | null> => {
+        capturedArgs.push(args as StructuredQuickResponseArgs<unknown>)
+        const result = respond ? respond(args as StructuredQuickResponseArgs<unknown>) : null
+        if (result === null) return null
+        return args.parse(result) as T | null
+      },
+    } as QuickResponseAdapter
+
+    return { adapter, getCapturedArgs: () => capturedArgs }
+  }
+
+  test("analyzes intent, compacts each source, and labels the final brief by chat id", async () => {
+    const { adapter, getCapturedArgs } = createMockAdapter()
+    const sessions = [
+      { chatId: "abc", entries: [userPrompt("session one context")] },
+      { chatId: "def", entries: [userPrompt("session two context")] },
+    ]
+
+    const result = await generateMergePromptForChats(
+      "Merge these sessions",
+      sessions,
+      "/tmp/test",
+      undefined,
+      adapter,
+    )
+
+    const args = getCapturedArgs()
+    expect(args).toHaveLength(3)
+    expect(args[0]!.task).toContain("analysis")
+    expect(args[1]!.task).toBe("session context compaction")
+    expect(args[2]!.task).toBe("session context compaction")
+    expect(args[1]!.prompt).toContain("session one context")
+    expect(args[2]!.prompt).toContain("session two context")
+    expect(result).toContain("### abc")
+    expect(result).toContain("### def")
+  })
+
+  test("includes preset hint in the analysis call when provided", async () => {
+    const { adapter, getCapturedArgs } = createMockAdapter()
+    const sessions = [
+      { chatId: "a", entries: [userPrompt("one")] },
+      { chatId: "b", entries: [userPrompt("two")] },
+    ]
+
+    await generateMergePromptForChats(
+      "Compare approaches",
+      sessions,
+      "/tmp/test",
+      "compare_decide",
+      adapter,
+    )
+
+    const args = getCapturedArgs()
+    expect(args[0]!.prompt).toContain("Selected preset: Compare & decide.")
+  })
+
+  test("throws for empty sessions", async () => {
+    const { adapter } = createMockAdapter()
+
+    await expect(
+      generateMergePromptForChats("merge", [], "/tmp/test", undefined, adapter),
+    ).rejects.toThrow()
+  })
+
+  test("throws for more than MAX_MERGE_SESSIONS sessions", async () => {
+    const { adapter } = createMockAdapter()
+    const sessions = Array.from({ length: MAX_MERGE_SESSIONS + 1 }, (_, i) => ({
+      chatId: `s${i}`,
+      entries: [userPrompt(`session ${i}`)],
+    }))
+
+    await expect(
+      generateMergePromptForChats("merge", sessions, "/tmp/test", undefined, adapter),
+    ).rejects.toThrow()
+  })
+
+  test("returns a composed fallback brief when adapter calls fail", async () => {
+    const { adapter } = createMockAdapter(() => null)
+    const sessions = [
+      { chatId: "a", entries: [userPrompt("one")] },
+      { chatId: "b", entries: [userPrompt("two")] },
+    ]
+
+    const result = await generateMergePromptForChats(
+      "My merge intent",
+      sessions,
+      "/tmp/test",
+      undefined,
+      adapter,
+    )
+
+    expect(result).toContain("## Objective\nMy merge intent")
+    expect(result).toContain("### a")
+    expect(result).toContain("### b")
+  })
+
+  test("returns a generated brief on success", async () => {
+    const { adapter } = createMockAdapter((args) => {
+      if (args.task.includes("analysis")) {
+        return {
+          compactInstruction: "Keep only the verified findings.",
+          nextInstruction: "Resolve the best combined next step.",
+        }
+      }
+      if (args.prompt.includes("User: one")) {
+        return { summary: "Summary for source one." }
+      }
+      return { summary: "Summary for source two." }
+    })
+    const sessions = [
+      { chatId: "a", entries: [userPrompt("one")] },
+      { chatId: "b", entries: [userPrompt("two")] },
+    ]
+
+    const result = await generateMergePromptForChats(
+      "Merge intent",
+      sessions,
+      "/tmp/test",
+      undefined,
+      adapter,
+    )
+
+    expect(result).toContain("## Objective\nResolve the best combined next step.")
+    expect(result).toContain("### a\nSummary for source one.")
+    expect(result).toContain("### b\nSummary for source two.")
+  })
+})

package/src/server/generate-merge-context.ts

@@ -0,0 +1,141 @@
+import type { TranscriptEntry } from "../shared/types"
+import { getMergePreset, MAX_MERGE_SESSIONS } from "../shared/merge-presets"
+import { QuickResponseAdapter } from "./quick-response"
+import { toTranscriptLine, truncateLine } from "./transcript-utils"
+import { buildSessionSeedPrompt } from "./session-seed"
+
+const LOG_PREFIX = "[generate-merge-context]"
+
+export const MAX_MERGE_TOTAL_CHARS = 14_000
+export const MERGE_FLOOR_PER_SESSION_CHARS = 500
+const MAX_MERGE_LINE_CHARS = 700
+
+/** Slice entries to only those after the last context_cleared boundary, if any. */
+function sliceAfterLastContextCleared(entries: TranscriptEntry[]): TranscriptEntry[] {
+  let lastClearedIndex = -1
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    if (entries[i]!.kind === "context_cleared") {
+      lastClearedIndex = i
+      break
+    }
+  }
+  return lastClearedIndex >= 0 ? entries.slice(lastClearedIndex + 1) : entries
+}
+
+/** Build a bounded transcript excerpt that respects a custom character budget. */
+export function buildBudgetedTranscriptExcerpt(
+  entries: TranscriptEntry[],
+  charBudget: number,
+): string {
+  const sliced = sliceAfterLastContextCleared(entries)
+
+  const lines = sliced
+    .map((e) => toTranscriptLine(e, MAX_MERGE_LINE_CHARS))
+    .filter((line): line is string => Boolean(line))
+
+  if (lines.length === 0) return "No prior transcript context was available."
+
+  const header = "Recent source transcript excerpt:"
+  const headerCost = header.length + 1 // +1 for the newline
+
+  // Take from the end (most recent first) until budget is exhausted
+  const selected: string[] = []
+  let remaining = charBudget - headerCost
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i]!
+    const cost = line.length + 1 // +1 for the newline separator
+    if (remaining - cost < 0) break
+    selected.unshift(line)
+    remaining -= cost
+  }
+
+  if (selected.length === 0) {
+    // Even a single line doesn't fit; truncate the last line to fit
+    const lastLine = lines[lines.length - 1]!
+    const maxLen = Math.max(0, charBudget - headerCost - 1)
+    if (maxLen > 0) {
+      selected.push(truncateLine(lastLine, maxLen))
+    } else {
+      return "No prior transcript context was available."
+    }
+  }
+
+  const omittedCount = lines.length - selected.length
+  const finalHeader = omittedCount > 0
+    ? `Recent source transcript excerpt. Older relevant lines omitted: ${omittedCount}.`
+    : header
+
+  return [finalHeader, ...selected].join("\n")
+}
+
+/** Compute how many usable transcript characters each session contributes. */
+function computeUsableLength(entries: TranscriptEntry[]): number {
+  const sliced = sliceAfterLastContextCleared(entries)
+  return sliced
+    .map((e) => toTranscriptLine(e, MAX_MERGE_LINE_CHARS))
+    .filter((line): line is string => Boolean(line))
+    .reduce((sum, line) => sum + line.length, 0)
+}
+
+/** Allocate character budgets across sessions proportionally to their content size.
+ * Empty sessions get 0. Every non-empty session gets at least MERGE_FLOOR_PER_SESSION_CHARS. */
+export function allocateSessionBudgets(
+  sessions: { entries: TranscriptEntry[] }[],
+): number[] {
+  if (sessions.length > MAX_MERGE_SESSIONS) {
+    throw new Error(
+      `${LOG_PREFIX} Cannot merge more than ${MAX_MERGE_SESSIONS} sessions (got ${sessions.length})`,
+    )
+  }
+
+  const usableLengths = sessions.map((s) => computeUsableLength(s.entries))
+  const nonEmptyCount = usableLengths.filter((len) => len > 0).length
+
+  if (nonEmptyCount === 0) {
+    return usableLengths.map(() => 0)
+  }
+
+  const totalFloor = nonEmptyCount * MERGE_FLOOR_PER_SESSION_CHARS
+  const remainder = Math.max(0, MAX_MERGE_TOTAL_CHARS - totalFloor)
+  const totalUsable = usableLengths.reduce((sum, len) => sum + len, 0)
+
+  return usableLengths.map((len) => {
+    if (len === 0) return 0
+    const proportional = totalUsable > 0
+      ? Math.floor(remainder * (len / totalUsable))
+      : Math.floor(remainder / nonEmptyCount)
+    return MERGE_FLOOR_PER_SESSION_CHARS + proportional
+  })
+}
+
+/** Generate a merge prompt that synthesizes context from multiple sessions.
+ * Requires 2–MAX_MERGE_SESSIONS sessions. Returns the generated prompt or the
+ * normalized intent as a fallback if the adapter fails. */
+export async function generateMergePromptForChats(
+  mergeIntent: string,
+  sessions: { chatId: string; entries: TranscriptEntry[] }[],
+  cwd: string,
+  presetId?: string,
+  adapter: QuickResponseAdapter = new QuickResponseAdapter(),
+): Promise<string> {
+  if (sessions.length < 1) {
+    throw new Error(
+      `${LOG_PREFIX} Merge requires at least 1 session (got ${sessions.length})`,
+    )
+  }
+  if (sessions.length > MAX_MERGE_SESSIONS) {
+    throw new Error(
+      `${LOG_PREFIX} Cannot merge more than ${MAX_MERGE_SESSIONS} sessions (got ${sessions.length})`,
+    )
+  }
+
+  const preset = getMergePreset(presetId)
+  return buildSessionSeedPrompt({
+    mode: "merge",
+    intent: mergeIntent,
+    preset,
+    sources: sessions,
+    cwd,
+    adapter,
+  })
+}

package/src/server/generate-title.ts

@@ -0,0 +1,36 @@
+import { QuickResponseAdapter } from "./quick-response"
+
+const TITLE_SCHEMA = {
+  type: "object",
+  properties: {
+    title: { type: "string" },
+  },
+  required: ["title"],
+  additionalProperties: false,
+} as const
+
+function normalizeGeneratedTitle(value: unknown): string | null {
+  if (typeof value !== "string") return null
+  const normalized = value.replace(/\s+/g, " ").trim().slice(0, 80)
+  if (!normalized || normalized === "New Chat") return null
+  return normalized
+}
+
+export async function generateTitleForChat(
+  messageContent: string,
+  cwd: string,
+  adapter = new QuickResponseAdapter()
+): Promise<string | null> {
+  const result = await adapter.generateStructured<string>({
+    cwd,
+    task: "conversation title generation",
+    prompt: `Generate a short, descriptive title (under 30 chars) for a conversation that starts with this message.\n\n${messageContent}`,
+    schema: TITLE_SCHEMA,
+    parse: (value) => {
+      const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+      return normalizeGeneratedTitle(output.title)
+    },
+  })
+
+  return result
+}

package/src/server/git-clone-policy.test.ts

@@ -0,0 +1,138 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { $ } from "bun"
+import { EventStore } from "./event-store"
+import { RepoManager } from "./repo-manager"
+import { GitClonePolicy } from "./git-clone-policy"
+
+describe("GitClonePolicy", () => {
+  const tempDirs: string[] = []
+
+  async function makeTempDir(): Promise<string> {
+    const dir = await mkdtemp(path.join(tmpdir(), "git-clone-policy-"))
+    tempDirs.push(dir)
+    return dir
+  }
+
+  afterEach(async () => {
+    for (const dir of tempDirs) {
+      await rm(dir, { recursive: true, force: true }).catch(() => {})
+    }
+    tempDirs.length = 0
+  })
+
+  test("successful clone sets status to cloned with correct path and branch", async () => {
+    const dataDir = await makeTempDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const repoManager = new RepoManager()
+
+    let stateChanged = false
+    const policy = new GitClonePolicy(store, repoManager, () => {
+      stateChanged = true
+    })
+
+    // Create a bare repo to clone from
+    const bareDir = await makeTempDir()
+    await $`git init --bare ${bareDir}`.quiet()
+
+    // Need at least one commit so branch exists
+    const seedDir = await makeTempDir()
+    await $`git clone ${bareDir} ${seedDir}`.quiet()
+    await $`git -C ${seedDir} -c user.email=ci@example.com -c user.name=CI commit --allow-empty -m "init"`.quiet()
+    await $`git -C ${seedDir} push origin main`.quiet().nothrow()
+    // Push whatever default branch was created
+    await $`git -C ${seedDir} push`.quiet()
+
+    const repoId = "repo-1"
+    const workspaceId = "ws-1"
+    const targetPath = path.join(await makeTempDir(), "cloned-repo")
+
+    await store.startRepoClone(repoId, workspaceId, bareDir, targetPath, "test-repo")
+    expect(store.state.reposById.get(repoId)?.status).toBe("pending")
+
+    await policy.onRepoCloneStarted(repoId, bareDir, targetPath)
+
+    const repo = store.state.reposById.get(repoId)
+    expect(repo).toBeDefined()
+    expect(repo!.status).toBe("cloned")
+    expect(repo!.localPath).toBe(targetPath)
+    expect(repo!.branch).toBeTruthy()
+    expect(store.state.reposByPath.has(targetPath)).toBe(true)
+    expect(stateChanged).toBe(true)
+  })
+
+  test("onStateChange throwing does not prevent clone from completing", async () => {
+    const dataDir = await makeTempDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const repoManager = new RepoManager()
+
+    const policy = new GitClonePolicy(store, repoManager, () => {
+      throw new Error("broadcast exploded")
+    })
+
+    const bareDir = await makeTempDir()
+    await $`git init --bare ${bareDir}`.quiet()
+    const seedDir = await makeTempDir()
+    await $`git clone ${bareDir} ${seedDir}`.quiet()
+    await $`git -C ${seedDir} -c user.email=ci@example.com -c user.name=CI commit --allow-empty -m "init"`.quiet()
+    await $`git -C ${seedDir} push`.quiet()
+
+    const repoId = "repo-safe"
+    const targetPath = path.join(await makeTempDir(), "safe-clone")
+    await store.startRepoClone(repoId, "ws-safe", bareDir, targetPath, null)
+
+    await policy.onRepoCloneStarted(repoId, bareDir, targetPath)
+
+    expect(store.state.reposById.get(repoId)!.status).toBe("cloned")
+  })
+
+  test("onStateChange throwing does not prevent error status on failed clone", async () => {
+    const dataDir = await makeTempDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const repoManager = new RepoManager()
+
+    const policy = new GitClonePolicy(store, repoManager, () => {
+      throw new Error("broadcast exploded")
+    })
+
+    const repoId = "repo-safe-fail"
+    const targetPath = path.join(await makeTempDir(), "should-fail")
+    await store.startRepoClone(repoId, "ws-safe", "/nonexistent/path", targetPath, null)
+
+    await policy.onRepoCloneStarted(repoId, "/nonexistent/path", targetPath)
+
+    expect(store.state.reposById.get(repoId)!.status).toBe("error")
+  })
+
+  test("failed clone sets status to error", async () => {
+    const dataDir = await makeTempDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const repoManager = new RepoManager()
+
+    let stateChanged = false
+    const policy = new GitClonePolicy(store, repoManager, () => {
+      stateChanged = true
+    })
+
+    const repoId = "repo-2"
+    const workspaceId = "ws-2"
+    const badOrigin = "/nonexistent/repo/path"
+    const targetPath = path.join(await makeTempDir(), "should-fail")
+
+    await store.startRepoClone(repoId, workspaceId, badOrigin, targetPath, null)
+    expect(store.state.reposById.get(repoId)?.status).toBe("pending")
+
+    await policy.onRepoCloneStarted(repoId, badOrigin, targetPath)
+
+    const repo = store.state.reposById.get(repoId)
+    expect(repo).toBeDefined()
+    expect(repo!.status).toBe("error")
+    expect(stateChanged).toBe(true)
+  })
+})

package/src/server/git-clone-policy.ts

@@ -0,0 +1,27 @@
+import type { EventStore } from "./event-store"
+import type { RepoManager } from "./repo-manager"
+
+const LOG_PREFIX = "[GitClonePolicy]"
+
+export class GitClonePolicy {
+  constructor(
+    private store: EventStore,
+    private repoManager: RepoManager,
+    private onStateChange?: () => void,
+  ) {}
+
+  /** Fire-and-forget: clones repo, then emits repo_cloned or repo_clone_failed */
+  async onRepoCloneStarted(repoId: string, origin: string, targetPath: string): Promise<void> {
+    try {
+      await this.repoManager.clone(origin, targetPath)
+      const info = await this.repoManager.addLocal(targetPath)
+      await this.store.markRepoCloned(repoId, targetPath, info.branch)
+      try { this.onStateChange?.() } catch { /* broadcast failure is non-fatal */ }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      console.warn(`${LOG_PREFIX} Clone failed for ${origin}:`, message)
+      await this.store.markRepoCloneFailed(repoId, message)
+      try { this.onStateChange?.() } catch { /* broadcast failure is non-fatal */ }
+    }
+  }
+}

package/src/server/harness-types.ts

@@ -0,0 +1 @@
+export type { HarnessEvent, HarnessToolRequest, HarnessTurn } from "../shared/harness-types"