kanna-code 0.9.1 → 0.11.0

package/src/server/ws-router.ts

@@ -6,7 +6,7 @@ import type { AgentCoordinator } from "./agent"
 import type { DiscoveredProject } from "./discovery"
 import { EventStore } from "./event-store"
 import { openExternal } from "./external-open"
-import { FileTreeManager } from "./file-tree-manager"
+import { KeybindingsManager } from "./keybindings"
 import { ensureProjectDirectory } from "./paths"
 import { TerminalManager } from "./terminal-manager"
 import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
@@ -19,7 +19,7 @@ interface CreateWsRouterArgs {
   store: EventStore
   agent: AgentCoordinator
   terminals: TerminalManager
-  fileTree: FileTreeManager
+  keybindings: KeybindingsManager
   refreshDiscovery: () => Promise<DiscoveredProject[]>
   getDiscoveredProjects: () => DiscoveredProject[]
   machineDisplayName: string
@@ -33,7 +33,7 @@ export function createWsRouter({
   store,
   agent,
   terminals,
-  fileTree,
+  keybindings,
   refreshDiscovery,
   getDiscoveredProjects,
   machineDisplayName,
@@ -68,26 +68,26 @@ export function createWsRouter({
       }
     }
 
-    if (topic.type === "terminal") {
+    if (topic.type === "keybindings") {
       return {
         v: PROTOCOL_VERSION,
         type: "snapshot",
         id,
         snapshot: {
-          type: "terminal",
-          data: terminals.getSnapshot(topic.terminalId),
+          type: "keybindings",
+          data: keybindings.getSnapshot(),
         },
       }
     }
 
-    if (topic.type === "file-tree") {
+    if (topic.type === "terminal") {
       return {
         v: PROTOCOL_VERSION,
         type: "snapshot",
         id,
         snapshot: {
-          type: "file-tree",
-          data: fileTree.getSnapshot(topic.projectId),
+          type: "terminal",
+          data: terminals.getSnapshot(topic.terminalId),
         },
       }
     }
@@ -142,16 +142,11 @@ export function createWsRouter({
     pushTerminalEvent(event.terminalId, event)
   })
 
-  const disposeFileTreeEvents = fileTree.onInvalidate((event) => {
+  const disposeKeybindingEvents = keybindings.onChange(() => {
     for (const ws of sockets) {
       for (const [id, topic] of ws.data.subscriptions.entries()) {
-        if (topic.type !== "file-tree" || topic.projectId !== event.projectId) continue
-        send(ws, {
-          v: PROTOCOL_VERSION,
-          type: "event",
-          id,
-          event,
-        })
+        if (topic.type !== "keybindings") continue
+        send(ws, createEnvelope(id, topic))
       }
     }
   })
@@ -164,6 +159,15 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           return
         }
+        case "settings.readKeybindings": {
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: keybindings.getSnapshot() })
+          return
+        }
+        case "settings.writeKeybindings": {
+          const snapshot = await keybindings.write(command.bindings)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
+          return
+        }
         case "project.open": {
           await ensureProjectDirectory(command.localPath)
           const project = await store.openProject(command.localPath)
@@ -257,11 +261,6 @@ export function createWsRouter({
           pushTerminalSnapshot(command.terminalId)
           return
         }
-        case "file-tree.readDirectory": {
-          const result = await fileTree.readDirectory(command)
-          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
-          return
-        }
       }
 
       broadcastSnapshots()
@@ -276,11 +275,6 @@ export function createWsRouter({
       sockets.add(ws)
     },
     handleClose(ws: ServerWebSocket<ClientState>) {
-      for (const topic of ws.data.subscriptions.values()) {
-        if (topic.type === "file-tree") {
-          fileTree.unsubscribe(topic.projectId)
-        }
-      }
       sockets.delete(ws)
     },
     broadcastSnapshots,
@@ -300,9 +294,6 @@ export function createWsRouter({
 
       if (parsed.type === "subscribe") {
         ws.data.subscriptions.set(parsed.id, parsed.topic)
-        if (parsed.topic.type === "file-tree") {
-          fileTree.subscribe(parsed.topic.projectId)
-        }
         if (parsed.topic.type === "local-projects") {
           void refreshDiscovery().then(() => {
             if (ws.data.subscriptions.has(parsed.id)) {
@@ -315,11 +306,7 @@ export function createWsRouter({
       }
 
       if (parsed.type === "unsubscribe") {
-        const topic = ws.data.subscriptions.get(parsed.id)
         ws.data.subscriptions.delete(parsed.id)
-        if (topic?.type === "file-tree") {
-          fileTree.unsubscribe(topic.projectId)
-        }
         send(ws, { v: PROTOCOL_VERSION, type: "ack", id: parsed.id })
         return
       }
@@ -328,7 +315,7 @@ export function createWsRouter({
     },
     dispose() {
       disposeTerminalEvents()
-      disposeFileTreeEvents()
+      disposeKeybindingEvents()
     },
   }
 }

package/src/shared/branding.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test"
+import {
+  getDataDir,
+  getDataDirDisplay,
+  getDataRootName,
+  getKeybindingsFilePath,
+  getKeybindingsFilePathDisplay,
+  getRuntimeProfile,
+} from "./branding"
+
+describe("runtime profile helpers", () => {
+  test("defaults to the prod profile when unset", () => {
+    expect(getRuntimeProfile({})).toBe("prod")
+    expect(getDataRootName({})).toBe(".kanna")
+    expect(getDataDir("/tmp/home", {})).toBe("/tmp/home/.kanna/data")
+    expect(getDataDirDisplay({})).toBe("~/.kanna/data")
+    expect(getKeybindingsFilePath("/tmp/home", {})).toBe("/tmp/home/.kanna/keybindings.json")
+    expect(getKeybindingsFilePathDisplay({})).toBe("~/.kanna/keybindings.json")
+  })
+
+  test("switches to dev paths for the dev profile", () => {
+    const env = { KANNA_RUNTIME_PROFILE: "dev" }
+
+    expect(getRuntimeProfile(env)).toBe("dev")
+    expect(getDataRootName(env)).toBe(".kanna-dev")
+    expect(getDataDir("/tmp/home", env)).toBe("/tmp/home/.kanna-dev/data")
+    expect(getDataDirDisplay(env)).toBe("~/.kanna-dev/data")
+    expect(getKeybindingsFilePath("/tmp/home", env)).toBe("/tmp/home/.kanna-dev/keybindings.json")
+    expect(getKeybindingsFilePathDisplay(env)).toBe("~/.kanna-dev/keybindings.json")
+  })
+})

package/src/shared/branding.ts

@@ -1,23 +1,58 @@
 export const APP_NAME = "Kanna"
 export const CLI_COMMAND = "kanna"
 export const DATA_ROOT_NAME = ".kanna"
+export const DEV_DATA_ROOT_NAME = ".kanna-dev"
 export const PACKAGE_NAME = "kanna-code"
+export const RUNTIME_PROFILE_ENV_VAR = "KANNA_RUNTIME_PROFILE"
 // Read version from package.json — JSON import works in both Bun and Vite
 import pkg from "../../package.json"
 export const SDK_CLIENT_APP = `kanna/${pkg.version}`
 export const LOG_PREFIX = "[kanna]"
 export const DEFAULT_NEW_PROJECT_ROOT = `~/${APP_NAME}`
 
-export function getDataRootName() {
-  return DATA_ROOT_NAME
+export type RuntimeProfile = "dev" | "prod"
+
+type RuntimeEnv = Record<string, string | undefined> | undefined
+
+function getRuntimeEnv(): RuntimeEnv {
+  const candidate = globalThis as typeof globalThis & {
+    process?: {
+      env?: Record<string, string | undefined>
+    }
+  }
+  return candidate.process?.env
+}
+
+export function getRuntimeProfile(env: RuntimeEnv = getRuntimeEnv()): RuntimeProfile {
+  return env?.[RUNTIME_PROFILE_ENV_VAR]?.trim().toLowerCase() === "dev" ? "dev" : "prod"
+}
+
+export function getDataRootName(env: RuntimeEnv = getRuntimeEnv()) {
+  return getRuntimeProfile(env) === "dev" ? DEV_DATA_ROOT_NAME : DATA_ROOT_NAME
+}
+
+export function getDataRootDir(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${homeDir}/${getDataRootName(env)}`
+}
+
+export function getDataRootDirDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `~/${getDataRootName(env)}`
+}
+
+export function getDataDir(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDir(homeDir, env)}/data`
+}
+
+export function getDataDirDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDirDisplay(env)}/data`
 }
 
-export function getDataDir(homeDir: string) {
-  return `${homeDir}/${DATA_ROOT_NAME}/data`
+export function getKeybindingsFilePath(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDir(homeDir, env)}/keybindings.json`
 }
 
-export function getDataDirDisplay() {
-  return `~/${DATA_ROOT_NAME.slice(1)}/data`
+export function getKeybindingsFilePathDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDirDisplay(env)}/keybindings.json`
 }
 
 export function getCliInvocation(arg?: string) {

package/src/shared/protocol.ts

@@ -1,8 +1,7 @@
 import type {
   AgentProvider,
   ChatSnapshot,
-  FileTreeDirectoryPage,
-  FileTreeSnapshot,
+  KeybindingsSnapshot,
   LocalProjectsSnapshot,
   ModelOptions,
   SidebarData,
@@ -18,7 +17,7 @@ export interface EditorOpenSettings {
 export type SubscriptionTopic =
   | { type: "sidebar" }
   | { type: "local-projects" }
-  | { type: "file-tree"; projectId: string }
+  | { type: "keybindings" }
   | { type: "chat"; chatId: string }
   | { type: "terminal"; terminalId: string }
 
@@ -45,6 +44,8 @@ export type ClientCommand =
   | { type: "project.create"; localPath: string; title: string }
   | { type: "project.remove"; projectId: string }
   | { type: "system.ping" }
+  | { type: "settings.readKeybindings" }
+  | { type: "settings.writeKeybindings"; bindings: KeybindingsSnapshot["bindings"] }
   | {
       type: "system.openExternal"
       localPath: string
@@ -73,13 +74,6 @@ export type ClientCommand =
   | { type: "terminal.input"; terminalId: string; data: string }
   | { type: "terminal.resize"; terminalId: string; cols: number; rows: number }
   | { type: "terminal.close"; terminalId: string }
-  | {
-      type: "file-tree.readDirectory"
-      projectId: string
-      directoryPath: string
-      cursor?: string
-      limit?: number
-    }
 
 export type ClientEnvelope =
   | { v: 1; type: "subscribe"; id: string; topic: SubscriptionTopic }
@@ -89,24 +83,16 @@ export type ClientEnvelope =
 export type ServerSnapshot =
   | { type: "sidebar"; data: SidebarData }
   | { type: "local-projects"; data: LocalProjectsSnapshot }
-  | { type: "file-tree"; data: FileTreeSnapshot }
+  | { type: "keybindings"; data: KeybindingsSnapshot }
   | { type: "chat"; data: ChatSnapshot | null }
   | { type: "terminal"; data: TerminalSnapshot | null }
 
-export type FileTreeEvent = {
-  type: "file-tree.invalidate"
-  projectId: string
-  directoryPaths: string[]
-}
-
 export type ServerEnvelope =
   | { v: 1; type: "snapshot"; id: string; snapshot: ServerSnapshot }
-  | { v: 1; type: "event"; id: string; event: TerminalEvent | FileTreeEvent }
+  | { v: 1; type: "event"; id: string; event: TerminalEvent }
   | { v: 1; type: "ack"; id: string; result?: unknown }
   | { v: 1; type: "error"; id?: string; message: string }
 
-export type FileTreeReadDirectoryResult = FileTreeDirectoryPage
-
 export function isClientEnvelope(value: unknown): value is ClientEnvelope {
   if (!value || typeof value !== "object") return false
   const candidate = value as Partial<ClientEnvelope>

package/src/shared/types.ts

@@ -167,28 +167,25 @@ export interface LocalProjectsSnapshot {
   projects: LocalProjectSummary[]
 }
 
-export type FileTreeEntryKind = "file" | "directory" | "symlink"
+export type KeybindingAction =
+  | "toggleEmbeddedTerminal"
+  | "toggleRightSidebar"
+  | "openInFinder"
+  | "openInEditor"
+  | "addSplitTerminal"
 
-export interface FileTreeEntry {
-  name: string
-  relativePath: string
-  kind: FileTreeEntryKind
-  extension?: string
+export const DEFAULT_KEYBINDINGS: Record<KeybindingAction, string[]> = {
+  toggleEmbeddedTerminal: ["cmd+j", "ctrl+`"],
+  toggleRightSidebar: ["cmd+b", "ctrl+b"],
+  openInFinder: ["cmd+alt+f", "ctrl+alt+f"],
+  openInEditor: ["cmd+shift+o", "ctrl+shift+o"],
+  addSplitTerminal: ["cmd+/", "ctrl+/"],
 }
 
-export interface FileTreeDirectoryPage {
-  directoryPath: string
-  entries: FileTreeEntry[]
-  nextCursor: string | null
-  hasMore: boolean
-  error?: string
-}
-
-export interface FileTreeSnapshot {
-  projectId: string
-  rootPath: string
-  pageSize: number
-  supportsRealtime: true
+export interface KeybindingsSnapshot {
+  bindings: Record<KeybindingAction, string[]>
+  warning: string | null
+  filePathDisplay: string
 }
 
 export interface McpServerInfo {
@@ -244,46 +241,46 @@ interface ToolCallBase<TKind extends string, TInput> {
 }
 
 export interface AskUserQuestionToolCall
-  extends ToolCallBase<"ask_user_question", { questions: AskUserQuestionItem[] }> {}
+  extends ToolCallBase<"ask_user_question", { questions: AskUserQuestionItem[] }> { }
 
 export interface ExitPlanModeToolCall
-  extends ToolCallBase<"exit_plan_mode", { plan?: string; summary?: string }> {}
+  extends ToolCallBase<"exit_plan_mode", { plan?: string; summary?: string }> { }
 
 export interface TodoWriteToolCall
-  extends ToolCallBase<"todo_write", { todos: TodoItem[] }> {}
+  extends ToolCallBase<"todo_write", { todos: TodoItem[] }> { }
 
 export interface SkillToolCall
-  extends ToolCallBase<"skill", { skill: string }> {}
+  extends ToolCallBase<"skill", { skill: string }> { }
 
 export interface GlobToolCall
-  extends ToolCallBase<"glob", { pattern: string }> {}
+  extends ToolCallBase<"glob", { pattern: string }> { }
 
 export interface GrepToolCall
-  extends ToolCallBase<"grep", { pattern: string; outputMode?: string }> {}
+  extends ToolCallBase<"grep", { pattern: string; outputMode?: string }> { }
 
 export interface BashToolCall
-  extends ToolCallBase<"bash", { command: string; description?: string; timeoutMs?: number; runInBackground?: boolean }> {}
+  extends ToolCallBase<"bash", { command: string; description?: string; timeoutMs?: number; runInBackground?: boolean }> { }
 
 export interface WebSearchToolCall
-  extends ToolCallBase<"web_search", { query: string }> {}
+  extends ToolCallBase<"web_search", { query: string }> { }
 
 export interface ReadFileToolCall
-  extends ToolCallBase<"read_file", { filePath: string }> {}
+  extends ToolCallBase<"read_file", { filePath: string }> { }
 
 export interface WriteFileToolCall
-  extends ToolCallBase<"write_file", { filePath: string; content: string }> {}
+  extends ToolCallBase<"write_file", { filePath: string; content: string }> { }
 
 export interface EditFileToolCall
-  extends ToolCallBase<"edit_file", { filePath: string; oldString: string; newString: string }> {}
+  extends ToolCallBase<"edit_file", { filePath: string; oldString: string; newString: string }> { }
 
 export interface SubagentTaskToolCall
-  extends ToolCallBase<"subagent_task", { subagentType?: string }> {}
+  extends ToolCallBase<"subagent_task", { subagentType?: string }> { }
 
 export interface McpGenericToolCall
-  extends ToolCallBase<"mcp_generic", { server: string; tool: string; payload: Record<string, unknown> }> {}
+  extends ToolCallBase<"mcp_generic", { server: string; tool: string; payload: Record<string, unknown> }> { }
 
 export interface UnknownToolCall
-  extends ToolCallBase<"unknown_tool", { payload: Record<string, unknown> }> {}
+  extends ToolCallBase<"unknown_tool", { payload: Record<string, unknown> }> { }
 
 export type NormalizedToolCall =
   | AskUserQuestionToolCall