The literal string is right there. Any text tool handles this.
Add
pando as first param to the-id in src/metabase/util.cljc; pass nil at call sites
What is pandō?
A structural code engine for AI agents.
pandō treats code as data, not text — the way your compiler, linter, and refactor tools always have.
It operates on the graph: symbols, imports, types, call paths, re-exports.
Across the whole project.
Your agent stops grepping and starts navigating the same structure the rest of your toolchain already sees.
Why not just use text tools?
Today’s agents are genuinely smart. They plan, reason, write tests, run tools, recover from mistakes.
But when one reaches for your code, the only hand you’ve given it is grep.
Ask an agent to rename a function exported through a barrel file: it updates the declaration, forgets the re-export, and leaves the callers silently broken.
The workarounds are familiar: “don’t forget to check index.ts,” custom system prompts, “run the type-checker after every edit” loops.
Your code was never really text.
Your compiler knows. Your linter knows. Your refactor engine knows.
The agent just never got handed the graph.
Code is data.
Does it actually work?
You rename getUser to fetchProfile. Every import, every re-export, every aliased call needs to update — without touching the unrelated getUser in another module.
Text tools get the first case. pandō gets all three.
Text tools can’t tell loadUser came from this function.
Re-exported through a barrel, imported from a different path. The graph finds every one. No false positives, no false negatives.
Why bother?
Structure, not strings.
Same guarantees, every operation.
:exact
Agent-generated changes are compiler-checked before they land.
rename getUser → fetchProfile
14 call sites updated
:safe
Edits apply atomically. Either the whole graph updates, or nothing does.
move src/core.ts → src/engine.ts
23 import references updated
snapshot created · rollback ready
:local
Runs on your machine. Far less code reaches the LLM.
text tools: thousands of tokens per rename
pandō: one structural call
What's in the toolkit?
Everything operates on the graph. Here’s what ships.
Stable targets
Every target is a path + content hash. Edits to unrelated code won’t break your references.
Semantic queries
Find nodes, references, callers, requires, public vars — by meaning, not by string match.
Structural mutations
Rename, replace, insert, delete. filter-map-reduce for batch transforms across matched nodes.
System topology
See who calls what, what depends on what, how modules connect.
Safety
Pre-flight diagnostics. Post-op validation. Snapshots before every mutation. One-command rollback.
Scope control
Limit operations to a workspace, a project, or only what’s reachable from a given entry point.
First-class language support:
TypeScript · JavaScript · Python · Java · Clojure · ClojureScript · C# · C/C++ · Dart