Deterministic wiki

Repowise renders the whole wiki from your code's structure: the parsed AST, the dependency graph, and git history, with no model in the loop. That structural wiki is complete on its own and costs nothing. A model is not a second way to build the wiki. It adds one thing: prose on the subsystem (concept) pages, the numbered tree that describes how the codebase fits together above the file level.

Without a key those subsystem pages are structural stubs and every other page is already final, which makes a keyless run the right first pass on a codebase you have not indexed before.

How to get it#

repowise init --yes              # keyless: structural wiki, subsystem pages as stubs
repowise init --yes --no-prose   # the same thing, guaranteed no spend

--no-prose renders the subsystem pages as stubs instead of prose. --prose asks for the model prose and needs a key. (--index-only and --docs llm|deterministic still work as deprecated aliases: --index-only and --docs deterministic map to --no-prose, --docs llm maps to --prose.)

You also land on the keyless wiki without asking, in three cases:

• No provider is resolvable (no key set, no --provider, nothing in config).
• You answer No at the cost gate. The index you already built is kept and the subsystem pages are left as stubs.
• The cost gate has no terminal to ask on. When stdin is not a TTY it never prompts, it auto-declines, which is what makes repowise init --yes safe to run from a script or an agent.

What it renders#

The full page set. Every type below is rendered from structure with no key. The subsystem-and-overview set is where a model, when configured, replaces the stub with prose; a keyless run leaves it structural.

The pages are honest about where they came from. A structural page ends with a footer saying it was derived from structure, and a structural repo overview describes composition, entry points, clusters, and dependencies rather than what the project does end to end, because no structural render can derive intent from an AST. Architecture diagrams are the one exception to the keyless/with-key split above: they are derived deterministically from the dependency graph with no model in the layout path either way, so adding a key buys you prose, never a different diagram.

What it costs#

Nothing. No API key, no tokens, no outbound network calls on the generation pass. It is the same local computation that produces the graph, git, health, and dead-code layers, applied to page rendering.

What it lacks#

Two things, and they are worth being clear about:

Prose on the subsystem pages. A structural page can say that PaymentProcessor is called by six modules, sits in the checkout cluster, and has been bug-fixed four times this quarter. It cannot say why retries were made idempotent. That paragraph, across the concept tree and the overview, is what the model pass buys you. Your file pages do not change: they are structural either way.

Semantic search, until you configure an embedder. Full-text and symbol search work on a keyless index. Concept search and the RAG behind get_answer need embeddings, and the embedder defaults to mock when no key is detected. The embedder is separate from the LLM provider, so you can add semantic search without ever writing a page with a model. See Environment variables.

Everything else, the dependency graph, git signals, hotspots, ownership, bus factor, code health, dead code, change risk, decision archaeology, and the MCP tools built on them, is identical either way. None of it was ever a model product.

Adding the prose later#

The upgrade works in place on the index you already have. It does not re-index from scratch.

A slice at a time, with repowise generate:

repowise generate                       # every unwritten subsystem page, one cost estimate
repowise generate --path src/api        # just the subsystem pages under one directory
repowise generate --all                 # rewrite the prose on every subsystem page

The whole wiki at once, with repowise update --full:

repowise update --full --provider anthropic

Semantic search, once an embedder is configured, with repowise reindex. That embeds the pages you have. No LLM calls, no page regeneration.

In the dashboard, the Docs view on a keyless repo offers the generation job directly rather than showing you an empty page.

Related#

• Auto-generated wiki, the subsystem prose pass
• Quickstart, the keyless first run
• Indexing commands, init, update, generate