heartcode 0.1.14 → 0.1.24

package/src/client.js

@@ -18,6 +18,13 @@ export function estMessages(messages) {
   const text = JSON.stringify(messages ?? [], (k, v) => (k === 'url' && typeof v === 'string' && v.startsWith('data:') ? (images++, '') : v))
   return est(text) + images * 800
 }
+// A request's size in a model's tokens, estimated: its messages and tools, by that model's ratio of
+// counted to estimated tokens (context.js). The same measure decides when to compact (agent.js) and
+// whether a request fits the model the list moves on to.
+export const tokensOf = (messages, tools, ratio = 1) => Math.round((estMessages(messages) + (tools?.length ? est(JSON.stringify(tools)) : 0)) * ratio)
+// The share of a model's window a conversation may take: the rest is room for the reply. Past it,
+// the conversation is compacted first.
+export const COMPACT_SHARE = 0.85
 
 // "Request too large" (the context window, or a provider's per-request or per-minute input cap):
 // the same request can never work, so it isn't retried; the caller sends less. Returns the
@@ -136,7 +143,7 @@ export function fitFor(messages, can, model) {
 // Refusals a provider may make of one part of a request, learned when sending it without that
 // part works (then kept in the model's profile for a day): temperature, reasoning_effort, the
 // usage in a stream, the thinking sent back, the tools' full schemas, images.
-export const QUIRKS = ['noTemperature', 'noEffort', 'noStreamUsage', 'noReasoningBack', 'simpleSchemas', 'noImages']
+export const QUIRKS = ['noTemperature', 'noEffort', 'noStreamUsage', 'noReasoningBack', 'simpleSchemas', 'noImages', 'noParallel']
 
 export class Client {
   constructor({ baseUrl, apiKey, model, provider, timeout = 600_000 } = {}) {
@@ -402,6 +409,7 @@ export class Client {
   // 60s, or the server's Retry-After) until it works or the signal aborts. onRetry(error, ms,
   // attempt) reports each wait; onRetry(null) reports the recovery.
   async chat(body, opts = {}) {
+    this.refresh?.() // the settings and this model's profile as they are now (bin/heartcode.js)
     if (!this.onRetry) {
       return await this.#timed(body, opts)
     }
@@ -412,9 +420,15 @@ export class Client {
     const tried = new Set() // places in the model list tried for this request
     const down = new Set() // providers that answered it with an error (400 or above): their other models are skipped
     for (let attempt = 0; ; attempt++) {
+      // The list moved on to a model whose window can't hold this request (a smaller one): not sent
+      // to it as it is; the caller compacts the conversation for that model, then sends it (fit: the
+      // caller can; agent.js).
+      if (attempt && opts.fit && this.can?.context && tokensOf(body.messages, body.tools, this.tokenRatio) > this.can.context * COMPACT_SHARE) {
+        throw Object.assign(new Error(`the conversation is too big for ${this.provider} · ${this.model} (~${tokensOf(body.messages, body.tools, this.tokenRatio)} tokens; its window is ${this.can.context})`), { tooBig: true })
+      }
+      if (attempt) this.onRetry(null) // the wait is over and the retried request is starting: drop the countdown, back to the normal spinner
       try {
         const r = await this.#timed(body, { ...opts, once: true })
-        if (attempt) this.onRetry(null)
         const rot = this.rotation
         if (rot && rot.good !== rot.list[rot.at]) this.onSwitch?.((rot.good = rot.list[rot.at]))
         return r
@@ -482,6 +496,7 @@ export class Client {
     if (this.quirks.noTemperature) delete req.temperature
     if (this.effort && !this.quirks.noEffort) req.reasoning_effort = this.effort
     if (req.stream && !this.quirks.noStreamUsage) req.stream_options = { include_usage: true } // token counts for the status bar
+    if (req.tools?.length && !this.quirks.noParallel) req.parallel_tool_calls = true // several calls in one reply (llama.cpp's default is one)
     let res
     let sent
     let firstAt
@@ -539,11 +554,13 @@ export class Client {
       if (/temperature/i.test(said) && 'temperature' in req && !this.quirks.noTemperature) return without('noTemperature')
       if (/reasoning_effort/.test(said) && 'reasoning_effort' in req && !this.quirks.noEffort) return without('noEffort')
       if (/stream_options/.test(said) && req.stream_options && !this.quirks.noStreamUsage) return without('noStreamUsage')
+      if (/parallel_tool_calls/.test(said) && req.parallel_tool_calls && !this.quirks.noParallel) return without('noParallel')
       if (reasoningSent && /reasoning(?!_effort)/i.test(said)) return without('noReasoningBack')
       if (imagesSent && /image|vision|multimodal|modalit|content.{0,20}(type|part)/i.test(said)) return without('noImages')
       if (req.tools?.length && !this.quirks.simpleSchemas && /schema|function_declarations|parameters|additionalProperties|exclusiveM|minItems|unknown name|invalid.{0,40}(tool|function)|tools\[/i.test(said)) return without('simpleSchemas')
       if (imagesSent) return without('noImages')
       if (reasoningSent) return without('noReasoningBack')
+      if (req.parallel_tool_calls && !this.quirks.noParallel) return without('noParallel') // refused without naming it
       throw e
     }
     // Tokens the last request used (prompt + reply): what the status bar shows against the context size.
@@ -582,6 +599,16 @@ export class Client {
     let finishReason
     const calls = []
     let raw = '' // the stream as it came (its start), kept for a reply that turns out empty
+    // A reply going round (a small model repeating itself, which could fill the window): checked
+    // every 2000 characters of its thinking, its text and each call's arguments; cut where it began.
+    let looped = null
+    const checked = new Map()
+    const watch = (what, text) => {
+      if (looped || text.length - (checked.get(what) ?? 0) < 2000) return
+      checked.set(what, text.length)
+      const at = loopStart(text)
+      if (at >= 0) looped = { what, at, sample: text.slice(-200).replace(/\s+/g, ' ').trim().slice(0, 120) }
+    }
     const emit = (v) => {
       if (onToken && v.startsWith(emitted) && v.length > emitted.length) {
         onToken(v.slice(emitted.length))
@@ -636,6 +663,7 @@ export class Client {
         if (r) {
           reasoning += r
           onReasoning?.(r)
+          watch('reasoning', reasoning)
         }
         for (const tc of d.tool_calls ?? []) {
           const i = tc.index ?? (tc.id ? calls.length : Math.max(calls.length - 1, 0))
@@ -644,6 +672,7 @@ export class Client {
           if (tc.function?.name) call.function.name ||= tc.function.name
           if (tc.function?.arguments) call.function.arguments += tc.function.arguments
           onToolDelta?.(call.function.name, call.function.arguments)
+          watch(`call ${i}`, call.function.arguments)
         }
         if (d.content) {
           content += d.content
@@ -653,11 +682,23 @@ export class Client {
             thought = t
           }
           emit(visible(content, thinks))
+          watch('content', content)
         }
+        if (looped) break
+      }
+      if (looped) {
+        await reader.cancel().catch(() => {}) // the server stops generating
+        break
       }
     }
     clearTimeout(timer)
-    const result = done(content, reasoning, calls.filter(Boolean), usage, finishReason, thinks)
+    if (looped) {
+      log('reply', `${this.model}: went into a loop in its ${looped.what} (cut after ${looped.at} characters): "${looped.sample}"`)
+      if (looped.what === 'reasoning') reasoning = reasoning.slice(0, looped.at)
+      if (looped.what === 'content') content = content.slice(0, looped.at)
+    }
+    const result = done(content, reasoning, looped ? [] : calls.filter(Boolean), usage, looped ? 'loop' : finishReason, thinks) // a call cut short isn't made
+    if (looped) result.looped = looped.sample
     emit(result.content)
     if (!result.content.trim() && !result.toolCalls.length && !result.reasoning) {
       result.raw = raw // nothing read from it: what came, for the requests log
@@ -674,6 +715,21 @@ export class Client {
   }
 }
 
+// Where a text started going round: its newest 200 characters are already there 6+ times in its
+// last 12,000 (a phrase or a block of up to 2000 characters, repeated). -1: it isn't.
+export function loopStart(text) {
+  if (text.length < 2000) return -1
+  const probe = text.slice(-200)
+  const win = text.slice(-12_000)
+  let n = 0
+  let first = -1
+  for (let i = win.indexOf(probe); i !== -1; i = win.indexOf(probe, i + 1)) {
+    n++
+    if (first < 0) first = i
+  }
+  return n >= 6 ? text.length - win.length + first : -1
+}
+
 // A tool's arguments as the most limited providers take them (Gemini's function declarations):
 // only types, properties, required, items, enum and descriptions; a choice of types (anyOf, oneOf,
 // ["string", "null"]) becomes its first real one.

package/src/config.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url'
 export const HOME = process.env.HEART_HOME || path.join(os.homedir(), '.heart')
 export const CONFIG_FILE = path.join(HOME, 'config.json')
 
-const SETTINGS = ['context', 'effort', 'permissions', 'autoCompact', 'director', 'theme', 'format', 'lsp', 'voice', 'rotation', 'log', 'logRequests', 'logDetail', 'logDays']
+const SETTINGS = ['context', 'effort', 'permissions', 'autoCompact', 'director', 'theme', 'format', 'lsp', 'voice', 'queue', 'rotation', 'log', 'logRequests', 'logDetail', 'logDays']
 const LOCAL_NAMES = { 11434: 'ollama', 1234: 'lmstudio', 8080: 'llamacpp' }
 
 export function readJson(file, fallback) {
@@ -106,12 +106,13 @@ export function loadConfig(flags = {}) {
     if (cfg.provider !== name) cfg.model = undefined
     cfg.provider = name
     cfg.adhoc = name
-    cfg.fixed = true
   } else if (apiKey && cfg.providers[cfg.provider] && !cfg.providers[cfg.provider].apiKey) {
     cfg.providers[cfg.provider].apiKey = apiKey
   }
   const model = flags.model || process.env.HEART_MODEL
-  if (model && !isAuto(model)) Object.assign(cfg, parseModel(model, cfg.providers, cfg.provider), { fixed: true })
+  if (model && !isAuto(model)) Object.assign(cfg, parseModel(model, cfg.providers, cfg.provider))
+  // -m / an ad-hoc URL pins the chosen model for this run (a session of one): cfg.session, below
+  if ((baseUrl || (model && !isAuto(model))) && cfg.providers[cfg.provider] && cfg.model) cfg.session = [{ provider: cfg.provider, model: cfg.model }]
   synced(cfg, readJson(CONFIG_FILE, {}))
   return cfg
 }
@@ -120,8 +121,10 @@ export function loadConfig(flags = {}) {
 function saved(cfg) {
   const providers = byName(cfg.providers)
   if (cfg.adhoc) delete providers[cfg.adhoc]
-  const keep = cfg.adhoc && cfg.provider === cfg.adhoc ? fromFile() : null // the run-only provider isn't saved as current
-  const out = { providers, provider: keep ? keep.provider : cfg.provider, model: keep ? keep.model : cfg.model }
+  // a run-only provider (-m URL) or models chosen for this session (cfg.session, /select_model) aren't
+  // saved as the current model: the pin is local, it must not become everyone's #1 on disk
+  const keep = (cfg.adhoc && cfg.provider === cfg.adhoc) || cfg.session?.length ? fromFile() : null // a run-only provider or a model set chosen for this session isn't saved as the current
+  const out = { providers, provider: keep?.provider ?? cfg.provider, model: keep?.model ?? cfg.model }
   for (const k of SETTINGS) if (cfg[k] !== undefined) out[k] = cfg[k]
   return JSON.parse(JSON.stringify(out))
 }
@@ -160,7 +163,9 @@ export const whatOf = (k) => (['provider', 'model', 'providers'].includes(k) ? '
 export function takeIn(cfg) {
   const disk = readJson(CONFIG_FILE, null)
   if (!disk || same(disk, file)) return []
-  const keys = keysOf(disk, file).filter((k) => (k === 'providers' || k === 'provider' || k === 'model' || SETTINGS.includes(k)) && !same(disk[k], file?.[k]))
+  // doesn't move it (its provider/model stay); everything else is still taken in
+  const takes = (k) => k === 'providers' || k === 'provider' || k === 'model' || SETTINGS.includes(k)
+  const keys = keysOf(disk, file).filter((k) => takes(k) && !same(disk[k], file?.[k]))
   for (const k of keys) {
     const value = k === 'providers' ? { ...byName(disk.providers), ...(cfg.adhoc && { [cfg.adhoc]: cfg.providers[cfg.adhoc] }) } : disk[k]
     value === undefined ? delete cfg[k] : (cfg[k] = value)

package/src/headless.js

@@ -83,7 +83,7 @@ export async function runHeadless(app, opts) {
   const emit = (obj) => process.stdout.write(JSON.stringify(obj) + '\n')
   const s = await app.session()
   if (!s) {
-    const error = 'no model set up: add a provider and choose a model (heart settings), or pass --base-url and --model'
+    const error = app.allOff() ? "the providers of all your models are switched off: switch one on (heart settings), or pass --model" : 'no model set up: add a provider and choose a model (heart settings), or pass --base-url and --model'
     if (out === 'text') process.stderr.write(`heartcode: ${error}\n`)
     else emit({ type: 'result', subtype: 'error_during_execution', is_error: true, result: error, num_turns: 0, session_id: app.chat.id })
     return 1

package/src/lsp.js

@@ -1,35 +1,45 @@
-// After HeartCode writes a file, a language server for it (when one is installed) says what is now
-// wrong, and the errors go back to the model with the edit's result: it fixes a type error right
-// away instead of finding it at the end, or never.
-// Servers, each found on PATH or in the project's node_modules/.bin: typescript-language-server,
-// gopls, pyright (or basedpyright), rust-analyzer, clangd, dart. One per language and project,
-// started at the first edit and kept until HeartCode exits. The settings page (General → Features) turns it off.
+// Language servers, chosen by the model: it works out which server a language needs (from the
+// project, the web), checks it's installed (find_command), and uses it with the lsp tool, naming
+// the command: definitions, references, hover, errors. HeartCode starts each server once per
+// project and command, and keeps it until it exits. A server the model used for a kind of file is
+// remembered for the project (~/.heart/lsp.json): after each edit of such a file its errors go
+// back to the model with the edit's result. The settings page (General → Features) turns that off.
 import fs from 'node:fs'
 import path from 'node:path'
 import { spawn } from 'node:child_process'
-import { pathToFileURL } from 'node:url'
+import { pathToFileURL, fileURLToPath } from 'node:url'
 import { log } from './log.js'
+import { HOME, readJson, writeJson } from './config.js'
 
-const SERVERS = [
-  { name: 'typescript', ext: /\.(m?[jt]sx?|cjs|cts)$/, cmds: [['typescript-language-server', '--stdio']], id: (f) => (/\.[cm]?tsx?$/.test(f) ? (f.endsWith('x') ? 'typescriptreact' : 'typescript') : f.endsWith('x') ? 'javascriptreact' : 'javascript') },
-  { name: 'go', ext: /\.go$/, cmds: [['gopls']], id: () => 'go' },
-  { name: 'python', ext: /\.pyi?$/, cmds: [['pyright-langserver', '--stdio'], ['basedpyright-langserver', '--stdio']], id: () => 'python' },
-  { name: 'rust', ext: /\.rs$/, cmds: [['rust-analyzer']], id: () => 'rust' },
-  { name: 'c', ext: /\.(c|cc|cpp|cxx|h|hh|hpp)$/, cmds: [['clangd']], id: (f) => (/\.(c|h)$/.test(f) ? 'c' : 'cpp') },
-  { name: 'dart', ext: /\.dart$/, cmds: [['dart', 'language-server', '--client-id', 'heartcode']], id: () => 'dart' },
-]
-
-// Extra servers for tests or the user: { name, ext, cmds, id }; tried before the built-in ones.
-export const extraServers = []
-
-function find(root, cmd) {
-  const local = path.join(root, 'node_modules', '.bin', cmd)
-  if (fs.existsSync(local)) return local
-  if (path.isAbsolute(cmd)) return fs.existsSync(cmd) ? cmd : null
-  for (const d of (process.env.PATH ?? '').split(path.delimiter)) if (d && fs.existsSync(path.join(d, cmd))) return path.join(d, cmd)
+const SERVERS_FILE = path.join(HOME, 'lsp.json') // { [project root]: { [".ts"]: { server, language } } }
+
+// Where a command is: the project's node_modules/.bin, else PATH (with Windows' extensions). null: not installed.
+export function findCommand(root, cmd) {
+  const exts = process.platform === 'win32' ? ['', ...(process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').map((e) => e.toLowerCase())] : ['']
+  const runnable = (p) => {
+    try {
+      const st = fs.statSync(p)
+      if (!st.isFile()) return false
+      if (process.platform !== 'win32') fs.accessSync(p, fs.constants.X_OK)
+      return true
+    } catch {
+      return false
+    }
+  }
+  if (cmd.includes('/') || cmd.includes(path.sep)) {
+    const abs = path.resolve(root, cmd)
+    return runnable(abs) ? abs : null
+  }
+  for (const d of [path.join(root, 'node_modules', '.bin'), ...(process.env.PATH ?? '').split(path.delimiter)]) {
+    if (!d) continue
+    for (const e of exts) if (runnable(path.join(d, cmd + e))) return path.join(d, cmd + e)
+  }
   return null
 }
 
+// "typescript-language-server --stdio" → its words ("…" and '…' keep spaces)
+const words = (cmd) => [...String(cmd).matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)].map((m) => m[1] ?? m[2] ?? m[3])
+
 class Server {
   constructor(spec, argv, root) {
     Object.assign(this, { spec, root, next: 1, pending: new Map(), docs: new Map(), diags: new Map(), waiters: new Set(), dead: false })
@@ -66,7 +76,13 @@ class Server {
       rootPath: root,
       workspaceFolders: [{ uri, name: path.basename(root) }],
       capabilities: {
-        textDocument: { synchronization: { didSave: true }, publishDiagnostics: { versionSupport: true } },
+        textDocument: {
+          synchronization: { didSave: true },
+          publishDiagnostics: { versionSupport: true },
+          definition: { linkSupport: true },
+          references: {},
+          hover: { contentFormat: ['plaintext', 'markdown'] },
+        },
         workspace: { configuration: true, workspaceFolders: true },
         window: { workDoneProgress: true },
       },
@@ -118,6 +134,18 @@ class Server {
     }
   }
 
+  // The file as it is on disk, opened (or brought up to date) in the server.
+  async open(abs) {
+    await this.ready
+    const uri = pathToFileURL(abs).href
+    const text = fs.readFileSync(abs, 'utf8')
+    const version = (this.docs.get(uri) ?? 0) + 1
+    if (version === 1) this.notify('textDocument/didOpen', { textDocument: { uri, languageId: this.spec.language, version, text } })
+    else this.notify('textDocument/didChange', { textDocument: { uri, version }, contentChanges: [{ text }] })
+    this.docs.set(uri, version)
+    return { uri, text }
+  }
+
   // The file's errors after this change: waits for the server's report on it, then for it to go
   // quiet (servers often send a fast report, then a full one).
   async check(abs, text, wait) {
@@ -125,7 +153,7 @@ class Server {
     const uri = pathToFileURL(abs).href
     const since = Date.now()
     const version = (this.docs.get(uri) ?? 0) + 1
-    if (version === 1) this.notify('textDocument/didOpen', { textDocument: { uri, languageId: this.spec.id(abs), version, text } })
+    if (version === 1) this.notify('textDocument/didOpen', { textDocument: { uri, languageId: this.spec.language, version, text } })
     else this.notify('textDocument/didChange', { textDocument: { uri, version }, contentChanges: [{ text }] })
     this.notify('textDocument/didSave', { textDocument: { uri }, text })
     this.docs.set(uri, version)
@@ -153,37 +181,128 @@ class Server {
   }
 }
 
-const running = new Map() // root + server name → Server, or null (none installed / it died)
+const running = new Map() // root + command → Server
 process.on('exit', () => {
-  for (const s of running.values()) s?.stop()
+  for (const sv of running.values()) sv.stop()
 })
 
-function serverFor(root, rel) {
-  const spec = [...extraServers, ...SERVERS].find((x) => x.ext.test(rel))
-  if (!spec) return null
-  const key = `${root}\0${spec.name}`
-  if (!running.has(key)) {
-    let server = null
-    for (const [cmd, ...args] of spec.cmds) {
-      const bin = find(root, cmd)
-      if (!bin) continue
-      server = new Server(spec, [bin, ...args], root)
-      log('lsp', `started ${spec.name}: ${bin} ${args.join(' ')}`)
-      break
-    }
-    running.set(key, server)
+// The server for this command in this project: running already, or started now. A string: why not.
+function serverFor(root, server, language) {
+  const argv = words(server)
+  if (!argv.length) return 'no command given'
+  const key = `${root}\0${argv.join(' ')}`
+  const had = running.get(key)
+  if (had && !had.dead) return had
+  const bin = findCommand(root, argv[0])
+  if (!bin) return `${argv[0]} is not installed`
+  const sv = new Server({ name: argv[0], language }, [bin, ...argv.slice(1)], root)
+  log('lsp', `started ${bin} ${argv.slice(1).join(' ')} (${language})`)
+  running.set(key, sv)
+  return sv
+}
+
+// The servers this project's kinds of file use: { ".ts": { server, language } }
+export const knownServers = (root) => readJson(SERVERS_FILE, {})[root] ?? {}
+function remember(root, ext, server, language) {
+  const all = readJson(SERVERS_FILE, {})
+  const mine = (all[root] ??= {})
+  if (mine[ext]?.server === server && mine[ext]?.language === language) return
+  mine[ext] = { server, language }
+  writeJson(SERVERS_FILE, all)
+}
+
+// For the system prompt: "typescript-language-server --stdio (typescript) for .ts, .tsx"
+export function serversNote(root) {
+  const by = new Map()
+  for (const [ext, { server, language }] of Object.entries(knownServers(root))) {
+    const k = `${server} (${language})`
+    by.set(k, [...(by.get(k) ?? []), ext])
   }
-  const s = running.get(key)
-  return s && !s.dead ? s : null
+  return [...by].map(([k, exts]) => `${k} for ${exts.join(', ')}`).join('; ')
 }
 
-const SEVERITY = { 1: 'error', 2: 'warning' }
+// Waits for a promise, at most ms; the server is unref'd, so this keeps HeartCode up meanwhile.
+async function within(p, ms, what) {
+  let t
+  const keep = setInterval(() => {}, 1000)
+  try {
+    return await Promise.race([p, new Promise((_, reject) => (t = setTimeout(() => reject(new Error(`no answer to ${what} in ${ms / 1000} seconds`)), ms)))])
+  } finally {
+    clearTimeout(t)
+    clearInterval(keep)
+  }
+}
+
+const SEVERITY = { 1: 'error', 2: 'warning', 3: 'info', 4: 'hint' }
+const at = (root, uri, range) => {
+  const abs = uri.startsWith('file:') ? fileURLToPath(uri) : uri
+  const rel = path.relative(root, abs)
+  let text = ''
+  try {
+    text = fs.readFileSync(abs, 'utf8').split('\n')[range.start.line]?.trim().slice(0, 160) ?? ''
+  } catch {}
+  return `${rel.startsWith('..') ? abs : rel}:${range.start.line + 1}:${range.start.character + 1}${text ? `: ${text}` : ''}`
+}
+const hoverText = (c) => (Array.isArray(c) ? c.map(hoverText).join('\n') : typeof c === 'string' ? c : (c?.value ?? ''))
+
+// The lsp tool: { server: the command, language: its language id, action, file, line, column | name }
+export async function lspTool(s, args, signal) {
+  const { root } = s
+  const server = String(args.server ?? '').trim()
+  const language = String(args.language ?? '').trim()
+  const action = String(args.action ?? '')
+  if (!server || !language) return 'error: lsp needs "server" (the command that starts it, like "typescript-language-server --stdio") and "language" (its language id, like "typescript")'
+  if (!['definition', 'references', 'hover', 'errors'].includes(action)) return 'error: "action" is one of definition, references, hover, errors'
+  if (!args.file) return 'error: lsp needs "file"'
+  const abs = path.resolve(root, String(args.file))
+  if (!fs.existsSync(abs)) return `error: no file ${args.file}`
+  const sv = serverFor(root, server, language)
+  if (typeof sv === 'string') return `error: ${sv}. Check with find_command; install it, or use search and read_file instead.`
+  const first = !sv.used
+  const ms = first ? 60_000 : 20_000 // the first request waits for the server to start and index
+  try {
+    if (action === 'errors') {
+      const list = await within(sv.check(abs, fs.readFileSync(abs, 'utf8'), first ? 30_000 : 6000), ms, 'the errors check')
+      sv.used = true
+      remember(root, path.extname(abs), server, language)
+      if (!list) return `${server} sent no report on ${args.file} in time.`
+      if (!list.length) return `${server}: no problems in ${args.file}.`
+      return list.slice(0, 30).map((d) => `${at(root, pathToFileURL(abs).href, d.range)} — ${SEVERITY[d.severity ?? 1]}: ${String(d.message).split('\n')[0]}`).join('\n') + (list.length > 30 ? `\n… ${list.length - 30} more` : '')
+    }
+    const { uri, text } = await within(sv.open(abs), ms, 'opening the file')
+    const lines = text.split('\n')
+    const line = Math.max(1, Math.min(Number(args.line) || 1, lines.length)) - 1
+    let col = Number(args.column) > 0 ? Number(args.column) - 1 : -1
+    if (col < 0 && args.name) {
+      const m = new RegExp(`\\b${String(args.name).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).exec(lines[line])
+      if (!m) return `error: "${args.name}" isn't on line ${line + 1} of ${args.file}: ${lines[line].trim().slice(0, 120)}`
+      col = m.index
+    }
+    if (col < 0) col = Math.max(0, lines[line].search(/\S/))
+    const pos = { textDocument: { uri }, position: { line, character: col } }
+    const method = { definition: 'textDocument/definition', references: 'textDocument/references', hover: 'textDocument/hover' }[action]
+    const res = await within(sv.request(method, action === 'references' ? { ...pos, context: { includeDeclaration: true } } : pos), ms, action)
+    sv.used = true
+    remember(root, path.extname(abs), server, language)
+    if (action === 'hover') return hoverText(res?.contents).trim().slice(0, 3000) || 'nothing to show there'
+    const locs = (Array.isArray(res) ? res : res ? [res] : []).map((l) => ({ uri: l.uri ?? l.targetUri, range: l.range ?? l.targetSelectionRange ?? l.targetRange }))
+    if (!locs.length) return `no ${action === 'definition' ? 'definition' : 'references'} found for line ${line + 1}, column ${col + 1} (${lines[line].trim().slice(0, 80)})`
+    return locs.slice(0, 50).map((l) => at(root, l.uri, l.range)).join('\n') + (locs.length > 50 ? `\n… ${locs.length - 50} more` : '')
+  } catch (e) {
+    if (signal?.aborted) throw Object.assign(new Error('stopped'), { name: 'AbortError' })
+    log('lsp', `${server}: ${e.message}`)
+    return `error: ${server}: ${e.message}. Use search and read_file instead, or another server.`
+  }
+}
 
-// What's wrong in the file now, as a note for the model, or '' (no server, nothing wrong, or no
-// report in time). Errors only, unless there are none: the last check's errors are fixed is said too.
+// After an edit: what's wrong in the file now, as a note for the model, or '' (no server used for
+// this kind of file in the project, nothing wrong, or no report in time). Errors only, unless there
+// are none: the last check's errors are fixed is said too.
 export async function diagnose(s, rel, text) {
-  const server = serverFor(s.root, rel)
-  if (!server) return ''
+  const known = knownServers(s.root)[path.extname(rel)]
+  if (!known) return ''
+  const server = serverFor(s.root, known.server, known.language)
+  if (typeof server === 'string') return ''
   const abs = path.join(s.root, rel)
   let list
   const keep = setInterval(() => {}, 1000) // the server is unref'd: this keeps HeartCode up while it answers

package/src/mcp.js

@@ -11,6 +11,8 @@
 // HeartCode exits.
 import { spawn } from 'node:child_process'
 import crypto from 'node:crypto'
+import fs from 'node:fs'
+import os from 'node:os'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { HOME, readJson, readConfig, writeJson, VERSION } from './config.js'
@@ -21,7 +23,12 @@ import { savedToken, signIn } from './oauth.js'
 export const DEFAULT_SERVERS = {
   'chrome-devtools': {
     command: 'npx',
-    args: ['-y', 'chrome-devtools-mcp@latest'],
+    // headless: no window pops up (works over SSH too); isolated: its own throwaway profile, so
+    // runs don't fight over one. Override args in ~/.heart/mcp.json for a visible browser.
+    args: ['-y', 'chrome-devtools-mcp@latest', '--headless', '--isolated'],
+    // a screenshot/snapshot saved by a relative path lands in the server's cwd: a scratch dir, not
+    // the project, so the browser never litters it (pages are opened by absolute file:// URLs).
+    scratchCwd: true,
     description: 'a Chrome browser: open pages, click, fill forms, read the console and network requests, take screenshots',
   },
 }
@@ -118,7 +125,8 @@ class Server {
   async #spawn(init) {
     const { command, args = [], env = {} } = this.cfg
     log('mcp', `starting ${this.name}: ${command} ${args.join(' ')}`)
-    const child = (this.child = spawn(command, args, { cwd: this.root ?? undefined, env: { ...process.env, ...env }, stdio: ['pipe', 'pipe', 'pipe'], detached: process.platform !== 'win32' })) // in the project, so a relative path in its config works
+    const cwd = this.cfg.scratchCwd ? scratchDir(this.root, this.name) : (this.root ?? undefined) // in the project, so a relative path in its config works; a browser gets a scratch dir instead
+    const child = (this.child = spawn(command, args, { cwd, env: { ...process.env, ...env }, stdio: ['pipe', 'pipe', 'pipe'], detached: process.platform !== 'win32' }))
     let buf = ''
     child.stdout.setEncoding('utf8') // a character split between two chunks stays whole
     child.stdout.on('data', (d) => {
@@ -327,6 +335,16 @@ class Server {
 const TOOLS_FILE = path.join(HOME, 'mcp-tools.json')
 const keyOf = (cfg) => crypto.createHash('sha256').update(JSON.stringify(cfg)).digest('hex').slice(0, 16)
 
+// A throwaway working directory for a server (the browser), so files it writes by a relative path
+// don't land in the project. One per project, under the OS temp dir.
+function scratchDir(root, name) {
+  const dir = path.join(os.tmpdir(), 'heartcode', name, crypto.createHash('sha256').update(root ?? '').digest('hex').slice(0, 12))
+  try {
+    fs.mkdirSync(dir, { recursive: true })
+  } catch {}
+  return dir
+}
+
 // All configured servers for a project; nothing runs until a server is first used.
 // onSignIn(name, url): set by the screen, to show a remote server's sign-in page (none headless).
 export class Mcp {

package/src/sessions.js

@@ -129,7 +129,6 @@ export function restoreFiles(chat, from) {
 export const ago = (iso) => {
   const s = (Date.now() - Date.parse(iso)) / 1000
   if (s < 60) return 'just now'
-  if (s < 3600) return `${Math.floor(s / 60)}m ago`
-  if (s < 86400) return `${Math.floor(s / 3600)}h ago`
-  return `${Math.floor(s / 86400)}d ago`
+  const n = Math.floor(s < 3600 ? s / 60 : s < 86400 ? s / 3600 : s / 86400)
+  return `${n} ${s < 3600 ? 'minute' : s < 86400 ? 'hour' : 'day'}${n === 1 ? '' : 's'} ago`
 }