kanna-code 0.41.7 → 0.42.0

package/src/server/provider-catalog.test.ts

@@ -3,8 +3,10 @@ import {
   SERVER_PROVIDERS,
   applyClaudeSdkModels,
   codexServiceTierFromModelOptions,
+  cursorModelIdForOptions,
   normalizeClaudeModelOptions,
   normalizeCodexModelOptions,
+  normalizeCursorModelOptions,
   normalizeServerModel,
   resetServerProvidersForTests,
 } from "./provider-catalog"
@@ -44,12 +46,12 @@ describe("provider catalog normalization", () => {
   })
 
   test("normalizes Codex model options and fast mode defaults", () => {
-    expect(normalizeCodexModelOptions(undefined)).toEqual({
-      reasoningEffort: "high",
+    expect(normalizeCodexModelOptions("gpt-5.6-sol", undefined)).toEqual({
+      reasoningEffort: "medium",
       fastMode: false,
     })
 
-    const normalized = normalizeCodexModelOptions({
+    const normalized = normalizeCodexModelOptions("gpt-5.6-terra", {
       codex: {
         reasoningEffort: "xhigh",
         fastMode: true,
@@ -61,13 +63,38 @@ describe("provider catalog normalization", () => {
       fastMode: true,
     })
     expect(codexServiceTierFromModelOptions(normalized)).toBe("fast")
+
+    expect(normalizeCodexModelOptions("gpt-5.6-sol", {
+      codex: { reasoningEffort: "ultra" },
+    }).reasoningEffort).toBe("ultra")
+    expect(normalizeCodexModelOptions("gpt-5.6-luna", {
+      codex: { reasoningEffort: "ultra" },
+    }).reasoningEffort).toBe("max")
+    expect(normalizeCodexModelOptions("gpt-5.6-luna", undefined, "minimal").reasoningEffort).toBe("low")
+  })
+
+  test("normalizes Cursor model options and applies the fast model suffix", () => {
+    expect(normalizeCursorModelOptions(undefined)).toEqual({ fastMode: false })
+    expect(normalizeCursorModelOptions({ cursor: { fastMode: true } })).toEqual({ fastMode: true })
+
+    expect(cursorModelIdForOptions("composer-2.5", { fastMode: false })).toBe("composer-2.5")
+    expect(cursorModelIdForOptions("composer-2.5", { fastMode: true })).toBe("composer-2.5-fast")
+    // Idempotent if the base id already carries the suffix.
+    expect(cursorModelIdForOptions("composer-2.5-fast", { fastMode: true })).toBe("composer-2.5-fast")
+  })
+
+  test("resolves the Cursor default model through the server catalog", () => {
+    // Exercises the catalog lookup + default fallback (throws if "cursor" is unregistered).
+    expect(normalizeServerModel("cursor")).toBe("composer-2.5")
+    expect(normalizeServerModel("cursor", "composer-2.5-fast")).toBe("composer-2.5")
   })
 
   test("normalizes server model ids through the shared alias catalog", () => {
-    expect(normalizeServerModel("codex")).toBe("gpt-5.5")
+    expect(normalizeServerModel("codex")).toBe("gpt-5.6-sol")
     expect(normalizeServerModel("claude", "fable")).toBe("fable")
     expect(normalizeServerModel("claude", "opus")).toBe("claude-opus-4-8")
     expect(normalizeServerModel("codex", "gpt-5-codex")).toBe("gpt-5.3-codex")
+    expect(normalizeServerModel("codex", "gpt-5.6")).toBe("gpt-5.6-sol")
   })
 
   test("resolves Claude API model ids for 1m context window", () => {

package/src/server/provider-catalog.ts

@@ -2,6 +2,7 @@ import type {
   AgentProvider,
   ClaudeModelOptions,
   CodexModelOptions,
+  CursorModelOptions,
   ClaudeContextWindow,
   ModelOptions,
   ProviderCatalogEntry,
@@ -11,20 +12,15 @@ import type {
 import {
   DEFAULT_CLAUDE_MODEL_OPTIONS,
   DEFAULT_CODEX_MODEL_OPTIONS,
+  DEFAULT_CURSOR_MODEL_OPTIONS,
   PROVIDERS,
   normalizeClaudeContextWindow,
+  normalizeCodexReasoningEffort,
   normalizeProviderModelId,
   isClaudeReasoningEffort,
   isCodexReasoningEffort,
 } from "../shared/types"
 
-const HARD_CODED_CODEX_MODELS: ProviderModelOption[] = [
-  { id: "gpt-5.5", label: "GPT-5.5", supportsEffort: false },
-  { id: "gpt-5.4", label: "GPT-5.4", supportsEffort: false },
-  { id: "gpt-5.3-codex", label: "GPT-5.3 Codex", supportsEffort: false },
-  { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark", supportsEffort: false },
-]
-
 export interface ClaudeSdkModelInfo {
   value: string
   displayName?: string
@@ -35,15 +31,7 @@ export interface ClaudeSdkModelInfo {
 }
 
 function createServerProviders(): ProviderCatalogEntry[] {
-  return PROVIDERS.map((provider) =>
-    provider.id === "codex"
-      ? {
-          ...provider,
-          defaultModel: "gpt-5.5",
-          models: HARD_CODED_CODEX_MODELS,
-        }
-      : provider
-  )
+  return structuredClone(PROVIDERS)
 }
 
 export const SERVER_PROVIDERS: ProviderCatalogEntry[] = createServerProviders()
@@ -137,14 +125,17 @@ export function normalizeClaudeModelOptions(
   }
 }
 
-export function normalizeCodexModelOptions(modelOptions?: ModelOptions, legacyEffort?: string): CodexModelOptions {
+export function normalizeCodexModelOptions(
+  model: string,
+  modelOptions?: ModelOptions,
+  legacyEffort?: string,
+): CodexModelOptions {
   const reasoningEffort = modelOptions?.codex?.reasoningEffort
   return {
-    reasoningEffort: isCodexReasoningEffort(reasoningEffort)
-      ? reasoningEffort
-      : isCodexReasoningEffort(legacyEffort)
-        ? legacyEffort
-        : DEFAULT_CODEX_MODEL_OPTIONS.reasoningEffort,
+    reasoningEffort: normalizeCodexReasoningEffort(
+      model,
+      isCodexReasoningEffort(reasoningEffort) ? reasoningEffort : legacyEffort,
+    ),
     fastMode: typeof modelOptions?.codex?.fastMode === "boolean"
       ? modelOptions.codex.fastMode
       : DEFAULT_CODEX_MODEL_OPTIONS.fastMode,
@@ -154,3 +145,18 @@ export function normalizeCodexModelOptions(modelOptions?: ModelOptions, legacyEf
 export function codexServiceTierFromModelOptions(modelOptions: CodexModelOptions): ServiceTier | undefined {
   return modelOptions.fastMode ? "fast" : undefined
 }
+
+export function normalizeCursorModelOptions(modelOptions?: ModelOptions): CursorModelOptions {
+  return {
+    fastMode: typeof modelOptions?.cursor?.fastMode === "boolean"
+      ? modelOptions.cursor.fastMode
+      : DEFAULT_CURSOR_MODEL_OPTIONS.fastMode,
+  }
+}
+
+// Cursor encodes "fast" in the model id itself (composer-2.5 vs composer-2.5-fast),
+// so we apply the suffix at spawn time rather than tracking a separate service tier.
+export function cursorModelIdForOptions(baseModel: string, modelOptions: CursorModelOptions): string {
+  if (!modelOptions.fastMode) return baseModel
+  return baseModel.endsWith("-fast") ? baseModel : `${baseModel}-fast`
+}

package/src/server/read-models.test.ts

@@ -146,6 +146,9 @@ describe("read models", () => {
     expect(chat?.history.recentLimit).toBe(200)
     expect(chat?.availableProviders.length).toBeGreaterThan(1)
     expect(chat?.availableProviders.find((provider) => provider.id === "codex")?.models.map((model) => model.id)).toEqual([
+      "gpt-5.6-sol",
+      "gpt-5.6-terra",
+      "gpt-5.6-luna",
       "gpt-5.5",
       "gpt-5.4",
       "gpt-5.3-codex",
@@ -397,6 +400,18 @@ describe("read models", () => {
       sessionToken: "thread-1",
       lastTurnOutcome: null,
     })
+    state.chatsById.set("chat-cursor", {
+      id: "chat-cursor",
+      projectId: "project-1",
+      title: "Cursor",
+      createdAt: 4,
+      updatedAt: 4,
+      unread: false,
+      provider: "cursor",
+      planMode: false,
+      sessionToken: "cursor-session",
+      lastTurnOutcome: null,
+    })
 
     const sidebar = deriveSidebarData(
       state,
@@ -407,5 +422,7 @@ describe("read models", () => {
     expect(sidebar.projectGroups[0]?.chats.find((chat) => chat.chatId === "chat-active")?.canFork).toBeUndefined()
     expect(sidebar.projectGroups[0]?.chats.find((chat) => chat.chatId === "chat-pending")?.canFork).toBe(true)
     expect(sidebar.projectGroups[0]?.chats.find((chat) => chat.chatId === "chat-draining")?.canFork).toBeUndefined()
+    // Cursor has no fork primitive, so forking is disabled even with a live session.
+    expect(sidebar.projectGroups[0]?.chats.find((chat) => chat.chatId === "chat-cursor")?.canFork).toBeUndefined()
   })
 })

package/src/server/read-models.ts

@@ -31,6 +31,8 @@ function canForkChat(
   drainingChatIds: Set<string>,
 ) {
   if (!chat.provider) return false
+  // Cursor has no fork/branch primitive, so forking would silently start a fresh session.
+  if (chat.provider === "cursor") return false
   if (!chat.sessionToken && !chat.pendingForkSessionToken) return false
   if (activeStatuses.has(chat.id)) return false
   if (drainingChatIds.has(chat.id)) return false

package/src/server/transcript.ts

@@ -0,0 +1,14 @@
+import { randomUUID } from "node:crypto"
+import type { TranscriptEntry } from "../shared/types"
+
+/** Stamp a transcript entry with a generated id and creation time. */
+export function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
+  entry: T,
+  createdAt = Date.now()
+): TranscriptEntry {
+  return {
+    _id: randomUUID(),
+    createdAt,
+    ...entry,
+  } as TranscriptEntry
+}

package/src/server/ws-router.test.ts

@@ -102,6 +102,13 @@ const DEFAULT_APP_SETTINGS_SNAPSHOT: AppSettingsSnapshot = {
       },
       planMode: false,
     },
+    cursor: {
+      model: "composer-2.5",
+      modelOptions: {
+        fastMode: false,
+      },
+      planMode: false,
+    },
   },
   warning: null,
   filePathDisplay: "~/.kanna/data/settings.json",

package/src/server/ws-router.ts

@@ -15,7 +15,7 @@ import { EventStore } from "./event-store"
 import { openExternal } from "./external-open"
 import { KeybindingsManager } from "./keybindings"
 import { killLocalHttpServer, listLocalHttpServers } from "./local-http-servers"
-import { ensureProjectDirectory, resolveLocalPath } from "./paths"
+import { cloneRepository, ensureProjectDirectory, resolveClonePath, resolveLocalPath } from "./paths"
 import { readProjectQuickActions, writeProjectQuickActions } from "./project-quick-actions"
 import { writeStandaloneTranscriptExport } from "./standalone-export"
 import { TerminalManager } from "./terminal-manager"
@@ -473,9 +473,16 @@ export function createWsRouter({
         planMode: false,
       },
       codex: {
-        model: "gpt-5.5",
+        model: "gpt-5.6-sol",
+        modelOptions: {
+          reasoningEffort: "medium",
+          fastMode: false,
+        },
+        planMode: false,
+      },
+      cursor: {
+        model: "composer-2.5",
         modelOptions: {
-          reasoningEffort: "high",
           fastMode: false,
         },
         planMode: false,
@@ -512,6 +519,14 @@ export function createWsRouter({
           ...patch.providerDefaults?.codex?.modelOptions,
         },
       },
+      cursor: {
+        ...snapshot.providerDefaults.cursor,
+        ...patch.providerDefaults?.cursor,
+        modelOptions: {
+          ...snapshot.providerDefaults.cursor.modelOptions,
+          ...patch.providerDefaults?.cursor?.modelOptions,
+        },
+      },
     },
   })
   const resolvedAppSettings = {
@@ -1212,6 +1227,14 @@ export function createWsRouter({
           await broadcastFilteredSnapshots({ includeSidebar: true })
           return
         }
+        case "project.clone": {
+          const cloneDest = await resolveClonePath(command.localPath, command.fallbackPath)
+          await cloneRepository(command.cloneUrl, cloneDest)
+          const project = await store.openProject(cloneDest, command.title)
+          await refreshDiscovery()
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: { projectId: project.id, localPath: cloneDest } })
+          break
+        }
         case "project.remove": {
           await store.removeProject(command.projectId)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })

package/src/shared/assert.ts

@@ -0,0 +1,7 @@
+/**
+ * Exhaustiveness guard for discriminated unions. Reaching this at runtime means
+ * a case was missed; referencing `value: never` makes it a compile-time error too.
+ */
+export function assertNever(value: never): never {
+  throw new Error(`Unexpected value: ${JSON.stringify(value)}`)
+}

package/src/shared/git-url.ts

@@ -0,0 +1,54 @@
+/**
+ * Utilities for detecting and parsing GitHub/GitLab clone URLs.
+ */
+
+const GIT_URL_PATTERNS = [
+  // HTTPS: https://github.com/owner/repo or https://github.com/owner/repo.git
+  /^https?:\/\/(github\.com|gitlab\.com)\/([^/]+)\/([^/.]+?)(?:\.git)?\/?$/,
+  // SSH: git@github.com:owner/repo.git
+  /^git@(github\.com|gitlab\.com):([^/]+)\/([^/.]+?)(?:\.git)?\/?$/,
+]
+
+export interface ParsedGitUrl {
+  host: string
+  owner: string
+  repo: string
+  url: string
+}
+
+/**
+ * Check if a string looks like a GitHub or GitLab repository URL.
+ */
+export function isGitRepoUrl(input: string): boolean {
+  const trimmed = input.trim()
+  return GIT_URL_PATTERNS.some((pattern) => pattern.test(trimmed))
+}
+
+/**
+ * Parse a GitHub/GitLab URL into its components.
+ * Returns null if the input isn't a valid git repo URL.
+ */
+export function parseGitRepoUrl(input: string): ParsedGitUrl | null {
+  const trimmed = input.trim()
+  for (const pattern of GIT_URL_PATTERNS) {
+    const match = trimmed.match(pattern)
+    if (match) {
+      return {
+        host: match[1]!,
+        owner: match[2]!,
+        repo: match[3]!,
+        url: trimmed,
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Normalize a git repo URL to HTTPS format for cloning.
+ */
+export function toCloneUrl(input: string): string {
+  const parsed = parseGitRepoUrl(input)
+  if (!parsed) return input.trim()
+  return `https://${parsed.host}/${parsed.owner}/${parsed.repo}.git`
+}

package/src/shared/json.ts

@@ -0,0 +1,14 @@
+/** Small, dependency-free coercion helpers for parsing untrusted JSON values. */
+
+export function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null
+  return value as Record<string, unknown>
+}
+
+export function asString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined
+}
+
+export function asNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined
+}

package/src/shared/protocol.ts

@@ -73,6 +73,7 @@ export type ClientCommand =
   | { type: "project.open"; localPath: string }
   | { type: "project.create"; localPath: string; title: string }
   | { type: "project.rename"; projectId: string; title: string }
+  | { type: "project.clone"; cloneUrl: string; localPath: string; fallbackPath?: string; title: string }
   | { type: "project.remove"; projectId: string }
   | { type: "sidebar.reorderProjectGroups"; projectIds: string[] }
   | { type: "project.readDiffPatch"; projectId: string; path: string }

package/src/shared/types.test.ts

@@ -1,8 +1,11 @@
 import { describe, expect, test } from "bun:test"
 import {
   deriveClaudeModelLabel,
+  getCodexReasoningOptions,
   normalizeClaudeModelId,
   normalizeCodexModelId,
+  normalizeCodexReasoningEffort,
+  isCodexReasoningEffort,
   supportsClaudeMaxReasoningEffort,
 } from "./types"
 
@@ -21,8 +24,54 @@ describe("shared model normalization", () => {
   })
 
   test("normalizes legacy Codex aliases and defaults to the latest catalog model", () => {
-    expect(normalizeCodexModelId()).toBe("gpt-5.5")
+    expect(normalizeCodexModelId()).toBe("gpt-5.6-sol")
+    expect(normalizeCodexModelId("gpt-5.6")).toBe("gpt-5.6-sol")
+    expect(normalizeCodexModelId("gpt-5.6-terra")).toBe("gpt-5.6-terra")
+    expect(normalizeCodexModelId("gpt-5.6-luna")).toBe("gpt-5.6-luna")
     expect(normalizeCodexModelId("gpt-5-codex")).toBe("gpt-5.3-codex")
+    expect(normalizeCodexModelId("not-a-real-model")).toBe("gpt-5.6-sol")
+  })
+
+  test("exposes model-specific GPT-5.6 reasoning efforts", () => {
+    expect(getCodexReasoningOptions("gpt-5.6-sol").map((option) => option.id)).toEqual([
+      "low", "medium", "high", "xhigh", "max", "ultra",
+    ])
+    expect(getCodexReasoningOptions("gpt-5.6-terra").map((option) => option.id)).toEqual([
+      "low", "medium", "high", "xhigh", "max", "ultra",
+    ])
+    expect(getCodexReasoningOptions("gpt-5.6-luna").map((option) => option.id)).toEqual([
+      "low", "medium", "high", "xhigh", "max",
+    ])
+  })
+
+  test("preserves all 17 supported GPT-5.6 model and reasoning combinations", () => {
+    const combinations = [
+      ["gpt-5.6-sol", ["low", "medium", "high", "xhigh", "max", "ultra"]],
+      ["gpt-5.6-terra", ["low", "medium", "high", "xhigh", "max", "ultra"]],
+      ["gpt-5.6-luna", ["low", "medium", "high", "xhigh", "max"]],
+    ] as const
+
+    expect(combinations.reduce((count, [, efforts]) => count + efforts.length, 0)).toBe(17)
+    for (const [model, efforts] of combinations) {
+      for (const effort of efforts) {
+        expect(normalizeCodexReasoningEffort(model, effort)).toBe(effort)
+      }
+    }
+  })
+
+  test("normalizes unsupported GPT-5.6 reasoning efforts", () => {
+    expect(normalizeCodexReasoningEffort("gpt-5.6-sol", "minimal")).toBe("low")
+    expect(normalizeCodexReasoningEffort("gpt-5.6-luna", "ultra")).toBe("max")
+    expect(normalizeCodexReasoningEffort("gpt-5.6-terra", "ultra")).toBe("ultra")
+    expect(normalizeCodexReasoningEffort("gpt-5.6-sol", "unknown")).toBe("medium")
+  })
+
+  test("recognizes public and legacy Codex reasoning values", () => {
+    expect(isCodexReasoningEffort("max")).toBe(true)
+    expect(isCodexReasoningEffort("ultra")).toBe(true)
+    expect(isCodexReasoningEffort("minimal")).toBe(true)
+    expect(getCodexReasoningOptions("gpt-5.6-sol").find((option) => option.id === "xhigh")?.label).toBe("Extra High")
+    expect(getCodexReasoningOptions("gpt-5.6-sol").find((option) => option.id === "ultra")?.description).toContain("subagents")
   })
 
   test("uses declarative metadata for Claude max-effort support", () => {