heartcode 0.1.3 → 0.1.5

package/bin/heartcode.js

@@ -509,7 +509,7 @@ class App {
   modelChoices(typed, start, end) {
     const mine = this.myModels()
     const twice = (m) => mine.filter((t) => t.model === m).length > 1
-    const items = mine.map((t, i) => ({ value: twice(t.model) ? `${t.provider} ${t.model}` : t.model, desc: `${t.provider} · #${i + 1}${i === 0 ? ' · in use' : ''}`, start, end }))
+    const items = mine.map((t, i) => ({ value: twice(t.model) ? `${t.provider} ${t.model}` : t.model, desc: `${t.provider} · #${i + 1}${i === 0 ? ' · in use' : ''} · ${this.canText(t)}`, start, end }))
     return rank(items, typed).slice(0, 200)
   }
 
@@ -626,11 +626,21 @@ class App {
     const now = this.s?.client.rotation?.list[this.s.client.rotation.at] ?? this.myModels()[0]
     return this.myModels()
       .filter((t) => !(t.provider === now?.provider && t.model === now?.model))
-      .map((t) => {
-        const cl = this.client(t.provider, t.model)
-        const st = strategy(loadProfile(cl) || profileFrom(cl, limitsOf(t.provider, cl.baseUrl, t.model)))
-        return { ...t, tools: st.actions === 'tools', images: st.vision, thinking: st.thinking, context: st.context }
-      })
+      .map((t) => ({ ...t, ...this.abilities(t) }))
+  }
+
+  // What a model can do, from its saved profile or models.dev (guessed: neither knows it).
+  abilities(t) {
+    const cl = this.client(t.provider, t.model)
+    const p = loadProfile(cl) || profileFrom(cl, limitsOf(t.provider, cl.baseUrl, t.model))
+    const st = strategy(p)
+    return { tools: st.actions === 'tools', images: st.vision, thinking: st.thinking, context: st.context, guessed: p.source === 'assumed' && !p.set }
+  }
+
+  // "tools · images · thinking · 1M", for the model lists.
+  canText(t) {
+    const a = this.abilities(t)
+    return [a.tools ? 'tools' : 'no tools', a.images && 'images', a.thinking && 'thinking', kTokens(a.context) + (a.guessed ? '?' : '')].filter(Boolean).join(' · ')
   }
 
   // Your models, in order: this one (#1), then the fallbacks (chosen on /settings, where every
@@ -658,7 +668,7 @@ class App {
       if (!Object.keys(cfg.providers).length && (await this.detectLocal())) return this.session()
       return ui.print(NO_MODELS)
     }
-    const items = mine.map((t, i) => ({ label: t.model, group: t.provider, t, current: i === 0, desc: [i === 0 ? '#1 · in use' : `#${i + 1} · fallback`, loadProfile(this.client(t.provider, t.model)) && '✓ tested'].filter(Boolean).join(' · ') }))
+    const items = mine.map((t, i) => ({ label: t.model, group: t.provider, t, current: i === 0, desc: [i === 0 ? '#1 · in use' : `#${i + 1} · fallback`, this.canText(t)].join(' · ') }))
     const it = await ui.pick('Choose a model (more on /settings)', items, { filter })
     if (it && !it.current) await this.useMine(it.t)
   }
@@ -1258,6 +1268,7 @@ async function repl(app, f = {}) {
   ui.onEscape = () => ctl?.abort()
   ui.onBtw = (q) => app.btw(q, true) // /btw typed while it works
   ui.isCommand = (l) => app.isCommand(l)
+  loadPrices().then(() => ui.render?.()) // models.dev: what each model can do, for the model lists
   ui.voiceConfig = () => ({ voice: cfg.voice, providers: cfg.providers })
   // Ctrl+C: stops what's running; clears the input if there's text; otherwise asks before quitting
   // (a second Ctrl+C within 2s quits, also when something is stuck).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heartcode",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "A coding CLI for any local or OpenAI-compatible model, including small models without tool calling.",
   "type": "module",
   "bin": {

package/prompts/agent.md

@@ -170,10 +170,12 @@ The user didn't answer. Decide yourself, carry on, and say in your reply what yo
 <!-- Starts a helper agent (only in the main conversation, not in helpers). -->
 Hand a side job to a helper agent with its own fresh context, so the details stay out of this conversation: searching or reading a lot of code to answer a question, researching on the web, reviewing changes. It has the same tools (no helpers of its own) and sees only your prompt, so say exactly what to do and what to report. Its final reply comes back as the result. description: 3-5 words for the user.
 
+Several agent calls in one reply run at the same time. Use that to split independent work (one helper per part), or to ask several helpers the same thing (different models, or the same one more than once) and combine their answers: compare them, keep what they agree on, check where they differ.
+
 ## tool-agent-model
 
 <!-- The agent tool's "model", there when the user has other models. -->
-Another of your models to do the job (from "Your other models" in the system prompt, as "provider model"), when it needs what you can't do. Leave out to do it with yourself.
+Another of your models to do the job (from "Your other models" in the system prompt, as "provider model"), when it needs what you can't do or you want its view too. Leave out for a helper on your own model.
 
 ## team
 
@@ -183,7 +185,7 @@ Another of your models to do the job (from "Your other models" in the system pro
 The user set up these models besides you (you: tool calls, {{you}}):
 {{models}}
 
-You can hand a job to one of them with the agent tool and its "model". Never decline a part of the task, or say you can't do it, because it needs something you can't do (see an image, call tools, think longer, read more than fits your context): give that part to a model here that can, with everything it needs in the prompt (file paths, what to look for, what to report), then go on with its answer. Answering yourself is better when you can.
+You can hand a job to one of them with the agent tool and its "model", and to several at once (several agent calls in one reply), for a second opinion or to compare answers. Never decline a part of the task, or say you can't do it, because it needs something you can't do (see an image, call tools, think longer, read more than fits your context): give that part to a model here that can, with everything it needs in the prompt (file paths, what to look for, what to report), then go on with its answer. Answering yourself is better when you can.
 
 ## images-described
 

package/src/agent.js

@@ -167,10 +167,10 @@ export class Session {
     if (want) {
       const team = this.team?.() ?? []
       const t = team.find((x) => `${x.provider} ${x.model}` === want) ?? team.find((x) => x.model === want || want.endsWith(` ${x.model}`))
-      if (!t) return `error: no model "${want}". Yours: ${team.map((x) => `${x.provider} ${x.model}`).join(', ') || 'none besides this one'}`
-      ;({ client, profile, strat } = await this.engineFor(t))
+      if (t) ({ client, profile, strat } = await this.engineFor(t))
+      else if (want !== client.model && !want.endsWith(` ${client.model}`)) return `error: no model "${want}". Yours: ${[client.model, ...team.map((x) => `${x.provider} ${x.model}`)].join(', ')}`
     }
-    const label = clip((want ? `${client.model}: ` : '') + (String(args.description ?? '').trim() || task.split('\n')[0]), 60)
+    const label = clip(`${client.model}: ${String(args.description ?? '').trim() || task.split('\n')[0]}`, 60)
     const helper = new Session({ client, profile, strat, root: this.root, ui: helperUI(this.ui, label), chat: newChat(this.root) })
     Object.assign(helper, { isSub: true, mcp: this.mcp, skills: this.skills, hooks: this.hooks, allowTools: this.allowTools, denyTools: this.denyTools, maxTurns: this.maxTurns, autoCompact: this.autoCompact, appendSystem: this.appendSystem, fileCache: this.fileCache, noFormat: this.noFormat, noLsp: this.noLsp })
     helper.track = (rel, before) => this.track(rel, before)
@@ -545,7 +545,7 @@ async function runNative(s, task, images, signal) {
     fitMessages(s.messages, budget())
     pairTools(s.messages)
     ui.spinner('thinking')
-    const out = ui.response()
+    const out = ui.response(client.model) // named: helpers think too (theirs are named in helperUI)
     const stream = strat.toolsStream
     let res
     try {
@@ -604,12 +604,25 @@ async function runNative(s, task, images, signal) {
       continue
     }
 
+    // Helpers (agent) asked for in one reply work at the same time: the same model or several.
+    // ponytail: no cap on how many at once; add one if a provider's rate limit makes them crawl.
+    const argsOf = (call) => {
+      try {
+        return JSON.parse(call.function.arguments || '{}')
+      } catch {
+        return null
+      }
+    }
+    const together = new Map()
+    for (const call of res.toolCalls) {
+      const args = argsOf(call)
+      if (call.function.name !== 'agent' || !args || !allowed(s, 'agent') || res.toolCalls.filter((x) => x.function.name === 'agent').length < 2) continue
+      ui.step('agent', clip([args.model && `${args.model}:`, args.description].filter(Boolean).join(' '), 80))
+      together.set(call.id, runTool('agent', args, s, signal))
+    }
     for (const call of res.toolCalls) {
       const name = call.function.name
-      let args = null
-      try {
-        args = JSON.parse(call.function.arguments || '{}')
-      } catch {}
+      const args = argsOf(call)
       const detail = !args
         ? ''
         : args.server
@@ -619,12 +632,12 @@ async function runNative(s, task, images, signal) {
             : name === 'manage'
               ? [args.action, args.kind, args.name].filter(Boolean).join(' ')
               : name === 'agent'
-                ? (args.description ?? '')
+                ? [args.model && `${args.model}:`, args.description].filter(Boolean).join(' ')
                 : name === 'todo' || name === 'ask_user'
                   ? ''
                   : (args.path ?? args.url ?? args.query ?? args.filter ?? args.name ?? '')
-      if (name !== 'run_command') ui.step(name, clip(detail, 80))
-      const out = !allowed(s, name) ? `error: the tool ${name} is not allowed here` : args ? await runTool(name, args, s, signal) : 'error: the tool arguments were not valid JSON'
+      if (name !== 'run_command' && !together.has(call.id)) ui.step(name, clip(detail, 80))
+      const out = together.has(call.id) ? await together.get(call.id) : !allowed(s, name) ? `error: the tool ${name} is not allowed here` : args ? await runTool(name, args, s, signal) : 'error: the tool arguments were not valid JSON'
       if (name === 'read_file' || name === 'search' || name === 'list_files' || name === 'web_fetch' || name === 'web_search') ui.result(`${out.split('\n').length} lines`)
       else if (name === 'agent' && !out.startsWith('error')) ui.result(`${s.ui.permission === 'plan' ? 'planned' : 'done'}: ${clip(out.split('\n').find((l) => l.trim()) ?? '', 100)}`)
       else if (out.startsWith('error')) ui.result(clip(out, 120))
@@ -657,13 +670,36 @@ async function notDone(s, signal, again) {
 
 // A helper agent's view of the screen: its steps are labelled, and its replies (which go to the
 // main agent) aren't shown as answers. Everything else is the main UI's.
+// Its thinking is shown whole when its reply is in (helpers working at once don't mix), named.
+// Questions to the user (confirm, pick, ask) wait their turn: helpers working at once ask one by one.
+const asking = new WeakMap() // ui → the question being asked
 function helperUI(ui, label) {
-  const quiet = { think() {}, text() {}, end() {} }
+  const response = () => {
+    const t0 = Date.now()
+    let thought = ''
+    return {
+      think: (t) => (thought += t ?? ''),
+      text() {},
+      end() {
+        if (!thought.trim()) return
+        const secs = ((Date.now() - t0) / 1000).toFixed(1)
+        ui.print(c.faint(c.italic(`  ✻ ${label} thought for ${secs}s`)) + (ui.showThinking ? `\n${c.think(c.italic(thought.trim().replace(/^/gm, '    ')))}` : ''))
+      },
+    }
+  }
+  const inTurn = (k) => (...a) => {
+    const next = (asking.get(ui) ?? Promise.resolve()).then(() => ui[k](...a))
+    asking.set(ui, next.catch(() => {}))
+    return next
+  }
   const own = {
     step: (name, detail) => ui.step(`  ${label} › ${name}`, detail),
     result: (text) => ui.result(`  ${text}`),
-    response: () => quiet,
+    response,
     spinner: (text) => ui.spinner(`${label} · ${text}`),
+    confirm: inTurn('confirm'),
+    pick: inTurn('pick'),
+    ask: inTurn('ask'),
   }
   return new Proxy(ui, { get: (t, k) => (k in own ? own[k] : typeof t[k] === 'function' ? t[k].bind(t) : t[k]), set: (t, k, v) => ((t[k] = v), true) })
 }

package/src/ui.js

@@ -399,7 +399,8 @@ export class UI {
   }
 
   // One model reply: thinking (dim, its own block) kept apart from the answer.
-  response() {
+  // who: the model thinking, named over its thinking (helpers say their own: helperUI in agent.js)
+  response(who) {
     const t0 = Date.now()
     const secs = () => ((Date.now() - t0) / 1000).toFixed(1)
     const write = (x) => this.write(x)
@@ -407,7 +408,7 @@ export class UI {
     let text = null
     let thought = false
     const summary = () => {
-      if (thought && !this.showThinking) this.print(c.faint(c.italic(`✻ thought for ${secs()}s`)))
+      if (thought && !this.showThinking) this.print(c.faint(c.italic(`✻ ${who ? `${who} ` : ''}thought for ${secs()}s`)))
     }
     return {
       think: (t) => {
@@ -416,7 +417,7 @@ export class UI {
         if (!this.showThinking) return this.spinner(`thinking · ${secs()}s`)
         if (!think) {
           this.gap()
-          this.print(c.faint(c.italic('✻ Thinking…')))
+          this.print(c.faint(c.italic(`✻ ${who ? `${who} is thinking` : 'Thinking'}…`)))
           think = new Block(write, { style: (x) => c.think(c.italic(x)) })
         }
         think.push(t)
@@ -705,7 +706,13 @@ export class UI {
         m.off = rl.line
         return this.refreshMenu()
       }
-      if (m.on && key.name === 'tab') return it && this.#accept(it)
+      // Tab only completes the text: the menu closes (no list of a command's choices pops up); Enter runs it
+      if (m.on && key.name === 'tab') {
+        if (!it) return
+        this.#accept(it)
+        m.off = rl.line
+        return this.refreshMenu()
+      }
       if (it && key.name === 'return' && rl.line.slice(it.start, it.end) !== it.value) {
         this.#accept(it)
         if (it.insertOnly) return