picocode-core 0.9.119

package/src/session-index.js

@@ -0,0 +1,264 @@
+import { writeFileSync } from 'node:fs'
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { streamEvents } from './events.js'
+import { withIndexLock, withSessionLock } from './session-lock.js'
+
+const INDEX_VERSION = 4
+const INDEX_FILE = 'index.json'
+const DIRTY_SUFFIX = '.dirty'
+const DELETED_SUFFIX = '.jsonl.deleted'
+const FLUSH_DELAY_MS = 1000
+
+const dirtyFiles = new Set()
+const pendingEvents = new Map()
+let flushTimer = null
+let indexWrites = Promise.resolve()
+
+function messageText(content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content.filter((part) => part.type === 'text').map((part) => part.text).join('')
+}
+
+function applyEvent(meta, event) {
+  const next = { ...meta }
+  if (event.type === 'message' && ['user', 'assistant'].includes(event.data?.message?.role)) {
+    const { role, content } = event.data.message
+    const text = messageText(content).trim()
+    if (text) {
+      next.previewMessageCount++
+      next.preview = [...next.preview, { role, text }]
+      const userIndexes = next.preview.flatMap((message, index) => message.role === 'user' ? [index] : [])
+      if (userIndexes.length > 2) next.preview = next.preview.slice(userIndexes.at(-2))
+    }
+    if (role !== 'user') return next
+    next.turns++
+    if (!next.automaticTitle) {
+      next.automaticTitle = text.slice(0, 200) || null
+      if (!next.customTitle) next.title = next.automaticTitle || next.title
+    }
+  }
+  if (event.type === 'title') {
+    next.customTitle = event.data.text
+    next.title = event.data.text || next.automaticTitle || 'Untitled session'
+  }
+  if (event.type === 'color') next.color = event.data.value
+  return next
+}
+
+async function metadataFromFile(file) {
+  let meta = null
+  for await (const event of streamEvents(file)) {
+    if (!meta) {
+      if (event.type !== 'session') throw new Error('invalid session')
+      meta = {
+        file,
+        header: event,
+        title: 'Untitled session',
+        automaticTitle: null,
+        customTitle: undefined,
+        color: null,
+        turns: 0,
+        preview: [],
+        previewMessageCount: 0,
+        at: 0,
+      }
+    } else {
+      meta = applyEvent(meta, event)
+    }
+  }
+  if (!meta) throw new Error('invalid session')
+  meta.at = (await stat(file)).mtimeMs
+  return meta
+}
+
+function indexPath(dir) {
+  return join(dir, INDEX_FILE)
+}
+
+async function readIndex(dir) {
+  const parsed = JSON.parse(await readFile(indexPath(dir), 'utf-8'))
+  if (parsed.version !== INDEX_VERSION || !Array.isArray(parsed.sessions)) throw new Error('invalid session index')
+  return parsed.sessions
+}
+
+async function writeIndex(dir, sessions) {
+  await mkdir(dir, { recursive: true })
+  const file = indexPath(dir)
+  const temporary = `${file}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`
+  try {
+    await writeFile(temporary, JSON.stringify({ version: INDEX_VERSION, sessions }) + '\n')
+    await rename(temporary, file)
+  } finally {
+    await rm(temporary, { force: true })
+  }
+}
+
+function dirtyPath(file) {
+  return `${file}${DIRTY_SUFFIX}`
+}
+
+function fileFromDirtyName(dir, name) {
+  return join(dir, name.slice(0, -DIRTY_SUFFIX.length))
+}
+
+function enqueueIndexWrite(task) {
+  const result = indexWrites.then(task)
+  indexWrites = result.catch(() => {})
+  return result
+}
+
+async function rebuildIndex(dir, names) {
+  if (!names) {
+    try {
+      names = await readdir(dir)
+    } catch {
+      return []
+    }
+  }
+  const files = names.filter((name) => name.endsWith('.jsonl')).map((name) => join(dir, name))
+  const sessions = (await Promise.all(files.map((file) => metadataFromFile(file).catch(() => null)))).filter(Boolean)
+  await writeIndex(dir, sessions)
+  return sessions
+}
+
+async function refreshFiles(dir, sessions, files, eventsByFile = new Map()) {
+  for (const file of files) {
+    try {
+      const at = sessions.findIndex((session) => session.file === file)
+      const events = eventsByFile.get(file)
+      let row
+      if (at >= 0 && events?.length) {
+        const { mtimeMs } = await stat(file)
+        row = events.reduce(applyEvent, { ...sessions[at], at: mtimeMs })
+      } else {
+        row = await withSessionLock(file, () => metadataFromFile(file))
+      }
+      if (at < 0) sessions.push(row)
+      else sessions[at] = row
+    } catch (err) {
+      if (err.code === 'ENOENT') sessions = sessions.filter((session) => session.file !== file)
+      else throw err
+    }
+  }
+  await writeIndex(dir, sessions)
+  await Promise.all(files.map((file) => rm(dirtyPath(file), { force: true })))
+  return sessions
+}
+
+async function currentSessions(dir) {
+  const names = await readdir(dir)
+  let sessions
+  try {
+    sessions = await readIndex(dir)
+  } catch {
+    return rebuildIndex(dir, names)
+  }
+
+  const dirty = names.filter((name) => name.endsWith(`.jsonl${DIRTY_SUFFIX}`)).map((name) => fileFromDirtyName(dir, name))
+  if (dirty.length > 0) {
+    const files = [...new Set(dirty)]
+    sessions = await refreshFiles(dir, sessions, files)
+    files.forEach((file) => pendingEvents.delete(file))
+  }
+
+  const deleted = new Set(names.filter((name) => name.endsWith(DELETED_SUFFIX)).map((name) => join(dir, name.slice(0, -'.deleted'.length))))
+  if (deleted.size > 0) {
+    const filtered = sessions.filter((session) => !deleted.has(session.file))
+    if (filtered.length !== sessions.length) await writeIndex(dir, filtered)
+    sessions = filtered
+  }
+  return sessions
+}
+
+export function indexedSessions(dir) {
+  return enqueueIndexWrite(() => withIndexLock(dir, () => currentSessions(dir))).catch(async (err) => {
+    if (err.code === 'ENOENT') return []
+    throw err
+  })
+}
+
+export function markSessionIndexDirty(file, onError = () => {}) {
+  dirtyFiles.add(file)
+  try {
+    writeFileSync(dirtyPath(file), '')
+  } catch (err) {
+    onError(err)
+  }
+}
+
+function scheduleFlush() {
+  if (flushTimer) return
+  flushTimer = setTimeout(() => {
+    flushTimer = null
+    flushSessionIndex().catch(() => {})
+  }, FLUSH_DELAY_MS)
+  flushTimer.unref?.()
+}
+
+export function scheduleSessionIndexUpdate(file, event) {
+  dirtyFiles.add(file)
+  if (event) {
+    const events = pendingEvents.get(file) || []
+    events.push(event)
+    pendingEvents.set(file, events)
+  }
+  scheduleFlush()
+}
+
+export function flushSessionIndex() {
+  if (dirtyFiles.size === 0) return indexWrites
+  const files = [...dirtyFiles]
+  const eventsByFile = new Map(files.map((file) => [file, pendingEvents.get(file)]))
+  dirtyFiles.clear()
+  files.forEach((file) => pendingEvents.delete(file))
+  clearTimeout(flushTimer)
+  flushTimer = null
+  const byDir = Map.groupBy(files, dirname)
+  return enqueueIndexWrite(async () => {
+    const failed = []
+    await Promise.all([...byDir].map(async ([dir, projectFiles]) => {
+      try {
+        await withIndexLock(dir, async () => {
+          let sessions
+          let rebuilt = false
+          try {
+            sessions = await readIndex(dir)
+          } catch {
+            sessions = await rebuildIndex(dir)
+            rebuilt = true
+          }
+          await refreshFiles(dir, sessions, projectFiles, rebuilt ? new Map() : eventsByFile)
+        })
+      } catch (err) {
+        failed.push(...projectFiles)
+      }
+    }))
+    if (failed.length > 0) {
+      failed.forEach((file) => {
+        dirtyFiles.add(file)
+        const events = eventsByFile.get(file)
+        if (events?.length) pendingEvents.set(file, [...events, ...(pendingEvents.get(file) || [])])
+      })
+      scheduleFlush()
+      throw new Error('failed to update session index')
+    }
+  })
+}
+
+export function removeFromSessionIndex(file) {
+  dirtyFiles.delete(file)
+  pendingEvents.delete(file)
+  const dir = dirname(file)
+  return enqueueIndexWrite(() => withIndexLock(dir, async () => {
+    await rm(dirtyPath(file), { force: true })
+    let sessions
+    try {
+      sessions = await readIndex(dir)
+    } catch {
+      return
+    }
+    await writeIndex(dir, sessions.filter((session) => session.file !== file))
+  }))
+}

package/src/session-lock.js

@@ -0,0 +1,27 @@
+import { mkdir } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import lockfile from 'proper-lockfile'
+
+const lockOptions = {
+  realpath: false,
+  retries: { retries: 100, minTimeout: 10, maxTimeout: 100 },
+}
+
+async function withLock(target, lockfilePath, task) {
+  const release = await lockfile.lock(target, { ...lockOptions, lockfilePath })
+  try {
+    return await task()
+  } finally {
+    await release()
+  }
+}
+
+export async function withSessionLock(file, task) {
+  await mkdir(dirname(file), { recursive: true })
+  return withLock(file, `${file}.lock`, task)
+}
+
+export async function withIndexLock(dir, task) {
+  await mkdir(dir, { recursive: true })
+  return withLock(dir, join(dir, '.index.lock'), task)
+}

package/src/session.js

@@ -0,0 +1,160 @@
+import { access, appendFile, open, readdir, rm, writeFile } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+import { picoHome, sessionsDir, ensureDir, projectDir } from './paths.js'
+import { withSessionLock } from './session-lock.js'
+import { flushSessionIndex, indexedSessions, markSessionIndexDirty, removeFromSessionIndex, scheduleSessionIndexUpdate } from './session-index.js'
+import { makeEvent, makeHeader, readEvents, serializeLine } from './events.js'
+
+const appendQueues = new Map()
+const writeFailures = new Map()
+const creationFailures = new Map()
+const deletedSessions = new Set()
+
+let onWriteError = () => {}
+
+// appends are chained so they cannot interleave. a rejected link would poison
+// every later append on that file, so failures are reported and absorbed here
+// instead of propagating: one bad write must not silently end the log
+export function onSessionWriteError(handler) {
+  onWriteError = handler || (() => {})
+}
+
+function reportWriteError(file, err) {
+  try {
+    onWriteError(err, file)
+  } catch {}
+}
+
+function deletedPath(file) {
+  return `${file}.deleted`
+}
+
+async function repairIncompleteLine(file) {
+  let handle
+  try {
+    handle = await open(file, 'r+')
+  } catch (err) {
+    if (err.code === 'ENOENT') return
+    throw err
+  }
+  try {
+    const { size } = await handle.stat()
+    if (size === 0) return
+    const last = Buffer.alloc(1)
+    await handle.read(last, 0, 1, size - 1)
+    if (last[0] !== 0x0a) await handle.write('\n', size)
+  } finally {
+    await handle.close()
+  }
+}
+
+export function appendSessionEvent(file, event) {
+  if (deletedSessions.has(file)) return Promise.reject(new Error(`session has been deleted: ${file}`))
+  markSessionIndexDirty(file, (err) => reportWriteError(file, err))
+  const queued = (appendQueues.get(file) || Promise.resolve()).then(async () => {
+    try {
+      await withSessionLock(file, async () => {
+        if (deletedSessions.has(file)) throw new Error(`session has been deleted: ${file}`)
+        try {
+          await access(deletedPath(file))
+          throw new Error(`session has been deleted: ${file}`)
+        } catch (err) {
+          if (err.code !== 'ENOENT') throw err
+        }
+        if (event.type === 'session') {
+          await writeFile(file, serializeLine(event), { flag: 'wx' })
+        } else {
+          await repairIncompleteLine(file)
+          await appendFile(file, serializeLine(event))
+        }
+      })
+    } catch (err) {
+      writeFailures.set(file, err)
+      if (event.type === 'session') creationFailures.set(file, err)
+      reportWriteError(file, err)
+      scheduleSessionIndexUpdate(file)
+      return
+    }
+    writeFailures.delete(file)
+    scheduleSessionIndexUpdate(file, event)
+  })
+  appendQueues.set(file, queued)
+  return queued
+}
+
+export function createSession({ cwd, root, forkedFrom }) {
+  const header = makeHeader({ cwd, root, forkedFrom })
+  const file = join(ensureDir(sessionsDir(root)), `${header.id}.jsonl`)
+  const session = openSession({ file, header })
+  session.append(header)
+  return session
+}
+
+export async function forkSession({ source, cwd, root, events, label }) {
+  await source?.flush()
+  const session = createSession({ cwd, root, forkedFrom: source?.id })
+  for (const event of events) session.append(event)
+  const title = makeEvent('title', { text: label })
+  session.append(title)
+  await session.flush()
+  return { session, events: [...events, title] }
+}
+
+export function openSession({ file, header }) {
+  return {
+    id: header.id,
+    file,
+    header,
+    append(event) {
+      return appendSessionEvent(file, event)
+    },
+    async flush() {
+      await (appendQueues.get(file) || Promise.resolve())
+      const failure = creationFailures.get(file) || writeFailures.get(file)
+      if (failure) throw failure
+      return flushSessionIndex()
+    },
+  }
+}
+
+export async function loadSession(file) {
+  const events = await readEvents(file)
+  const header = events[0]?.type === 'session' ? events.shift() : null
+  if (!header) throw new Error(`not a pico session file: ${file}`)
+  return { header, events }
+}
+
+export async function deleteSession(file) {
+  const sessionId = basename(file, '.jsonl')
+  const project = dirname(dirname(file))
+  deletedSessions.add(file)
+  await (appendQueues.get(file) || Promise.resolve())
+  appendQueues.delete(file)
+  writeFailures.delete(file)
+  creationFailures.delete(file)
+  await withSessionLock(file, async () => {
+    await writeFile(deletedPath(file), '')
+    await rm(file, { force: true })
+  })
+  await removeFromSessionIndex(file)
+  await rm(join(project, 'scratchpads', sessionId), { recursive: true, force: true })
+}
+
+export function deleteProjectData(root) {
+  return rm(projectDir(root), { recursive: true, force: true })
+}
+
+export async function listSessions({ scope, root }) {
+  let sessions
+  if (scope === 'everywhere') {
+    const projectsDir = join(picoHome(), 'projects')
+    let projects = []
+    try {
+      projects = await readdir(projectsDir)
+    } catch {}
+    sessions = (await Promise.all(projects.map((project) => indexedSessions(join(projectsDir, project, 'sessions'))))).flat()
+  } else {
+    sessions = await indexedSessions(sessionsDir(root))
+  }
+  return sessions.filter((session) => session.title !== 'Untitled session').sort((a, b) => b.at - a.at)
+}

package/src/shells.js

@@ -0,0 +1,166 @@
+import { spawn } from 'node:child_process'
+
+const MAX_LINES = 2000
+
+function killTree(child, signal) {
+  if (!child.pid) return false
+  if (process.platform !== 'win32') {
+    try {
+      process.kill(-child.pid, signal)
+      return true
+    } catch {}
+  }
+  return child.kill(signal)
+}
+
+export function createShellManager({ onChange = () => {}, onExit = () => {} } = {}) {
+  const shells = new Map()
+  let nextId = 1
+
+  function publicView(shell) {
+    return {
+      id: shell.id,
+      command: shell.command,
+      description: shell.description,
+      sessionId: shell.sessionId,
+      sessionFile: shell.sessionFile,
+      cwd: shell.cwd,
+      status: shell.status,
+      exitCode: shell.exitCode,
+      startedAt: shell.startedAt,
+      endedAt: shell.endedAt,
+      killedBy: shell.killedBy,
+      lastLine: shell.lines.at(-1) || '',
+      lineCount: shell.lines.length,
+    }
+  }
+
+  function track(child, command, { cwd, description, sessionId, sessionFile, hidden = false } = {}) {
+    const id = String(nextId++)
+    const shell = {
+      id,
+      command,
+      description: description || null,
+      sessionId: sessionId || null,
+      sessionFile: sessionFile || null,
+      cwd: cwd || process.cwd(),
+      child,
+      status: 'running',
+      exitCode: null,
+      startedAt: Date.now(),
+      endedAt: null,
+      killedBy: null,
+      lines: [],
+      partial: '',
+      hidden,
+    }
+
+    const push = (chunk) => {
+      const text = shell.partial + chunk.toString()
+      const lines = text.split('\n')
+      shell.partial = lines.pop() || ''
+      shell.lines.push(...lines)
+      if (shell.lines.length > MAX_LINES) shell.lines.splice(0, shell.lines.length - MAX_LINES)
+      if (!shell.hidden) onChange()
+    }
+    child.stdout.on('data', push)
+    child.stderr.on('data', push)
+    child.on('error', (err) => {
+      push(`[failed to start: ${err.message}]\n`)
+    })
+    child.on('exit', (code, signal) => {
+      if (shell.partial) {
+        shell.lines.push(shell.partial)
+        shell.partial = ''
+      }
+      shell.status = 'exited'
+      shell.exitCode = code ?? (signal ? 1 : 0)
+      shell.endedAt = Date.now()
+      if (!shell.hidden) onChange()
+      if (!shell.hidden) onExit(publicView(shell))
+    })
+
+    shells.set(id, shell)
+    if (!shell.hidden) onChange()
+    return { id }
+  }
+
+  function start(command, options = {}) {
+    const child = spawn(command, {
+      shell: true,
+      cwd: options.cwd || process.cwd(),
+      env: { ...process.env, ...options.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: process.platform !== 'win32',
+    })
+    return track(child, command, options)
+  }
+
+  function get(id) {
+    const shell = shells.get(String(id))
+    if (!shell) throw new Error(`no shell with id ${id}; it is gone and cannot be inspected (exited shells disappear when dismissed)`)
+    return shell
+  }
+
+  return {
+    start,
+    track,
+    reveal(id) {
+      const shell = get(id)
+      if (shell.hidden) {
+        shell.hidden = false
+        onChange()
+        if (shell.status === 'exited') onExit(publicView(shell))
+      }
+      return publicView(shell)
+    },
+    discardHidden(id) {
+      const shell = shells.get(String(id))
+      if (shell?.hidden) shells.delete(String(id))
+    },
+    output(id, { tail = 100 } = {}) {
+      const shell = get(id)
+      return {
+        id: shell.id,
+        command: shell.command,
+        status: shell.status,
+        exitCode: shell.exitCode,
+        output: shell.lines.slice(-tail).join('\n'),
+        totalLines: shell.lines.length,
+      }
+    },
+    kill(id, by = 'model') {
+      const shell = get(id)
+      if (shell.status !== 'running') return { id: shell.id, status: shell.status, exitCode: shell.exitCode }
+      shell.killedBy = by
+      killTree(shell.child, 'SIGTERM')
+      setTimeout(() => {
+        if (shell.status === 'running') killTree(shell.child, 'SIGKILL')
+      }, 3000).unref()
+      return { id: shell.id, status: 'killing' }
+    },
+    dismiss(id) {
+      const shell = shells.get(String(id))
+      if (shell && shell.status === 'exited') {
+        shells.delete(String(id))
+        if (!shell.hidden) onChange()
+      }
+    },
+    list() {
+      return [...shells.values()].filter((shell) => !shell.hidden).map(publicView)
+    },
+    running() {
+      return [...shells.values()].filter((s) => s.status === 'running').length
+    },
+    killAll() {
+      for (const shell of shells.values()) {
+        if (shell.status === 'running') {
+          shell.killedBy = 'user'
+          try {
+            killTree(shell.child, 'SIGKILL')
+          } catch {}
+        }
+      }
+    },
+  }
+}