picocode-core 0.9.119

package/src/fuzzy.js

@@ -0,0 +1,41 @@
+export function fuzzyScore(query, path) {
+  const q = query.toLowerCase()
+  const s = path.toLowerCase()
+  if (!q) return 0
+
+  const substringIndex = s.indexOf(q)
+  if (substringIndex !== -1) return 10_000 - substringIndex - s.length / 10_000
+
+  let best = -1
+  for (let start = s.indexOf(q[0]); start !== -1; start = s.indexOf(q[0], start + 1)) {
+    let score = 0
+    let prev = -1
+    let matched = true
+    for (const ch of q) {
+      const i = s.indexOf(ch, prev === -1 ? start : prev + 1)
+      if (i === -1) {
+        matched = false
+        break
+      }
+      if (prev !== -1 && i === prev + 1) score += 3
+      if (i === 0 || '/.-_'.includes(s[i - 1])) score += 2
+      score += 1
+      prev = i
+    }
+    if (matched && score > best) best = score
+  }
+  if (best < 0) return -1
+  const base = s.slice(s.lastIndexOf('/') + 1)
+  if (base.startsWith(q)) best += 8
+  else if (base.includes(q)) best += 5
+  return best - s.length / 100
+}
+
+export function rankFuzzy(items, query, score) {
+  if (!query) return items
+  return items
+    .map((item, index) => ({ item, index, score: score(query, item) }))
+    .filter((entry) => entry.score >= 0)
+    .sort((a, b) => b.score - a.score || a.index - b.index)
+    .map((entry) => entry.item)
+}

package/src/git.js

@@ -0,0 +1,156 @@
+import { spawn } from 'node:child_process'
+import { readFileSync, statSync, watch } from 'node:fs'
+import { dirname, isAbsolute, join, resolve } from 'node:path'
+
+const DEBOUNCE_MS = 500
+const POLL_MS = 15000
+const GIT_TIMEOUT_MS = 5000
+
+function findGitDir(startDir) {
+  let dir = startDir
+  while (true) {
+    const candidate = join(dir, '.git')
+    try {
+      const info = statSync(candidate)
+      if (info.isDirectory()) return candidate
+      const text = readFileSync(candidate, 'utf-8')
+      const match = text.match(/^gitdir:\s*(.+?)\s*$/m)
+      if (match) return isAbsolute(match[1]) ? match[1] : resolve(dir, match[1])
+    } catch {}
+    const parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+function readBranch(gitDir) {
+  try {
+    const head = readFileSync(join(gitDir, 'HEAD'), 'utf-8').trim()
+    const ref = head.match(/^ref: refs\/heads\/(.+)$/)
+    return ref ? ref[1] : head.slice(0, 7)
+  } catch {
+    return null
+  }
+}
+
+function parseShortstat(output) {
+  const added = output.match(/(\d+) insertion/)
+  const removed = output.match(/(\d+) deletion/)
+  return {
+    added: added ? Number(added[1]) : 0,
+    removed: removed ? Number(removed[1]) : 0,
+  }
+}
+
+export function createGitService({ onChange = () => {} } = {}) {
+  let enabled = false
+  let root = null
+  let gitDir = null
+  let epoch = 0
+  let watcher = null
+  let poll = null
+  let debounce = null
+  let child = null
+  let rerun = false
+  let current = null
+
+  function teardown() {
+    epoch += 1
+    watcher?.close()
+    watcher = null
+    if (poll) clearInterval(poll)
+    poll = null
+    if (debounce) clearTimeout(debounce)
+    debounce = null
+    child?.kill('SIGKILL')
+    child = null
+    rerun = false
+    if (current) {
+      current = null
+      onChange()
+    }
+  }
+
+  function setup() {
+    teardown()
+    if (!enabled || !root) return
+    gitDir = findGitDir(root)
+    if (!gitDir) return
+    const started = epoch
+    try {
+      watcher = watch(gitDir, () => {
+        if (epoch === started) refresh()
+      })
+      watcher.on('error', () => {})
+    } catch {
+      watcher = null
+    }
+    poll = setInterval(run, POLL_MS)
+    poll.unref?.()
+    run()
+  }
+
+  function refresh() {
+    if (!enabled || !gitDir || debounce) return
+    debounce = setTimeout(() => {
+      debounce = null
+      run()
+    }, DEBOUNCE_MS)
+    debounce.unref?.()
+  }
+
+  function run() {
+    if (!enabled || !gitDir || !root) return
+    if (child) {
+      rerun = true
+      return
+    }
+    const started = epoch
+    const branch = readBranch(gitDir)
+    const proc = spawn('git', ['--no-optional-locks', 'diff', 'HEAD', '--shortstat'], {
+      cwd: root,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+    child = proc
+    let output = ''
+    proc.stdout.on('data', (chunk) => {
+      output += chunk
+    })
+    const timeout = setTimeout(() => proc.kill('SIGKILL'), GIT_TIMEOUT_MS)
+    timeout.unref?.()
+    let finished = false
+    const done = (code) => {
+      if (finished) return
+      finished = true
+      clearTimeout(timeout)
+      if (child === proc) child = null
+      if (epoch !== started) return
+      const stats = code === 0 ? parseShortstat(output) : { added: 0, removed: 0 }
+      const next = branch ? { branch, ...stats } : null
+      if (JSON.stringify(next) !== JSON.stringify(current)) {
+        current = next
+        onChange()
+      }
+      if (rerun) {
+        rerun = false
+        refresh()
+      }
+    }
+    proc.on('close', done)
+    proc.on('error', () => done(-1))
+  }
+
+  return {
+    status: () => current,
+    refresh,
+    retarget(nextRoot) {
+      root = nextRoot
+      setup()
+    },
+    setEnabled(value) {
+      enabled = value === true
+      setup()
+    },
+    dispose: teardown,
+  }
+}

package/src/history.js

@@ -0,0 +1,51 @@
+import { appendFile, readFile, readdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { picoHome, projectDir, projectHistoryFile, ensureDir } from './paths.js'
+
+const MAX_PROMPTS_PER_SCOPE = 1000
+
+export async function appendPrompt(root, text) {
+  ensureDir(projectDir(root))
+  await appendFile(projectHistoryFile(root), JSON.stringify({ text, at: Date.now() }) + '\n')
+}
+
+function parsePromptLines(text) {
+  return text
+    .split('\n')
+    .map((line) => {
+      try {
+        return line.trim() ? JSON.parse(line) : null
+      } catch {
+        return null
+      }
+    })
+    .filter(Boolean)
+}
+
+async function readPrompts(file, scope) {
+  try {
+    const entries = parsePromptLines(await readFile(file, 'utf-8'))
+    return entries
+      .filter((e) => typeof e.text === 'string' && e.text.trim())
+      .slice(-MAX_PROMPTS_PER_SCOPE)
+      .map((e) => ({ text: e.text, at: e.at || 0, scope }))
+  } catch {
+    return []
+  }
+}
+
+export function loadProjectPrompts(root) {
+  return readPrompts(projectHistoryFile(root), 'project')
+}
+
+export async function loadGlobalPrompts() {
+  const projectsDir = join(picoHome(), 'projects')
+  let projects = []
+  try {
+    projects = await readdir(projectsDir)
+  } catch {}
+  const nested = await Promise.all(
+    projects.map((p) => readPrompts(join(projectsDir, p, 'history.jsonl'), 'everywhere')),
+  )
+  return nested.flat().sort((a, b) => b.at - a.at).slice(0, MAX_PROMPTS_PER_SCOPE)
+}

package/src/init.js

@@ -0,0 +1,25 @@
+export const INIT_PROMPT = `Initialize or improve this repository's AGENTS.md guidance for future pico sessions.
+
+Do this discovery yourself as the main agent. Do not call agent_plan, agent_start, agent_list, agent_collect, or delegate any part of this task to another agent.
+
+Inspect the repository directly and then create or update its AGENTS.md files. Read enough of the actual project to understand its structure and workflows, including the relevant manifests, documentation, configuration, source layout, tests, scripts, and existing instruction files. Use targeted searches and representative files rather than exhaustively reading every file. If an AGENTS.md already exists, preserve useful human-authored guidance and improve it conservatively instead of replacing it blindly. Check CLAUDE.md files for useful repository guidance when relevant, but write canonical guidance to AGENTS.md.
+
+Write instructions that help an agent work correctly in this specific repository. Capture only durable, non-obvious information such as:
+
+- the project's purpose and high-level architecture
+- important module boundaries and data flow
+- authoritative build, test, lint, typecheck, and development commands
+- repository-specific conventions and constraints
+- where and how to add common kinds of changes
+- validation expectations and operational gotchas
+
+Keep the root AGENTS.md concise: aim for 100-200 lines or roughly 1,000-2,000 tokens, and treat about 3,000 tokens as a hard default ceiling. This is guidance, not generated documentation. Prefer terse sections and bullets. Omit generic programming advice, exhaustive directory listings, dependency inventories, and facts that are obvious from standard files or easy to rediscover. Do not speculate or document claims you have not verified.
+
+If materially different subtrees need scoped instructions, put focused AGENTS.md files in those subtrees instead of expanding the root file. Create them only when they reduce total context and contain genuinely local guidance; do not fragment the instructions unnecessarily or duplicate the root file. Remember that a nested file augments the root instructions for work in that subtree.
+
+Make the edits in this invocation, then briefly summarize which AGENTS.md files you created or changed and what you verified.`
+
+export function initPrompt(args = '') {
+  const request = args.trim()
+  return request ? `${INIT_PROMPT}\n\nAdditional request from the user:\n${request}` : INIT_PROMPT
+}

package/src/keys.js

@@ -0,0 +1,26 @@
+import { setKeys } from '@prsm/ai'
+
+const PROVIDERS = [
+  { id: 'google', label: 'Gemini', env: ['GEMINI_API_KEY', 'GOOGLE_AI_API_KEY'] },
+  { id: 'anthropic', label: 'Claude', env: ['ANTHROPIC_API_KEY'] },
+  { id: 'openai', label: 'OpenAI', env: ['OPENAI_API_KEY'] },
+  { id: 'xai', label: 'Grok', env: ['XAI_API_KEY'] },
+]
+
+export function discoverKeys(env = process.env) {
+  const keys = {}
+  for (const p of PROVIDERS) {
+    const name = p.env.find((n) => env[n])
+    if (name) keys[p.id] = env[name]
+  }
+  return keys
+}
+
+export function applyKeys(keys) {
+  setKeys(keys)
+  return Object.keys(keys)
+}
+
+export function keyHint(providerId) {
+  return PROVIDERS.find((p) => p.id === providerId)?.env[0] || `${providerId.toUpperCase()}_API_KEY`
+}

package/src/mcp.js

@@ -0,0 +1,280 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { connectMCP } from '@prsm/ai'
+import { globalMcpFile, projectMcpFile, projectDir, ensureDir, picoHome } from './paths.js'
+
+function tokenize(str) {
+  const tokens = []
+  const re = /([A-Za-z0-9_-]+=)?"([^"]*)"|([A-Za-z0-9_-]+=)?'([^']*)'|(\S+)/g
+  let m
+  while ((m = re.exec(str))) {
+    if (m[1] !== undefined || m[3] !== undefined) tokens.push((m[1] ?? m[3]) + (m[2] ?? m[4]))
+    else tokens.push(m[2] ?? m[4] ?? m[5])
+  }
+  return tokens
+}
+
+export function parseCommand(str) {
+  const tokens = tokenize(str)
+
+  const env = {}
+  while (tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[0])) {
+    const sep = tokens[0].indexOf('=')
+    env[tokens[0].slice(0, sep)] = tokens[0].slice(sep + 1)
+    tokens.shift()
+  }
+  if (!tokens.length) throw new Error('empty command')
+  return { command: tokens[0], args: tokens.slice(1), env }
+}
+
+export function parseServerSpec(str) {
+  const tokens = tokenize(str)
+  if (!/^https?:\/\//.test(tokens[0] || '')) return { type: 'stdio', ...parseCommand(str) }
+
+  const [url, ...rest] = tokens
+  const headers = {}
+  for (const token of rest) {
+    const sep = token.indexOf('=')
+    if (sep < 1) throw new Error(`http server spec only takes a url and Header=value pairs, got "${token}"`)
+    headers[token.slice(0, sep)] = token.slice(sep + 1)
+  }
+  return { type: 'http', url, headers }
+}
+
+export const REDACTED_HEADER = '••••••••'
+
+export function isSensitiveHeader(name) {
+  return /^(authorization|proxy-authorization|cookie|set-cookie|x-api-key|api-key|token|secret)$/i.test(name)
+}
+
+function quoteHeaderValue(value) {
+  if (!/[\s'"\\]/.test(value)) return value
+  if (!value.includes('"')) return `"${value}"`
+  if (!value.includes("'")) return `'${value}'`
+  throw new Error('header values cannot contain both single and double quotes')
+}
+
+export function formatHttpServerSpec(url, headers) {
+  const values = Object.entries(headers).map(([name, value]) => `${name}=${quoteHeaderValue(value)}`)
+  return [url, ...values].join(' ')
+}
+
+export function redactServerSpec(command) {
+  let spec
+  try {
+    spec = parseServerSpec(command)
+  } catch {
+    return command
+  }
+  if (spec.type !== 'http') return command
+  const headers = Object.fromEntries(Object.entries(spec.headers).map(([name, value]) => [name, isSensitiveHeader(name) ? REDACTED_HEADER : value]))
+  return formatHttpServerSpec(spec.url, headers)
+}
+
+async function readJson(file, fallback) {
+  try {
+    return JSON.parse(await readFile(file, 'utf-8'))
+  } catch {
+    return fallback
+  }
+}
+
+export function readRegistry() {
+  return readJson(globalMcpFile(), { servers: {} })
+}
+
+export async function writeRegistry(registry) {
+  ensureDir(picoHome())
+  await writeFile(globalMcpFile(), JSON.stringify(registry, null, 2) + '\n')
+}
+
+export async function readProjectConfig(root) {
+  const config = await readJson(projectMcpFile(root), {})
+  return { disabled: config.disabled || {}, servers: config.servers || {} }
+}
+
+export async function writeProjectConfig(root, config) {
+  ensureDir(projectDir(root))
+  await writeFile(projectMcpFile(root), JSON.stringify(config, null, 2) + '\n')
+}
+
+export async function createMcpTransport(command) {
+  const spec = parseServerSpec(command)
+  if (spec.type === 'http') {
+    const { StreamableHTTPClientTransport } = await import('@modelcontextprotocol/sdk/client/streamableHttp.js')
+    const fetch = (url, init) => init?.method === 'GET'
+      ? Promise.resolve(new Response(null, { status: 405 }))
+      : globalThis.fetch(url, init)
+    return new StreamableHTTPClientTransport(new URL(spec.url), {
+      requestInit: Object.keys(spec.headers).length ? { headers: spec.headers } : undefined,
+      fetch,
+    })
+  }
+  const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js')
+  return new StdioClientTransport({
+    command: spec.command,
+    args: spec.args,
+    env: { ...process.env, ...spec.env },
+    stderr: 'pipe',
+  })
+}
+
+export async function createMcpRuntime({ root, onChange = () => {} }) {
+  const registry = await readRegistry()
+  const projectConfig = await readProjectConfig(root)
+  const servers = new Map()
+
+  const register = (name, command, scope) => {
+    servers.set(name, {
+      name,
+      command,
+      scope,
+      enabled: !projectConfig.disabled[name],
+      status: projectConfig.disabled[name] ? 'disabled' : 'idle',
+      error: null,
+      connection: null,
+      transport: null,
+    })
+  }
+  for (const [name, command] of Object.entries(registry.servers)) register(name, command, 'global')
+  for (const [name, command] of Object.entries(projectConfig.servers)) register(name, command, 'project')
+
+  async function connect(name) {
+    const server = servers.get(name)
+    if (!server) return
+    server.status = 'connecting'
+    server.error = null
+    onChange()
+    try {
+      server.transport = await createMcpTransport(server.command)
+      server.connection = await connectMCP({
+        name,
+        transport: () => server.transport,
+      })
+      server.status = 'connected'
+    } catch (err) {
+      server.status = 'error'
+      server.error = String(err.message || err).slice(0, 300)
+      server.connection = null
+      server.transport = null
+    }
+    onChange()
+  }
+
+  async function disconnect(name) {
+    const server = servers.get(name)
+    if (server?.connection) {
+      await server.connection.close().catch(() => {})
+      server.connection = null
+    }
+  }
+
+  return {
+    connectAll() {
+      const pending = []
+      for (const server of servers.values()) {
+        if (server.enabled) pending.push(connect(server.name))
+      }
+      return Promise.allSettled(pending)
+    },
+    async add(name, command, scope = 'global') {
+      if (scope === 'project') {
+        const config = await readProjectConfig(root)
+        config.servers[name] = command
+        await writeProjectConfig(root, config)
+      } else {
+        const registry = await readRegistry()
+        registry.servers[name] = command
+        await writeRegistry(registry)
+      }
+      servers.set(name, { name, command, scope, enabled: true, status: 'idle', error: null, connection: null, transport: null })
+      await connect(name)
+    },
+    async update(name, command) {
+      const server = servers.get(name)
+      if (!server) return
+      if (server.scope === 'project') {
+        const config = await readProjectConfig(root)
+        config.servers[name] = command
+        await writeProjectConfig(root, config)
+      } else {
+        const registry = await readRegistry()
+        registry.servers[name] = command
+        await writeRegistry(registry)
+      }
+      await disconnect(name)
+      server.command = command
+      server.status = server.enabled ? 'idle' : 'disabled'
+      server.error = null
+      onChange()
+      if (server.enabled) await connect(name)
+    },
+    async remove(name) {
+      const scope = servers.get(name)?.scope
+      if (scope === 'project') {
+        const config = await readProjectConfig(root)
+        delete config.servers[name]
+        await writeProjectConfig(root, config)
+      } else {
+        const registry = await readRegistry()
+        delete registry.servers[name]
+        await writeRegistry(registry)
+      }
+      await disconnect(name)
+      servers.delete(name)
+      onChange()
+    },
+    async toggle(name) {
+      const server = servers.get(name)
+      if (!server) return
+      const config = await readProjectConfig(root)
+      if (server.enabled) {
+        // flip the visible state first: a slow-closing server (headless
+        // browsers, heavy processes) must not make disable feel dead
+        server.enabled = false
+        server.status = 'disabled'
+        onChange()
+        config.disabled[name] = true
+        await writeProjectConfig(root, config)
+        disconnect(name).catch(() => {})
+      } else {
+        server.enabled = true
+        delete config.disabled[name]
+        await writeProjectConfig(root, config)
+        await connect(name)
+      }
+    },
+    reconnect(name) {
+      return disconnect(name).then(() => connect(name))
+    },
+    list() {
+      return [...servers.values()].map((s) => ({
+        name: s.name,
+        command: s.command,
+        scope: s.scope,
+        enabled: s.enabled,
+        status: s.status,
+        error: s.error,
+        toolCount: s.connection?.tools.length || 0,
+        tools: (s.connection?.tools || []).map((t) => ({ name: t.name, description: t.description || '' })),
+      }))
+    },
+    tools() {
+      return [...servers.values()]
+        .filter((s) => s.connection)
+        .flatMap((s) => s.connection.tools)
+    },
+    closeAll() {
+      return Promise.allSettled([...servers.keys()].map(disconnect))
+    },
+    terminateAll() {
+      for (const server of servers.values()) {
+        const pid = server.transport?.pid
+        if (pid) {
+          try {
+            process.kill(pid, 'SIGTERM')
+          } catch {}
+        }
+      }
+    },
+  }
+}

package/src/memory.js

@@ -0,0 +1,120 @@
+import { readFile, readdir, writeFile, mkdir, unlink, rename, access } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+import { picoHome, projectDir } from './paths.js'
+import { parseFrontmatter } from './skills.js'
+
+export function globalMemoryDir() {
+  return join(picoHome(), 'memory')
+}
+
+export function projectMemoryDir(root) {
+  return join(projectDir(root), 'memory')
+}
+
+export function slugify(name) {
+  const slug = String(name)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60)
+  if (!slug) throw new Error('memory name must contain letters or numbers')
+  return slug
+}
+
+async function scanDir(dir, scope) {
+  let names = []
+  try {
+    names = await readdir(dir)
+  } catch {
+    return []
+  }
+  const memories = []
+  for (const file of names) {
+    if (!file.endsWith('.md')) continue
+    const disabled = file.startsWith('_')
+    const filename = disabled ? file.slice(1) : file
+    try {
+      const { meta, body } = parseFrontmatter(await readFile(join(dir, file), 'utf-8'))
+      memories.push({
+        name: meta.name || filename.slice(0, -3),
+        description: meta.description || '',
+        scope,
+        file: join(dir, file),
+        body: body.trim(),
+        disabled,
+      })
+    } catch {}
+  }
+  return memories
+}
+
+export function createMemory(root) {
+  const dirFor = (scope) => (scope === 'global' ? globalMemoryDir() : projectMemoryDir(root))
+
+  return {
+    async list() {
+      const global = await scanDir(globalMemoryDir(), 'global')
+      const project = await scanDir(projectMemoryDir(root), 'project')
+      return [...project, ...global].sort((a, b) =>
+        a.name.localeCompare(b.name) || Number(a.disabled) - Number(b.disabled) || a.scope.localeCompare(b.scope),
+      )
+    },
+    async remember({ name, description, content, scope = 'project' }) {
+      if (!['project', 'global'].includes(scope)) throw new Error('scope must be project or global')
+      const slug = slugify(name)
+      const dir = dirFor(scope)
+      await mkdir(dir, { recursive: true })
+      const file = join(dir, `${slug}.md`)
+      const text = `---\nname: ${slug}\ndescription: ${String(description).replace(/\n/g, ' ')}\n---\n${content}\n`
+      await writeFile(file, text, 'utf-8')
+      return { name: slug, scope, file }
+    },
+    async forget(target) {
+      const memories = await this.list()
+      const memory = typeof target === 'string'
+        ? memories.find((m) => m.name === target && !m.disabled)
+        : memories.find((m) => m.file === target.file)
+      if (!memory) throw new Error(`no memory named "${typeof target === 'string' ? target : target.name}"`)
+      await unlink(memory.file)
+      return { name: memory.name, scope: memory.scope }
+    },
+    async setDisabled(target, disabled) {
+      const memories = await this.list()
+      const memory = memories.find((m) => m.file === target.file)
+      if (!memory) throw new Error(`no memory named "${target.name}"`)
+      if (memory.disabled === disabled) return memory
+      const filename = basename(memory.file)
+      const destination = join(dirname(memory.file), disabled ? `_${filename}` : filename.slice(1))
+      try {
+        await access(destination)
+        throw new Error(`cannot ${disabled ? 'disable' : 'enable'} "${memory.name}": ${basename(destination)} already exists`)
+      } catch (err) {
+        if (err.code !== 'ENOENT') throw err
+      }
+      await rename(memory.file, destination)
+      return { ...memory, file: destination, disabled }
+    },
+    async recall(name) {
+      const memories = await this.list()
+      const active = memories.filter((m) => !m.disabled)
+      const memory = active.find((m) => m.name === name)
+      if (!memory) {
+        const known = active.map((m) => m.name).join(', ') || 'none'
+        throw new Error(`no memory named "${name}"; known memories: ${known}`)
+      }
+      return { name: memory.name, scope: memory.scope, file: memory.file, content: memory.body }
+    },
+  }
+}
+
+export function memoryIndex(memories, root) {
+  const active = memories.filter((m) => !m.disabled)
+  if (active.length === 0) {
+    return `You have no saved memories yet. This index lists them when you save durable facts with the remember tool; answer questions about your memories from this index alone, without searching the filesystem.`
+  }
+  const lines = active.map((m) => `- ${m.name} (${m.scope}): ${m.description}`)
+  return [
+    `Memories you have saved. This index is complete: answer questions about your memories from it directly, load one with the recall tool when its content is relevant, and never search the filesystem for memories. The files live in ${projectMemoryDir(root)} and ${globalMemoryDir()} and can be edited or deleted with ordinary tools when asked to curate them.`,
+    ...lines,
+  ].join('\n')
+}