heartcode 0.1.9 → 0.1.13

package/CHANGELOG.md

@@ -0,0 +1,89 @@
+# Changelog
+
+What changed in each version of HeartCode, newest first.
+
+## 0.1.13 (2026-10-30)
+
+- Settings no longer go back by themselves: a save writes only what changed, so another HeartCode
+  or settings page with an older copy doesn't undo your change (and keys HeartCode doesn't know stay).
+- A settings change reaches every HeartCode running on the same settings at once, mid-task too: the
+  model order, prompts and HEARTCODE.md, hooks, skills, MCP servers. Open settings pages update by themselves.
+- `--temp` runs going on at once share one throwaway folder: a change in one reaches the others,
+  never your real settings. Ctrl+C now cleans it up too.
+- Settings page: nothing is kept in the browser (the provider ranking, sorts and folds are in
+  ~/.heart); Save order is always there; Invert selection on Your models.
+
+## 0.1.12 (2026-10-30)
+
+- `auto` is the name for your model list (#1, then the next when one fails); `default` still works.
+- Models are written `provider/model` (`-m groq/openai/gpt-oss-120b`); the old `"provider model"` still works.
+- `heart models` prints what `-m` takes, one per line (`auto` first); `--json` gives an `id` for each.
+- `--fallback-model <provider/model>`, as in `claude -p`: tried after the `-m` model when it fails.
+- Settings changed while HeartCode runs (also `-p`, stream-json and editors over ACP) are taken in
+  without a restart: a new model order from the running task's next request.
+- Settings page: adding a provider, an MCP server or a skill opens a dialog; every dialog is 70% of
+  the screen wide. Your models can be sorted by a provider ranking you drag into order.
+
+## 0.1.11 (2026-10-30)
+
+- A changelog (this file) in place of the old TODO list.
+
+## 0.1.10 (2026-10-30)
+
+- Any model error (a rate limit, an outage, "request too large", a bad model name, a wrong key…)
+  moves on to the next model in your list, another provider's first, without the app using
+  HeartCode seeing it. A run stops with an error only when every model has failed.
+- No more token estimates deciding when to shrink a request or switch models. A long
+  conversation is summarized every 100 messages instead.
+- Settings: the rotation choice "at any error" is gone; it now works the same as "at its first
+  failure".
+
+## 0.1.9 (2026-10-29)
+
+- After an error, the next model tried is from another provider; the failing provider's other
+  models come only after every provider has had a go.
+- Model lists in Cloudflare's format (`{ "result": [...] }`) are read.
+- Settings: model lists no longer stay stuck on "loading…", and an empty saved list is fetched again.
+- A shorter system prompt, with the duplicates taken out.
+
+## 0.1.8 (2026-10-29)
+
+- Settings page: model tests run on the server, long model lists scroll smoothly, prices are
+  shown, and "Test all" shows its progress.
+
+## 0.1.7 (2026-10-29)
+
+- Each request is fitted to the model it goes to (images, tool calls, thinking).
+- Safer file changes.
+- Better handing of work to the other models.
+
+## 0.1.6 (2026-10-29)
+
+- Better handing of work to the other models.
+- A helper's steps are sent to apps using HeartCode, like Claude Code's subagents.
+- Fixed switching models.
+- npm page: GitHub links and keywords.
+
+## 0.1.5 (2026-10-28)
+
+- Several helpers can run at once; thinking is shown with its name; the model lists show what
+  each model can do.
+- Tab only completes, it doesn't send.
+
+## 0.1.3 (2026-10-28)
+
+- Another of your models does what the one in use can't (for example, looking at an image).
+- A path typed at the prompt is no longer taken for a command.
+
+## 0.1.2 (2026-10-28)
+
+- Logging: the size on disk, and a Delete all button.
+- Refresh model data from models.dev.
+- A Test button on the Your models page, a simpler list, and `-latest` model names matched in models.dev.
+- Screenshots in the README.
+
+## 0.1.1 (2026-10-28)
+
+- First release: MCP tools as real tools, fallback models that keep going, a model Test button.
+- The npm package holds only what HeartCode needs to run.
+- README, MIT license, and failures described in SKILL.md.

package/SKILL.md

@@ -14,63 +14,74 @@ answer (or JSON) and exits. Its flags and output match Claude Code's `claude -p`
 ```sh
 heart --version          # installed? (else: node /path/to/heart_cli/bin/heart.js --version)
 heart providers          # the providers set up, and their URLs (keys are masked)
-heart models --json      # the models to pass to -m: "default" first (the user's list, with fallbacks), then each model
-heart models --all --json   # every provider's models too (slower: asks each provider)
+heart models             # what -m takes, one per line: "auto" first, then the user's models (provider/model), #1 first
+heart models --json      # the same, as JSON
+heart models --all       # every provider's models too (slower: asks each provider)
 ```
 
-Read `--json`, not the text: the text layout is for people and may change.
+`heart models` prints one id per line, nothing else (like `opencode models`):
+
+```
+auto
+groq/openai/gpt-oss-120b
+openrouter/qwen/qwen3-coder
+```
+
+With `--json`:
 
 ```json
 { "models": [
-    { "place": null, "provider": null, "model": "default", "role": "default", "rotates": true, "about": "your models in order: #1, then the next when one fails (-m default, or no -m)" },
-    { "place": 1, "provider": "groq", "model": "openai/gpt-oss-120b", "role": "in use", "rotates": false },
-    { "place": 2, "provider": "openrouter", "model": "qwen/qwen3-coder", "role": "fallback", "rotates": false } ],
+    { "id": "auto", "fallbacks": true },
+    { "id": "groq/openai/gpt-oss-120b", "provider": "groq", "model": "openai/gpt-oss-120b", "place": 1 },
+    { "id": "openrouter/qwen/qwen3-coder", "provider": "openrouter", "model": "qwen/qwen3-coder", "place": 2 } ],
   "providers": [
-    { "name": "groq", "baseUrl": "https://api.groq.com/openai/v1", "list": true, "models": ["…"] },
+    { "name": "groq", "baseUrl": "https://api.groq.com/openai/v1", "list": true, "models": ["groq/…"] },
     { "name": "local", "baseUrl": "http://127.0.0.1:9/v1", "list": true, "models": [], "error": "cannot reach …" } ] }
 ```
 
-Each entry in `models` is something to pass to `-m`, in order:
+`id` is exactly what to pass to `-m`:
 
-- **`default`** (always first; `place` and `provider` are `null`): the user's list. `rotates: true`
-  when they have more than one model: #1 is used, and the next one in order when it fails.
-- **the user's models** (`place` 1, 2, …): `role` is `in use` for #1 and `fallback` for the rest;
-  `rotates: false`, since a model named on its own is used alone.
+- **`auto`** (always first): the user's list. `fallbacks: true` when it has more than one model:
+  #1 is used, and the next one in order when it fails. No `-m` means `auto` too. (`default` is
+  its old name and still works.)
+- **the user's models** (`place` 1, 2, …), as `provider/model`: #1 is the one `auto` starts with.
 
 No model set up yet: `models` is empty (and `heart -p` fails with "no model set up").
-`heart models [--all] <filter>` keeps only the entries whose `model` contains `<filter>`.
+`heart models [--all] <filter>` keeps only the ids that contain `<filter>`.
 
 `providers` (only with `--all`): every provider's models. `list: false`: the user switched that
 provider's list off, and `models` are the ones they added by name. A provider that can't be
-reached has an `error` and is skipped; the command still exits `0`.
+reached has an `error` (in text: a line on stderr) and is skipped; the command still exits `0`.
 
 **Which model to pass:**
 
 | `-m` | What runs |
 |---|---|
-| `default`, or no `-m` | the user's list: #1, and the next one in order when it fails (rate limits, outages…). Use this unless you need one particular model. |
-| a model from the list: `-m "<provider> <model>"` (`-m "groq openai/gpt-oss-120b"`), or `-m <model>` alone | that model alone: never another one, also when it fails (a rate limit or an outage is tried again, up to `--max-retries`) |
-
-**Failures:** a rate limit, a server error, a timeout, a reply that stops coming (nothing for 150s),
-a lost connection, or an error page from a proxy in front of the provider is waited out and tried
-again (or handed to the next model in the list), up to `--max-retries` (10). With the default
-list, a model that can't be used (a wrong key, no access to it, a name the server doesn't know:
-401, 403, 404) also makes way for the next one, and so does one that keeps replying with nothing. When a
-provider answers with an error (status 400 or above), the next model tried is from another
-provider; that provider's other models are tried only after every provider has had a go.
-A model that takes over with a smaller context window gets the conversation summarized first, if it
-wouldn't fit.
-The run stops with that error and exit code `1` when every model in the list fails that way, or
-when a single model (`-m <model>`) does. A request a server refuses (400) is sent as it is to two
-more models of the list at most, then the run stops (unless the user set the fallback rule to "at
-any error"). A provider that refuses a part
-of the request HeartCode can do without (the model's thinking sent back, keys in the tools'
-schemas, images) gets it again without that part, and that is remembered for the model for a day.
+| `auto`, or no `-m` | the user's list: #1, and the next one in order when it fails. Use this unless you need one particular model. |
+| `provider/model` (`-m groq/openai/gpt-oss-120b`), or a model of #1's provider alone | that model alone: never another one, also when it fails (a rate limit or an outage is tried again, up to `--max-retries`) |
+| that, plus `--fallback-model provider/model` (repeatable) | that model, then the fallbacks in order when it fails (as `claude -p --fallback-model`) |
+
+**Failures:** with `auto` (the list), any failure (an error status of any kind, a timeout, a reply
+that stops coming, a lost connection, an error page from a proxy, a model that keeps replying with
+nothing) makes way for the next model, from another provider first; that provider's other models
+are tried only after every provider has had a go. None of it shows: the run goes on with the model
+that answers. It stops with exit code `1` only when every model in the list fails: at once if they
+all refused the request outright, else after `--max-retries` (10) whole rounds of them. A single
+model (`-m <model>`) waits out rate limits and outages, up to `--max-retries` tries, and stops at
+any other error. A provider that refuses a part of the request HeartCode can do without (the
+model's thinking sent back, keys in the tools' schemas, images) gets it again without that part,
+and that is remembered for the model for a day. A long conversation is summarized every 100
+messages.
 Each request is fitted to the model it goes to: one that can't see gets a note in place of each
 image, one that can't call tools gets the tool calls as text.
 
 `--provider <name>` and `-u <url>` (a server for this run) also mean one model, alone.
 
+A run picks up settings the user changes meanwhile (`heart settings`, another HeartCode, or
+`~/.heart` by hand) without being restarted, from its next request: the model order, prompts,
+hooks, skills, MCP servers. `--temp` runs share one throwaway folder, so a change in one reaches the
+other `--temp` runs going on, never the real ones.
+
 `heart` is installed by `npm start` in the HeartCode folder. `heartcode` is the same command.
 Needs Node.js 20 or newer. No providers? See "Setting up a model" below.
 
@@ -123,7 +134,7 @@ can't switch the model you chose.
 | Everything (edits and commands) | `--permission-mode all` (the default unless the user set another) |
 | Changes kept apart from the user's files | `--worktree=<name>` (in a git repo): it works in `.heartcode/worktrees/<name>` on the branch `heartcode/<name>`; kept if anything changed (merge it from there), removed if nothing did |
 | A cap on how long it works | `--max-turns 30` (model steps), `--max-retries 3` (a failing provider) |
-| Nothing written to the user's `~/.heart` (sessions, logs, settings) | `--temp` |
+| Nothing written to the user's `~/.heart` (sessions, logs, settings) | `--temp` (a throwaway copy, shared by the `--temp` runs going on at once) |
 
 Tool names: HeartCode's own (`read_file`, `edit_file`, `write_file`, `run_command`, `search`,
 `list_files`, `web_fetch`, `web_search`…) or Claude Code's (`Read`, `Edit`, `Write`, `Bash`,
@@ -134,8 +145,9 @@ server's tools, `mcp` all of them.
 ## Choose the model
 
 ```sh
-heart -p -m default "…"                         # the user's list, with its fallbacks (the same as no -m)
-heart -p -m "groq openai/gpt-oss-120b" "…"     # that provider and model alone, for this run
+heart -p -m auto "…"                            # the user's list, with its fallbacks (the same as no -m)
+heart -p -m groq/openai/gpt-oss-120b "…"       # that provider and model alone, for this run
+heart -p -m groq/openai/gpt-oss-120b --fallback-model openrouter/qwen/qwen3-coder "…"   # and that one when it fails
 heart -p --provider ollama -m qwen3-coder "…"   # the same, written apart
 heart -p --effort high "…"                      # how hard a thinking model thinks
 ```

package/bin/heart.js

@@ -4,9 +4,10 @@
 //   heart .                   this folder
 //   heart ~/code/my-app       that folder (a folder: a file is an error)
 //   heart ~/code/my-app "fix the failing test" -m …   then anything heartcode takes (heart --help)
-//   heart --temp …            a throwaway ~/.heart: only your config.json (providers, keys), the
-//                             models' test results and prices copied in; deleted when HeartCode
-//                             quits; your own is never written to
+//   heart --temp …            a throwaway ~/.heart, shared by the --temp runs going on at once:
+//                             your config.json (providers, keys), the models' test results and
+//                             prices copied in; deleted when the last of them quits; your own is
+//                             never written to
 // Logs, when they're switched on (the settings page: Logging): each run's log in
 // ~/.heart/logs/runs/<day-month-year-hour-min-sec>/, a file per tab ("log": true in config.json);
 // each request to a model in ~/.heart/logs/requests/<same>/, a file per request ("logRequests").
@@ -30,15 +31,36 @@ const stamp = (() => {
   return `${d.getDate()}-${d.getMonth() + 1}-${d.getFullYear()}-${d.getHours()}-${d.getMinutes()}-${d.getSeconds()}`.replace(/\b(\d)\b/g, '0$1')
 })()
 
-// --temp: HeartCode's folder is a new one in the system's temp folder
+// --temp: HeartCode's folder is one in the system's temp folder, shared by every --temp run going
+// on at the same time (a setting changed in one reaches the others, as ~/.heart's do for the real
+// ones). The first one makes it, the last one to quit deletes it. Each run's pid is a file in
+// .runs/ (a run that crashed leaves one: its process is gone, so it doesn't count).
 const temp = args.includes('--temp')
 if (temp) {
   args.splice(args.indexOf('--temp'), 1)
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'heart-temp-'))
-  // your providers and keys; what HeartCode learned about each model and prices (or it tests them again)
-  for (const f of ['config.json', 'models', 'prices.json']) if (fs.existsSync(path.join(realHome, f))) fs.cpSync(path.join(realHome, f), path.join(dir, f), { recursive: true })
+  const dir = path.join(os.tmpdir(), `heart-temp-${os.userInfo().username}`)
+  const runs = path.join(dir, '.runs')
+  const alive = (pid) => {
+    try {
+      return process.kill(Number(pid), 0), true
+    } catch (e) {
+      return e.code === 'EPERM'
+    }
+  }
+  const others = () => (fs.existsSync(runs) ? fs.readdirSync(runs).filter((pid) => Number(pid) !== process.pid && (alive(pid) || (fs.rmSync(path.join(runs, pid), { force: true }), false))) : [])
+  if (!others().length) {
+    fs.rmSync(dir, { recursive: true, force: true }) // left by a crashed run: from your settings again
+    fs.mkdirSync(runs, { recursive: true })
+    // your providers and keys; what HeartCode learned about each model and prices (or it tests them again)
+    for (const f of ['config.json', 'models', 'prices.json']) if (fs.existsSync(path.join(realHome, f))) fs.cpSync(path.join(realHome, f), path.join(dir, f), { recursive: true })
+  }
+  fs.writeFileSync(path.join(runs, String(process.pid)), '')
   process.env.HEART_HOME = dir
-  process.on('exit', () => fs.rmSync(dir, { recursive: true, force: true }))
+  process.on('exit', () => {
+    fs.rmSync(path.join(runs, String(process.pid)), { force: true })
+    if (!others().length) fs.rmSync(dir, { recursive: true, force: true })
+  })
+  process.once('SIGINT', () => process.exit(130)) // Ctrl+C (heart settings, -p): through 'exit', so the folder goes too
 }
 
 // a folder first: HeartCode opens it (subcommands and options go straight through)