@jetcrab/pi-desk 1.1.16 → 1.1.20-dev

package/src/server/l2_biz/work-session/l2-work-session-chat-runtime.ts

@@ -108,7 +108,6 @@ interface L2WorkSessionChatRecord {
   source: L2ChatSource
   state: L2ChatSourceState
   sourceEventVersion: number
-  forceFullSync: boolean
   rawTemporaryMessages: Map<string, L4PiChatMessage>
   metadata: L2WorkSessionChatMetadata
   mainRunning: boolean
@@ -302,20 +301,6 @@ export class L2WorkSessionChatRuntime {
     return isCurrent() ? { cwd, isCurrent } : null
   }
 
-  refreshPluginMessages(): void {
-    for (const record of this.recordsByWorkId.values()) {
-      if (record.state.runtime.presentationMode === 'basic') continue
-      try {
-        this.reprojectRecord(record, record.state.runtime.presentationMode)
-      } catch (error) {
-        console.error('[Pi Desk][WorkSessionChatRuntime] 插件消息刷新失败，保留已有聊天', {
-          workId: record.source.workId,
-          message: error instanceof Error ? error.message : String(error)
-        })
-      }
-    }
-  }
-
   setPresentation(source: L2ChatSource, mode: L2ChatMode): Promise<void> {
     const record = this.currentRecord(source)
     return this.enqueueCommand(record, async () => {
@@ -363,7 +348,6 @@ export class L2WorkSessionChatRuntime {
       temporaryMessages,
       runtime: { ...record.state.runtime, presentationMode: mode }
     }
-    record.forceFullSync = true
     record.sourceEventVersion += 1
     this.publish({
       type: 'source_event',
@@ -380,16 +364,14 @@ export class L2WorkSessionChatRuntime {
 
   private async syncRecordRuntime(record: L2WorkSessionChatRecord): Promise<void> {
     const source = record.source
-    const runtime = L2ChatRuntimeSchema.parse({
-      ...(await getL4PiWorkSessionRuntime(source.sessionId).readChatRuntime()),
+    const runtime = await getL4PiWorkSessionRuntime(source.sessionId).readChatRuntime()
+    const nextRuntime = L2ChatRuntimeSchema.parse({
+      ...runtime,
       presentationMode: record.state.runtime.presentationMode
     })
     if (!this.isCurrentSource(source)) return
-    if (!sameRuntime(record.state.runtime, runtime))
-      this.applySourceEvent(source, { type: 'runtime_update', runtime })
-    if (runtime.extensionMode === 'basic' && record.state.runtime.presentationMode !== 'basic') {
-      this.reprojectRecord(record, 'basic')
-    }
+    if (!sameRuntime(record.state.runtime, nextRuntime))
+      this.applySourceEvent(source, { type: 'runtime_update', runtime: nextRuntime })
   }
 
   createSync(sourceInput: L2ChatSource, cursor: L2ChatCursor): L2PreparedChatSourceSync {
@@ -413,24 +395,23 @@ export class L2WorkSessionChatRuntime {
       })
     }
 
-    const event: L2ChatSessionSyncEvent =
-      cursor !== null && cursorMatches && !record.forceFullSync
-        ? {
-            type: 'session_sync',
-            mode: 'incremental',
-            baseCursor: cursor,
-            messages: messages.slice(cursor.index + 1).map(withoutL3ConversationMessageDetail),
-            temporaryMessages,
-            runtime
-          }
-        : {
-            type: 'session_sync',
-            mode: 'full',
-            baseCursor: null,
-            messages: messages.map(withoutL3ConversationMessageDetail),
-            temporaryMessages,
-            runtime
-          }
+    const event: L2ChatSessionSyncEvent = cursorMatches
+      ? {
+          type: 'session_sync',
+          mode: 'incremental',
+          baseCursor: cursor,
+          messages: messages.slice(cursor.index + 1).map(withoutL3ConversationMessageDetail),
+          temporaryMessages,
+          runtime
+        }
+      : {
+          type: 'session_sync',
+          mode: 'full',
+          baseCursor: null,
+          messages: messages.map(withoutL3ConversationMessageDetail),
+          temporaryMessages,
+          runtime
+        }
 
     return { event, watermark: record.sourceEventVersion }
   }
@@ -548,12 +529,6 @@ export class L2WorkSessionChatRuntime {
       } finally {
         if (this.recordsByWorkId.get(source.workId) === record) {
           await this.syncRecordRuntime(record)
-          if (
-            record.state.runtime.extensionMode === 'basic' &&
-            record.state.runtime.presentationMode !== 'basic'
-          ) {
-            this.reprojectRecord(record, 'basic')
-          }
         }
       }
     })
@@ -685,7 +660,6 @@ export class L2WorkSessionChatRuntime {
       source,
       state,
       sourceEventVersion: 0,
-      forceFullSync: isL4PiDeskSafeMode(),
       rawTemporaryMessages: new Map(),
       metadata: {
         sessionTitle: snapshot.sessionName ?? firstUserTitle,
@@ -714,6 +688,9 @@ export class L2WorkSessionChatRuntime {
     if (this.recordsByWorkId.get(record.source.workId) !== record) return
     const previousMetadata = record.metadata
     const previousStatus = this.statusForRecord(record)
+    const basic =
+      record.state.runtime.extensionMode === 'basic' ||
+      record.state.runtime.presentationMode === 'basic'
 
     switch (event.type) {
       case 'message_start':
@@ -726,7 +703,7 @@ export class L2WorkSessionChatRuntime {
             record.source,
             false,
             'temporary',
-            record.state.runtime.presentationMode === 'basic'
+            basic
           )
         })
         return
@@ -744,7 +721,7 @@ export class L2WorkSessionChatRuntime {
             record.source,
             false,
             'update',
-            record.state.runtime.presentationMode === 'basic'
+            basic
           )
         )
         if (update) this.applySourceEvent(record.source, update)
@@ -761,7 +738,7 @@ export class L2WorkSessionChatRuntime {
           record.source,
           false,
           'final',
-          record.state.runtime.presentationMode === 'basic'
+          basic
         )
         const update = buildL3ConversationMessageUpdate(current, publicFinal)
         if (update) this.applySourceEvent(record.source, update)
@@ -801,12 +778,6 @@ export class L2WorkSessionChatRuntime {
         if (!sameRuntime(record.state.runtime, runtime)) {
           this.applySourceEvent(record.source, { type: 'runtime_update', runtime })
         }
-        if (
-          runtime.extensionMode === 'basic' &&
-          record.state.runtime.presentationMode !== 'basic'
-        ) {
-          this.reprojectRecord(record, 'basic')
-        }
         return
       }
       case 'agent_started':
@@ -861,7 +832,8 @@ export class L2WorkSessionChatRuntime {
       record.source,
       true,
       'final',
-      record.state.runtime.presentationMode === 'basic'
+      record.state.runtime.extensionMode === 'basic' ||
+        record.state.runtime.presentationMode === 'basic'
     )
     record.state = { ...record.state, temporaryMessages }
   }

package/src/server/l2_biz/work-session/l2-work-session-manage.ts

@@ -250,10 +250,6 @@ export class WorkSessionManage {
     })
   }
 
-  refreshPluginMessages(): void {
-    this.chat.refreshPluginMessages()
-  }
-
   runPluginRestart<T>(operation: () => Promise<T>): Promise<T> {
     return this.runExclusive(async () => {
       await this.ensureHydrated()

package/src/server/l4_foundation/file/l4-project-file-index.ts

@@ -0,0 +1,276 @@
+import 'server-only'
+
+import { execFile } from 'node:child_process'
+import { readdir, realpath } from 'node:fs/promises'
+import { basename, relative, resolve, sep } from 'node:path'
+import { promisify } from 'node:util'
+import { listL4WorkSessionGitRepositoryRoots } from '@server/l4_foundation/git/l4-work-session-git'
+import { getL4FileSystemKey as fileSystemKey } from './l4-file-path'
+
+const execFileAsync = promisify(execFile)
+const SEARCH_CACHE_TTL_MS = 30_000
+const SEARCH_CACHE_MAX_CWDS = 20
+const SEARCH_INDEX_MAX_FILES = 50_000
+
+export const IGNORED_NAMES = new Set([
+  '.git',
+  'node_modules',
+  '.next',
+  'dist',
+  'build',
+  'coverage',
+  '.turbo'
+])
+
+interface SearchIndexCacheEntry {
+  files: string[]
+  truncated: boolean
+  expiresAt: number
+}
+
+const searchIndexCache = new Map<string, SearchIndexCacheEntry>()
+const pendingSearchIndexes = new Map<string, Promise<SearchIndexCacheEntry>>()
+
+function joinProtocolPath(parent: string, name: string): string {
+  return parent ? `${parent}/${name}` : name
+}
+
+export function isSupportedProtocolName(name: string): boolean {
+  return name.length > 0 && !name.includes('/') && !name.includes('\\') && !name.includes('\0')
+}
+
+function pathContainsIgnoredSegment(path: string): boolean {
+  return path.split('/').some((segment) => IGNORED_NAMES.has(segment))
+}
+
+export function invalidateSearchIndex(root: string): void {
+  const key = fileSystemKey(root)
+  searchIndexCache.delete(key)
+  pendingSearchIndexes.delete(key)
+}
+
+const GIT_SEARCH_OPTIONS = {
+  timeout: 10_000,
+  maxBuffer: 64 * 1024 * 1024,
+  env: { ...process.env, LC_ALL: 'C', GIT_OPTIONAL_LOCKS: '0' }
+}
+
+async function listFilesWithContainingGit(
+  root: string
+): Promise<{ files: string[]; truncated: boolean } | null> {
+  try {
+    const { stdout: topLevelOutput } = await execFileAsync(
+      'git',
+      ['-C', root, 'rev-parse', '--show-toplevel'],
+      GIT_SEARCH_OPTIONS
+    )
+    const topLevel = await realpath(topLevelOutput.trim())
+    const prefix = relative(topLevel, root).split(sep).join('/')
+    const { stdout } = await execFileAsync(
+      'git',
+      [
+        '-C',
+        topLevel,
+        'ls-files',
+        '--full-name',
+        '--cached',
+        '--others',
+        '--exclude-standard',
+        '-z',
+        '--',
+        prefix || '.'
+      ],
+      GIT_SEARCH_OPTIONS
+    )
+    const prefixWithSlash = prefix ? `${prefix}/` : ''
+    const all = stdout
+      .split('\0')
+      .flatMap((path) => {
+        if (!path) return []
+        const projectPath = prefixWithSlash
+          ? path.startsWith(prefixWithSlash)
+            ? path.slice(prefixWithSlash.length)
+            : ''
+          : path
+        return projectPath ? [projectPath] : []
+      })
+      .filter(
+        (path) =>
+          isSupportedProtocolName(basename(path)) &&
+          !path.includes('\\') &&
+          !pathContainsIgnoredSegment(path)
+      )
+    return {
+      files: all.slice(0, SEARCH_INDEX_MAX_FILES),
+      truncated: all.length > SEARCH_INDEX_MAX_FILES
+    }
+  } catch {
+    return null
+  }
+}
+
+function isPathInsideRepository(path: string, repositoryRoot: string): boolean {
+  return path === repositoryRoot || path.startsWith(`${repositoryRoot}/`)
+}
+
+async function listFilesInRepository(
+  projectRoot: string,
+  repositoryRoot: string,
+  nestedRepositoryRoots: readonly string[]
+): Promise<{ files: string[]; truncated: boolean } | null> {
+  const absoluteRoot = repositoryRoot
+    ? resolve(projectRoot, ...repositoryRoot.split('/'))
+    : projectRoot
+  try {
+    const { stdout } = await execFileAsync(
+      'git',
+      [
+        '-C',
+        absoluteRoot,
+        'ls-files',
+        '--full-name',
+        '--cached',
+        '--others',
+        '--exclude-standard',
+        '-z'
+      ],
+      GIT_SEARCH_OPTIONS
+    )
+    const files = stdout.split('\0').flatMap((path) => {
+      if (!path || path.includes('\\') || pathContainsIgnoredSegment(path)) return []
+      const projectPath = joinProtocolPath(repositoryRoot, path)
+      if (
+        nestedRepositoryRoots.some((nestedRoot) => isPathInsideRepository(projectPath, nestedRoot))
+      ) {
+        return []
+      }
+      return isSupportedProtocolName(basename(projectPath)) ? [projectPath] : []
+    })
+    return {
+      files: files.slice(0, SEARCH_INDEX_MAX_FILES),
+      truncated: files.length > SEARCH_INDEX_MAX_FILES
+    }
+  } catch {
+    return null
+  }
+}
+
+async function listFilesWithWalk(
+  root: string,
+  excludedRepositoryRoots: readonly string[] = []
+): Promise<{ files: string[]; truncated: boolean }> {
+  const files: string[] = []
+  const queue: Array<{ absolute: string; relative: string }> = [{ absolute: root, relative: '' }]
+  let queueIndex = 0
+
+  while (queueIndex < queue.length) {
+    const current = queue[queueIndex]!
+    queueIndex += 1
+    let dirents
+    try {
+      dirents = await readdir(current.absolute, { withFileTypes: true })
+    } catch {
+      continue
+    }
+
+    for (const entry of dirents) {
+      if (IGNORED_NAMES.has(entry.name) || !isSupportedProtocolName(entry.name)) continue
+      const childRelative = joinProtocolPath(current.relative, entry.name)
+      if (entry.isDirectory()) {
+        if (excludedRepositoryRoots.includes(childRelative)) continue
+        queue.push({ absolute: resolve(current.absolute, entry.name), relative: childRelative })
+        continue
+      }
+      if (!entry.isFile()) continue
+      files.push(childRelative)
+      if (files.length >= SEARCH_INDEX_MAX_FILES) return { files, truncated: true }
+    }
+  }
+
+  return { files, truncated: false }
+}
+
+async function listFilesWithRepositoryRoots(
+  projectRoot: string,
+  repositoryRoots: readonly string[]
+): Promise<{ files: string[]; truncated: boolean }> {
+  const files = new Set<string>()
+  let truncated = false
+  const hasProjectRootRepository = repositoryRoots.includes('')
+
+  if (!hasProjectRootRepository) {
+    const workspaceFiles = await listFilesWithWalk(projectRoot, repositoryRoots.filter(Boolean))
+    for (const path of workspaceFiles.files) files.add(path)
+    truncated ||= workspaceFiles.truncated
+  }
+
+  for (const repositoryRoot of repositoryRoots) {
+    const nestedRoots = repositoryRoots.filter(
+      (candidate) =>
+        candidate !== repositoryRoot &&
+        (repositoryRoot === '' || candidate.startsWith(`${repositoryRoot}/`))
+    )
+    let listing = await listFilesInRepository(projectRoot, repositoryRoot, nestedRoots)
+    if (!listing) {
+      const absoluteRoot = repositoryRoot
+        ? resolve(projectRoot, ...repositoryRoot.split('/'))
+        : projectRoot
+      const nestedRelativeRoots = nestedRoots.map((root) =>
+        repositoryRoot ? root.slice(repositoryRoot.length + 1) : root
+      )
+      const fallback = await listFilesWithWalk(absoluteRoot, nestedRelativeRoots)
+      listing = {
+        files: fallback.files.map((path) => joinProtocolPath(repositoryRoot, path)),
+        truncated: fallback.truncated
+      }
+    }
+    for (const path of listing.files) {
+      files.add(path)
+      if (files.size >= SEARCH_INDEX_MAX_FILES) {
+        return { files: [...files], truncated: true }
+      }
+    }
+    truncated ||= listing.truncated
+  }
+
+  return { files: [...files], truncated }
+}
+
+export async function getSearchIndex(root: string): Promise<SearchIndexCacheEntry> {
+  const key = fileSystemKey(root)
+  const now = Date.now()
+  const cached = searchIndexCache.get(key)
+  if (cached && cached.expiresAt > now) return cached
+
+  const active = pendingSearchIndexes.get(key)
+  if (active) return active
+
+  const load: Promise<SearchIndexCacheEntry> = Promise.resolve().then(async () => {
+    const repositoryRoots = await listL4WorkSessionGitRepositoryRoots(root)
+    const listing =
+      repositoryRoots.length > 0
+        ? await listFilesWithRepositoryRoots(root, repositoryRoots)
+        : ((await listFilesWithContainingGit(root)) ?? (await listFilesWithWalk(root)))
+    const next: SearchIndexCacheEntry = {
+      ...listing,
+      expiresAt: now + SEARCH_CACHE_TTL_MS
+    }
+    if (pendingSearchIndexes.get(key) === load) {
+      for (const [cacheKey, entry] of searchIndexCache) {
+        if (entry.expiresAt <= Date.now()) searchIndexCache.delete(cacheKey)
+      }
+      while (searchIndexCache.size >= SEARCH_CACHE_MAX_CWDS) {
+        const oldestKey = searchIndexCache.keys().next().value as string
+        searchIndexCache.delete(oldestKey)
+      }
+      searchIndexCache.set(key, next)
+    }
+    return next
+  })
+  pendingSearchIndexes.set(key, load)
+  try {
+    return await load
+  } finally {
+    if (pendingSearchIndexes.get(key) === load) pendingSearchIndexes.delete(key)
+  }
+}