picocode-core 0.9.119

package/src/tools/web.js

@@ -0,0 +1,84 @@
+const DEFAULT_SLICE_CHARS = 24000
+const MAX_SLICE_CHARS = 100000
+
+export function resolveDredge(config = {}, env = process.env) {
+  const url = env.DREDGE_URL || config.dredge?.url || null
+  if (!url) return null
+  return {
+    url: url.replace(/\/+$/, ''),
+    apiKey: env.DREDGE_API_KEY || config.dredge?.apiKey || null,
+  }
+}
+
+const CALL_TIMEOUT_MS = 120000
+
+async function call(dredge, path, params, signal) {
+  const query = new URLSearchParams(params)
+  // bounded above dredge's own 90s queue ceiling so a wedged server becomes
+  // a tool error instead of a hung turn
+  const signals = [AbortSignal.timeout(CALL_TIMEOUT_MS), ...(signal ? [signal] : [])]
+  const response = await fetch(`${dredge.url}${path}?${query}`, {
+    signal: AbortSignal.any(signals),
+    headers: dredge.apiKey ? { authorization: `Bearer ${dredge.apiKey}` } : {},
+  })
+  const body = await response.json().catch(() => null)
+  if (!body) throw new Error(`dredge returned http ${response.status} with no usable body`)
+  return body
+}
+
+export function createWebTools({ dredge, recorder, signal }) {
+  return [
+    {
+      name: 'web_search',
+      description:
+        'Search the web. Google-style operators work: site:, filetype:pdf, quoted phrases. Returns ranked results; pass a result url to web_fetch to read it.',
+      schema: {
+        q: { type: 'string', description: 'the search query' },
+        description: { type: 'string', description: 'briefly explain what this search is intended to find, shown to the human watching' },
+      },
+      execute: async ({ q }) => {
+        recorder.extra({ title: q })
+        const body = await call(dredge, '/search', { q }, signal)
+        if (!body.ok) throw new Error(body.error?.message || 'search failed')
+        const results = (body.results || []).map((r) => ({
+          title: r.title,
+          url: r.url,
+          snippet: r.snippet,
+          source: r.source,
+        }))
+        if (results.length === 0) {
+          const backends = (body.backends || []).map((b) => `${b.name}: ${b.status}`).join(', ')
+          return { results, note: backends ? `no results · backends: ${backends}` : 'no results' }
+        }
+        return { results }
+      },
+    },
+    {
+      name: 'web_fetch',
+      description:
+        'Fetch a url and read it as clean markdown (html, pdf, docx, and textual formats like json). Long documents arrive in slices: the result says which slice you have (e.g. "slice 1 of 12") and next_cursor continues from there. Every slice you fetch permanently occupies conversation context, so only walk cursors for content you actually need, and raise maxChars only when the task genuinely needs a bigger window.',
+      schema: {
+        url: { type: 'string', description: 'the url to fetch' },
+        cursor: { type: 'string', description: 'pagination cursor from a previous web_fetch of the same url', optional: true },
+        maxChars: { type: 'number', description: `slice size in characters, default ${DEFAULT_SLICE_CHARS}, max ${MAX_SLICE_CHARS}`, optional: true },
+      },
+      execute: async ({ url, cursor, maxChars }) => {
+        recorder.extra({ title: url.replace(/^https?:\/\//, '').slice(0, 80) })
+        const slice = Math.min(MAX_SLICE_CHARS, Math.max(1000, maxChars || DEFAULT_SLICE_CHARS))
+        const body = await call(dredge, '/fetch', { url, maxChars: slice, ...(cursor && { cursor }) }, signal)
+        if (!body.ok) {
+          const { code, message, retryable } = body.error || {}
+          throw new Error(`${code || 'fetch failed'}: ${message || url}${retryable ? ' (retryable)' : ''}`)
+        }
+        const { markdown, metadata, pagination } = body.doc
+        return {
+          markdown,
+          title: metadata?.title || null,
+          finalUrl: metadata?.final_url || url,
+          ...(pagination?.total_chunks > 1 && { slice: `${pagination.chunk_index + 1} of ${pagination.total_chunks}` }),
+          ...(pagination?.next_cursor && { next_cursor: pagination.next_cursor }),
+        }
+      },
+    },
+  ]
+}

package/src/tools/write.js

@@ -0,0 +1,48 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { makeWriteEdit } from '../reversible-edit.js'
+import { makeDiff } from './diff.js'
+
+export function createWrite({ cwd, recorder, tracker }) {
+  return {
+    name: 'write',
+    description: 'Write content to a file, creating it and any parent directories if needed. Overwrites existing content.',
+    schema: {
+      description: { type: 'string', description: 'briefly explain why this tool call is needed, shown to the human watching' },
+      path: { type: 'string', description: 'file path, relative to the working directory or absolute' },
+      content: { type: 'string', description: 'the full file content to write' },
+    },
+    execute: async ({ path, content }) => {
+      const full = resolve(cwd, path)
+      recorder.extra({ title: path })
+      await mkdir(dirname(full), { recursive: true })
+      let before = null
+      try {
+        before = await readFile(full, 'utf-8')
+      } catch (err) {
+        if (err.code !== 'ENOENT') throw err
+      }
+
+      if (before === content) {
+        return { ok: true, path, unchanged: true, note: 'file already had exactly this content' }
+      }
+      await writeFile(full, content, 'utf-8')
+
+      const result = { ok: true, path }
+      if (before !== null) {
+        const diff = makeDiff(path, before, content)
+        recorder.extra({ diff, revert: makeWriteEdit(full, before, content, true) })
+        result.additions = diff.additions
+        result.deletions = diff.deletions
+      } else {
+        const diff = makeDiff(path, '', content)
+        recorder.extra({ diff, revert: makeWriteEdit(full, '', content, false), created: true })
+        result.additions = diff.additions
+        result.created = true
+      }
+      const context = tracker.check(full)
+      if (context.length) result.context_from_agents_md = context
+      return result
+    },
+  }
+}

package/src/update.js

@@ -0,0 +1,82 @@
+import { exec } from 'node:child_process'
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { picoHome, ensureDir } from './paths.js'
+
+const CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000
+const REGISTRY_URL = 'https://registry.npmjs.org/picocode/latest'
+
+function stateFile() {
+  return join(picoHome(), 'update-check.json')
+}
+
+async function readState() {
+  try {
+    return JSON.parse(await readFile(stateFile(), 'utf-8'))
+  } catch {
+    return {}
+  }
+}
+
+async function writeState(patch) {
+  const state = { ...(await readState()), ...patch }
+  ensureDir(picoHome())
+  await writeFile(stateFile(), JSON.stringify(state) + '\n')
+}
+
+export async function fetchLatestVersion({ timeoutMs = 5000 } = {}) {
+  if (process.env.PICO_FAKE_LATEST) return process.env.PICO_FAKE_LATEST
+  const response = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(timeoutMs) })
+  const body = await response.json()
+  return body.version || null
+}
+
+export function newerVersion(current, latest) {
+  if (!latest || latest === current) return null
+  const parse = (v) => String(v).split('.').map((n) => parseInt(n, 10) || 0)
+  const cur = parse(current)
+  const next = parse(latest)
+  for (let i = 0; i < 3; i++) {
+    if ((next[i] ?? 0) > (cur[i] ?? 0)) return latest
+    if ((next[i] ?? 0) < (cur[i] ?? 0)) return null
+  }
+  return null
+}
+
+// at most one registry hit per interval, one notification per version, all
+// failures silent: an update check must never cost the session anything.
+// PICO_FAKE_LATEST bypasses cadence and memory so the toast can be demoed
+export async function checkForUpdate(currentVersion) {
+  const fake = !!process.env.PICO_FAKE_LATEST
+  const state = await readState()
+  if (!fake && state.lastCheck && Date.now() - state.lastCheck < CHECK_INTERVAL_MS) return null
+
+  let latest = null
+  try {
+    latest = await fetchLatestVersion()
+  } catch {
+    return null
+  } finally {
+    if (!fake) await writeState({ lastCheck: Date.now() }).catch(() => {})
+  }
+
+  const newer = newerVersion(currentVersion, latest)
+  if (!newer) return null
+  if (!fake && state.notifiedVersion === newer) return null
+  return {
+    version: newer,
+    markNotified: () => (fake ? Promise.resolve() : writeState({ notifiedVersion: newer }).catch(() => {})),
+  }
+}
+
+export function isDevInstall(entryUrl) {
+  return !String(entryUrl).includes('/node_modules/')
+}
+
+export function runUpdate() {
+  return new Promise((resolve) => {
+    exec('npm install -g picocode@latest', { timeout: 180000 }, (err, stdout, stderr) => {
+      resolve({ ok: !err, output: [stdout, stderr].filter(Boolean).join('\n').trim().slice(0, 400) })
+    })
+  })
+}

package/src/user-tools.js

@@ -0,0 +1,59 @@
+import { readdir, stat } from 'node:fs/promises'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { picoHome } from './paths.js'
+
+export function globalToolsDir() {
+  return join(picoHome(), 'tools')
+}
+
+export function projectToolsDir(root) {
+  return join(root, '.pico', 'tools')
+}
+
+function validate(tool, file) {
+  if (!tool || typeof tool !== 'object') throw new Error('default export is not a tool object')
+  if (typeof tool.name !== 'string' || !tool.name) throw new Error('tool.name must be a string')
+  if (typeof tool.description !== 'string') throw new Error('tool.description must be a string')
+  if (typeof tool.execute !== 'function') throw new Error('tool.execute must be a function')
+  if (!tool.schema || typeof tool.schema !== 'object') throw new Error('tool.schema must be an object')
+  return { ...tool, _file: file }
+}
+
+async function loadTool(file, context) {
+  const { mtimeMs } = await stat(file)
+  const module = await import(`${pathToFileURL(file).href}?v=${mtimeMs}`)
+  const exported = module.default
+  const tool = typeof exported === 'function' ? await exported(context) : exported
+  return validate(tool, file)
+}
+
+async function scanDir(dir, context, source) {
+  let names = []
+  try {
+    names = await readdir(dir)
+  } catch {
+    return { tools: [], errors: [] }
+  }
+  const tools = []
+  const errors = []
+  for (const name of names) {
+    if (!name.endsWith('.js') && !name.endsWith('.mjs')) continue
+    const file = join(dir, name)
+    try {
+      tools.push({ ...(await loadTool(file, context)), source })
+    } catch (err) {
+      errors.push({ file, error: String(err.message || err).slice(0, 200) })
+    }
+  }
+  return { tools, errors }
+}
+
+export async function scanUserTools({ cwd, root }) {
+  const context = { cwd, root }
+  const global = await scanDir(globalToolsDir(), context, 'global')
+  const project = await scanDir(projectToolsDir(root), context, 'project')
+  const byName = new Map()
+  for (const tool of [...global.tools, ...project.tools]) byName.set(tool.name, tool)
+  return { tools: [...byName.values()], errors: [...global.errors, ...project.errors] }
+}

package/src/wakeups.js

@@ -0,0 +1,40 @@
+export function createWakeupManager({ onFire = () => {}, onChange = () => {} } = {}) {
+  const wakeups = new Map()
+  let nextId = 1
+
+  return {
+    schedule(delaySeconds, note) {
+      const seconds = Math.max(5, Math.round(delaySeconds))
+      const id = String(nextId++)
+      const at = Date.now() + seconds * 1000
+      const timer = setTimeout(() => {
+        wakeups.delete(id)
+        onChange()
+        onFire({ id, note, at })
+      }, seconds * 1000)
+      wakeups.set(id, { id, note, at, timer })
+      onChange()
+      return { id, at, seconds }
+    },
+    cancel(id) {
+      const wakeup = wakeups.get(String(id))
+      if (!wakeup) throw new Error(`no pending wake-up with id ${id}`)
+      clearTimeout(wakeup.timer)
+      wakeups.delete(String(id))
+      onChange()
+      return { id: wakeup.id, cancelled: true }
+    },
+    list() {
+      return [...wakeups.values()]
+        .map(({ id, note, at }) => ({ id, note, at }))
+        .sort((a, b) => a.at - b.at)
+    },
+    pending() {
+      return wakeups.size
+    },
+    cancelAll() {
+      for (const wakeup of wakeups.values()) clearTimeout(wakeup.timer)
+      wakeups.clear()
+    },
+  }
+}