trace_execution
python3 only. Runs the same sandboxed executor executecode uses, plus a per-line event trace (events: line/call/return/exception, changed locals per step) and a static branch/line-coverage report (branches, linesexecuted, linesneverexecuted) from an AST parse — answers "which lines ran, in what orde
How to use it
Project documentation lists trace_execution for the Codecalc MCP server. Add the server to your MCP client (Claude Desktop, Cursor, Windsurf and others), then check which tools your installed version makes available. Tool availability can depend on configuration and credentials. A server handshake does not verify this tool’s behavior. See the full listing for setup details.
Install Codecalc
uvx codecalc[full]Other tools in Codecalc (39)
Are (ab)/c and a(b/c) identical? refactor verification (with float/truncation caveat)
Static Big-O estimate from code structure, parsed with tree-sitter (every supported language). Reports analysis: tree-sitter\
Programmer-mode integer facts and operations, selected by mode: analysis (was bitanalysis), op (was bitop), widths (was intwidths), repr (was baserepr) — those four former standalone tools were retired in 0.12.0 (CHANGELOG.md)
python3 only. Decides, with z3, which if/elif/else arms and while/for(range, static bounds) loops in ONE function can ever be taken for ANY input — reachable/dead/unknown per branch, a witness when reachable, and boundaryinputs (min/max/equality-edge, via z3 Optimize) shaped for compareedgecases's t
EXACT arithmetic: 0.1+0.2 == 0.3 is True; arbitrary-precision ints, bitwise ops inline, whitelisted math funcs, pi/e/tau
mean, median, sample stdev, CV (CV > 0.2 = noise swamps the effect)
Birthday-bound hash collision: 1e5 items/32 bits ≈ 0.69, 1e6/64 ≈ 2.7e-8
Run the same logic in N languages on edge-case inputs (empty, zero, negative, float precision) and flag behavioral divergence
Exact threshold verdict with shortfall: ('1/25', '>', '0.05') → False, shortfall 1/100
Dimensional unit conversion via sympy: length, mass, time, speed, energy, power, force, pressure, temperature (°C/°F/K), volume, area, data, frequency
Byte sizes both ways: KiB/MiB (binary) AND KB/MB (decimal)
Epoch s/ms/µs/ns → ISO 8601 UTC, implausible readings suppressed
Symbolic math: integrate(x2, x), sqrt(144) + 210
Run code in any language → stdout/stderr/exitcode/verdict (OK/TLE/MLE/OLE/RTE)/cpums/peakmemorykb; per-call limits (maxmemorymb, maxoutputkb, maxcpu), nonet, compact. With a session and no explicit maxoutputkb, oversized output spills into the session workspace (stdoutspill/stderrspill) instead of j
Provider-selected execution using the same canonical limits as executecode, with progress + partial output when the provider supports streaming
Pull a named function + its dependency closure (imports, referenced helpers) into a standalone program and run it (ast-exact for python3, best-effort elsewhere)
What binary64 actually stores: exact value, raw bits, ULP, neighbours, representable-or-not
Humanised duration + per-day/per-30d rates
Install packages (uv pip/npm/gem/go/cargo...) into a session or shared cache
Execution-provider identity, interface version, host class, and machine-readable capabilities
31 languages with extension, compile flag, runtime availability
All 140+ unit aliases for convertunits
Structured matrix ops: det/inverse/eigenvalues/transpose/rank/trace on a rows array — never a caller string through sympify, so evaluateexpression's [/] RCE screen never applies. Each entry screened individually
Exact share and percentage of PART/TOTAL (rationals accepted)
p50/p90/p95/p99 by nearest-rank AND interpolation; warns n<100
22 physical constants with values (c, h, NA, kB, G, g, me, R, ...)
Any base 2..36, fractions included, non-termination flagged (0.1 base 2)
Cancel a background run; idempotent on an already-terminal run, honest about providers that cannot cancel mid-flight
Poll a background run: status while running, the full executecode result shape once terminal
Submit code for background execution; returns a runid immediately instead of holding the call open
List files created by executed code (results, images, CSVs)
Multi-file programs: execute an entry file that imports other session files (helper.py, data/...) in the workspace
Archive a session's workspace to a snapshot stored OUTSIDE the jailed workspace (action="save"), or restore one into a new session or, with replace=True, back into the same session (action="restore"); action="list"/"delete" manage them. Files only — never a stateful session's REPL variables. Snapsho
Persistent session; python3/node get a stateful REPL worker (variables/imports persist across calls), other languages a workspace dir
Symbolic algebra, selected by op: solve (was solveexpression), solvelinear (was solvelinear, name unchanged), simplify (was simplifyexpression), limit (was limitexpression) — those four former standalone tools were retired in 0.12.0 (CHANGELOG.md)
Boolean algebra: a and b or not c, p xor q, a implies b
Prove an optimisation: you write the candidate, the executor confirms it still agrees with the original AND times both — accepted only if equivalent and measurably faster. Accepted is graded crosschecked
Prove a port is equivalent: you write the translation, the executor runs both versions on the same inputs and reports match / diverged / inconclusive per input. A pass is graded crosschecked (see Grade vocabulary)
SMT-LIB2 satisfiability + model. An unsat verdict is graded solverproven; sat is graded ungraded (decided, but not proof-shaped — see Grade vocabulary)