@niroai/niro 0.9.0 → 0.10.1

package/CHANGELOG.md

@@ -2,6 +2,75 @@
 
 Notable changes to `@niroai/niro`. Dates are release dates.
 
+## 0.10.0 — 2026-08-28
+
+One command to get started, and a way to check what Niro is worth.
+
+### Upgrading
+
+```bash
+npm install -g @niroai/niro@latest
+```
+
+Nothing extra is needed from 0.9.0. Every existing command works exactly as before; the new
+ones sit alongside them.
+
+**`niro start` replaces four steps with one.** Getting started used to mean learning a sequence
+from a README: install, `niro login`, change into the right folder, `niro init`, then
+`niro mcp install`. Each step was fine on its own; the sequence was the problem, because the
+entry point was documentation and documentation is optional. One user ran `niro init` in their
+home folder. Typing `niro` on its own printed an eighteen-command help listing, which is the
+worst possible first screen for someone who knows none of them.
+
+```bash
+npx @niroai/niro start
+```
+
+That signs you in, installs itself properly, shows you what it is about to index and asks
+before uploading anything, builds the graph, connects your assistant, and offers to measure
+the difference. Run it again in any other repo and it skips whatever is already done. It opens
+by saying what Niro does and roughly how long this takes, and it asks whether you have an
+access code before it installs anything, so nobody without one fills in a form that rejects
+them at the end.
+
+Two screens are worth calling out. Before uploading, it shows you the folder, the build files
+it recognised, the module count and the git branch, and waits: the one screen worth reading
+rather than skipping. And a folder it refuses, such as your home folder, now asks for a
+different one instead of exiting, which is what made that mistake so easy to make.
+
+`niro init`, `niro login` and `niro mcp install` are untouched. They are the scriptable path,
+they take flags, and `niro start` simply calls them in order.
+
+**`niro ab` measures what Niro changes.** Rather than take our word for it, Niro can run
+*itself off* for half your sessions and show you the two halves side by side. While a window is
+open each session lands in an "on" or "off" bucket by a deterministic split; the off half works
+without Niro.
+
+```bash
+niro ab enable          # start a 14-day window (it states the scope and asks first)
+niro ab report          # the with-Niro / without-Niro comparison
+niro ab disable         # stop early
+```
+
+It applies to your whole account, not just the repo you are standing in, and it says so before
+starting. `niro start` offers it once, at the end of a first setup, and defaults to no.
+
+**Setup prints about half as much.** A real run printed roughly 230 lines and only half were
+ours. PM2's process table and generated systemd unit file, about 55 lines, are captured now and
+shown only if something fails. The assistant list shows five clients and a count rather than all
+fourteen with their config paths (`niro mcp install --list` for the rest). `niro init` stopped
+telling you to run `niro mcp install` two seconds before the wizard did it for you.
+
+**Output is indented consistently.** Printed lines used eight different indents across the CLI,
+so nothing said what belonged to what. Everything now sits on one ladder: headings and step
+markers, their messages one level in, detail one level further. Output from `niro init`, and
+from the editor CLIs it shells out to, is folded into that ladder instead of printing flush
+left in the middle of a step.
+
+**Fixes.** The spinner and the upload progress bar wrote straight to the terminal and so
+ignored indentation entirely. `niro mcp install --list` was added. Two em-dashes and one
+invented URL were removed from text you read on screen.
+
 ## 0.9.0 — 2026-08-26
 
 One change to how the client waits, and two fixes for cases where Niro and your machine

package/README.md

@@ -1,313 +1,233 @@
-# niro — MCP server + CLI (@niroai/niro)
+# niro: CLI + MCP server (`@niroai/niro`)
 
-The command-line tool **and** MCP server for [Niro](https://niroai.dev) — the AI code-intelligence platform.
+Command-line tool and MCP server for [Niro](https://niroai.dev). Niro reads your code and builds
+a map of how it fits together, so your AI assistant answers from that map instead of guessing.
 
-One package gives you three things:
+One package installs three things: the `niro` command, the MCP server your assistant talks to,
+and two agent skills so you can ask for Niro tasks in plain English.
 
-1. **`niro` CLI** — onboard repos, build the code graph, and manage projects from the terminal.
-2. **A Niro MCP server** — lets an AI assistant answer questions about *your* codebase using Niro's graph. 14 clients supported (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, GitHub Copilot CLI, Factory, Goose, OpenCode, Cline, Kiro, Antigravity, Claude Desktop) — see **[docs/connect-your-ai-assistant.md](https://unpkg.com/@niroai/niro/docs/connect-your-ai-assistant.md)** for the exact command per client.
-3. **Two agent skills** (installed by `niro mcp install`) so you can drive Niro from chat in plain English instead of typing CLI commands:
-   - **`niro-skill`** — answers questions about your code (structure, call chains, blast radius) using the Niro MCP tools.
-   - **`niro-cli`** — runs the CLI for you (onboard, status, rebuild, edit env vars, remove) from a conversation.
+Requires Node.js 18 or newer. Niro is in private beta: you need an access code, which you get
+from the **Request Access** button at [www.niro.ai](https://www.niro.ai).
 
-> **Two ways to do everything:** every task below shows the **terminal** command *and* how you'd **ask the agent**. Pick whichever you prefer — they call the same code.
-
-## Working on branches
+---
 
-Your projects cover the repos and branches you chose to index. On every question, Niro routes
-to the project matching your repo and current branch. When you are on a branch **no project
-covers** (with real changes), Niro refuses to answer from stale code. Your assistant offers the fix:
+## Get started
 
 ```bash
-niro new-temp-project     # run once in the repo folder
+cd ~/code/my-service
+npx @niroai/niro start
 ```
 
-This creates your own private copy of the project that follows your branch and your
-uncommitted edits, live (keep `niro watch` running). Your original project is not changed.
-Switching branches needs nothing: Niro answers from your copy on the new
-branch, and from the matching indexed project on branches you already cover. When your branch
-is merged:
+Signs you in, installs itself, shows you what it is about to index and asks first, builds the
+graph, and connects your assistant. Run it again in any other repo; it skips what is done.
 
-```bash
-niro discard-temp-project
-```
+Then restart your assistant and ask it something:
 
-If you forget, idle copies are cleaned up automatically after two weeks. Full guide:
-[docs/working-on-branches.md](https://unpkg.com/@niroai/niro/docs/working-on-branches.md)
-(plain-text file, ships inside the package too).
+```
+"What breaks if I change PaymentService.refund?"
+```
 
 ---
 
-## Install
+## What you can ask for
 
-```bash
-npm install -g @niroai/niro
-niro --version
-```
-
-Requires **Node.js 18+**. Background auto-sync of local folders uses [PM2](https://pm2.keymetrics.io/) — `niro init` offers to install it for you (or run `npm install -g pm2` yourself).
-
-By default the CLI talks to Niro's cloud (`https://aiorchestrator.niroai.dev`) and the MCP server to `https://aiassistant.niroai.dev`. To point at your own instance, set `NIRO_API_URL`, and pass `--url <url>` to `niro mcp install` (or set `NIRO_MCP_SERVER_URL`).
+| | |
+|---|---|
+| Anything about your code | call chains, structure, entry points, API endpoints |
+| What breaks if you change something | blast radius across services, including callers a search cannot find |
+| A standing review | issues already in the code, by severity, in the browser |
+| Root causes from your alerts | connect Sentry, Slack, Jira, Linear or CloudWatch and an alert arrives as a bug with the analysis done |
 
 ---
 
-## 60-second setup
+## Everyday commands
 
 ```bash
-niro login            # opens your browser to approve this device
-cd ~/code/my-service
-niro init             # onboard this folder: create project, upload, build the graph
-niro mcp install      # connect one AI assistant — pick it at the prompt, or pass --client
+niro status
 ```
+Is my index up to date?
 
-`niro mcp install` configures **one** assistant per run — pick it at the prompt, or pass `--client <id>`. 14 clients supported; see **[docs/connect-your-ai-assistant.md](https://unpkg.com/@niroai/niro/docs/connect-your-ai-assistant.md)** for the full list and the exact command for each. Run it once for each assistant you use. The MCP server URL is picked automatically (own instance? pass `--url <url>`). Restart your AI assistant once after, and you're done — ask it about your code, or ask it to run Niro tasks for you.
-
----
-
-## Scenario 1 — Log in
+```bash
+niro start
+```
+Index another repo. Cross-service answers need more than one.
 
-`niro login` opens a browser, you approve the device, and a long-lived credential is stored at `~/.niro/credentials.json` (mode `0600`). Short-lived tokens refresh automatically.
+```bash
+niro info
+```
+What does Niro know about this folder: repo, branch, which project it maps to.
 
-**Terminal**
 ```bash
-niro login                              # browser device flow (default)
-niro whoami                             # who am I logged in as?
-niro logout                             # revoke + remove local credentials
+niro projects
 ```
+Every project in your account.
 
-**Ask the agent**
-> "Am I logged in to Niro?" — the agent runs `niro whoami`. If you're not, it will **ask you to run `niro login` yourself** in your terminal (it can't drive a browser sign-in or handle your credentials).
+```bash
+niro build
+```
+Rebuild the index by hand and watch it finish.
 
 ---
 
-## Scenario 2 — Onboard a folder you're working in
+## Working on a branch
 
-`niro init` does the whole thing end-to-end: detect the repo, **upload its source + config files**, create a Niro project, scan for environment variables, build the graph, and (optionally) keep it synced.
+Your index covers the branches you chose to build. On a branch nothing covers, Niro says so
+rather than answering from stale code.
 
-**Terminal**
 ```bash
-cd ~/code/my-service
-niro init                       # onboard the current folder
-niro init ./api                 # onboard a specific path
-niro init --defaults            # accept discovered defaults, don't prompt
-niro init -X '**/test/**' -F '**/*.spec.ts'   # exclude modules / files
+niro new-temp-project
 ```
+Run once in the repo folder. Makes a private copy that follows your branch and uncommitted
+edits. Your shared project is untouched.
 
-During `init` you'll be asked, **per environment variable**, which value to use — and when a variable is defined in more than one config file you pick which file drives it (see Scenario 6).
-
-**Ask the agent**
-> "Onboard this folder into Niro." The `niro-cli` skill checks auth, runs `niro info` to see if it's already indexed, then runs `niro init` for you and walks you through the env-var values in chat.
-
-**Note for cloud:** Niro indexes your folder by **uploading its files** (it can't read your laptop's disk). Source and committed config files (`package.json`, `pom.xml`, `application.yml`, …) are uploaded; anything your repo `.gitignore`s (like a real `.env`) is **never** uploaded. One caveat: that filtering needs the folder to be a git repository. If you onboard a plain folder that is not a git repository, there is no `.gitignore` to honour and only the filename rules apply, so keep secrets out of it.
+```bash
+niro discard-temp-project
+```
+Run when the branch is merged. Forgotten copies are cleaned up after two weeks.
 
-**What can be onboarded:** the folder has to look like a project — a build file (`package.json`, `pom.xml`, `go.mod`, `*.csproj`, …) at the folder itself or just below it. A monorepo root whose build files sit one or two levels down is fine. A folder with no build file is refused; pass `--force` if you really mean it. Your home folder, the filesystem root and system folders are refused outright, and `--force` does not override that — onboarding one of those would upload source from every project on the machine.
+Full guide: [docs/working-on-branches.md](https://unpkg.com/@niroai/niro/docs/working-on-branches.md)
 
 ---
 
-## Scenario 3 — "What does Niro know about this folder?"
+## Measure what Niro changes
 
-**Terminal**
 ```bash
-niro info                # repo URL, branch, which project(s) map here, index status
-niro info --json         # machine-readable
-niro status              # live build status for the pinned project
-niro status my-service --json
+niro ab enable
 ```
+Runs Niro **off** for half your sessions for 14 days, so you can compare. Applies to your whole
+account, and asks before it starts.
 
-If a folder maps to **more than one** project, `info` lists them and (in the terminal) `build`/`edit`/`remove` ask you to pick one.
+```bash
+niro ab report
+```
+The with-Niro and without-Niro comparison.
 
-**Ask the agent**
-> "What does Niro know about this folder?" / "Is this repo indexed?" — the agent runs `niro info --json` and explains it.
+```bash
+niro ab disable
+```
+Stop early. Every session uses Niro again.
 
 ---
 
-## Scenario 4 — See all your projects
+## Connect another assistant
 
-**Terminal**
 ```bash
-niro projects            # account-wide list (alias: `niro ls`)
-niro projects --json
+niro mcp install
 ```
+Pick from the list, or `--client <id>` to skip the prompt. Restart the assistant afterwards.
 
-**Ask the agent**
-> "List my Niro projects." — runs `niro projects --json`.
-
----
-
-## Scenario 5 — Rebuild the index after changes
-
-**Terminal**
 ```bash
-niro build               # full rebuild of the project pinned to this folder
-niro build my-service    # by alias or id
-niro build --no-full-rebuild   # incremental
-niro build --no-watch          # trigger and return immediately
+niro mcp install --list
 ```
+All 14 supported clients and the file each one is configured through.
 
-**Ask the agent**
-> "Rebuild the Niro index for this project." — runs `niro build`.
+```bash
+niro mcp uninstall --all -y
+```
+Removes everything install added: MCP config, hooks and skills. Leaves you logged in.
 
-*(If you set up auto-sync in Scenario 8, you rarely need to rebuild by hand.)*
+Per-client details: [docs/connect-your-ai-assistant.md](https://unpkg.com/@niroai/niro/docs/connect-your-ai-assistant.md)
 
 ---
 
-## Scenario 6 — Manage environment variables (and pick which file drives each)
-
-Niro discovers env-var **names** from your code and their **default values** from committed config files. When the same variable appears in several files (e.g. `application.yml` vs `application-prod.yml`), you choose which file's value to use — the same as the web UI.
+## Managing projects
 
-**Terminal**
 ```bash
-niro edit --list-env                       # show vars, which file drives each, "appears in N files"
-niro edit --list-env --json                # machine-readable (secret values masked)
-niro edit --set-env PORT=9000              # set a value directly (never printed back)
-niro edit --set-env-from PORT=application-prod.yml   # adopt that file's value for PORT
-niro edit --rescan-env                     # re-scan after adding config files
+niro edit --list-env
 ```
+Environment variables Niro found, with secret values masked.
 
-Secret values are always masked (`****`) — whether the variable *name* looks secret (`DB_PASSWORD`) **or** its *value* embeds credentials (`DATABASE_URL=postgres://user:pass@host`). You pick those by file name; the value is never shown.
-
-**Ask the agent**
-> "Set PORT from application-prod.yml" or "What env vars does this project have?" — the agent runs `niro edit --list-env --json`, shows you the choices, and applies your pick with `--set-env-from`. It chooses **by file name** and never handles raw secret values.
-
----
+```bash
+niro edit --set-env KEY=VALUE
+```
+Set one. The value is never printed or logged.
 
-## Scenario 7 — Rename a project, or add/remove a repo
+```bash
+niro edit --alias new-name
+```
+Rename a project.
 
-**Terminal**
 ```bash
-niro edit --alias new-name                 # rename the project
-niro edit --add-repo <gitId>               # map a registered repo into the project
-niro edit --remove-repo <gitId>            # unmap a repo (non-destructive)
-niro edit --project my-service --alias renamed   # target a project explicitly
+niro remove --unmap-repo <gitId>
 ```
+Detach a repo from a project. Nothing is deleted.
 
-**Ask the agent**
-> "Rename this Niro project to `payments-api`." / "Remove repo X from this project."
+```bash
+niro remove --project --confirm-name <name>
+```
+Delete a whole project. Destructive, hence the confirmation.
 
 ---
 
-## Scenario 8 — Keep a local folder auto-synced
-
-`niro init` and `niro add repo` install a background daemon (via PM2) that re-uploads your changes and keeps the graph fresh — honoring `.gitignore` so secrets never leave your machine.
+## Keeping in sync
 
-**Terminal**
 ```bash
-niro service install     # install + start the niro-watch daemon (auto-starts on login)
 niro service status
-niro service uninstall
-niro watch               # run a watch in the foreground (debugging / no PM2)
 ```
+Is the background watcher running? It syncs your indexed folders as you edit.
 
----
-
-## Scenario 9 — Remove a project or detach a repo
-
-**Terminal**
 ```bash
-niro remove --unmap-repo <gitId>                         # detach one repo (non-destructive)
-niro remove --project --confirm-name my-service          # delete the WHOLE project (guarded)
+niro service install
 ```
+Start it and have it come back on login. Needs PM2 (`npm install -g pm2`).
 
-`--project` is destructive, so it **requires** `--confirm-name` to exactly match the project's alias or id.
-
-**Ask the agent**
-> "Remove the Niro project `my-service`." — the agent confirms with you, then runs `niro remove --project --confirm-name my-service`.
+```bash
+niro watch
+```
+Watch this folder in the foreground instead, for one session.
 
 ---
 
-## Scenario 10 — Ask your AI assistant about your code
+## Reference
 
-After `niro mcp install` (and a restart of your assistant), the `niro-skill` routes code questions through Niro's graph instead of grep:
+Add `--help` to any command for its flags. Add `--json` to `whoami`, `info`, `status`,
+`projects`, `build`, `ab report` and `edit --list-env` for machine-readable output.
 
-> "What calls `chargeCard()`?"
-> "What breaks if I change the `Invoice` schema?"
-> "Where is the auth middleware wired up?"
-> "Is there existing code that parses webhooks before I write a new one?"
+| File | What it holds |
+|---|---|
+| `~/.niro/credentials.json` | Your login, mode `0600` |
+| `~/.niro/config.json` | Backend URLs saved during setup |
+| `~/.niro/projects.json` | Per-folder sync state |
+| `.niro-project` | Pins a repo folder to a Niro project |
 
-This works in any folder that resolves to a Niro project (via its git remote or a `.niro-project` pin).
+| Variable | What it sets | Default |
+|---|---|---|
+| `NIRO_API_URL` | Backend the CLI talks to | `https://aiorchestrator.niroai.dev` |
+| `NIRO_MCP_SERVER_URL` | Backend the MCP server talks to | `https://aiassistant.niroai.dev` |
+| `NIRO_API_KEY` | Read by the MCP server when running headless. For CI, prefer `niro login --api-key` | none |
+| `NIRO_UPLOAD_CONCURRENCY` / `_TIMEOUT_MS` / `_MAX_TOTAL_BYTES` / `_MAX_FILES` | Tune the first upload | 4 / 60000 / 1 GiB / 50000 |
 
-**Where does the MCP point?**
-> "Which backend is my Niro MCP connected to?" — the `niro-cli` skill inspects your editor's MCP config and reports the URL + connection status.
+Running your own instance? Set `NIRO_API_URL` before `niro login`, and pass `--url <url>` to
+`niro mcp install`.
 
 ---
 
-## Scenario 11 — Disconnect an AI assistant (uninstall the MCP)
-
-`niro mcp uninstall` is the exact inverse of `niro mcp install`: it removes the MCP server registration and everything install added for that editor — the niro hooks in `~/.claude/settings.json`, the `## Niro MCP` section in `CLAUDE.md` / `AGENTS.md`, the generated `niro-skill` / `niro-cli` skills, and Cursor's allowlist entry + project rule. It only touches niro's own entries; your other hooks, MCP servers, and notes are left intact.
-
-**Terminal**
-```bash
-niro mcp uninstall                      # interactive: pick client(s) (or "all")
-niro mcp uninstall --client claude-code # remove from one editor, no prompt
-niro mcp uninstall --client claude-code,codex  # remove from several in one go
-niro mcp uninstall --all -y             # remove from every editor, skip the confirm
-```
-
-It does **not** sign you out — your `niro login` session in `~/.niro/credentials.json` is kept (run `niro logout` to clear it), and the `niro` command itself stays installed (remove it with `npm rm -g @niroai/niro`). The shared `~/.agents/skills` (used by both Codex and Windsurf) is only deleted once the last of those two editors is disconnected, so uninstalling one never breaks the other.
-
-**Ask the agent**
-> "Disconnect Niro from Claude Code." / "Uninstall the Niro MCP from all my editors."
-
----
+## What leaves your machine
 
-## Command reference
+Source and config files from the folder you confirmed, and nothing else. `.gitignore` is
+honoured, so a gitignored `.env` is never sent. Raw `.env` and `*.properties` files are not in
+the upload set; committed files like `application.yml` and `.env.example` are, because they hold
+defaults rather than secrets.
 
-| Command | What it does |
-|---|---|
-| `niro login` / `logout` / `whoami` | Authenticate / sign out / show current account |
-| `niro init [path]` | Onboard a folder end-to-end (upload, project, env scan, build, watch) |
-| `niro info [path]` | What Niro knows about this folder (repo, branch, project(s), status) |
-| `niro projects` (`niro ls`) | List all projects in your account |
-| `niro status [project]` | Live build status for a project |
-| `niro build [project]` | Trigger a rebuild and stream progress |
-| `niro edit …` | Rename, map/unmap repos, manage env vars (incl. `--set-env-from`) |
-| `niro remove …` | Delete a project (`--project`, guarded) or detach a repo (`--unmap-repo`) |
-| `niro add repo [path\|url]` | Register a local folder or remote git URL |
-| `niro add project` | Create a project from registered repos |
-| `niro watch [path]` / `niro service …` | Foreground watch / manage the auto-sync daemon |
-| `niro mcp install` | Connect an AI assistant + install the agent skills (one per run; `--client <id>` to skip the prompt, `--url <url>` for your own backend) |
-| `niro mcp uninstall` | Disconnect an AI assistant — reverses `mcp install` (`--client <id>` / `--all`, `-y` to skip confirm) |
-| `niro delete [project]` | Older whole-project delete (prefer `niro remove --project`) |
-
-Add `--json` to `whoami`, `info`, `status`, `projects`, `build`, and `edit --list-env` for machine-readable output. Add `--help` to any command for its full flags.
+Secret values are never printed: `--set-env` does not echo them, and `--list-env` masks anything
+that looks like a secret by name or by content.
 
 ---
 
-## Config & local state
+## If something is wrong
 
-| Location | Purpose |
-|---|---|
-| `~/.niro/credentials.json` | Auth credential + token (mode `0600`) |
-| `~/.niro/config.json` | `apiUrl` / `mcpServerUrl` saved during setup |
-| `~/.niro/projects.json` | Per-folder sync state (gitId, patterns, file hashes) |
-| `.niro-project` (in a repo) | Pins that folder to a Niro project (single line: project id or alias) |
+**The assistant ignores Niro.** Restart it. Skills load at startup, so a fresh `niro mcp install`
+does nothing until you do.
 
-| Environment variable | Purpose | Default |
-|---|---|---|
-| `NIRO_API_URL` | CLI → ai-orchestrator base URL | `https://aiorchestrator.niroai.dev` |
-| `NIRO_MCP_SERVER_URL` | MCP server (ai-assistant) base URL | `https://aiassistant.niroai.dev` |
-| `NIRO_API_KEY` | Read by the **MCP server** (e.g. headless `niro mcp serve`) — not a CLI-command auth path; for CI use `niro login --api-key` | — |
-| `NIRO_UPLOAD_CONCURRENCY` / `NIRO_UPLOAD_TIMEOUT_MS` / `NIRO_UPLOAD_MAX_TOTAL_BYTES` / `NIRO_UPLOAD_MAX_FILES` | Tune the initial upload | 4 / 60000 / 1 GiB / 50000 |
+**`niro: command not found`.** Your global npm bin is not on `PATH`. Check with `npm bin -g`.
 
----
+**This folder maps to several projects.** Pass `--project <alias|id>`, or pick one when asked.
 
-## Security notes
+**Auto-sync is not running.** `npm install -g pm2`, then `niro service install`.
 
-- **Secrets stay on your machine.** Uploads honor `.gitignore` (and `.git/info/exclude` / global excludes), so a gitignored `.env` is never sent. Raw `.env`/`*.properties` files aren't in the upload set; committed config files (`application.yml`, `.env.example`, …) are, because they hold *behavioral* defaults, not secrets.
-- **Secret values are never printed.** `--set-env` / `--set-env-from` never echo a value, and `--list-env` masks any value that looks like a secret — by key name *or* by content (connection strings, keys).
-- **The agent never handles raw secret values.** It picks env sources *by file name*; you type any real secret yourself.
+**A folder was refused.** Niro will not index your home folder, or a folder with no build file
+in it. Point it at the repo you meant.
 
 ---
 
-## Troubleshooting
-
-- **The agent doesn't run Niro commands** — restart your AI assistant after `niro mcp install` (skills load at startup). Re-running `niro mcp install` refreshes the skills if they've been updated.
-- **`niro` not found** — ensure your global npm bin is on `PATH` (`npm bin -g`).
-- **A folder maps to multiple projects** — pass `--project <alias|id>` (or pick one when prompted).
-- **Auto-sync isn't running** — install PM2 (`npm install -g pm2`) then `niro service install`.
-
----
-
-## License
-
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@niroai/niro",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "Niro — one package: the niro CLI plus the Niro MCP server (code intelligence for AI coding assistants).",
   "keywords": [
     "niro",