@yesprasad/fluent-graph 0.1.0 → 0.2.0

package/LICENSE

@@ -22,7 +22,7 @@ Built with focus on making ServiceNow Pro Developer Fluent development with now-
 
 ## Acknowledgments
 
-ServiceNow SDK team for building the Fluent DSL compiler
+ServiceNow SDK team for building the now-sdk and Fluent DSL compiler
 MIT License
 
 Copyright (c) 2024 ServiceNow Inc.

package/README.md

@@ -1,11 +1,44 @@
 # fluent-graph
 
-**Build-time lineage extraction and impact analysis for ServiceNow Fluent SDK projects.**
+**Dependency visibility and impact analysis for ServiceNow Fluent SDK projects.**
+
+**Catch breaking changes before deployment by mapping hidden relationships between tables, fields, scripts, and UI actions.**
+
+---
+
+## The Problem
+
+You're refactoring a ServiceNow custom table. You delete a field. You deploy.
+
+**Production breaks.**
+
+14 client scripts fail. 3 business rules error out. 2 dashboards go blank.
+
+**You realise the breaking changes at runtime in production instance.**
+
+---
+## The Solution
+**Welcome to Fluent-Graph**
 
 `fluent-graph` observes the ServiceNow SDK's internal compilation process to extract dependency graphs, detect identity conflicts, and perform blast-radius analysis—without modifying your source code or re-parsing Fluent DSL.
 
+run - npx @yesprasad/fluent-graph blast incident
+**Output:**
+```
+🔥 BLAST RADIUS ANALYSIS
+Target: incident
+
+⚠️  3 artifacts will break if you modify this table:
+  • bank_incident_onload (Client Script)
+  • cs_incident_onload (Client Script)  
+  • cs_incident_onchange_caller (Client Script)
+```
+
+🔥 **Now you know before you deploy.**
+
 ---
 
+
 ## What It Does
 
 - **Extracts artifact lineage** from SDK projects (tables, columns, scripts, business rules)
@@ -34,7 +67,7 @@ fluent-graph blast <table_name or artifact_name>
 **Or use directly with npx (no installation needed):**
 ```bash
 cd your-fluent-project
-npx fluent-graph extract
+npx @yesprasad/fluent-graph extract
 ```
 
 **Verify installation:**
@@ -48,59 +81,6 @@ fluent-graph --version
 
 **Output:**
 ```
-✔ ✅ SDK detected at /node_modules/@servicenow/sdk
-✔ Workspace SDK loaded
-✔ Project loaded
-✔ Graph built: 181 nodes, 141 edges
-
-📊 LINEAGE MAP
-────────────────────────────────────────────────────────────
-
-📦 DATA SCHEMA
-┌─────────────────────────────────────────────┬───────────────┐
-│ Table                                       │ Status        │
-├─────────────────────────────────────────────┼───────────────┤
-│ x_1566039_seventh_critical_account         │ [ACTIVE]      │
-│ x_1566039_seventh_critical_account_incident_ext │ [ACTIVE] │
-│ x_1566039_seventh_customer                 │ [ACTIVE]      │
-│ x_1566039_seventh_account                  │ [ACTIVE]      │
-│ x_1566039_seventh_fraud_alert              │ [ACTIVE]      │
-│ x_1566039_seventh_risk_score               │ [ACTIVE]      │
-│ x_1566039_seventh_call_case                │ [ACTIVE]      │
-│ x_1566039_seventh_compliance_flag          │ [ACTIVE]      │
-│ x_1566039_seventh_account_extension        │ [ACTIVE]      │
-└─────────────────────────────────────────────┴───────────────┘
-
-🔗 SCHEMA RELATIONSHIPS (Reference Fields)
-┌─────────────────────────────────────────────┬───────────────────┬─────────────────────────────┐
-│ Table                                       │ Field             │ Target Table                │
-├─────────────────────────────────────────────┼───────────────────┼─────────────────────────────┤
-│ x_1566039_seventh_critical_account          │ assigned_team     │ sys_user_group              │
-│ x_1566039_seventh_critical_account_incident_ext │ bank_account  │ x_bank_critical_account     │
-│ x_1566039_seventh_account                   │ owner             │ x_1566039_seventh_account   │
-│ x_1566039_seventh_risk_score                │ account           │ x_1566039_seventh_account   │
-└─────────────────────────────────────────────┴───────────────────┴─────────────────────────────┘
-
-⚙️ LOGIC ATTACHMENTS (Scripts & Actions)
-┌─────────┬────────────────────────────────────┬───────────────────────────────────────────────┬──────────────┬──────────────────┐
-│ (index) │ Name                               │ Table                                         │ Type         │ Artifact Type    │
-├─────────┼────────────────────────────────────┼───────────────────────────────────────────────┼──────────────┼──────────────────┤
-│ 0       │ bank_incident_onload               │ incident                                      │ [onLoad]     │ script client    │
-│ 1       │ bank_account_onchange              │ x_1566039_seventh_critical_account          │ [onChange]   │ script client    │
-│ 2       │ cs_task_onload                     │ task                                          │ [onLoad]     │ script client    │
-│ 3       │ cs_task_onchange_priority          │ x_1566039_seventh_critical_account_incident_ext │ [onChange] │ script client    │
-│ 4       │ cs_alert_onload                    │ x_1566039_seventh_fraud_alert                 │ [onLoad]     │ script client    │
-│ 5       │ cs_risk_onchange_score             │ x_1566039_seventh_risk_score                  │ [onChange]   │ script client    │
-│ 6       │ Auto-close empty Change Requests   │ change_request                                │ [action]     │ script           │
-│ 7      │ View car info                      │ x_snc_ts_custom_cars                           │ [action]     │ ui action        │
-│ 8      │ SampleScriptInclude                │ [global]                                      │ [action]     │ script include   │
-└─────────┴────────────────────────────────────┴───────────────────────────────────────────────┴──────────────┴──────────────────┘
-
-🔒 SECURITY & ACCESS (ACLs)
-┌──────────────────────────────┬───────────────────────┬───────────────────────────┐
-│ ACL                           │ Level / Roles         │ Table                     │
-├──────────────────────────────┼───────────────────────┼───────────────────────────┤
-│ DELETE on task.description    │ Field-level, Roles: ✔ ✅ SDK detected at /node_modules/@servicenow/sdk
 ✔ Workspace SDK loaded
 ✔ Project loaded
 ✔ Graph built: 181 nodes, 141 edges
@@ -336,13 +316,12 @@ Typical extraction times on SDK 4.1.x:
 | Project Size | Artifacts | Extraction Time |
 |--------------|-----------|-----------------|
 | Small        | 50-100    | < 5 seconds     |
-| Medium       | 100-500   | 5-15 seconds    |
-| Large        | 500-1000  | 15-30 seconds   |
-| Enterprise   | 1000+     | 30-60 seconds   |
+| Medium       | 100-500   | 5-10 seconds    |
+| Large        | 500-1000  | 10-20 seconds   |
+| Enterprise   | 1000+     | 20-30 seconds   |
 
-*Times measured on MacBook Air M1, 16GB RAM*
+*Times measured on MacBook Air M1, 16GB RAM and approximated*
 
-**Note:** First run is slower (SDK initialization). Subsequent runs are faster.
 
 ## Limitations
 
@@ -370,24 +349,6 @@ Typical extraction times on SDK 4.1.x:
 
 ---
 
-## Contributing
-
-This is an early-stage tool built to solve real problems in Fluent development. Contributions are welcome, especially:
-
-### Areas We Need Help
-
-1. **SDK Version Testing**
-   - Test against SDK 4.0.x, 4.2.x, 5.0.x
-   - Document breaking changes in graph structure
-   
-2. **Edge Extraction Improvements**
-   - Capture more FK relationships from Fluent DSL
-   - Handle complex reference scenarios (polymorphic refs, etc.)
-   
-3. **Artifact Type Coverage**
-   - Add support for: Workflows, Flow Designer, Notifications
-   - Validate ACL/UI Policy detection
-
 ### Development Setup
 ```bash
 git clone https://github.com/yesprasad/fluent-graph

package/dist/blast/traversal.d.ts

@@ -0,0 +1,48 @@
+import type { LineageGraph, ArtifactNode, ArtifactEdge } from '../types/graphs';
+export interface TraversalNode {
+    node: ArtifactNode;
+    hop: number;
+    /** Chain of node names from target → this node (inclusive). */
+    path: string[];
+    /** The edge that caused this node to be discovered. */
+    viaEdge: ArtifactEdge;
+}
+export interface TraversalResult {
+    /** The representative local graph node for the target (non-child preferred), or null if platform. */
+    target: ArtifactNode | null;
+    targetName: string;
+    /** All discovered nodes across all hops, sorted by hop ASC then name ASC. */
+    hops: TraversalNode[];
+    maxHopReached: number;
+    /** Times a visited node was skipped (cycle prevention + same-name deduplication). */
+    cyclesPrevented: number;
+}
+/**
+ * BFS reverse-traversal over the dependency graph.
+ *
+ * KEY DESIGN DECISIONS:
+ *
+ * 1. A logical "entity" is identified by node NAME, not by node ID.
+ *    Multiple physical nodes can share a name (e.g., a table and all its
+ *    field/documentation records are all named "x_my_table"). The BFS
+ *    treats them as one logical node — once any physical node for a name
+ *    is discovered, ALL siblings for that name are immediately marked
+ *    visited so they never appear again.
+ *
+ * 2. The initial target is seeded with ALL physical nodes sharing the
+ *    target name (plus the synthetic "platform:tableName" ID). This
+ *    ensures incoming edges are found regardless of which physical node
+ *    the edge was recorded against.
+ *
+ * 3. Edge matching uses BOTH:
+ *    - edge.to === currentNodeId  (exact physical node)
+ *    - edge.targetTable === currentNodeName  (canonical name — reliable
+ *      for platform nodes and catches mis-targeted edges)
+ *
+ * 4. ALL edge types are traversed. Display filtering is the caller's job.
+ *
+ * @param graph           The loaded LineageGraph.
+ * @param targetTableName The table name the user asked about.
+ * @param maxDepth        Maximum hop depth. Silently clamped to 25.
+ */
+export declare function traverseBlastRadius(graph: LineageGraph, targetTableName: string, maxDepth: number): TraversalResult;

package/dist/blast/traversal.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseBlastRadius = traverseBlastRadius;
+/**
+ * Build a map from node name → all node IDs with that name.
+ * Used to treat same-name siblings (sys_dictionary, sys_db_object, etc.
+ * representing the same table) as a single logical entity.
+ */
+function buildNameIndex(graph) {
+    const index = new Map();
+    for (const node of graph.nodes) {
+        const ids = index.get(node.name) ?? [];
+        ids.push(node.id);
+        index.set(node.name, ids);
+    }
+    return index;
+}
+/**
+ * BFS reverse-traversal over the dependency graph.
+ *
+ * KEY DESIGN DECISIONS:
+ *
+ * 1. A logical "entity" is identified by node NAME, not by node ID.
+ *    Multiple physical nodes can share a name (e.g., a table and all its
+ *    field/documentation records are all named "x_my_table"). The BFS
+ *    treats them as one logical node — once any physical node for a name
+ *    is discovered, ALL siblings for that name are immediately marked
+ *    visited so they never appear again.
+ *
+ * 2. The initial target is seeded with ALL physical nodes sharing the
+ *    target name (plus the synthetic "platform:tableName" ID). This
+ *    ensures incoming edges are found regardless of which physical node
+ *    the edge was recorded against.
+ *
+ * 3. Edge matching uses BOTH:
+ *    - edge.to === currentNodeId  (exact physical node)
+ *    - edge.targetTable === currentNodeName  (canonical name — reliable
+ *      for platform nodes and catches mis-targeted edges)
+ *
+ * 4. ALL edge types are traversed. Display filtering is the caller's job.
+ *
+ * @param graph           The loaded LineageGraph.
+ * @param targetTableName The table name the user asked about.
+ * @param maxDepth        Maximum hop depth. Silently clamped to 25.
+ */
+function traverseBlastRadius(graph, targetTableName, maxDepth) {
+    const depth = Math.min(maxDepth, 25);
+    const nameIndex = buildNameIndex(graph);
+    // All physical nodes for the target name (may be many — sys_dictionary,
+    // sys_db_object, sys_documentation, etc. all named the same thing).
+    const targetPhysicalNodes = graph.nodes.filter(n => n.name === targetTableName);
+    // Prefer a non-child / primary node as the canonical representative.
+    // We can't use the registry here (pure function), so heuristic: prefer
+    // any node where the table name itself matches the target name (for custom
+    // tables this is the sys_db_object entry); otherwise first found.
+    const target = targetPhysicalNodes[0] ?? null;
+    // Pre-visit the platform shadow ID and ALL physical nodes for the target.
+    const visited = new Set();
+    const platformId = `platform:${targetTableName}`;
+    visited.add(platformId);
+    for (const n of targetPhysicalNodes)
+        visited.add(n.id);
+    // Seed the frontier with one entry per physical target node + platform shadow.
+    // This ensures we catch edges recorded against any of the physical nodes.
+    const seedIds = new Set([platformId, ...targetPhysicalNodes.map(n => n.id)]);
+    let frontier = [...seedIds].map(id => ({
+        nodeId: id,
+        nodeName: targetTableName,
+        hop: 0,
+        path: [targetTableName],
+    }));
+    const results = [];
+    // Track which logical names we have already emitted in results (for dedup).
+    const emittedNames = new Set([targetTableName]);
+    let maxHopReached = 0;
+    let cyclesPrevented = 0;
+    while (frontier.length > 0) {
+        const nextFrontier = [];
+        for (const entry of frontier) {
+            if (entry.hop >= depth)
+                continue;
+            // Reverse-edge scan: all edges whose destination is the current node.
+            const incomingEdges = graph.edges.filter(edge => edge.to === entry.nodeId ||
+                (entry.nodeName.length > 0 && edge.targetTable === entry.nodeName));
+            for (const edge of incomingEdges) {
+                const sourceNode = graph.nodes.find(n => n.id === edge.from);
+                if (!sourceNode)
+                    continue;
+                if (visited.has(sourceNode.id)) {
+                    cyclesPrevented++;
+                    continue;
+                }
+                // Mark this physical node visited.
+                visited.add(sourceNode.id);
+                // Mark ALL sibling physical nodes (same name) visited immediately
+                // so they never surface as separate hop results.
+                const siblings = nameIndex.get(sourceNode.name) ?? [];
+                for (const sibId of siblings) {
+                    if (!visited.has(sibId))
+                        visited.add(sibId);
+                }
+                const newHop = entry.hop + 1;
+                const newPath = [...entry.path, sourceNode.name];
+                // Only emit one result per logical name (the first physical node found).
+                if (!emittedNames.has(sourceNode.name)) {
+                    emittedNames.add(sourceNode.name);
+                    results.push({
+                        node: sourceNode,
+                        hop: newHop,
+                        path: newPath,
+                        viaEdge: edge,
+                    });
+                }
+                // Continue BFS from this logical entity, using the canonical name.
+                // Also seed entries for all sibling physical IDs so their incoming
+                // edges are explored too.
+                for (const sibId of siblings) {
+                    nextFrontier.push({
+                        nodeId: sibId,
+                        nodeName: sourceNode.name,
+                        hop: newHop,
+                        path: newPath,
+                    });
+                }
+                if (newHop > maxHopReached) {
+                    maxHopReached = newHop;
+                }
+            }
+        }
+        frontier = nextFrontier;
+    }
+    // Sort by hop ASC, then name ASC for stable output.
+    results.sort((a, b) => a.hop - b.hop || a.node.name.localeCompare(b.node.name));
+    return {
+        target,
+        targetName: targetTableName,
+        hops: results,
+        maxHopReached,
+        cyclesPrevented,
+    };
+}

package/dist/cli/commands/blast.js

@@ -42,11 +42,17 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const cli_table3_1 = __importDefault(require("cli-table3"));
+const registry_1 = require("../../sdk/registry");
+const detector_1 = require("../../sdk/detector");
+const traversal_1 = require("../../blast/traversal");
 exports.blastCommand = new commander_1.Command('blast')
     .description('Analyze blast radius for a target table')
     .argument('<target>', 'Target table name (e.g., incident, x_bank_account)')
     .option('-g, --graph <path>', 'Path to graph JSON file', 'fluent-graph.json')
     .option('-f, --format <type>', 'Output format: table, json, csv', 'table')
+    .option('--depth <n>', 'Maximum traversal depth', '10')
+    .option('--show-paths', 'Show the full dependency chain for each transitive artifact')
+    .option('--direct-only', 'Show only hop-1 (direct) impacts')
     .option('--include-deleted', 'Include deleted artifacts in the analysis')
     .option('--no-banner', 'Skip banner (inherited)')
     .action(async (targetTableName, options) => {
@@ -54,22 +60,27 @@ exports.blastCommand = new commander_1.Command('blast')
         const graphFilePath = path.isAbsolute(options.graph)
             ? options.graph
             : path.join(process.cwd(), options.graph);
+        // Load registry for type name derivation (best-effort; falls back gracefully)
+        const registry = new registry_1.ArtifactTypeRegistry();
+        const sdkDetection = await (0, detector_1.detectSDK)(process.cwd());
+        if (sdkDetection.found && sdkDetection.sdkPath) {
+            registry.load(sdkDetection.sdkPath);
+        }
         if (!fs.existsSync(graphFilePath)) {
             console.error(chalk_1.default.red(`\n❌ Error: Graph file not found at ${graphFilePath}`));
             process.exit(1);
         }
         const lineageGraph = JSON.parse(fs.readFileSync(graphFilePath, 'utf8'));
-        // STEP 1: Determine target node (real node or shadow for platform)
+        // ── STEP 1: Validate target exists or is referenced ─────────────────────
         const targetNode = lineageGraph.nodes.find(node => node.name === targetTableName);
         const targetNodeId = targetNode ? targetNode.id : `platform:${targetTableName}`;
         const isBaseTable = !targetNode;
-        // STEP 2: Check if target is referenced at all
         const isTargetReferenced = lineageGraph.edges.some(edge => edge.to === targetNodeId || edge.targetTable === targetTableName);
         if (!targetNode && !isTargetReferenced) {
             console.log(chalk_1.default.red(`\n❌ Target "${targetTableName}" not found or referenced`));
             console.log(chalk_1.default.yellow('\n💡 Available custom tables:'));
             const customTables = lineageGraph.nodes
-                .filter(node => node.table === 'sys_db_object' && node.action !== 'DELETE')
+                .filter(node => registry.getPluginName(node.table) === 'TablePlugin' && !registry.isChild(node.table) && node.action !== 'DELETE')
                 .map(node => node.name)
                 .sort();
             customTables.forEach(tableName => console.log(chalk_1.default.gray(' • ') + chalk_1.default.white(tableName)));
@@ -80,7 +91,7 @@ exports.blastCommand = new commander_1.Command('blast')
             platformTables.forEach(tableName => console.log(chalk_1.default.gray(' • ') + chalk_1.default.magenta(tableName)));
             process.exit(1);
         }
-        // STEP 3: Display header
+        // ── STEP 2: Display header ───────────────────────────────────────────────
         console.log(chalk_1.default.yellow.bold('\n🔥 BLAST RADIUS ANALYSIS'));
         console.log(chalk_1.default.gray('═'.repeat(80)));
         console.log(chalk_1.default.gray('Target:   ') + chalk_1.default.white(targetTableName) + (isBaseTable ? chalk_1.default.yellow(' [Base Table]') : ''));
@@ -88,111 +99,137 @@ exports.blastCommand = new commander_1.Command('blast')
             console.log(chalk_1.default.gray('File:     ') + chalk_1.default.gray(targetNode.source.file));
         }
         console.log(chalk_1.default.gray('═'.repeat(80)));
-        // STEP 4: Collect impacted artifacts from edges
-        const impactedArtifacts = lineageGraph.edges
-            .filter(edge => edge.to === targetNodeId || edge.targetTable === targetTableName)
-            .map(edge => {
-            const sourceNode = lineageGraph.nodes.find(node => node.id === edge.from);
-            if (!sourceNode || (!options.includeDeleted && sourceNode.action === 'DELETE'))
-                return null;
-            // Friendly type mapping
-            let artifactType = 'unknown';
-            switch (sourceNode.table) {
-                case 'sys_script_client':
-                    artifactType = 'client_script';
-                    break;
-                case 'sys_script':
-                    artifactType = 'business_rule';
-                    break;
-                case 'sys_security_acl':
-                    artifactType = 'acl';
-                    break;
-                case 'sys_ui_action':
-                    artifactType = 'ui_action';
-                    break;
-                case 'sys_script_include':
-                    artifactType = 'script_include';
-                    break;
-                case 'sys_dictionary':
-                    artifactType = 'field';
-                    break; // For schema/FK
-                default: artifactType = sourceNode.table.replace('sys_', '').replace('_', ' ');
-            }
-            // Reason based on edge type
-            const impactReason = edge.type === 'schema_relationship'
-                ? `FK reference via ${edge.via || 'field'}`
-                : `${sourceNode.attributes?.type || sourceNode.attributes?.when || edge.via || 'attachment'}`;
-            return {
-                artifact: sourceNode.name,
-                type: artifactType,
-                file: sourceNode.source.file,
-                reason: impactReason,
-                state: sourceNode.action
-            };
-        })
-            .filter((artifact) => artifact !== null);
-        if (impactedArtifacts.length === 0) {
+        // ── STEP 3: BFS traversal ────────────────────────────────────────────────
+        const maxDepth = options.directOnly ? 1 : Math.max(1, parseInt(options.depth, 10) || 10);
+        const traversal = (0, traversal_1.traverseBlastRadius)(lineageGraph, targetTableName, maxDepth);
+        // ── STEP 4: Apply display filter ─────────────────────────────────────────
+        // Show a node if it has a source file OR is a non-deleted local node.
+        // Suppress SDK-managed child records that have no user-authored source.
+        const isDisplayable = (tn) => {
+            if (!options.includeDeleted && tn.node.action === 'DELETE')
+                return false;
+            if (tn.node.source.file)
+                return true;
+            // Suppress isChild records with no source file (intermediate composition nodes)
+            if (registry.isChild(tn.node.table))
+                return false;
+            return true;
+        };
+        const displayed = traversal.hops.filter(isDisplayable);
+        const directImpact = displayed.filter(tn => tn.hop === 1);
+        const transitiveImpact = displayed.filter(tn => tn.hop > 1);
+        if (displayed.length === 0) {
             console.log(chalk_1.default.green('\n✅ Zero dependencies detected in local project.\n'));
             return;
         }
-        // STEP 5: Output based on format
+        // ── STEP 5: Output ───────────────────────────────────────────────────────
         switch (options.format) {
-            case 'json':
-                console.log(JSON.stringify(impactedArtifacts, null, 2));
+            case 'json': {
+                const output = displayed.map(tn => ({
+                    artifact: tn.node.name,
+                    type: registry.getDisplayGroupName(tn.node.table).toLowerCase(),
+                    file: tn.node.source.file,
+                    hop: tn.hop,
+                    path: tn.path,
+                    via: tn.viaEdge.via ?? tn.viaEdge.type,
+                    edgeType: tn.viaEdge.type,
+                    state: tn.node.action,
+                }));
+                console.log(JSON.stringify(output, null, 2));
                 break;
-            case 'csv':
-                console.log('Artifact,Type,File,Reason,State');
-                impactedArtifacts.forEach(impactedArtifact => {
-                    console.log(`"${impactedArtifact.artifact}","${impactedArtifact.type}","${impactedArtifact.file}","${impactedArtifact.reason}","${impactedArtifact.state}"`);
+            }
+            case 'csv': {
+                console.log('Artifact,Type,File,Hop,Via,State,Path');
+                displayed.forEach(tn => {
+                    const via = tn.viaEdge.via ?? tn.viaEdge.type;
+                    const pathStr = tn.path.join(' > ');
+                    console.log(`"${tn.node.name}","${registry.getDisplayGroupName(tn.node.table).toLowerCase()}","${tn.node.source.file}",${tn.hop},"${via}","${tn.node.action}","${pathStr}"`);
                 });
                 break;
+            }
             case 'table':
-            default:
-                const table = new cli_table3_1.default({
-                    head: [
+            default: {
+                // ── Direct Impact section ────────────────────────────────────────────
+                if (directImpact.length > 0) {
+                    console.log(chalk_1.default.bold('\n⚡ DIRECT IMPACT') + chalk_1.default.gray(' (Hop 1)'));
+                    const directTable = new cli_table3_1.default({
+                        head: [
+                            chalk_1.default.cyan('Artifact'),
+                            chalk_1.default.cyan('Type'),
+                            chalk_1.default.cyan('File'),
+                            chalk_1.default.cyan('Via'),
+                            chalk_1.default.cyan('State'),
+                        ],
+                        wordWrap: true,
+                        style: { head: [], border: ['gray'] },
+                    });
+                    directImpact.forEach(tn => {
+                        const via = formatVia(tn);
+                        const stateColor = tn.node.action === 'DELETE' ? chalk_1.default.red : chalk_1.default.green;
+                        directTable.push([
+                            chalk_1.default.white(tn.node.name),
+                            chalk_1.default.gray(registry.getDisplayGroupName(tn.node.table).toLowerCase()),
+                            chalk_1.default.gray(tn.node.source.file || '—'),
+                            chalk_1.default.gray(via),
+                            stateColor(tn.node.action === 'DELETE' ? 'DELETE' : 'ACTIVE'),
+                        ]);
+                    });
+                    console.log(directTable.toString());
+                }
+                // ── Transitive Impact section ────────────────────────────────────────
+                if (transitiveImpact.length > 0 && !options.directOnly) {
+                    console.log(chalk_1.default.bold('\n🌊 TRANSITIVE IMPACT') + chalk_1.default.gray(' (Hop 2+)'));
+                    const transitiveHead = [
                         chalk_1.default.cyan('Artifact'),
                         chalk_1.default.cyan('Type'),
                         chalk_1.default.cyan('File'),
-                        chalk_1.default.cyan('Reason'),
-                        chalk_1.default.cyan('State')
-                    ],
-                    wordWrap: true,
-                    style: { head: [], border: ['gray'] }
-                });
-                impactedArtifacts.forEach(impactedArtifact => {
-                    const typeIcon = impactedArtifact.type === 'field' ? '🔗'
-                        : impactedArtifact.type === 'client_script' ? '⚡'
-                            : impactedArtifact.type === 'business_rule' ? '🔧'
-                                : impactedArtifact.type === 'acl' ? '🔒'
-                                    : '';
-                    const stateColor = impactedArtifact.state === 'DELETE' ? chalk_1.default.red : chalk_1.default.green;
-                    table.push([
-                        chalk_1.default.white(impactedArtifact.artifact),
-                        `${typeIcon} ${chalk_1.default.gray(impactedArtifact.type)}`,
-                        chalk_1.default.gray(impactedArtifact.file),
-                        impactedArtifact.reason,
-                        stateColor(impactedArtifact.state)
-                    ]);
-                });
-                console.log('\n' + table.toString());
-                // STEP 6: Impact Summary
+                        chalk_1.default.cyan('Hop'),
+                        chalk_1.default.cyan('State'),
+                    ];
+                    if (options.showPaths) {
+                        transitiveHead.push(chalk_1.default.cyan('Path'));
+                    }
+                    const transitiveTable = new cli_table3_1.default({
+                        head: transitiveHead,
+                        wordWrap: true,
+                        style: { head: [], border: ['gray'] },
+                    });
+                    transitiveImpact.forEach(tn => {
+                        const stateColor = tn.node.action === 'DELETE' ? chalk_1.default.red : chalk_1.default.green;
+                        const row = [
+                            chalk_1.default.white(tn.node.name),
+                            chalk_1.default.gray(registry.getDisplayGroupName(tn.node.table).toLowerCase()),
+                            chalk_1.default.gray(tn.node.source.file || '—'),
+                            chalk_1.default.yellow(String(tn.hop)),
+                            stateColor(tn.node.action === 'DELETE' ? 'DELETE' : 'ACTIVE'),
+                        ];
+                        if (options.showPaths) {
+                            row.push(chalk_1.default.gray(tn.path.join(' → ')));
+                        }
+                        transitiveTable.push(row);
+                    });
+                    console.log(transitiveTable.toString());
+                }
+                // ── Impact Summary ───────────────────────────────────────────────────
                 console.log(chalk_1.default.yellow('\n📊 IMPACT SUMMARY'));
-                const riskLevel = impactedArtifacts.length < 3 ? 'LOW'
-                    : impactedArtifacts.length < 8 ? 'MEDIUM'
-                        : 'HIGH';
+                const totalCount = displayed.length;
+                const riskLevel = totalCount < 3 ? 'LOW' : totalCount < 8 ? 'MEDIUM' : 'HIGH';
                 const riskColor = riskLevel === 'LOW' ? chalk_1.default.green
                     : riskLevel === 'MEDIUM' ? chalk_1.default.yellow
                         : chalk_1.default.red;
-                console.log(chalk_1.default.gray('Total Impacted: ') + chalk_1.default.cyan(impactedArtifacts.length));
-                console.log(chalk_1.default.gray('Risk Level:     ') + riskColor.bold(riskLevel));
+                console.log(chalk_1.default.gray('Total Impacted:    ') + chalk_1.default.cyan(totalCount) +
+                    chalk_1.default.gray(` (${directImpact.length} direct, ${transitiveImpact.length} transitive)`));
+                console.log(chalk_1.default.gray('Max Depth Reached: ') + chalk_1.default.cyan(traversal.maxHopReached));
+                console.log(chalk_1.default.gray('Risk Level:        ') + riskColor.bold(riskLevel));
                 console.log(chalk_1.default.gray('─'.repeat(80)) + '\n');
                 if (riskLevel === 'HIGH') {
-                    console.log(chalk_1.default.yellow('⚠️ High impact - Review carefully'));
+                    console.log(chalk_1.default.yellow('⚠️  High impact — review carefully before deploying'));
                 }
                 else if (riskLevel === 'MEDIUM') {
                     console.log(chalk_1.default.yellow('💡 Moderate impact'));
                 }
                 break;
+            }
         }
     }
     catch (error) {
@@ -200,3 +237,11 @@ exports.blastCommand = new commander_1.Command('blast')
         process.exit(1);
     }
 });
+/** Format the "Via" column label from a traversal node's edge. */
+function formatVia(tn) {
+    const edge = tn.viaEdge;
+    if (edge.type === 'schema_relationship') {
+        return `${edge.via ?? 'ref'} (ref field)`;
+    }
+    return edge.via ?? edge.type;
+}