Skip to main content
Version: 0.1.146

Reading the analysis

The analysis is what the platform understood about your legacy system. It is not a rewrite plan and it is not a specification yet — it is the evidence everything after it is argued from, and it is worth reading before you accept any of it.

As-Is Architecture​

The legacy system's structure as extracted from the code: its components, how they relate, and where the boundaries fall. This is generated, so read it as a reading of the code rather than as a statement of intent. Where it is wrong, it is usually wrong in an informative way — it reflects what the code actually says rather than what the original design intended.

The database​

Three surfaces, from different angles:

  • DB ER Diagram — the entities and their relationships.
  • DB Table Catalog — every table found, with its columns.
  • DB Objects — views, procedures and the rest of what lives in the schema.

These come from the code and the schema as found. A table the legacy application never touches can still appear here; a table built by a process outside the codebase may not.

Views​

What the legacy application presents to its users, screen by screen. The View Catalog is the inventory; individual views carry the detail. These matter more than they look like they should: a to-be scenario about a screen is anchored to the view it describes, and the implementation agents are told which view they are reproducing.

Modules​

The module is the unit of work. Discovery, decision and delivery all happen a module at a time, on one branch, and one agent per role does a whole module's work. This is the single most useful organising idea in the product: if you are wondering why features are grouped the way they are, or why an implementation touched more than you expected, the module is usually the answer.

A module is created by naming it — in Group Features to Module from the features list, or in the Module field of Discover Features. When the name has no Latin letters, an English name (optional) field appears beneath it: the module's branch is named from it, so 客戶管理 with the English name customer management works on module/customer-management-…. Leave it empty and Repave names the module in English itself within a minute or so. Rename in the module's ⋯ menu edits both names later.

External and internal systems​

What the legacy system talks to, and what will happen to each: kept, replaced, or mocked. Discovery files each system in one of two lists:

  • External Systems are owned by a third party: an email provider, a card processor, a SaaS service.
  • Internal Systems are your organisation's own systems that the legacy app integrates with but that are not part of the code being modernized: core banking, a shared login service, an internal CRM. The architecture draws them inside your organisation's boundary, and implementation reuses the contract or client library the legacy code already has for them. An internal system is either kept or abandoned in the modernized app; replacing it is your own decision, not this migration's.

When the code does not settle who owns a system (a host that only appears as a setting, or a vendor package you may run yourself), discovery does not guess. It asks you in the agent chat, with what it found, and waits for your answer: pick Internal or External and click Send answer, and it files the system where you said. The running-agents list shows the run as Waiting for you until then. If you click Let the agent decide, it files the system where the evidence leans and tells you which way it went.

When the project has Agents can ask you and hear from you turned off, discovery cannot ask while it runs. It files the system under External Systems and asks in a Needs your decision card at the top of both pages instead, where one click on Internal or External settles it. Either way, a later discovery run never reopens your answer. You can also move any system between the two lists from its row; the move takes its scenario references with it, and Undo puts it back.

Linking an internal system to another Repave project​

When an internal system's code is itself a Repave project (your app calls an API provider your organisation is modernizing too), the two get linked. Usually you do nothing: discovery links a system when its calls clearly match another project's APIs, and asks you in the agent chat when two projects match equally or the evidence is thin. Answer with the project, or Neither project. For systems found before, click Find linked projects on Internal Systems, or the link icon on one system's row. A link an agent made says why when you expand its row.

It does not matter which project comes first. Repave checks the links again whenever either side changes: when a job finishes in either project, when a system moves into Internal Systems, when someone edits an API, and every ten minutes. A clear match is linked by itself, and its row says Linked automatically with the evidence. An unsure one starts an agent that asks you in the agent chat. Linked systems follow the other project's changes: a new API gives an unmatched call its endpoint, a renamed one updates your citations, and a scenario added later is cited too.

A no covers only the projects it was about. Neither project in the chat, or removing a link, means agents won't link the system to those projects again, but a project created later can still be asked about. A system whose calls your own project's code serves, such as a repository in your own workspace, is part of the app and is never linked: its row says Part of this app, with Delete it.

To link by hand, edit the system and choose the project under Linked Repave project, then which of its APIs apply: its legacy APIs, its modernized API catalog, or both. With both, the as-is work cites the legacy APIs and the to-be work cites the modernized ones, following the other project's own mapping from each legacy API to its replacement. Choosing Not linked removes a link, even to a project you can't open, and agents won't link that system to that project again.

To decide which project a system is, the agent can read every project in this installation: their API catalogs and legacy code, read-only. What it quotes as evidence can show a little of a project you can't open.

Linking does these things:

  • Every call names the exact API it uses. Expanding the row lists the APIs your code calls, each with where it calls them; Show all shows the rest of the other project's catalog. When the other project's code serves a call its catalog is missing, the agent adds that API to its catalog, marked Added by your project there. If that project's people delete it, it is not added again.
  • A call through another project shows where it ends up. When the other project is itself a gateway or a service that calls on, each API your code calls says where it goes next, such as → Core Banking Platform · Account Balance API, and expanding it shows every hop under Goes on to. Where the path stops, it says why: an internal system there not linked yet, no matching API, or an external system.
  • Your scenarios cite its APIs. Repave adds each API to the scenarios whose code makes the call. When no calls were recorded yet, an agent finds them first; the row says so while it works. Calls that still match no API are listed.
  • Your agents build against its real contracts. Implementation reads the contracts of the APIs your code calls, generates the client and the test stubs from them, and reads the other project's address from a setting named after the system, such as CORE_BANKING_BASE_URL.
  • You see what needs attention. The row flags an API the other project is dropping, an API your scenarios cite that is no longer in its catalog, and a link that was lost because the other project was deleted or its owner removed the link.

Linking needs edit access to your project and access to the other one. Once linked, everyone on your project can read the other project's API catalog, and nothing else of it. The other project's API Catalog shows which projects link to it, and its owner can remove a link. Its people see your project's name there even if they can't open your project, but not your internal systems or features: those are only counted.

Seeing how your projects connect​

Once any of your projects is linked to another, or shares a database or message broker with another, the home page offers Map beside the project cards. The map shows your projects and the projects they link with as boxes, with an arrow from each project to the project whose APIs it calls. Each arrow is labelled with how many of that project's APIs it uses and how many calls are recorded, such as 4 APIs · 5 calls. An API counts whether your code calls it or one of your scenarios cites it.

Click an arrow to see what the link carries: each API, how many calls use it, and the features that use it, along with any calls that match none of the other project's APIs and any that are a gateway's forwarding rules. Open in takes you to the linked systems on Internal Systems, already expanded, whatever filter that page last had. Back closes the panel.

Click a project's box to select it. Its panel has Open project, the box where you describe a change to analyze (see Seeing what a change affects), and that project's recent analyses. A box you can't open isn't selectable.

Databases and message brokers that more than one project uses are drawn as rounded boxes. The arrow between a project and a database says how many tables, views and procedures it reads and writes, such as reads 3 · writes 1; for a broker, how many queues and topics it consumes from and publishes to. Click one to see which project reads and writes each object. If two connections were matched to the same database by mistake, Not this one beside a connection of a project you can edit takes it out; Repave's agents never put it back.

The map shows every link that touches a project you can open. A project at the other end is named even if you can't open it, and is shown greyed out with a lock. Its features aren't listed, and a link between two projects you can't open isn't drawn.

A system marked for mocking gets an explicit mock strategy that implementation agents respect, rather than each agent inventing its own. Renaming or merging a system keeps every scenario reference in step, and deleting one warns you about the references first and cleans them up rather than leaving scenarios pointing at nothing.

Seeing what a change affects​

Change impact, under Analysis in every project, answers what a change you are about to make affects: in this project, and in every project that depends on it through an API, a shared database table, or a message queue or topic.

Describe the change in plain English, such as "Remove middleName from the customer response and make CUSTOMER.PHONE not null", and click Analyze. You can do the same from the map: select the project's box and describe the change in its panel, and the result is drawn on the map. Starting an analysis needs edit access to the project; anyone who can open it can read past analyses.

An agent reads the project's code and records what the change touches: an API it serves, a table it writes or whose shape changes, or a queue or topic it publishes to or consumes from. Repave then follows each one to every place in another project that calls that API or uses that table or queue, and the agent reads each place and says whether the change Breaks it, Needs a check (the code doesn't say), or leaves it Not affected, with a one-line reason and the place in the code. When a place that breaks or needs a check is part of one of its own project's APIs, the analysis goes on to the projects that call that API, up to five projects along any path.

The report lists:

  • what the change touches in your project, and your own scenarios it affects;
  • each project it reaches, with its verdicts and the scenarios that exercise each place. A project you can't open is named with its counts only, such as 1 break · 1 check;
  • Regression scenarios to re-run in each project;
  • Not covered: what the analysis could not see, such as an internal system not linked to a project, calls that match no API, a connection not yet matched to a shared database, or a name built at run time. It is always shown, and says "Nothing was out of reach." when nothing was.

Show on map draws the analysis on the map: the projects it reaches carry their counts, and the rest of the map is dimmed.

Nobody has to prepare a project for this. Each project's connections — the APIs it serves, the calls it makes, the databases and brokers it uses and where — are mapped from its code once the code arrives, and again when the code changes. A database or broker counts as shared when an agent finds that two projects' connections point at the same one; when it is not sure, it asks you in the agent chat. Until a project's connections are mapped for the first time, its Analyze button waits and says so. A maintenance project, which brings its own app rather than a legacy codebase, is mapped, linked and analyzed through its app's code.

The legacy code itself​

The Legacy Code Viewer shows the source. You will mostly arrive here from a scenario: a scenario's related files open at the lines they were annotated with, so you land on the code the behaviour was extracted from rather than at the top of a file.

What is extracted, and what is inferred​

Worth holding in mind as you read:

  • The database catalogs, the view inventory and the file-level structure are extracted. They are what the code contains.
  • The architecture, the module grouping and the scenarios are inferred. They are a model's reading of the code, and they are what you are being asked to review.

Requirements-based analysis, where your installation has it enabled, is deliberately kept out of the as-is Gherkin: a requirement is something you want, and the as-is records only what the legacy system does.

Re-running it​

Analysis is re-runnable. The common reasons are a codebase that has moved on since it was uploaded, or an analysis that was clearly wrong about something structural. Re-running replaces the analysis, so review anything you have already decided before you do.

Next: Reviewing the as-is specification.