codeaf

Overview ¶

The cache from the command line: what it holds, and the one destructive verb that empties it.

`codeaf cache` answers the question and changes nothing. `codeaf cache clean` deletes ~/.codeaf/cache — the shared toolchain caches every task worker fills (internal/cachedir says what lives there and what never does) — and because a deletion cannot be undone it is guarded the way destructive command lines are guarded everywhere a person has already learned: the blast radius is printed first, sizes and path included, and then the confirmation is a TYPED WORD rather than a y. `rebuild` asks y/N because the journal survives it; this one actually destroys bytes, so the answer that proceeds is a word written out, and any other line — including an empty one, including EOF on a pipe — keeps everything. --yes is the scripted door and skips the question, which is rebuild's own arrangement.

AND THE WORD IS THE SAME WORD THE CHAT WANTS. In the chat the deletion is `/cache clean now`, because the chat cannot pass a flag; here it used to be the word "clean", so the one prompt in the product that deletes gigabytes asked for a different word depending on which surface a person had learned first. One word, [cacheCleanWord], in both. `--yes` stays as the script's spelling and is not a word anybody types at a prompt.

The model-call log from the command line.

`codeaf logs` is the reading end of internal/calllog: the file every model call in the process writes a line to, always, without a proxy in front of anything. The file is JSON Lines because a machine reads it too; this command exists because a person does not want to.

One line per call. A call that is still in flight shows as one — that is the whole reason the log writes a row on the way OUT as well as on the way back: a planning call four minutes into a 65,536-token ceiling used to be indistinguishable from a process doing nothing at all.

THE READER SHOWS EVERYTHING THE RECORD HOLDS. A field that is on the row and not on the line is a field a person has to leave the tool to read, and the half of the row that used to be invisible — the lane asked for, the lane that answered, what was done about a silence and what it cost — is exactly the half somebody opens this command to see. Anything the row does not carry is absent rather than zero.

Command codeaf is an agent you talk to, and hand work to when you walk away.

codeaf                       open the conversation this directory was having
codeaf do "<task>"           hand it one job and read the answer on stdout
codeaf plan new "<goal>"     write a plan to a file without running it

The static plan pipeline it opened life as is four subcommands of `plan` now, and it is one feature of many rather than the product.

The manual from the command line: every page this build carries, one page as it is written, or the sections that answer a question.

It exists because the manual had exactly one reader and it was not the person. Everything codeaf knows about itself was reachable only through the belt's `manual` tool — which is a model call, so it needs an API key, costs money on every lookup, and hands back a RETELLING that nobody can tell from an invented one. That is the exact failure internal/manual was written to prevent, and the questions people ask most are the ones they ask BEFORE any of that is set up: what is this, what does it cost, what can it do, who can see my files.

So this command needs no key, makes no model call, opens no store, spends nothing, and prints the pages VERBATIM. A person reading the manual here is reading the manual.

AND NOTHING HERE IS CUT SHORT. internal/manual's caps exist because a model pays for its context by the token; a terminal does not, and a page truncated on the one surface where the whole of it is free would be a budget wearing a reason it does not have. Paging is the terminal's job, not this command's.

The two streams every door writes to, named once so that a door cannot choose the wrong one by accident.

THE RULE, AND IT IS THE WHOLE OF THE RULE: STDOUT IS THE ANSWER — the deliverable, the JSON, the rows, the table, the thing a script captures — and everything a person reads ABOUT the run goes to stderr: the preamble, the progress, the warning, the question, the path a record was kept at.

It matters because the most common thing anybody does with a headless verb is put a pipe after it. `codeaf plan new "x" --json | jq` breaks the moment a `goal:` line is in the stream, `codeaf logs | grep -c .` is off by one while a path header is the first line, and `codeaf cache clean | tee log` used to hand the person a blank terminal waiting for a word they could not see — because the question had gone into the file with the data.

`codeaf do` already kept this exactly (do.go) and it is the standard the rest of the binary is held to. [TestNoDoorPrintsItsCommentaryToStdout] reads the package with go/ast and names any door that stops keeping it.