Features — CodeIQ Pro's 14 Modules

code-Map

Code Structure & Blast Radius

The living map of how your whole system is wired.

code-Map parses your source into one interactive graph — files, classes, functions and the calls between them — across 21 languages, and reconstructs the database relationships a legacy schema never declared.

✓Typed graph of File → Class → Function with CALLS / DECLARES / EXTENDS edges
✓21 languages: Java, C#, Go, TypeScript, JavaScript, PHP, Ruby, Rust, Kotlin, Swift, Scala, C/C++, Python, VB.NET, ASP.NET Web Forms & WPF, and more
✓Dependency-free regex fallback so it still works on air-gapped installs
✓Blast-radius analysis — everything that breaks if you change a node, transitively, across every app on a shared database
✓Reconstructed foreign keys from the JOINs in your own SQL (legacy DBs declare none)

✦ Cuts onboarding from months to hours✦ Turns risky changes into scoped ones✦ Makes a shared-DB estate finally legible

See code-Map on your code →

app.codeiqpro.com/code-structure-&-blast-radius

Example. A developer is asked to change `psf_emp.employee_number`. code-Map shows it's read or written by 47 functions across 9 applications and 6 reconstructed relationships depend on it — so the 'small' change is scoped correctly before a line is touched.

code-Data

Database Intelligence

The real data model — including the relationships it never declared.

code-Data maps every table, column, type, stored procedure and lookup, flags PII, reconstructs the hidden relationships, and traces any single column end-to-end across the system.

✓Full schema: tables, columns, types, nullability, stored procedures, views, queries
✓Automatic PII flagging and captured reference/lookup data (the real codes)
✓Reconstructed relationships from SQL joins, with the query as evidence
✓Interactive ER relationship graph, exportable to Mermaid
✓Column-level lineage — same-name spread, writers, readers, and the screens a column surfaces on
✓Feature Map: role → module → screen, reconstructed from the database's own menu tables

✦ Locate personal data before an auditor does✦ See relationships a schema tool can't✦ Change data with the full picture

See code-Data on your code →

app.codeiqpro.com/database-intelligence

Example. A compliance officer opens lineage on `psf_emp.date_of_birth`: it spreads to 15 tables, is written by 4 functions, read by 148, and surfaces on 2 screens — an instant, evidence-backed map of everywhere that PII travels.

code-Ask

Grounded Q&A

Ask in plain English; get cited answers, never invented.

code-Ask answers natural-language questions about your codebase, grounded in the graph and cited to real code. If it doesn't know, it says so — it never hallucinates tables or APIs.

✓Natural-language questions resolved to real nodes
✓Anti-hallucination guardrails: invented-identifier validation, thin-grounding refusal, de-speculation
✓Citations back to the exact tables, functions and screens used
✓Cross-project mode — ask across a whole portfolio at once
✓Semantic + lexical search with a dependency-free fallback

✦ Trustworthy answers you can act on✦ No dangerous hallucinated schema✦ Works air-gapped, on your models

See code-Ask on your code →

app.codeiqpro.com/grounded-q&a

Example. Asked 'how do work patterns work?', generic AI invents columns. code-Ask answers with the real tables — `ta_shift`, `wp_link`, `wpLookup` — cited to 4 tables and 6 screens, because it validated every identifier against the graph first.

code-Recall

Answer Memory

Confirmed answers that are semantic, self-invalidating, and proactive.

code-Recall preserves the answers your team accepts as correct — across re-index — and surfaces them on related questions. It matches by meaning (not keywords), anchors each answer to the code it cited so it self-flags stale when that code changes, and ranks by relevance so the freshest best answer wins.

✓Semantic recall — matches by embedding similarity (genuinely semantic with a local/remote model), not just keywords
✓Node-anchored auto-stale — a confirmed answer links to the code it cited and flags itself stale when that code drifts or disappears
✓Decay + proactive ranking — scored by similarity × recency × confirmations; surfaced before you finish asking
✓Human-accepted answers preserved across graph rebuilds, dated and attributed
✓Feedback loop from the Ask screen (👍) feeds it — never crosses the proven/inferred trust boundary

✦ Finds prior answers by meaning, not keywords✦ Answers self-invalidate when the code moves — no stale trust✦ Proactive: the right prior answer at the right moment✦ Knowledge compounds, safely

See code-Recall on your code →

app.codeiqpro.com/answer-memory

Example. An architect confirms 'how does an employee link to a work pattern?'. Later a new hire asks 'how is a worker tied to their shift schedule?' — different words — and code-Recall surfaces the confirmed answer via **semantic match**. When the cited `wpLookup` code later changes, the answer auto-flags **stale** so no one trusts an outdated reply.

code-KB

Knowledge Graph Store

One portable brain per project — with a real graph engine on top.

code-KB is the store itself — a self-contained knowledge graph per project (SQLite, optional Neo4j) that every other module reasons over. On top of it sits a graph engine: trace how any two nodes connect, rank the most load-bearing nodes, check integrity, diff what changed between re-indexes, and export the whole graph for interop — all on-prem and reachable by AI agents over MCP.

✓Embedded SQLite graph; optional Neo4j backend for scale; no server required
✓Shortest-path — trace how any two nodes connect (code ↔ database ↔ screen)
✓Hub & PageRank centrality — rank the most load-bearing nodes (what everything depends on)
✓Integrity check — orphan/dangling-edge and isolation health
✓Snapshot & diff — the KB's own changelog: what changed between two re-indexes
✓Graph export / import (SCIP/LSIF-style JSON) — interoperate with other tools, round-trippable
✓Order-independent ingest, provenance on every fact, and preservation of human knowledge across re-index
✓MCP-native: the whole graph — and its path/hub queries — exposed to approved AI agents

✦ A real graph engine (paths, centrality, diff) without a Neo4j licence✦ Interoperable via graph export — feed other tools, or round-trip your graph✦ Your code and knowledge never leave your environment✦ Agent-ready, portable, versionable understanding

See code-KB on your code →

app.codeiqpro.com/knowledge-graph-store

Example. Ask code-KB to connect `SWPOverride.aspx` to `wp_link` and it traces a real 4-hop path (screen → feature → table); the hub ranking flags `psf_emp` as one of the most-depended-on nodes across the estate; a diff after a re-index lists exactly which tables and functions changed.

AutoWiki

Living Documentation

Documentation that never goes stale — and is richer than hand-written docs.

AutoWiki generates documentation from the graph and refreshes it on every re-index — grounded, cited, and never drifting. Each page carries an auto-drawn diagram, a freshness badge, live source snippets that read the current code, and a grounded 'ask this page' chat.

✓Pages generated from the graph, not hand-maintained — refreshes on re-index
✓Auto-drawn neighbourhood diagram per page (inline SVG — no external renderer, air-gapped-safe)
✓Freshness / drift badge — 'Live, regenerated from the graph', plus stale-note flags from code-Brain
✓Live source snippets — embed the current code, so docs and code can never drift apart
✓‘Ask this page’ — grounded, cited chat scoped to the page (powered by code-Ask)
✓Inline graph callouts — auto-inject PII warnings, standards violations, who-to-ask and reference data
✓Sidebar search to filter the whole wiki instantly
✓As-of timeline — bi-temporal view of what was recorded about a page over time
✓Guided tours — step through a module's screens in order
✓One-click static export — the whole wiki as a self-contained Markdown bundle (on-prem publish)
✓Theming — inherits light/dark and every accent theme
✓Onboarding & coverage view (mapped / missed / thin / stale files)

✦ Zero-maintenance docs that are visual, interactive & searchable✦ Snippets and callouts that can't drift from the code✦ PII / who-knows / reference surfaced right in the docs✦ Grounded answers, guided tours, and on-prem publishing

See AutoWiki on your code →

app.codeiqpro.com/living-documentation

Example. Opening the `psf_emp` page shows an auto-drawn map of its joined tables and the screens that touch it, a '✓ Live' freshness badge, and an inline **⚠️ PII: date_of_birth** callout — while a function page pulls the current source straight from `CalDetails.aspx.vb:17`, so the snippet can never go stale. A one-click export turns the whole wiki into a 60-page Markdown bundle.

code-Guard

Security & PII Governance

Catch violations and data exposure before they ship.

code-Guard finds where untrusted input reaches dangerous sinks, ingests results from your existing SAST tools, and maps every PII column to the screens that expose it — all on the graph.

✓Taint findings — source → sink (SQL/exec)
✓SARIF import from Semgrep, CodeQL, Snyk, Bandit, ESLint — fused onto the graph with blast-radius + PII context
✓PII exposure map: every personal-data column → the screens that show it
✓Violations surfaced with evidence; RBAC + append-only audit trail

✦ Your existing scanners become feeders, not silos✦ PII exposure you can actually see✦ Findings with real blast-radius

See code-Guard on your code →

app.codeiqpro.com/security-&-pii-governance

Example. A team imports their CodeQL SARIF; code-Guard maps each finding to the real function, then shows that a `path-traversal` finding sits on a screen that also renders a PII column — context CodeQL's report alone can't give.

code-Book

Standards Engine

Your standards, encoded and enforced across the whole graph.

code-Book turns your coding, security and data standards into machine-checkable rules the whole platform reasons against — and imports external rule sets so nothing is duplicated.

✓Standards as rules with severity, rationale and exemplars
✓GOVERNS (applicability) + VIOLATES (deterministic checks) across the graph
✓Custom rules — author graph-assert rules (a node label must, or must not, have a given edge) right in the UI, no code
✓Imports external rules — SARIF rules become code-Book standards
✓Waiver ledger — dated, attributed, reasoned exceptions

✦ Standards that are actually enforced, not just written✦ Your own rules without writing code✦ One rulebook across tools✦ Governed, auditable exceptions

See code-Book on your code →

app.codeiqpro.com/standards-engine

Example. An org's 'no string-built SQL' standard is encoded once; code-Book flags every violating query across nine apps, imported Semgrep rules join the same rulebook automatically, and a one-line custom rule — 'a stored procedure with no caller is dead' — surfaces 24 orphaned procs on CompuFast.

code-Fix

Governed Remediation

Nothing changes your code without a human.

code-Fix drafts standards-aware patches with full context, routes them through review, and applies them only on human approval — auditable and git-revertible.

✓Fix packets carry source + blast radius + governing standards + what they clear
✓Propose → review → approve → apply — human-gated
✓code-Council-gated: a blocked fix needs an explicit, recorded override
✓git-revertible; optional branch + PR mode

✦ Change safety by construction✦ Every change auditable & reversible✦ Standards improve, not regress

See code-Fix on your code →

app.codeiqpro.com/governed-remediation

Example. A missing auth check on `CTsiRules.SaveRule` is drafted as a fix; the council approves, a human clicks apply, and it lands as a git-revertible change with a full audit entry — no unreviewed auto-fix.

code-Council

Multi-Persona Review

A panel that reaches a governed verdict on a change.

code-Council runs a panel of expert personas over a proposed change and aggregates their votes into a governed decision — a human still approves, but the panel advises with grounded evidence.

✓Persona panels for fix / change / governance / migration
✓Aggregates APPROVE / CONCERN / REJECT into approved / needs-review / blocked
✓Grounded in the node's real KB facts; gates the fix loop
✓PR-bot — formats the panel's verdict into a ready-to-post Markdown merge-request comment
✓One-click post to a GitLab MR or GitHub PR (token-gated; approver role) — a human still approves the merge

✦ A second (and third) opinion, grounded✦ The review lands on the PR/MR, not in a silo✦ Blocks risky changes early✦ Keeps the audit trail intact

See code-Council on your code →

app.codeiqpro.com/multi-persona-review

Example. On a leave-approval change to ELeave.aspx, the panel returns BLOCKED (2 of 3 reject) with each reviewer's cited reasoning — formatted as a merge-request comment and posted to the MR, where a human still makes the call.

code-Spec

Specifications

Reverse-engineer the spec your rewrite must match — and author new ones.

code-Spec writes the as-is specification of a legacy module from the graph, and authors specs for brand-new features grounded in the existing system so they reuse what's already there.

✓As-is spec: purpose, screens by role, fields, tables + real reference data, relationships, stored-proc logic, PII
✓To-build spec: grounded reuse of real tables + an appended code-Plan build plan
✓Bidirectional — KB→spec for legacy, spec→build→KB for new development
✓Guard-checked purpose; clean Markdown output

✦ The document nobody kept, recovered✦ New features that fit the system✦ One artifact from legacy to new build

See code-Spec on your code →

app.codeiqpro.com/specifications

Example. code-Spec generates the Attendance spec — purpose, 20 screens by role, real reference codes (055·Public Holiday), reconstructed joins and the PII column — the exact contract a rewrite must satisfy.

code-Plan

Goal Planning

Turn a plain-English goal into an ordered, grounded task plan.

code-Plan resolves a goal to the real entities involved and produces an ordered task list that references actual screens, tables and functions — not invented ones.

✓Resolves the goal to real screens / tables / functions
✓4–8 ordered tasks, with modernize / feature / generic templates
✓Grounded execution — each step carries its real node, blast radius, governing standards and open violations, ready to hand to the governed code-Fix loop
✓Guard-checked — flags any step referencing a name not in the KB

✦ Plans grounded in reality✦ Every step is a real, checkable target✦ Faster, safer scoping✦ No invented steps

See code-Plan on your code →

app.codeiqpro.com/goal-planning

Example. Goal: 'add audit logging to leave requests' → 11 grounded steps, each a real screen or table (ELeave.aspx, SAnnLeaveCalc.aspx, hol_errs…) with its blast radius, not a guess.

code-Modernize

Legacy Migration

Migrate legacy code without dropping behavior.

code-Modernize carves the app into dependency-safe slices, recommends a strategy per slice, and proves the new build preserves the legacy contract — statically with a parity gate and dynamically with generated tests.

✓Contract surface — the tables, columns, endpoints and writes to preserve
✓Dependency-safe slicing + per-slice strategy (Rewrite / Strangler-fig / Encapsulate-&-wrap), ordered least-depended-on-first, PII-flagged
✓Target design — choose the new stack and preview the modern app
✓Parity gate — a graph diff proving nothing was dropped (PASS/WARN/FAIL)
✓Characterization tests — golden-master Gherkin generated from the contract, to run against the new build

✦ Turns a gamble into a sequence of safe steps✦ Proves the rewrite preserved behavior✦ Nothing silently lost

See code-Modernize on your code →

app.codeiqpro.com/legacy-migration

Example. A 20-year app breaks into 318 slices (237 Rewrite, 74 Strangler-fig, 7 Encapsulate); after the rewrite, the parity gate confirms 90 tables written are all preserved and 0 PII paths dropped, and the generated Gherkin proves it dynamically.

code-Brain

Decision Memory

Capture the why, anchored to the code — automatically.

code-Brain records decisions, rationale and incidents anchored to real code nodes, ages them when the code drifts, and now fills itself by distilling meaningful git commits.

✓Facts anchored to real code nodes; bi-temporal (learned vs valid time)
✓Stale-flagging — a fact ages when the code it describes changes
✓Confidence + promotion policy — low-confidence/PII notes route to human review
✓Who-knows — ranks who to ask from git authorship + recorded decisions
✓Auto-capture from git — distils meaningful commits into anchored, drift-aware facts

✦ Raises the bus factor✦ Memory that fills itself and stays honest✦ Find the right expert fast

See code-Brain on your code →

app.codeiqpro.com/decision-memory

Example. code-Brain scans the repo and captures 'Fix SQL injection in login by parameterizing the auth query' as a fact anchored to `auth.py` — and flags it stale automatically if that code later changes.

See all 14 modules on your codebase

Book a walkthrough — we'll map a real module of your legacy system live.

Talk to sales Explore products

Everything CodeIQ Pro does, on one graph.

Map, question and document any legacy system.