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

The system remembers what your team has confirmed.

code-Recall preserves the answers your team has accepted as correct — across re-index — and surfaces them on related questions so knowledge accumulates instead of being re-derived.

✓Human-accepted answers preserved across graph rebuilds
✓Similarity matching to surface 'previously confirmed by '
✓Feedback loop from the Ask screen (👍) feeds it

✦ Knowledge compounds over time✦ Less repeated investigation✦ Confirmed answers never rot

See code-Recall on your code →

app.codeiqpro.com/answer-memory

Example. An architect confirms the answer to 'why does the nightly job run twice?'. Weeks later a new hire asks a related question and sees *'Previously confirmed by A. Sharma'* — the knowledge didn't evaporate.

code-KB

Knowledge Graph Store

One portable brain per project.

code-KB is the store itself — a self-contained knowledge graph per project (SQLite, optional Neo4j) that every other module reasons over, and that your AI agents can reach over MCP.

✓Embedded SQLite graph; optional Neo4j backend for scale; no server required
✓Order-independent ingest with deferred-edge resolution
✓Human knowledge (facts, waivers, recall) preserved across re-index
✓Provenance on every fact — proven (deterministic) vs inferred
✓MCP-native: the whole graph exposed to approved AI agents

✦ Your code and knowledge never leave your environment✦ Portable, versionable understanding✦ Agent-ready out of the box

See code-KB on your code →

app.codeiqpro.com/knowledge-graph-store

Example. Nine CompuFast apps that share one database each get their own kb.db, plus a portfolio view across all of them — one brain per app, one map for the estate.

AutoWiki

Living Documentation

Documentation that never goes stale.

AutoWiki generates documentation from the graph and refreshes it on every re-index — grounded in real code facts and cited, so it never drifts from reality.

✓Pages generated from the graph, not hand-maintained
✓Refreshes on re-index — always current
✓Grounded and cited to real code
✓Onboarding & coverage view (mapped / missed / thin / stale files)

✦ Zero-maintenance docs✦ Docs you can actually trust✦ Faster onboarding

See AutoWiki on your code →

app.codeiqpro.com/living-documentation

Example. The Attendance module's wiki page lists its 9 employee + 11 supervisor screens and 21 tables — regenerated from the graph, so it's right today, not two years ago.

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
✓Imports external rules — SARIF rules become code-Book standards
✓Waiver ledger — dated, attributed, reasoned exceptions

✦ Standards that are actually enforced, not just written✦ 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, and imported Semgrep rules join the same rulebook automatically.

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

✦ A second (and third) opinion, grounded✦ Blocks risky changes early✦ Keeps the audit trail intact

See code-Council on your code →

app.codeiqpro.com/multi-persona-review

Example. Before applying a change to a shared table, the migration panel flags a concern about a dependent app — surfaced by a persona that reasoned over the blast radius in the graph.

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
✓Guard-checked — flags any step referencing a name not in the KB

✦ Plans grounded in reality✦ Faster, safer scoping✦ No invented steps

See code-Plan on your code →

app.codeiqpro.com/goal-planning

Example. Goal: 'modernize the Attendance module' → an ordered plan citing the real screens and tables involved, so the first task isn't 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.