ARNO

Apply several edits as one atomic unit: all land or none do. Ops: replace_text, replace_range, replace_symbol, delete_symbol, insert. Anchors are validated before anything is written, touched files are formatted, and one validation runs at the end instead of one per edit. Prefer this over several single edits when changing more than one site.

What ARNO can do in this workspace, in one call: per language, whether a grammar or a text scan reads it, which language server runs or is missing, and which formatter applies; whether git is there; the build, typecheck and test commands check would run; declared commands. Call it first in an unfamiliar repository instead of learning from failed calls.

Return the current workspace revision and a list of changed paths.

Run a validation command on demand and wait for the verdict: kind build (default), typecheck or tests. Uses the repository's own Makefile target, npm script or cargo command when present. Waits by default and returns pass/fail directly. Every result names the command that ran; dryRun names it without running anything. In a repository with several projects, pass target to check one; with no command at the root, the answer lists the projects.

Mark a revertible point: snapshots the files ARNO has edited this session and records git's HEAD. Not a commit, and does not touch git. Checkpoints last for the session.

Assemble everything needed to act on one symbol in a single call: implementation, related types, direct callers, tests exercising it, current diagnostics, and whether it changed since HEAD. Replaces find + references + test search + diagnostics round trips.

Create a brand-new file, and any missing parent directories. Refuses to overwrite an existing one — use replace_text or apply to modify existing content.

Declare a named command in .arno/commands.json — a reproduction, a benchmark — to run with run_command in this and later sessions; the file is reviewed like any change. Declaring an existing name replaces it; do not redeclare one just to run it.

Delete a file, not a directory; fails if it does not exist. Reverting to an earlier checkpoint recreates it. To edit content use replace_text or apply.

Delete one declaration entirely. The range comes from arno's parse, so the caller never has to find the closing brace; the blank line the declaration left behind is removed too.

Return the actual patch text for the workspace or one path — the 'what changed' companion to changes()'s 'how much changed'. Includes untracked files. Pass since to diff against another revision (HEAD~3, a branch, a SHA), which is how to see what a branch has done once part of the work is already committed. A large patch comes a page at a time, whole lines, with continue=<handle> for the rest.

Poll the event stream starting after a cursor position.

Locate declarations by name AND return their source in one call — the fused search-and-read that replaces `grep -n 'func X' -A 30`. Exact name matches win over substring ones. Use this instead of outline and read_range when you have not located the symbol yet. Pass queries to find several names in one call.

Literal or regex text search across the workspace, returning path:line matches with optional trailing context — the replacement for `grep -rn`. Use this for anything that is not a declaration name: struct fields, string literals, error messages, config keys, or any search needing a path filter. Use find instead when you want a declaration and its body. Pass queries to search several patterns in one call.

List the commits that touched one symbol's lines, via git log -L — 'why does this code exist' without reading a whole file's history. Commits only by default; set includePatch for the diff hunks.

Add text to a file without replacing anything — a new function, a new section, an extra case. Use this for additive work instead of rewriting a surrounding symbol. With no anchor it appends to the end of the file; with one it places the text before or after that anchor, refusing if the anchor is absent or matches more than once. Several additions or edits at once belong in apply.

Fetch the raw output for a background validation job after a summary was already returned. A long output comes a page at a time, whole lines, with continue=<handle> for the rest.

Fetch the status and decisive summary for a background validation job.

Return the declaration outline for a file, along with freshness and structured section buckets.

Read a file verbatim, whole or by line range — the replacement for `cat` and `sed -n`. Omit both line numbers to read the whole file, which is how to read go.mod, a Makefile, or any JSON/YAML/TOML config that has no symbols to address. An end line past the end of the file reads to the end. A dependency's source reads as dep:<name>/<path>, read-only. Several ranges, in one file or many, go in one call: {"ranges": [{"path": "a.go", "lines": "280-400"}, {"path": "b.go", "lines": "700-760"}]}.

Find where a symbol is referenced. Uses gopls when available (Source=lsp, compiler-resolved); otherwise falls back to the approximate name-matched call graph (Source=approximate).

Rename a symbol repository-wide via gopls, rewriting every call site deterministically. Refuses rather than guessing when gopls is unavailable or the language is unsupported — it never renames from approximate name matches.

Overwrite an existing file's entire contents — for rewriting a document rather than amending it, where there is no anchor to edit against. Refuses to create a new file; use create_file for that. Prefer replace_text or apply when only part of the file changes.

Replace a whole declaration. symbolId takes either the full path::Name@line ID or just path::Name when that name is unique in the file — no lookup call needed first. An ambiguous name is refused with the candidates listed.

Replace an exact, unique string in a file. An anchor string does not move when the lines around it do, which is why follow-up edits address text rather than line numbers. Refuses when the anchor is absent or matches more than once — extend it with surrounding context to disambiguate. For several sites, use apply: atomic, one validation, no diagnostics from half-done intermediate states.

Select the most relevant files and symbols within a token budget for a task query.

Restore the files ARNO changed to their state at a checkpoint — edited files restored, files deleted since recreated, files created since removed — as one new revision, all or nothing. Only files ARNO touched are restored, and git is never moved. Refuses if a commit has landed since the checkpoint, because restoring would overwrite committed work — use git to move past a commit.

Run a command the repository declares, by name, and wait for the verdict: pass/fail with the decisive output. Use it instead of a shell for anything check does not cover. No name lists the declared commands. Nothing fits? declare_command it once.

Rerun a failing test, a test file, or changed files' tests; waits for pass/fail and the first failure. Full suite: check kind tests.

Report how arno's own tools have been used in this workspace: calls, response bytes and timing per tool, plus the failure classes that most often end with a caller falling back to the shell. Records no arguments, no response bodies and no error text.

Declare which git worktree this session works in, or list them. ARNO serves the worktree it was started in, whatever directory the caller is in now, so a session working in another worktree must say so once: workspace path=<its worktree>. Every later call then acts there, and so do the session's subagents. A subagent working in a different worktree passes root=<path> on its own calls instead. Call with no path to list the worktrees and see which is the default.

Return a plain, bounded directory/file structure listing for orientation (not relevance-ranked).