kanna-code 0.8.2 → 0.9.0

package/src/server/file-tree-manager.ts

@@ -0,0 +1,372 @@
+import { readdir, watch, type FSWatcher } from "node:fs"
+import { lstat, realpath } from "node:fs/promises"
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+import type { FileTreeEvent } from "../shared/protocol"
+import type { FileTreeDirectoryPage, FileTreeSnapshot } from "../shared/types"
+
+const DEFAULT_PAGE_SIZE = 200
+const MAX_PAGE_SIZE = 500
+const INVALIDATION_DEBOUNCE_MS = 90
+
+interface ProjectLookup {
+  localPath: string
+}
+
+interface ProjectRuntime {
+  subscriberCount: number
+  watchers: Map<string, FSWatcher>
+  pendingInvalidations: Set<string>
+  invalidateTimer: Timer | null
+}
+
+interface GitIgnoreCacheEntry {
+  repoRoot: string | null
+  projectRealPath: string
+}
+
+interface CreateFileTreeManagerArgs {
+  getProject: (projectId: string) => ProjectLookup | null
+}
+
+interface DirectoryCandidate {
+  name: string
+  absolutePath: string
+  relativePath: string
+  kind: "file" | "directory" | "symlink"
+  extension?: string
+}
+
+export class FileTreeManager {
+  private readonly getProject: CreateFileTreeManagerArgs["getProject"]
+  private readonly projectRuntimes = new Map<string, ProjectRuntime>()
+  private readonly gitIgnoreCache = new Map<string, GitIgnoreCacheEntry>()
+  private readonly invalidateListeners = new Set<(event: FileTreeEvent) => void>()
+
+  constructor(args: CreateFileTreeManagerArgs) {
+    this.getProject = args.getProject
+  }
+
+  getSnapshot(projectId: string): FileTreeSnapshot {
+    const project = this.requireProject(projectId)
+    return {
+      projectId,
+      rootPath: project.localPath,
+      pageSize: DEFAULT_PAGE_SIZE,
+      supportsRealtime: true,
+    }
+  }
+
+  async readDirectory(args: {
+    projectId: string
+    directoryPath: string
+    cursor?: string
+    limit?: number
+  }): Promise<FileTreeDirectoryPage> {
+    const project = this.requireProject(args.projectId)
+    const rootPath = await realpath(project.localPath)
+    const directoryPath = normalizeRelativeDirectoryPath(args.directoryPath)
+    const absoluteDirectoryPath = resolveProjectPath(rootPath, directoryPath)
+    const info = await lstat(absoluteDirectoryPath).catch(() => null)
+
+    if (!info) {
+      return {
+        directoryPath,
+        entries: [],
+        nextCursor: null,
+        hasMore: false,
+        error: "Directory not found",
+      }
+    }
+
+    if (!info.isDirectory()) {
+      return {
+        directoryPath,
+        entries: [],
+        nextCursor: null,
+        hasMore: false,
+        error: "Path is not a directory",
+      }
+    }
+
+    const pageSize = clampPageSize(args.limit)
+    const candidates = await new Promise<DirectoryCandidate[]>((resolve, reject) => {
+      readdir(absoluteDirectoryPath, { withFileTypes: true }, async (error, dirents) => {
+        if (error) {
+          reject(error)
+          return
+        }
+
+        try {
+          const nextCandidates = await Promise.all(
+            dirents.map(async (dirent): Promise<DirectoryCandidate | null> => {
+              const name = dirent.name
+              if (name === ".git") return null
+
+              const childRelativePath = joinRelativePath(directoryPath, name)
+              const childAbsolutePath = resolveProjectPath(rootPath, childRelativePath)
+
+              let kind: DirectoryCandidate["kind"] = "file"
+              if (dirent.isDirectory()) {
+                kind = "directory"
+              } else if (dirent.isSymbolicLink()) {
+                kind = "symlink"
+              }
+
+              if (kind === "symlink") {
+                const stat = await lstat(childAbsolutePath).catch(() => null)
+                if (stat?.isDirectory()) {
+                  kind = "symlink"
+                }
+              }
+
+              return {
+                name,
+                absolutePath: childAbsolutePath,
+                relativePath: childRelativePath,
+                kind,
+                extension: getExtension(name),
+              }
+            })
+          )
+
+          resolve(nextCandidates.filter((candidate): candidate is DirectoryCandidate => candidate !== null))
+        } catch (caughtError) {
+          reject(caughtError)
+        }
+      })
+    }).catch((error: unknown) => {
+      const message = error instanceof Error ? error.message : String(error)
+      return Promise.reject(new Error(message))
+    })
+
+    const visibleCandidates = await this.filterIgnored(args.projectId, rootPath, candidates)
+    visibleCandidates.sort(compareCandidates)
+
+    const start = parseCursor(args.cursor)
+    const page = visibleCandidates.slice(start, start + pageSize)
+    const nextCursor = start + page.length < visibleCandidates.length ? String(start + page.length) : null
+
+    this.ensureWatchedDirectory(args.projectId, directoryPath)
+
+    return {
+      directoryPath,
+      entries: page.map((candidate) => ({
+        name: candidate.name,
+        relativePath: candidate.relativePath,
+        kind: candidate.kind,
+        extension: candidate.extension,
+      })),
+      nextCursor,
+      hasMore: nextCursor !== null,
+    }
+  }
+
+  subscribe(projectId: string) {
+    const runtime = this.ensureRuntime(projectId)
+    runtime.subscriberCount += 1
+    this.ensureWatchedDirectory(projectId, "")
+  }
+
+  unsubscribe(projectId: string) {
+    const runtime = this.projectRuntimes.get(projectId)
+    if (!runtime) return
+    runtime.subscriberCount = Math.max(0, runtime.subscriberCount - 1)
+    if (runtime.subscriberCount > 0) return
+    this.disposeRuntime(projectId)
+  }
+
+  onInvalidate(listener: (event: FileTreeEvent) => void) {
+    this.invalidateListeners.add(listener)
+    return () => {
+      this.invalidateListeners.delete(listener)
+    }
+  }
+
+  dispose() {
+    for (const projectId of [...this.projectRuntimes.keys()]) {
+      this.disposeRuntime(projectId)
+    }
+  }
+
+  private requireProject(projectId: string) {
+    const project = this.getProject(projectId)
+    if (!project) {
+      throw new Error("Project not found")
+    }
+    return project
+  }
+
+  private ensureRuntime(projectId: string) {
+    const existing = this.projectRuntimes.get(projectId)
+    if (existing) {
+      return existing
+    }
+
+    const runtime: ProjectRuntime = {
+      subscriberCount: 0,
+      watchers: new Map(),
+      pendingInvalidations: new Set(),
+      invalidateTimer: null,
+    }
+    this.projectRuntimes.set(projectId, runtime)
+    return runtime
+  }
+
+  private ensureWatchedDirectory(projectId: string, directoryPath: string) {
+    const runtime = this.projectRuntimes.get(projectId)
+    if (!runtime || runtime.subscriberCount === 0) return
+    if (runtime.watchers.has(directoryPath)) return
+
+    const project = this.requireProject(projectId)
+    const absolutePath = resolveProjectPath(project.localPath, directoryPath)
+    const watcher = watch(absolutePath, { persistent: false }, () => {
+      this.queueInvalidation(projectId, directoryPath)
+    })
+
+    watcher.on("error", () => {
+      this.queueInvalidation(projectId, directoryPath)
+      watcher.close()
+      runtime.watchers.delete(directoryPath)
+    })
+
+    runtime.watchers.set(directoryPath, watcher)
+  }
+
+  private queueInvalidation(projectId: string, directoryPath: string) {
+    const runtime = this.projectRuntimes.get(projectId)
+    if (!runtime) return
+    runtime.pendingInvalidations.add(directoryPath)
+    if (runtime.invalidateTimer) return
+
+    runtime.invalidateTimer = setTimeout(() => {
+      runtime.invalidateTimer = null
+      const directoryPaths = [...runtime.pendingInvalidations]
+      runtime.pendingInvalidations.clear()
+      if (directoryPaths.length === 0) return
+      const event: FileTreeEvent = {
+        type: "file-tree.invalidate",
+        projectId,
+        directoryPaths: directoryPaths.sort(),
+      }
+      for (const listener of this.invalidateListeners) {
+        listener(event)
+      }
+    }, INVALIDATION_DEBOUNCE_MS)
+  }
+
+  private disposeRuntime(projectId: string) {
+    const runtime = this.projectRuntimes.get(projectId)
+    if (!runtime) return
+    for (const watcher of runtime.watchers.values()) {
+      watcher.close()
+    }
+    runtime.watchers.clear()
+    if (runtime.invalidateTimer) {
+      clearTimeout(runtime.invalidateTimer)
+    }
+    runtime.pendingInvalidations.clear()
+    this.projectRuntimes.delete(projectId)
+  }
+
+  private async filterIgnored(projectId: string, rootPath: string, candidates: DirectoryCandidate[]) {
+    if (candidates.length === 0) return candidates
+
+    const cache = this.getGitIgnoreCache(projectId, rootPath)
+    if (!cache.repoRoot) return candidates
+
+    const visible = candidates.filter((candidate) => isWithinPath(cache.repoRoot as string, candidate.absolutePath))
+    const pathsToCheck = visible.map((candidate) => path.relative(cache.repoRoot as string, candidate.absolutePath))
+    if (pathsToCheck.length === 0) return candidates
+
+    const result = spawnSync("git", ["-C", cache.repoRoot, "check-ignore", "--stdin"], {
+      input: pathsToCheck.join("\n"),
+      encoding: "utf8",
+    })
+
+    if (result.status !== 0 && result.status !== 1) {
+      return candidates
+    }
+
+    const ignored = new Set(
+      result.stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+    )
+
+    return candidates.filter((candidate) => {
+      if (!isWithinPath(cache.repoRoot as string, candidate.absolutePath)) {
+        return true
+      }
+      const repoRelative = path.relative(cache.repoRoot as string, candidate.absolutePath)
+      return !ignored.has(repoRelative)
+    })
+  }
+
+  private getGitIgnoreCache(projectId: string, rootPath: string) {
+    const cached = this.gitIgnoreCache.get(projectId)
+    if (cached?.projectRealPath === rootPath) {
+      return cached
+    }
+
+    const result = spawnSync("git", ["-C", rootPath, "rev-parse", "--show-toplevel"], { encoding: "utf8" })
+    const repoRoot = result.status === 0 ? result.stdout.trim() || null : null
+    const nextEntry = {
+      repoRoot,
+      projectRealPath: rootPath,
+    }
+    this.gitIgnoreCache.set(projectId, nextEntry)
+    return nextEntry
+  }
+}
+
+function clampPageSize(limit?: number) {
+  if (!limit || !Number.isFinite(limit)) return DEFAULT_PAGE_SIZE
+  return Math.min(MAX_PAGE_SIZE, Math.max(1, Math.floor(limit)))
+}
+
+function parseCursor(cursor?: string) {
+  if (!cursor) return 0
+  const parsed = Number.parseInt(cursor, 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0
+}
+
+function normalizeRelativeDirectoryPath(directoryPath: string) {
+  if (!directoryPath || directoryPath === ".") return ""
+  const normalized = directoryPath.replaceAll("\\", "/").replace(/^\/+|\/+$/g, "")
+  if (!normalized) return ""
+  const segments = normalized.split("/")
+  if (segments.includes("..")) {
+    throw new Error("Directory path must stay within the project root")
+  }
+  return normalized
+}
+
+function resolveProjectPath(rootPath: string, relativePath: string) {
+  const resolved = path.resolve(rootPath, relativePath || ".")
+  if (!isWithinPath(rootPath, resolved)) {
+    throw new Error("Path must stay within the project root")
+  }
+  return resolved
+}
+
+function isWithinPath(rootPath: string, candidatePath: string) {
+  const relative = path.relative(rootPath, candidatePath)
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+function joinRelativePath(parent: string, name: string) {
+  return parent ? `${parent}/${name}` : name
+}
+
+function compareCandidates(left: DirectoryCandidate, right: DirectoryCandidate) {
+  if (left.kind === "directory" && right.kind !== "directory") return -1
+  if (left.kind !== "directory" && right.kind === "directory") return 1
+  return left.name.localeCompare(right.name, undefined, { sensitivity: "base", numeric: true })
+}
+
+function getExtension(name: string) {
+  const extension = path.extname(name)
+  return extension ? extension.slice(1).toLowerCase() : undefined
+}

package/src/server/server.ts

@@ -3,6 +3,7 @@ import { APP_NAME } from "../shared/branding"
 import { EventStore } from "./event-store"
 import { AgentCoordinator } from "./agent"
 import { discoverProjects, type DiscoveredProject } from "./discovery"
+import { FileTreeManager } from "./file-tree-manager"
 import { getMachineDisplayName } from "./machine-name"
 import { TerminalManager } from "./terminal-manager"
 import { createWsRouter, type ClientState } from "./ws-router"
@@ -30,6 +31,9 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   let server: ReturnType<typeof Bun.serve<ClientState>>
   let router: ReturnType<typeof createWsRouter>
   const terminals = new TerminalManager()
+  const fileTree = new FileTreeManager({
+    getProject: (projectId) => store.getProject(projectId),
+  })
   const agent = new AgentCoordinator({
     store,
     onStateChange: () => {
@@ -40,6 +44,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     store,
     agent,
     terminals,
+    fileTree,
     refreshDiscovery,
     getDiscoveredProjects: () => discoveredProjects,
     machineDisplayName,
@@ -101,6 +106,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
       await agent.cancel(chatId)
     }
     router.dispose()
+    fileTree.dispose()
     terminals.closeAll()
     await store.compact()
     server.stop(true)

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

@@ -23,6 +23,10 @@ describe("ws-router", () => {
         getSnapshot: () => null,
         onEvent: () => () => {},
       } as never,
+      fileTree: {
+        getSnapshot: () => ({ projectId: "project-1", rootPath: "/tmp/project-1", pageSize: 200, supportsRealtime: true }),
+        onInvalidate: () => () => {},
+      } as never,
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
       machineDisplayName: "Local Machine",
@@ -58,6 +62,10 @@ describe("ws-router", () => {
         onEvent: () => () => {},
         write: () => {},
       } as never,
+      fileTree: {
+        getSnapshot: () => ({ projectId: "project-1", rootPath: "/tmp/project-1", pageSize: 200, supportsRealtime: true }),
+        onInvalidate: () => () => {},
+      } as never,
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
       machineDisplayName: "Local Machine",
@@ -87,4 +95,113 @@ describe("ws-router", () => {
       },
     ])
   })
+
+  test("subscribes and unsubscribes file-tree topics and acks directory reads", async () => {
+    const fileTree = {
+      subscribeCalls: [] as string[],
+      unsubscribeCalls: [] as string[],
+      subscribe(projectId: string) {
+        this.subscribeCalls.push(projectId)
+      },
+      unsubscribe(projectId: string) {
+        this.unsubscribeCalls.push(projectId)
+      },
+      getSnapshot: (projectId: string) => ({
+        projectId,
+        rootPath: "/tmp/project-1",
+        pageSize: 200,
+        supportsRealtime: true as const,
+      }),
+      readDirectory: async () => ({
+        directoryPath: "",
+        entries: [],
+        nextCursor: null,
+        hasMore: false,
+      }),
+      onInvalidate: () => () => {},
+    }
+
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: { getActiveStatuses: () => new Map() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      fileTree: fileTree as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+    })
+    const ws = new FakeWebSocket()
+
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "tree-sub-1",
+        topic: { type: "file-tree", projectId: "project-1" },
+      })
+    )
+
+    expect(fileTree.subscribeCalls).toEqual(["project-1"])
+    expect(ws.sent[0]).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "snapshot",
+      id: "tree-sub-1",
+      snapshot: {
+        type: "file-tree",
+        data: {
+          projectId: "project-1",
+          rootPath: "/tmp/project-1",
+          pageSize: 200,
+          supportsRealtime: true,
+        },
+      },
+    })
+
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "tree-read-1",
+        command: {
+          type: "file-tree.readDirectory",
+          projectId: "project-1",
+          directoryPath: "",
+        },
+      })
+    )
+
+    await Promise.resolve()
+    expect(ws.sent[1]).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "tree-read-1",
+      result: {
+        directoryPath: "",
+        entries: [],
+        nextCursor: null,
+        hasMore: false,
+      },
+    })
+
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "unsubscribe",
+        id: "tree-sub-1",
+      })
+    )
+
+    expect(fileTree.unsubscribeCalls).toEqual(["project-1"])
+    expect(ws.sent[2]).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "tree-sub-1",
+    })
+  })
 })

package/src/server/ws-router.ts

@@ -6,6 +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 { ensureProjectDirectory } from "./paths"
 import { TerminalManager } from "./terminal-manager"
 import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
@@ -18,6 +19,7 @@ interface CreateWsRouterArgs {
   store: EventStore
   agent: AgentCoordinator
   terminals: TerminalManager
+  fileTree: FileTreeManager
   refreshDiscovery: () => Promise<DiscoveredProject[]>
   getDiscoveredProjects: () => DiscoveredProject[]
   machineDisplayName: string
@@ -31,6 +33,7 @@ export function createWsRouter({
   store,
   agent,
   terminals,
+  fileTree,
   refreshDiscovery,
   getDiscoveredProjects,
   machineDisplayName,
@@ -77,6 +80,18 @@ export function createWsRouter({
       }
     }
 
+    if (topic.type === "file-tree") {
+      return {
+        v: PROTOCOL_VERSION,
+        type: "snapshot",
+        id,
+        snapshot: {
+          type: "file-tree",
+          data: fileTree.getSnapshot(topic.projectId),
+        },
+      }
+    }
+
     return {
       v: PROTOCOL_VERSION,
       type: "snapshot",
@@ -127,6 +142,20 @@ export function createWsRouter({
     pushTerminalEvent(event.terminalId, event)
   })
 
+  const disposeFileTreeEvents = fileTree.onInvalidate((event) => {
+    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,
+        })
+      }
+    }
+  })
+
   async function handleCommand(ws: ServerWebSocket<ClientState>, message: Extract<ClientEnvelope, { type: "command" }>) {
     const { command, id } = message
     try {
@@ -228,6 +257,11 @@ 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()
@@ -242,6 +276,11 @@ 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,
@@ -261,6 +300,9 @@ 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)) {
@@ -273,7 +315,11 @@ 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
       }
@@ -282,6 +328,7 @@ export function createWsRouter({
     },
     dispose() {
       disposeTerminalEvents()
+      disposeFileTreeEvents()
     },
   }
 }