tovio.Sign inSee it work

Semantic diff.
Review beyond
the lines.

Which interface changed?
What needs a closer look?

TOVIO compares the code structure recorded with two commits. See exported symbols added, removed, or changed, then follow the recorded dependents to decide what to review next.

Follow a review Read the guide
One checkout change. Three separate views.
Choose the review question to explore

What changed in the source?

src/checkout/total.ts · signature excerpt

- export function calculateTotal(items: Item[]): Money
+ export function calculateTotal(
+   items: Item[], currency: Currency
+ ): Money

The exported function now requires a currency argument. A reviewer still needs to check the implementation and its callers.

Which exported symbol changed?

$ tovio semantic diff
Changed (breaking)~ calculateTotal(). (signature)

Breaking interface change(s) detected · advisory

Review the changed public definition. The classification calls attention to a possible compatibility issue; it does not prove that any particular caller breaks.

Where should review go next?

$ tovio semantic impact 'calculateTotal().' --depth 2
Recorded dependent · 1 hop
submitCheckout().src/checkout/form.ts
Recorded covering test
checkoutTotalTest().covers submitCheckout().

Inspect the recorded dependents and relevant tests. An empty result means no relationship was recorded, not that the change has no impact.

Illustrative excerpts, not a live run. Diff compares committed symbol graphs; impact is a separate query over recorded relationships.

A small API edit.
A wider review.

You add a required currency argument to checkout’s total function. The patch is short. The useful next question is which public definition changed—and which recorded callers still need attention.

  1. Read the patch.

    Understand the actual edit and its intent. A semantic summary accompanies source review; it cannot replace it.

  2. Read the symbol diff.

    Find the exported definition in the advisory report. A compatibility signal is easier to spot than reconstructing it from every changed line.

  3. Follow the impact.

    Use the separate impact query to find recorded dependents and covering tests. Update callers, examine the tests, and run your checks.

In this example, review the checkout form’s call to calculateTotal and the test that exercises it. A recorded test relationship is a navigation hint, not a test result.

Spend review time
where it matters.

Semantic diff puts structural changes in front of the people reviewing them. It is especially useful when the important change could get buried in a larger patch.

Changing a shared API

Spot removed or changed exports before consumers are overlooked. Follow up with impact analysis to build a review list from the relationships TOVIO recorded.

Reviewing an agent’s work

Ask for the exported-symbol report alongside the patch. Give the reviewer a structural summary to investigate instead of relying only on the agent’s description of its changes.

Refactoring dependencies or tests

Inspect dependency and test-relationship deltas when they are available. See which recorded connections changed without mistaking them for runtime coverage measurements.

Recorded with the code.
Compared across commits.

For supported languages, indexing is built in and on by default. Changed files update the commit’s recorded symbol graph; the semantic commands read that history locally.

Changed files

Definitions and supported relationships are extracted from the source.

Versioned symbol graph

The index belongs to a commit and follows the same content-addressed object model.

Review signals

Compare two graphs for exported-symbol and recorded-relationship changes.

Added

An exported symbol appears in the new graph.

Additions alone do not trigger the breaking verdict.

Removed

An exported symbol disappears from the graph.

Flagged as breaking. Check migrations and dependent code.

Changed

An exported definition’s recorded shard or supertype set changes.

Flagged conservatively as breaking. Inspect the patch to understand compatibility.

Relationships changed

Recorded dependencies or test relationships are added or removed.

Extra review context when present; these deltas do not determine the breaking verdict.

Start with your
latest commit.

These are separate commands with separate questions. Commit the change first, inspect the report, then follow up where the evidence points.

What changed structurally?

With no arguments, compare HEAD’s first parent with HEAD. To select two commits, pass their commit addresses.

tovio semantic diff

Who might need attention?

Seed impact from the latest commit’s removed and changed symbols. The walk follows recorded dependents; it does not establish which calls will fail.

tovio semantic impact --depth 2
Use the report with agents or CI
tovio semantic diff --json

Read structured symbol and relationship deltas. Check a_indexed and b_indexed: an unindexed side is treated as an empty graph, so apparent additions or removals need that context. A breaking advisory does not itself make the diff command fail; automation must inspect the report.

Evaluate a protected lane’s semantic gate
tovio explain semantic --into main

The diff command is advisory. A protected lane can separately require semantic checks with semantic_check = required. Explain evaluates the target’s gate without landing. Read the gate configuration and failure rules before adopting it.

Useful context.
Explicit boundaries.

Keep the patch, type checker, and tests in the review loop. Semantic diff adds another view of the evidence.

Rust · TypeScript / JavaScript · Python · Go
Other languages, files that cannot be parsed, and files beyond indexing limits do not get a symbol-level view. Ordinary version-control operations remain available.
Recorded relationships can be incomplete
Dynamic dispatch, macros, or unresolved calls can be absent. No recorded dependent or test is not proof that none exists. The analysis does not execute tests.
Protected source stays within its access boundary
Protected symbol data is sealed to authorized readers. Results reflect the graph the reader can access, rather than exposing symbols from files they cannot read.
Names are compared, not intent inferred
A rename may appear as a removal and addition. The report does not establish behavioral equivalence, automatically classify every source edit, or certify a change as safe.

Review the code.
Follow the connections.

Try a familiar API change. Compare the patch with its symbol report, then inspect the recorded dependents and tests.

Plan an evaluation Explore symbol queries