@cuongtran001/kanna 0.39.2

package/src/server/project-paths.ts

@@ -0,0 +1,191 @@
+import path from "node:path"
+import { readdir } from "node:fs/promises"
+import { existsSync, statSync, type Dirent } from "node:fs"
+import { spawn } from "bun"
+
+export interface ProjectPath {
+  path: string
+  kind: "file" | "dir"
+}
+
+interface CacheEntry {
+  files: string[]
+  dirs: string[]
+  gitIndexMtime: number | null
+  builtAt: number
+}
+
+const CACHE = new Map<string, CacheEntry>()
+const CACHE_TTL_MS = 5 * 60 * 1000
+const MAX_WALK_ENTRIES = 10_000
+const DEFAULT_LIMIT = 50
+const MAX_LIMIT = 200
+
+const DEFAULT_WALK_EXCLUDES = new Set([
+  ".git", "node_modules", ".next", "dist", "build", ".svn", ".hg", ".jj", ".sl",
+])
+
+export function clearProjectPathCache(projectId?: string) {
+  if (projectId) CACHE.delete(projectId)
+  else CACHE.clear()
+}
+
+export async function listProjectPaths(args: {
+  projectId: string
+  localPath: string
+  query: string
+  limit?: number
+}): Promise<ProjectPath[]> {
+  const limit = Math.min(Math.max(args.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT)
+  const query = args.query ?? ""
+
+  if (query === "") {
+    return listTopLevelEntries(args.localPath, limit)
+  }
+
+  const entry = await getOrBuildCache(args.projectId, args.localPath)
+  return fuzzyRank(entry, query, limit)
+}
+
+async function listTopLevelEntries(localPath: string, limit: number): Promise<ProjectPath[]> {
+  try {
+    const entries = await readdir(localPath, { withFileTypes: true })
+    const result: ProjectPath[] = []
+    for (const e of entries) {
+      if (DEFAULT_WALK_EXCLUDES.has(e.name)) continue
+      if (e.name.startsWith(".")) continue
+      result.push(e.isDirectory()
+        ? { path: `${e.name}/`, kind: "dir" }
+        : { path: e.name, kind: "file" })
+    }
+    result.sort((a, b) => {
+      if (a.kind !== b.kind) return a.kind === "dir" ? -1 : 1
+      return a.path.localeCompare(b.path)
+    })
+    return result.slice(0, limit)
+  } catch {
+    return []
+  }
+}
+
+async function getOrBuildCache(projectId: string, localPath: string): Promise<CacheEntry> {
+  const existing = CACHE.get(projectId)
+  const gitIndexMtime = getGitIndexMtime(localPath)
+  const now = Date.now()
+
+  if (existing) {
+    const gitChanged = gitIndexMtime !== null && gitIndexMtime !== existing.gitIndexMtime
+    const expired = now - existing.builtAt > CACHE_TTL_MS
+    if (!gitChanged && !expired) return existing
+  }
+
+  const built = await buildCacheEntry(localPath)
+  const next: CacheEntry = { ...built, gitIndexMtime, builtAt: now }
+  CACHE.set(projectId, next)
+  return next
+}
+
+function getGitIndexMtime(localPath: string): number | null {
+  const indexPath = path.join(localPath, ".git", "index")
+  try {
+    return statSync(indexPath).mtimeMs
+  } catch {
+    return null
+  }
+}
+
+async function buildCacheEntry(localPath: string): Promise<Pick<CacheEntry, "files" | "dirs">> {
+  const gitFiles = await listGitFiles(localPath)
+  const files = gitFiles ?? await walkDirectory(localPath)
+  const dirs = deriveDirectories(files)
+  return { files, dirs }
+}
+
+async function listGitFiles(localPath: string): Promise<string[] | null> {
+  if (!existsSync(path.join(localPath, ".git"))) return null
+
+  const tracked = await runGit(localPath, ["-c", "core.quotepath=false", "ls-files"])
+  if (tracked === null) return null
+
+  const untracked = await runGit(localPath, [
+    "-c", "core.quotepath=false", "ls-files", "--others", "--exclude-standard",
+  ])
+
+  const all = new Set<string>()
+  for (const line of tracked) all.add(line)
+  for (const line of untracked ?? []) all.add(line)
+  return [...all].filter((p) => p.length > 0).map((p) => p.replaceAll("\\", "/"))
+}
+
+async function runGit(cwd: string, args: string[]): Promise<string[] | null> {
+  try {
+    const proc = spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "pipe" })
+    const stdout = await new Response(proc.stdout).text()
+    const exitCode = await proc.exited
+    if (exitCode !== 0) return null
+    return stdout.split("\n").filter(Boolean)
+  } catch {
+    return null
+  }
+}
+
+async function walkDirectory(root: string): Promise<string[]> {
+  const out: string[] = []
+  const queue: string[] = [""]
+  while (queue.length > 0 && out.length < MAX_WALK_ENTRIES) {
+    const rel = queue.shift()!
+    const abs = path.join(root, rel)
+    let entries: Dirent<string>[]
+    try {
+      entries = await readdir(abs, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const e of entries) {
+      if (DEFAULT_WALK_EXCLUDES.has(e.name)) continue
+      const nextRel = rel === "" ? e.name : `${rel}/${e.name}`
+      if (e.isDirectory()) {
+        queue.push(nextRel)
+      } else if (e.isFile()) {
+        out.push(nextRel)
+        if (out.length >= MAX_WALK_ENTRIES) break
+      }
+    }
+  }
+  return out
+}
+
+function deriveDirectories(files: string[]): string[] {
+  const dirs = new Set<string>()
+  for (const f of files) {
+    let idx = f.lastIndexOf("/")
+    while (idx > 0) {
+      dirs.add(f.slice(0, idx))
+      idx = f.lastIndexOf("/", idx - 1)
+    }
+  }
+  return [...dirs]
+}
+
+function fuzzyRank(entry: CacheEntry, query: string, limit: number): ProjectPath[] {
+  const q = query.toLowerCase()
+  const prefix: ProjectPath[] = []
+  const substring: ProjectPath[] = []
+
+  for (const f of entry.files) {
+    const hay = f.toLowerCase()
+    if (hay.startsWith(q)) prefix.push({ path: f, kind: "file" })
+    else if (hay.includes(q)) substring.push({ path: f, kind: "file" })
+  }
+  for (const d of entry.dirs) {
+    const hay = d.toLowerCase()
+    const withSlash = `${d}/`
+    if (hay.startsWith(q)) prefix.push({ path: withSlash, kind: "dir" })
+    else if (hay.includes(q)) substring.push({ path: withSlash, kind: "dir" })
+  }
+
+  const byPath = (a: ProjectPath, b: ProjectPath) => a.path.localeCompare(b.path)
+  prefix.sort(byPath)
+  substring.sort(byPath)
+  return [...prefix, ...substring].slice(0, limit)
+}

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

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test"
+import {
+  codexServiceTierFromModelOptions,
+  normalizeClaudeModelOptions,
+  normalizeCodexModelOptions,
+  normalizeServerModel,
+} from "./provider-catalog"
+import { resolveClaudeApiModelId } from "../shared/types"
+
+describe("provider catalog normalization", () => {
+  test("maps legacy Claude effort into shared model options", () => {
+    expect(normalizeClaudeModelOptions("claude-opus-4-7", undefined, "max")).toEqual({
+      reasoningEffort: "max",
+      contextWindow: "200k",
+    })
+  })
+
+  test("normalizes Claude context window only for supported models", () => {
+    expect(normalizeClaudeModelOptions("claude-sonnet-4-6", {
+      claude: {
+        reasoningEffort: "medium",
+        contextWindow: "1m",
+      },
+    })).toEqual({
+      reasoningEffort: "medium",
+      contextWindow: "1m",
+    })
+
+    expect(normalizeClaudeModelOptions("claude-haiku-4-5-20251001", {
+      claude: {
+        reasoningEffort: "medium",
+        contextWindow: "1m",
+      },
+    })).toMatchObject({
+      reasoningEffort: "medium",
+    })
+  })
+
+  test("normalizes Codex model options and fast mode defaults", () => {
+    expect(normalizeCodexModelOptions(undefined)).toEqual({
+      reasoningEffort: "high",
+      fastMode: false,
+    })
+
+    const normalized = normalizeCodexModelOptions({
+      codex: {
+        reasoningEffort: "xhigh",
+        fastMode: true,
+      },
+    })
+
+    expect(normalized).toEqual({
+      reasoningEffort: "xhigh",
+      fastMode: true,
+    })
+    expect(codexServiceTierFromModelOptions(normalized)).toBe("fast")
+  })
+
+  test("normalizes server model ids through the shared alias catalog", () => {
+    expect(normalizeServerModel("codex")).toBe("gpt-5.5")
+    expect(normalizeServerModel("claude", "opus")).toBe("claude-opus-4-7")
+    expect(normalizeServerModel("codex", "gpt-5-codex")).toBe("gpt-5.3-codex")
+  })
+
+  test("resolves Claude API model ids for 1m context window", () => {
+    expect(resolveClaudeApiModelId("claude-opus-4-7", "1m")).toBe("claude-opus-4-7[1m]")
+    expect(resolveClaudeApiModelId("claude-sonnet-4-6", "200k")).toBe("claude-sonnet-4-6")
+  })
+})

package/src/server/provider-catalog.ts

@@ -0,0 +1,87 @@
+import type {
+  AgentProvider,
+  ClaudeModelOptions,
+  CodexModelOptions,
+  ClaudeContextWindow,
+  ModelOptions,
+  ProviderCatalogEntry,
+  ProviderModelOption,
+  ServiceTier,
+} from "../shared/types"
+import {
+  DEFAULT_CLAUDE_MODEL_OPTIONS,
+  DEFAULT_CODEX_MODEL_OPTIONS,
+  PROVIDERS,
+  normalizeClaudeContextWindow,
+  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 const SERVER_PROVIDERS: ProviderCatalogEntry[] = PROVIDERS.map((provider) =>
+  provider.id === "codex"
+    ? {
+        ...provider,
+        defaultModel: "gpt-5.5",
+        models: HARD_CODED_CODEX_MODELS,
+      }
+    : provider
+)
+
+export function getServerProviderCatalog(provider: AgentProvider): ProviderCatalogEntry {
+  const entry = SERVER_PROVIDERS.find((candidate) => candidate.id === provider)
+  if (!entry) {
+    throw new Error(`Unknown provider: ${provider}`)
+  }
+  return entry
+}
+
+export function normalizeServerModel(provider: AgentProvider, model?: string): string {
+  const catalog = getServerProviderCatalog(provider)
+  const normalizedModel = normalizeProviderModelId(provider, model, catalog.defaultModel)
+  if (catalog.models.some((candidate) => candidate.id === normalizedModel)) {
+    return normalizedModel
+  }
+  return catalog.defaultModel
+}
+
+export function normalizeClaudeModelOptions(
+  model: string,
+  modelOptions?: ModelOptions,
+  legacyEffort?: string
+): ClaudeModelOptions {
+  const reasoningEffort = modelOptions?.claude?.reasoningEffort
+  return {
+    reasoningEffort: isClaudeReasoningEffort(reasoningEffort)
+      ? reasoningEffort
+      : isClaudeReasoningEffort(legacyEffort)
+        ? legacyEffort
+        : DEFAULT_CLAUDE_MODEL_OPTIONS.reasoningEffort,
+    contextWindow: normalizeClaudeContextWindow(model, modelOptions?.claude?.contextWindow as ClaudeContextWindow | undefined),
+  }
+}
+
+export function normalizeCodexModelOptions(modelOptions?: ModelOptions, legacyEffort?: string): CodexModelOptions {
+  const reasoningEffort = modelOptions?.codex?.reasoningEffort
+  return {
+    reasoningEffort: isCodexReasoningEffort(reasoningEffort)
+      ? reasoningEffort
+      : isCodexReasoningEffort(legacyEffort)
+        ? legacyEffort
+        : DEFAULT_CODEX_MODEL_OPTIONS.reasoningEffort,
+    fastMode: typeof modelOptions?.codex?.fastMode === "boolean"
+      ? modelOptions.codex.fastMode
+      : DEFAULT_CODEX_MODEL_OPTIONS.fastMode,
+  }
+}
+
+export function codexServiceTierFromModelOptions(modelOptions: CodexModelOptions): ServiceTier | undefined {
+  return modelOptions.fastMode ? "fast" : undefined
+}