daimon 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -4,6 +4,58 @@ All notable changes to Daimon are documented here. The format follows [Keep a Ch
 
 ## [Unreleased]
 
+## [0.7.0] — 2026-05-20
+
+Strategic theme: **Memory and reach.** v0.7 makes the *past* actionable (history surfaces) and broadens *what* daimon can manage (polyglot dev servers, whole-workspace orchestration, refreshed TUI).
+
+### Added (M37) — History dashboard surface
+
+- **T1a — Bundle-size persistence.** New `bundles` table in `~/.daimon/history.db` (`app, ts, initialKB, lazyKB, fileCount`). The registry persists one row per `onBundleUpdate` (Angular esbuild bundle parse), so the dashboard can render long-term bundle trends without an external store. The new table is additive — v0.6 history.db files migrate forward automatically on first open via `CREATE TABLE IF NOT EXISTS`. `daimon snapshot` carries the last 100 bundle rows per app in the payload.
+- **T1b — `GET /api/history/trends`.** New aggregated time-series endpoint: `?app=<name>&metric=<compile|bundle|errors|restarts>&since=<24h|7d|30d>` returns `{app, metric, since, points:[{t, v, v2?}], _meta:{aggregation, count}}`. `compile` averages ms per bucket. `bundle` returns initialKB as `v` and lazyKB as `v2`. `errors` counts `error-new` + `error-recur` events per bucket. `restarts` counts `status` transitions where `to=starting` and `from ∈ {error, serving, compiling}`. Aggregation is hour-buckets for `24h` and day-buckets for `7d`/`30d`. Companion endpoint `/api/history/bundles` returns raw rows.
+- **T1c — Dashboard `Trends` route.** New lazy-loaded `/trends` page with four charts (compile · bundle · errors · restarts) rendered via the existing chart.js lazy chunk from M30 — no new chart dep. Bundle chart stacks initialKB + lazyKB per app. Toggle between `24h` / `7d` / `30d` and between "All apps" and a single-app focus. Linked from the nav rail with `g t` shortcut.
+- **T1d — Fixture-daemon harness (partial H1).** New `test/history-trends.test.mjs` exercises `History.recordBundle` / `queryBundles` and the four `trends()` aggregations against a temp sqlite db, so the Trends backend is verified without a real `~/.daimon/history.db`. Wired into `npm test`.
+
+### Deferred (M37 → v0.7.1)
+
+- **H1 — Vitest + Playwright dashboard scaffolding.** The non-trivial dev-dep + per-component spec layer carries over from v0.6.1; only the History.ts fixture-daemon harness lands in v0.7.0. Reason: keeps the Trends surface shipping on schedule while leaving the dashboard-test footprint for a focused v0.7.1 weekend.
+- **H3 — WCAG AA contrast audit.** Visual inspection task across light/dark/reduced-motion tonal surfaces — also pushed to v0.7.1 alongside H1.
+
+### Changed (M37)
+
+- **Initial-route gzip transfer: 126.44 KB** — Trends route + `getTrends` + `getBundles` API are entirely lazy. Initial bundle stays under the 130 KB v0.6 ceiling.
+
+### Added (M38) — Whole-workspace orchestration
+
+- **T2a — `daimon orchestrate <profile>`.** New CLI / HTTP / MCP verb. `POST /api/orchestrate?profile=<name>&goal=serving|healthy|stable&timeoutMs=<n>[&dryRun=true&budget=<tokens>]`. Resolves the profile's app list, cascade-starts every app via the existing F18 depends-topo ordering, waits up to `timeoutMs/2` per app for the goal, and runs **one** round of `runAutoFix` + restart + wait on stragglers. Returns `{profile, goal, perApp:[{name, reached, tries, fixed?, stillFailing?:[…first 3 parsed errors], waitedMs}], totalMs, allReached}`. `goal=stable` requires serving + healthy + 5s idle (same definition as `focus --until stable`).
+- **T2b — MCP `orchestrate` tool.** Same surface exposed to Claude; documented as the recommended way to "bring up my whole workspace" in one call. Inputs: `profile, goal?, timeoutMs?, dryRun?, budget?`. Returns the same shape as the HTTP endpoint.
+- **T2c — Idempotency + dry-run.** Apps already at goal are no-ops (`tries:0, reached:true`). `--dry-run` returns `{dryRun:true, plannedOrder:[…topo levels…], alreadyHealthy:[…]}` without starting anything.
+- **`--budget <tokens>`.** Honors a token budget like `overview`: drops `stillFailing` entries first (≈60 tokens each), then trims already-reached `perApp` rows, recording counts in `_meta.omitted`.
+- **Decision locked in (no recursion).** Orchestrate runs at most **one** try-fix round per app. Stragglers land in `stillFailing` and the caller decides the next move. Keeps results predictable, preserves per-rule attribution, and avoids compound-round confusion. Upgrade path is bounded-by-progress retry, not an N-round cap.
+- **Tests:** new `test/orchestrate.test.mjs` covers (1) dry-run reports planned order, (2) unknown profile error, (3) already-healthy short-circuit, (4) happy-path cascade reaches goal, (5) one try-fix round + stillFailing surfacing.
+
+### Added (M39) — Polyglot dev-server discovery
+
+- **T3a — Marker-file detectors for non-JS stacks.** `discoverApps` now detects Django (`manage.py` containing a `django` import), Rails (`bin/rails` + `Gemfile`), FastAPI (`fastapi` mention in `pyproject.toml` or `requirements.txt`), Go air (`.air.toml` or `air.toml`), and Rust trunk (`Trunk.toml`). Each profile gets a sensible default serve command (`python manage.py runserver`, `bin/rails server`, `uvicorn main:app --reload`, `air`, `trunk serve`) which can be overridden via `overrides.<name>.command`.
+- **T3b — `DiscoveredApp.serverProfile`.** New optional field — `'angular'|'nx'|'vite'|'storybook'|'django'|'rails'|'fastapi'|'go-air'|'rust-trunk'`. Existing JS detectors now also tag their apps with `serverProfile` matching `workspaceType`. Polyglot apps get `workspaceType: 'polyglot'` + a specific `serverProfile`. The field is additive; v0.6 configs and snapshots still parse unchanged.
+- **T3c — Polyglot parser hints.** `parseLine` gains serving / compiling / error patterns for Django (`Watching for file changes with StatReloader` → compiling, `Quit the server with CONTROL-C` → serving, `Traceback` + `File "..."` back-fill → error+location), Rails (`Puma starting`, `Use Ctrl-C to stop`, `ActionController::*` / `NameError(...)` + `file.rb:L:in` back-fill), FastAPI (`Uvicorn running on`, `Application startup complete`, ASGI tracebacks), Go air (`building...`, `running...`, `file.go:L:C:` location detection + `panic:` patterns), and Rust trunk (`error[E0425]` + `--> file.rs:L:C` back-fill). New `ParserTool` values: `django`, `rails`, `fastapi`, `go-air`, `rust-trunk`, `python`. Stack-trace locations now resolve `.py` / `.rb` / `.go` / `.rs` file extensions alongside JS/TS.
+- **T3d — `daimon discover --explain` updates.** `/api/discovery/explain` (and `daimon discover --explain` / `daimon list --explain`) now annotate each detected app with `workspaceType` + `serverProfile` and append a `N polyglot app(s) found (django, fastapi, ...)` hint to the suggestion when any non-JS profile is present. The rejection-reason hint now also mentions `manage.py / Gemfile / pyproject.toml (fastapi) / .air.toml / Trunk.toml`.
+- **Polyglot doctor rules (report-only).** Three new sibling rules to M36's `orphan-node-modules`: `orphan-venv` (Python — flags missing `.venv` / `venv` or one stamped older than `pyproject.toml` / `requirements.txt`), `orphan-bundler-cache` (Ruby — `vendor/bundle` missing or older than `Gemfile.lock`), `orphan-cargo-target` (Rust — `target/` missing or older than `Cargo.lock`). All three are **report-only** and emit a `would suggest: ...` paragraph — daimon never runs `pip install`, `bundle install`, or `cargo build`. Default `doctor.autoFix.permitted` extends to include them.
+- **Parser corpus fixtures.** New `test/fixtures/parsers/{django,rails,fastapi,go-air,rust-trunk}.{log,expected.json}` covered by the existing M33 corpus test (≥95% capture rate + tool + status assertions).
+- **Tests:** new `test/polyglot-discovery.test.mjs` covers each detector (strict markers — `manage.py` without `django` import is rejected; JS detector precedence on Vite + `manage.py`; JS apps still tagged with `serverProfile === workspaceType`).
+- **Decisions locked in** (re-affirmed from PLAN-v0.7.md):
+  - Daimon **never invokes** `pip install`, `bundle install`, `cargo build`, `go mod download` — the polyglot orphan rules are report-only, never a shell-out.
+  - Polyglot detectors run **unconditionally** on every searchRoot, guarded by strict markers (`manage.py` must contain `django`, `pyproject.toml`/`requirements.txt` must declare `fastapi`) and JS precedence (`nx.json`/`angular.json`/vite/storybook detected first).
+  - No new `searchRoots[*].polyglot: true` opt-in is introduced.
+
+### Added (M40) — TUI parity refresh
+
+- **T6a — Shortcut alignment.** The Ink TUI now uses `/` for filter (the prior `t` tag-pick remains), `j`/`k` (in addition to `↑`/`↓`) for navigation, a `g <key>` chord that surfaces dashboard-style view hints (`g a` apps, `g e` errors, `g v` events, `g s` settings, `g n` sessions), and `r` requires a `y`/`n` snack-confirm before restarting — matching the dashboard's M35 anti-fatfinger behaviour. `o` (open URL) and `s` (start) are preserved. Stop is rebound to `S` (shift-S) because `x` now means try-fix (per T6c).
+- **T6b — Per-app 20-cell event ribbon.** Each app row in the TUI gains a second line with a 20-cell ASCII bar (`▓▓░▒▓▓░░░░░░░░░░░░░░ srv·err·cmp·stp`) representing the last 60 minutes of status events, computed with the same algorithm as the dashboard's H5 ribbon. Glyphs: `▓` serving, `█` error, `▒` compiling/starting, `░` stopped, `·` empty bucket. Powered by the new `src/tui/ribbon.ts` helper (covered by `test/tui-ribbon.test.mjs`).
+- **T6c — Focus / try-fix / orchestrate from the TUI.** New action keys on the selected app: `f` runs the M34 "focus until stable" wait (5s idle on serving + healthy, 180s budget) and surfaces the outcome in the footer status line; `x` runs `try-fix` (runAutoFix on the permitted rule set + restart + wait for healthy) and reports `fixed N` + reached/timeout; `O` (shift-O) opens an inline orchestrate dialog — type a profile name + Enter to run the M38 `orchestrateProfile` with `goal=healthy, timeoutMs=300_000` and see the result on the footer. All three call the in-process registry directly (no HTTP round-trip), so the TUI keeps working over SSH without network access.
+- **T6d — Headless mode unchanged.** `--headless` + `config.headless: true` continue to skip the TUI entirely. No new daemon flags.
+- **Footer status line.** A new auto-dismissing `[i] …` line surfaces the outcome of `f` / `x` / `O` actions (plus `r` confirm and `g <key>` view hints) for ~4 seconds — necessary because the TUI no longer relitigates ambient state when an in-flight action completes.
+- **Tests:** new `test/tui-ribbon.test.mjs` covers the ribbon helper (60-min window, error-over-serving ranking, per-app filtering, glyph rendering, count aggregation).
+
 ## [0.6.0] — 2026-05-20
 
 Strategic theme: **Every signal becomes actionable.** M33 deepens parser coverage so every tool's errors land structured; M34 turns daimon into a 3-call agent surface (overview → try-fix → focus); M35 ships keyboard / logs / ribbon polish; M36 broadens auto-heal with four new doctor rules and opt-in health-probe path discovery.

package/README.md

@@ -1,6 +1,6 @@
 # Daimon
 
-A local manager for Angular / Nx / Vite / Storybook dev servers. One daemon owns all your `serve` processes, auto-assigns ports, dedup'd error captures, exposes a loopback HTTP API + JSON CLI + MCP server. Built so you and Claude Code can both query app state without parsing thousands of log lines.
+A local manager for dev servers: Angular / Nx / Vite / Storybook out of the box, plus Django / Rails / FastAPI / Go-air / Rust-trunk (v0.7). One daemon owns all your `serve` processes, auto-assigns ports, dedup'd error captures across every supported tool, exposes a loopback HTTP API + JSON CLI + MCP server. Built so you and Claude Code can both query app state without parsing thousands of log lines.
 
 Loopback only. Single user. No cloud. No telemetry.
 
@@ -69,10 +69,10 @@ The daemon auto-spawns on the first `daimon` call that needs it. To suppress: `D
 ## CLI
 
 ```bash
-daimon list [--tag <name>] [--workspace <label>]
-daimon status <name>
+daimon list [--tag <name>] [--workspace <label>] [--explain] [--full] [--stream]
+daimon status <name> [--full]
 daimon errors <name> [--since 2m] [--since-last] [--client <id>] [--structured]
-daimon events [--since 1h] [--app <name>]
+daimon events [--since 1h] [--app <name>] [--stream]
 daimon wait <name> [--until serving|healthy|stopped|error] [--timeout 60s]
 daimon logs <name> [--tail N] [--since 30s]
 daimon start <name> [--with-deps]
@@ -80,39 +80,59 @@ daimon stop <name>
 daimon restart <name>
 daimon up [<profile>]              # topological start; waits for each level to reach healthy
 daimon down [<profile>]
+daimon overview [--workspace <label>] [--profile <name>] [--budget <tokens>]   # decision-ready snapshot
+daimon ensure <name> [--until serving|healthy] [--timeout 60s]
+daimon ensure-up <profile> [--until serving|healthy] [--timeout 60s]
+daimon focus <name> [--until serving|healthy|stable] [--timeout 180s]          # one-shot subscribe-then-act (v0.6)
+daimon try-fix <name> [--until healthy] [--timeout 60s]                        # doctor + restart + wait (v0.6)
+daimon orchestrate <profile> [--goal serving|healthy|stable] [--dry-run] [--budget <tokens>]   # whole-workspace bring-up (v0.7)
+daimon trends <name> --metric compile|bundle|errors|restarts [--since 24h|7d|30d]   # history time-series (v0.7)
+daimon discover [--explain] [--dry-run]   # what daimon would (or did) detect
+daimon why-empty                   # alias of `daimon list --explain`
 daimon history <name>              # uptime%, restart count, compile p50/p95, top errors
-daimon why <name>                  # last transition + 5 preceding events (great for "what just broke")
+daimon why <name>                  # last transition + 5 preceding events
 daimon tasks <name>                # discovered non-serve tasks
 daimon run <name> <task> [--watch] [-- args...]
 daimon snapshot <name>             # bundle state for bug reports
 daimon env <name> [--use <file>]   # env-file switcher
 daimon clean <name> [--deep] [--yes]
 daimon record / replay
-daimon doctor                      # config sanity checks; does not need the daemon
+daimon doctor [--auto-fix] [--dry-run]    # config sanity checks + rule-based self-repair (v0.5+)
+daimon pin-health <name> [--accept] [--path <p>]   # opt-in health-probe path discovery (v0.6)
+daimon export-config [--redacted]   # paste-ready config for bug reports
 daimon free-port <port> [--force]
-daimon init                        # interactive config scaffolder
+daimon init [--auto]               # interactive (or non-interactive) config scaffolder
 ```
 
-All CLI commands print compact JSON on stdout. Errors are compact JSON on stderr with non-zero exit. Exit codes: `0` success, `1` generic error, `2` timeout (used by `daimon wait`).
+All CLI commands print compact JSON on stdout by default (`--full` for the verbose v0.4 shape). Errors are compact JSON on stderr with non-zero exit. Exit codes: `0` success, `1` generic error, `2` timeout (used by `daimon wait`, `daimon focus`, `daimon ensure*`).
 
 ## HTTP API
 
-Bound to `127.0.0.1:<apiPort>` only. The dashboard at `/` lets you inspect state, restart apps, expand error drawers, and (in v0.4) edit configuration.
+Bound to `127.0.0.1:<apiPort>` only. The dashboard at `/` is an Angular 20 SPA (Material 3, zoneless, signals) bundled into the published tarball — it shows apps, errors grouped by file/app/tool, live logs, doctor, trends (v0.7), settings editor, and one-click actions.
 
 ```
-GET  /api/apps
+GET  /api/apps                                  # compact by default; ?format=full for v0.4 shape
 GET  /api/apps/:name
 GET  /api/apps/:name/errors[?since=2m]
 GET  /api/apps/:name/errors/since-last?client=<id>
 GET  /api/apps/:name/logs?tail=N&since=30s
-GET  /api/apps/:name/logs/stream         # Server-Sent Events
+GET  /api/apps/:name/logs/stream                # Server-Sent Events
 GET  /api/apps/:name/wait?until=serving&timeout=60
-GET  /api/events?since=5m&app=<name>
+GET  /api/events[?since=5m&app=<name>&stream=ndjson]
+GET  /api/overview[?budget=<tokens>&workspace=&profile=]      # v0.5
+GET  /api/discovery/explain                                    # v0.5
 GET  /api/history/{events,compile-times,tasks,summary/:name,why/:name}
-GET  /api/config                          # current config (env redacted)
+GET  /api/history/trends?app=&metric=&since=                  # v0.7
+GET  /api/history/bundles?app=                                # v0.7
+GET  /api/config                                # current config (env redacted)
 POST /api/apps/:name/(start|stop|restart|snapshot|clean|run/:task)
-PATCH /api/config                         # If-Match: <etag>; 412 on conflict
-POST /api/config/reload                   # soft reload — no running children killed
+POST /api/apps/:name/focus?until=…              # NDJSON event stream (v0.6)
+POST /api/apps/:name/try-fix?until=…            # v0.6
+POST /api/apps/:name/health/pin                 # v0.6 (with --accept)
+POST /api/orchestrate?profile=&goal=&timeoutMs=&dryRun=&budget=   # v0.7
+POST /api/doctor/auto-fix[?dryRun=true]
+PATCH /api/config                               # If-Match: <etag>; 412 on conflict
+POST /api/config/reload                         # soft reload — no running children killed
 POST /api/shutdown
 ```
 
@@ -121,34 +141,28 @@ If `config.apiToken` is set, mutating endpoints require `Authorization: Bearer <
 ## Claude Code integration
 
 ```bash
-daimon claude install --all
-# or pick: --skill, --commands, --agent
-# or interactive: daimon claude install
+daimon claude install        # writes a single SKILL.md (no per-command slash files since v0.5)
 ```
 
-Three selectable artifacts:
+Daimon installs a single skill at `~/.claude/skills/daimon/SKILL.md` (~120 useful tokens) that documents every verb inline. Old per-command `~/.claude/commands/daimon-*.md` files from v0.3/v0.4 are removed (or renamed to `.bak` if you've edited them since install). An optional `~/.claude/agents/daimon-runner.md` subagent can be installed with `--agent`.
 
-- **Skill** at `~/.claude/skills/daimon/SKILL.md` — comprehensive how-to and recipes.
-- **Slash commands** at `~/.claude/commands/daimon-{status,start,stop,restart,errors,logs,up,doctor,why,wait}.md`.
-- **Subagent** at `~/.claude/agents/daimon-runner.md` — specialized dev-loop orchestrator.
-
-Templates are rendered from a single source of truth (`src/cliSurface.ts`), so they cannot drift from the actual command surface.
+The skill is rendered from a single source of truth (`src/cliSurface.ts`) so it cannot drift from the actual command surface.
 
 Daimon stamps the current version into the artifact frontmatter. When you upgrade daimon, the next CLI call nudges you (once per 24h) to run `daimon claude update`. Silence with `DAIMON_NO_CLAUDE_NUDGE=1`.
 
 ```bash
 daimon claude status        # what's installed and at which version
 daimon claude update        # refresh based on the install manifest
-daimon claude uninstall [--all|--skill|--commands|--agent]
+daimon claude uninstall
 ```
 
-For raw MCP use (without slash commands or a subagent):
+For raw MCP use:
 
 ```bash
 claude mcp add daimon -- daimon mcp
 ```
 
-The MCP server exposes: `list_apps`, `get_status`, `get_errors`, `get_logs`, `start_app`, `stop_app`, `restart_app`, `wait_for_app`.
+The MCP server exposes: `list_apps`, `get_status`, `get_errors`, `get_logs`, `start_app`, `stop_app`, `restart_app`, `wait_for_app`, plus the agent-first verbs added in v0.5–v0.7: `overview`, `ensure`, `ensure_up`, `focus`, `try_fix`, `diff_errors`, `orchestrate`. The recommended session opener is `overview` (compact-by-default, token-budgetable); the recommended one-call workspace bring-up is `orchestrate <profile> goal=stable`.
 
 ## State files (in `~/.daimon/`)
 
@@ -156,7 +170,7 @@ The MCP server exposes: `list_apps`, `get_status`, `get_errors`, `get_logs`, `st
 - `daemon.lock` — `{ pid, apiPort, version, startedAt, headless }`
 - `state.json` — sticky port assignments
 - `cursors.json` — per-client error cursors for `--since-last`
-- `history.db` — SQLite of events, compile times, task runs
+- `history.db` — SQLite of events, compile times, task runs, and per-app bundle sizes (the last powers the v0.7 Trends dashboard)
 - `logs/<name>.log[.N]` — when `logs.enabled` is true
 - `snapshots/<name>-<ts>.json` — `daimon snapshot` output
 - `notifications.log` — desktop notification audit
@@ -183,7 +197,7 @@ The `summary.url` field returned by the API was synthetic `http://127.0.0.1:<por
 npm test
 ```
 
-Four small `node:test` files cover dependency-graph math, bundle parsing, notifier throttling, and compile-time regression. No vitest dependency.
+60 `node:test` cases across small focused files: dependency-graph math, bundle parsing, notifier throttling, compile-time regression, the parser fixture corpus (Vite/Storybook/Jest/Nx/Angular esbuild/webpack/Node/Django/Rails/FastAPI/Go-air/Rust-trunk — see `test/fixtures/parsers/`), `overview` budget truncation, auto-fix rule registry, `orchestrate` dry-run/cascade/try-fix paths, polyglot discovery (strict markers + JS precedence), and the TUI ribbon helper. No vitest dependency. The dashboard's Vitest + Playwright layer is deferred to v0.7.1.
 
 ## License