@yesprasad/fluent-graph 0.1.0

package/dist/cli/commands/blast.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blastCommand = void 0;
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+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('--include-deleted', 'Include deleted artifacts in the analysis')
+    .option('--no-banner', 'Skip banner (inherited)')
+    .action(async (targetTableName, options) => {
+    try {
+        const graphFilePath = path.isAbsolute(options.graph)
+            ? options.graph
+            : path.join(process.cwd(), options.graph);
+        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)
+        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')
+                .map(node => node.name)
+                .sort();
+            customTables.forEach(tableName => console.log(chalk_1.default.gray(' • ') + chalk_1.default.white(tableName)));
+            console.log(chalk_1.default.yellow('\n💡 Referenced platform tables:'));
+            const platformTables = [...new Set(lineageGraph.edges
+                    .filter(edge => edge.to.startsWith('platform:'))
+                    .map(edge => edge.to.split(':')[1]))].sort();
+            platformTables.forEach(tableName => console.log(chalk_1.default.gray(' • ') + chalk_1.default.magenta(tableName)));
+            process.exit(1);
+        }
+        // STEP 3: 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]') : ''));
+        if (!isBaseTable) {
+            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) {
+            console.log(chalk_1.default.green('\n✅ Zero dependencies detected in local project.\n'));
+            return;
+        }
+        // STEP 5: Output based on format
+        switch (options.format) {
+            case 'json':
+                console.log(JSON.stringify(impactedArtifacts, 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}"`);
+                });
+                break;
+            case 'table':
+            default:
+                const table = 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('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
+                console.log(chalk_1.default.yellow('\n📊 IMPACT SUMMARY'));
+                const riskLevel = impactedArtifacts.length < 3 ? 'LOW'
+                    : impactedArtifacts.length < 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('─'.repeat(80)) + '\n');
+                if (riskLevel === 'HIGH') {
+                    console.log(chalk_1.default.yellow('⚠️ High impact - Review carefully'));
+                }
+                else if (riskLevel === 'MEDIUM') {
+                    console.log(chalk_1.default.yellow('💡 Moderate impact'));
+                }
+                break;
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        process.exit(1);
+    }
+});

package/dist/cli/commands/extract.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+/**
+ * The Extract Command: Orchestrates the transformation of a ServiceNow Fluent
+ * project into a formal directed graph.
+ */
+export declare const extractCommand: Command;

package/dist/cli/commands/extract.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const detector_1 = require("../../sdk/detector");
+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.
+ */
+exports.extractCommand = new commander_1.Command('analyze')
+    .description('Analyze and extract dependency graph from the 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) => {
+    let spinner;
+    try {
+        const currentWorkingDir = process.cwd();
+        // Step 1: Detect ServiceNow SDK Environment
+        if (!options.quiet) {
+            spinner = (0, ora_1.default)('Detecting ServiceNow SDK...').start();
+        }
+        const sdkDetectionResult = await (0, detector_1.detectSDK)(currentWorkingDir);
+        if (!sdkDetectionResult.found) {
+            if (spinner)
+                spinner.fail('SDK not found');
+            console.error(chalk_1.default.red('\n❌ Error:'), sdkDetectionResult.error);
+            console.log(chalk_1.default.yellow('\n💡 Make sure you\'re in a ServiceNow Fluent project directory'));
+            process.exit(1);
+        }
+        if (spinner) {
+            spinner.succeed(`✅ SDK detected at ${chalk_1.default.gray(sdkDetectionResult.sdkPath)}`);
+        }
+        // Step 2: Dynamically Load Workspace SDK
+        if (!options.quiet) {
+            spinner = (0, ora_1.default)('Loading workspace SDK...').start();
+        }
+        const workspaceSDK = (0, loader_1.loadWorkspaceSDK)(sdkDetectionResult.sdkPath);
+        if (spinner) {
+            spinner.succeed('Workspace SDK loaded');
+        }
+        // Step 3: Instantiate the Project Proxy
+        if (!options.quiet) {
+            spinner = (0, ora_1.default)('Loading project configuration...').start();
+        }
+        const projectInstance = new workspaceSDK.sdkapi.Project({ rootDir: currentWorkingDir });
+        if (spinner) {
+            spinner.succeed('Project loaded');
+        }
+        // Step 4: Extract Lineage Graph
+        if (!options.quiet) {
+            spinner = (0, ora_1.default)('Building dependency graph...').start();
+        }
+        const lineageGraph = await (0, extractor_1.extractLineageGraph)(projectInstance);
+        if (spinner) {
+            spinner.succeed(`Graph built: ${chalk_1.default.cyan(lineageGraph.nodes.length)} nodes, ${chalk_1.default.cyan(lineageGraph.edges.length)} edges`);
+        }
+        // Step 5: Persist the Graph
+        const outputFilePath = path_1.default.isAbsolute(options.output)
+            ? options.output
+            : path_1.default.join(currentWorkingDir, options.output);
+        (0, writer_1.writeGraph)(lineageGraph, outputFilePath);
+        if (!options.quiet) {
+            console.log(chalk_1.default.green('\n✅ Analysis complete'));
+            console.log(chalk_1.default.gray('   Location:     ') + chalk_1.default.white(outputFilePath));
+            console.log(chalk_1.default.gray('   Complexity:   ') + chalk_1.default.cyan((lineageGraph.edges.length / lineageGraph.nodes.length).toFixed(2)) + chalk_1.default.gray(' edges/node'));
+            console.log(chalk_1.default.gray('   Generated at: ') + chalk_1.default.gray(new Date().toLocaleTimeString()));
+        }
+        // Step 6: Visual Lineage Map
+        if (options.display && !options.quiet) {
+            (0, display_1.displayLineageMap)(lineageGraph);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+            if (process.env.DEBUG) {
+                console.error(chalk_1.default.gray('\nStack trace:'));
+                console.error(error.stack);
+            }
+        }
+        else {
+            console.error(chalk_1.default.red('\n❌ Unknown error occurred'));
+            console.error(error);
+        }
+        process.exit(1);
+    }
+});

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,61 @@
+#!/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"));
+const extract_1 = require("./commands/extract");
+const blast_1 = require("./commands/blast");
+const banner_1 = require("./utils/banner");
+// ===== 1. Load package.json dynamically =====
+const packageJsonPath = path_1.default.join(__dirname, '../../package.json');
+const packageJsonContent = fs_1.default.readFileSync(packageJsonPath, 'utf-8');
+const packageJson = JSON.parse(packageJsonContent);
+// ===== 2. Initialize CLI program =====
+const program = new commander_1.Command();
+// Show banner on first run (unless --no-banner or --quiet flag)
+const showBanner = !process.argv.includes('--no-banner') && !process.argv.includes('--quiet');
+if (showBanner) {
+    (0, banner_1.displayBanner)();
+}
+// Use dynamic name, description, version
+program
+    .name(packageJson.name)
+    .description(packageJson.description)
+    .version(packageJson.version)
+    .option('--no-banner', 'Suppress ASCII banner');
+// ===== 3. Register commands =====
+program.addCommand(extract_1.extractCommand);
+program.addCommand(blast_1.blastCommand);
+// ===== 4. Default: show help if no command =====
+if (process.argv.length === 2) {
+    program.help();
+}
+program.parse(process.argv);

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

@@ -0,0 +1,2 @@
+export declare function displayBanner(): void;
+export declare function displayVersion(): void;

package/dist/cli/utils/banner.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayBanner = displayBanner;
+exports.displayVersion = displayVersion;
+const chalk_1 = __importDefault(require("chalk"));
+function displayBanner() {
+    const banner = `
+  ███████╗██╗     ██╗   ██╗███████╗███╗   ██╗████████╗ ██████╗ ██████╗  █████╗ ██████╗ ██╗  ██╗
+  ██╔════╝██║     ██║   ██║██╔════╝████╗  ██║╚══██╔══╝██╔════╝ ██╔══██╗██╔══██╗██╔══██╗██║  ██║
+  █████╗  ██║     ██║   ██║█████╗  ██╔██╗ ██║   ██║   ██║  ███╗██████╔╝███████║██████╔╝███████║
+  ██╔══╝  ██║     ██║   ██║██╔══╝  ██║╚██╗██║   ██║   ██║   ██║██╔══██╗██╔══██║██╔════╝██╔══██║
+  ██║     ███████╗╚██████╔╝███████╗██║ ╚████║   ██║   ╚██████╔╝██║  ██║██║  ██║██║     ██║  ██║
+  ╚═╝     ╚══════╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝  ╚═╝
+  `;
+    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'));
+}
+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'));
+}

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

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

package/dist/cli/utils/display.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayLineageMap = displayLineageMap;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+function displayLineageMap(graph) {
+    console.log(chalk_1.default.yellow.bold('\n📊 LINEAGE MAP'));
+    console.log(chalk_1.default.gray('═'.repeat(80)));
+    // ===== SECTION 1: DATA SCHEMA =====
+    const dataTables = graph.nodes.filter(node => node.table === 'sys_db_object' && node.action !== 'DELETE');
+    if (dataTables.length > 0) {
+        console.log(chalk_1.default.cyan.bold('\n📦 DATA SCHEMA'));
+        const table = new cli_table3_1.default({
+            head: [
+                chalk_1.default.cyan('Table Name'),
+                chalk_1.default.cyan('Status'),
+                chalk_1.default.cyan('Source File')
+            ],
+            wordWrap: true,
+            style: { head: [], border: ['gray'] }
+        });
+        dataTables.forEach(tableNode => {
+            const statusLabel = tableNode.action === 'DELETE' ? chalk_1.default.red('DELETE') : chalk_1.default.green('ACTIVE');
+            table.push([
+                chalk_1.default.white(tableNode.name),
+                statusLabel,
+                chalk_1.default.gray(tableNode.source.file)
+            ]);
+        });
+        console.log(table.toString());
+    }
+    // ===== SECTION 2: SCHEMA RELATIONSHIPS =====
+    const schemaEdges = graph.edges.filter(edge => edge.type === 'schema_relationship');
+    if (schemaEdges.length > 0) {
+        console.log(chalk_1.default.cyan.bold('\n🔗 SCHEMA RELATIONSHIPS (Reference Fields)'));
+        const table = new cli_table3_1.default({
+            head: [
+                chalk_1.default.cyan('Field'),
+                chalk_1.default.cyan('From Table'),
+                chalk_1.default.cyan('Target Table')
+            ],
+            wordWrap: true,
+            style: { head: [], border: ['gray'] }
+        });
+        schemaEdges.forEach(edge => {
+            const fromNode = graph.nodes.find(node => node.id === edge.from);
+            const fieldName = fromNode?.attributes?.element || edge.via || 'unknown';
+            const fromTableName = fromNode?.attributes?.name || 'unknown';
+            const targetTableName = edge.to.startsWith('platform:')
+                ? edge.to.split(':')[1]
+                : graph.nodes.find(node => node.id === edge.to)?.name || edge.to;
+            table.push([chalk_1.default.white(fieldName), chalk_1.default.gray(fromTableName), chalk_1.default.magenta(targetTableName)]);
+        });
+        console.log(table.toString());
+    }
+    // ===== SECTION 3: LOGIC ATTACHMENTS =====
+    const logicArtifacts = graph.nodes.filter(node => ['sys_script_client', 'sys_ui_action', 'sys_script', 'sys_script_include', 'sys_ui_policy'].includes(node.table) &&
+        node.action !== 'DELETE' &&
+        node.source.file);
+    if (logicArtifacts.length > 0) {
+        console.log(chalk_1.default.cyan.bold('\n⚙️  LOGIC ATTACHMENTS (Scripts & Actions)'));
+        const table = new cli_table3_1.default({
+            head: [
+                chalk_1.default.cyan('Artifact Name'),
+                chalk_1.default.cyan('Target Table'),
+                chalk_1.default.cyan('Type'),
+                chalk_1.default.cyan('Artifact Type')
+            ],
+            wordWrap: true,
+            style: { head: [], border: ['gray'] }
+        });
+        logicArtifacts.forEach(logicNode => {
+            const dependencyEdge = graph.edges.find(edge => edge.from === logicNode.id && edge.type === 'dependency');
+            const targetTable = dependencyEdge
+                ? (dependencyEdge.to.startsWith('platform:')
+                    ? dependencyEdge.to.split(':')[1]
+                    : graph.nodes.find(node => node.id === dependencyEdge.to)?.name || dependencyEdge.to)
+                : '[global]';
+            const typeLabel = logicNode.attributes?.type ? `[${logicNode.attributes.type}]` : '[action]';
+            const artifactType = (() => {
+                switch (logicNode.table) {
+                    case 'sys_script_client': return 'client script';
+                    case 'sys_script': return 'script';
+                    case 'sys_ui_action': return 'ui action';
+                    case 'sys_script_include': return 'script include';
+                    case 'sys_ui_policy': return 'ui policy';
+                    default: return logicNode.table;
+                }
+            })();
+            table.push([
+                chalk_1.default.white(logicNode.name),
+                chalk_1.default.gray(targetTable),
+                chalk_1.default.gray(typeLabel),
+                artifactType
+            ]);
+        });
+        console.log(table.toString());
+    }
+    // ===== SECTION 4: SECURITY & ACCESS (ACLs) =====
+    const aclNodes = graph.nodes.filter(node => node.table === 'sys_security_acl' && node.action !== 'DELETE');
+    if (aclNodes.length > 0) {
+        console.log(chalk_1.default.cyan.bold('\n🔒 SECURITY & ACCESS (ACLs)'));
+        const table = new cli_table3_1.default({
+            head: [
+                chalk_1.default.cyan('ACL'),
+                chalk_1.default.cyan('Level'),
+                chalk_1.default.cyan('Operation'),
+                chalk_1.default.cyan('Roles'),
+                chalk_1.default.cyan('Target Table')
+            ],
+            wordWrap: true,
+            style: { head: [], border: ['gray'] }
+        });
+        aclNodes.forEach(aclNode => {
+            const aclEdge = graph.edges.find(edge => edge.from === aclNode.id && edge.type === 'dependency');
+            const targetTable = aclEdge?.targetTable || (aclEdge?.to.startsWith('platform:') ? aclEdge.to.split(':')[1] : 'unknown');
+            const [nameTable, nameField] = aclNode.name.includes('.') ? aclNode.name.split('.') : [aclNode.name, '*'];
+            const isFieldLevel = nameField !== '*' && nameField !== undefined;
+            const level = isFieldLevel ? 'Field-level' : 'Table-level';
+            const operation = (aclNode.attributes?.operation || 'read').toUpperCase();
+            const roleEdges = graph.edges.filter(edge => edge.from === aclNode.id && edge.type === 'composition');
+            const roleNames = roleEdges
+                .map(edge => {
+                const roleNode = graph.nodes.find(node => node.id === edge.to);
+                return roleNode?.attributes?.name || roleNode?.name || 'unknown';
+            })
+                .filter(Boolean)
+                .sort();
+            const rolesDisplay = roleNames.length > 0 ? roleNames.join(', ') : chalk_1.default.gray('No roles specified');
+            const aclLabel = `${operation} on ${nameTable}${isFieldLevel ? `.${nameField}` : ''}`;
+            table.push([
+                chalk_1.default.yellow(aclLabel),
+                chalk_1.default.gray(level),
+                chalk_1.default.gray(operation),
+                rolesDisplay,
+                chalk_1.default.magenta(targetTable)
+            ]);
+        });
+        console.log(table.toString());
+    }
+    // ===== SECTION 5: PROJECT INSIGHTS =====
+    console.log(chalk_1.default.cyan.bold('\n🧠 PROJECT INSIGHTS'));
+    const platformDeps = graph.edges.filter(edge => edge.to.startsWith('platform:')).length;
+    const internalDeps = graph.edges.filter(edge => !edge.to.startsWith('platform:')).length;
+    const userArtifactTables = [
+        'sys_db_object',
+        'sys_script_client',
+        'sys_script',
+        'sys_business_rule',
+        'sys_ui_action',
+        'sys_security_acl',
+        'sys_script_include'
+    ];
+    const userArtifacts = graph.nodes.filter(node => node.action !== 'DELETE' &&
+        node.source.file &&
+        !node.id.startsWith('platform:') &&
+        userArtifactTables.includes(node.table));
+    console.log(` • Total User Artifacts: ${chalk_1.default.cyan(userArtifacts.length)}`);
+    const countsByType = userArtifacts.reduce((acc, node) => {
+        acc[node.table] = (acc[node.table] || 0) + 1;
+        return acc;
+    }, {});
+    console.log(` • User Artifacts Breakdown: ${JSON.stringify(countsByType, null, 2)}`);
+    console.log(` • Platform Dependencies: ${chalk_1.default.magenta(platformDeps)}`);
+    console.log(` • Internal References:   ${chalk_1.default.white(internalDeps)}`);
+    console.log(` • Total Artifacts:       ${chalk_1.default.cyan(graph.nodes.length)}`);
+    console.log(` • Total Relationships:   ${chalk_1.default.cyan(graph.edges.length)}`);
+    console.log(chalk_1.default.gray('═'.repeat(80)) + '\n');
+}