@yesprasad/fluent-graph 0.1.0 → 0.2.1

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;
+}

package/dist/cli/commands/extract.js

@@ -13,85 +13,6 @@ const loader_1 = require("../../sdk/loader");
 const extractor_1 = require("../../extractor");
 const writer_1 = require("../../output/writer");
 const display_1 = require("../utils/display");
-// /**
-//  * The Analyze Command: Orchestrates the transformation of a ServiceNow Fluent 
-//  * project into a formal directed graph.
-//  */
-// export const extractCommand = new Command('analyze')
-//   .description('Analyze and Extract dependency graph from current project')
-//   .option('-o, --output <path>', 'Output file path', 'fluent-graph.json')
-//   .option('-q, --quiet', 'Suppress console output')
-//   .option('--no-display', 'Skip visual display')
-//   .option('--no-banner', 'Skip banner (inherited)')
-//   .action(async (options) => {
-//     try {
-//       const cwd = process.cwd();
-//       let spinner: any;
-//       // Step 1: Detect ServiceNow SDK Environment
-//       if (!options.quiet) {
-//         spinner = ora('Detecting ServiceNow SDK...').start();
-//       }
-//       const sdk = await detectSDK(cwd);
-//       if (!sdk.found) {
-//         if (spinner) spinner.fail('SDK not found');
-//         console.error(chalk.red('\n❌ Error:'), sdk.error);
-//         console.log(chalk.yellow('\n💡 Make sure you\'re in a ServiceNow Fluent project directory'));
-//         process.exit(1);
-//       }
-//       if (spinner) {
-//         spinner.succeed(`✅ SDK detected at ${chalk.gray(sdk.sdkPath)}`);
-//       }
-//       // Step 2: Dynamically Load Workspace SDK
-//       if (!options.quiet) {
-//         spinner = ora('Loading workspace SDK...').start();
-//       }
-//       const { sdkapi } = loadWorkspaceSDK(sdk.sdkPath!);
-//       if (spinner) {
-//         spinner.succeed('Workspace SDK loaded');
-//       }
-//       // Step 3: Instantiate the Project Proxy
-//       if (!options.quiet) {
-//         spinner = ora('Loading project configuration...').start();
-//       }
-//       const project = new sdkapi.Project({ rootDir: cwd });
-//       if (spinner) {
-//         spinner.succeed('Project loaded');
-//       }
-//       // Step 4: Extract Lineage Graph
-//       // We pass the full project object, allowing the extractor to
-//       // access nodes, edges, and metadata (projectRoot, scope, etc.)
-//       if (!options.quiet) {
-//         spinner = ora('Building dependency graph...').start();
-//       }
-//       const graph = await extractLineageGraph(project);
-//       if (spinner) {
-//         spinner.succeed(`Graph built: ${chalk.cyan(graph.nodes.length)} nodes, ${chalk.cyan(graph.edges.length)} edges`);
-//       }
-//       // Step 5: Persist the Graph (The "Iterable" result)
-//       const outputPath = path.isAbsolute(options.output)
-//         ? options.output
-//         : path.join(cwd, options.output);
-//       writeGraph(graph, outputPath);
-//       if (!options.quiet) {
-//         console.log(chalk.green('\n✅ Analysis complete'));
-//         console.log(chalk.gray('   Location:     ') + chalk.white(outputPath));
-//         console.log(chalk.gray('   Complexity:   ') + chalk.cyan((graph.edges.length / graph.nodes.length).toFixed(2)) + chalk.gray(' edges/node'));
-//         console.log(chalk.gray('   Generated at: ') + chalk.gray(new Date().toLocaleTimeString()));
-//       }
-//       // Step 6: Visual Lineage Map
-//       // "Artifact-Agnostic" display logic
-//       if (options.display && !options.quiet) {
-//         displayLineageMap(graph);
-//       }
-//     } catch (err: any) {
-//       console.error(chalk.red('\n❌ Error:'), err.message);
-//       if (process.env.DEBUG) {
-//         console.error(chalk.gray('\nStack trace:'));
-//         console.error(err.stack);
-//       }
-//       process.exit(1);
-//     }
-//   });
 /**
  * The Extract Command: Orchestrates the transformation of a ServiceNow Fluent
  * project into a formal directed graph.
@@ -141,7 +62,7 @@ exports.extractCommand = new commander_1.Command('analyze')
         if (!options.quiet) {
             spinner = (0, ora_1.default)('Building dependency graph...').start();
         }
-        const lineageGraph = await (0, extractor_1.extractLineageGraph)(projectInstance);
+        const lineageGraph = await (0, extractor_1.extractLineageGraph)(projectInstance, workspaceSDK.registry);
         if (spinner) {
             spinner.succeed(`Graph built: ${chalk_1.default.cyan(lineageGraph.nodes.length)} nodes, ${chalk_1.default.cyan(lineageGraph.edges.length)} edges`);
         }
@@ -158,7 +79,7 @@ exports.extractCommand = new commander_1.Command('analyze')
         }
         // Step 6: Visual Lineage Map
         if (options.display && !options.quiet) {
-            (0, display_1.displayLineageMap)(lineageGraph);
+            (0, display_1.displayLineageMap)(lineageGraph, workspaceSDK.registry);
         }
     }
     catch (error) {

package/dist/cli/index.d.ts

@@ -1,2 +1 @@
-#!/usr/bin/env node
 export {};

package/dist/cli/index.js

@@ -1,33 +1,8 @@
-#!/usr/bin/env node
 "use strict";
-// import { Command } from 'commander';
-// import chalk from 'chalk';
-// import { extractCommand } from './commands/extract';
-// import { blastCommand } from './commands/blast';
-// import { displayBanner } from './utils/banner';
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// const program = new Command();
-// // Show banner on first run (unless --no-banner flag)
-// const showBanner = !process.argv.includes('--no-banner') && !process.argv.includes('--quiet');
-// if (showBanner) {
-//   displayBanner();
-// }
-// program
-//   .name('fluent-graph')
-//   .description('Dependency/ Lineage graph extraction & Blast-radius/ impact analysis for ServiceNow Fluent Artifacts')
-//   .version('1.0.0')
-//   .option('--no-banner', 'Suppress ASCII banner');
-// // Add commands
-// program.addCommand(extractCommand);
-// program.addCommand(blastCommand);
-// // Default behavior: show help if no command provided
-// if (process.argv.length === 2) {
-//   program.help();
-// }
-// program.parse(process.argv);
 const commander_1 = require("commander");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));

package/dist/cli/utils/banner.js

@@ -16,10 +16,10 @@ function displayBanner() {
   ╚═╝     ╚══════╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝  ╚═╝
   `;
     console.log(chalk_1.default.cyan(banner));
-    console.log(chalk_1.default.gray('        Dependency/ Lineage graph extraction & Blast-radius/ impact analysis for ServiceNow Fluent Artifacts'));
-    console.log(chalk_1.default.gray('        ─────────────────────────────────────────────────────────────────────────────\n'));
+    console.log(chalk_1.default.gray('        Dependency visibility and impact analysis for ServiceNow Fluent SDK projects'));
+    console.log(chalk_1.default.gray('        ────────────────────────────────────────────────────────────────────────────\n'));
 }
 function displayVersion() {
     console.log(chalk_1.default.cyan.bold('Fluent Graph') + chalk_1.default.gray(' v0.1.0'));
-    console.log(chalk_1.default.gray('Dependency visibility for ServiceNow Fluent projects\n'));
+    console.log(chalk_1.default.gray('Dependency visibility and impact analysis for ServiceNow Fluent SDK projects\n'));
 }

package/dist/cli/utils/display.d.ts

@@ -1,2 +1,3 @@
 import { LineageGraph } from '../../types/graphs';
-export declare function displayLineageMap(graph: LineageGraph): void;
+import { ArtifactTypeRegistry } from '../../sdk/registry';
+export declare function displayLineageMap(graph: LineageGraph, registry: ArtifactTypeRegistry): void;