infrawise 0.1.0 → 0.2.0

package/dist/core/config.js

@@ -0,0 +1,163 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigError = exports.InfrawiseConfigSchema = void 0;
+exports.loadConfig = loadConfig;
+exports.generateDefaultConfig = generateDefaultConfig;
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+exports.InfrawiseConfigSchema = zod_1.z.object({
+    project: zod_1.z.string().min(1, 'Project name is required'),
+    aws: zod_1.z
+        .object({
+        profile: zod_1.z.string().optional().default('default'),
+        region: zod_1.z.string().optional().default('us-east-1'),
+    })
+        .optional()
+        .default({}),
+    dynamodb: zod_1.z.object({ enabled: zod_1.z.boolean().optional().default(true), includeTables: zod_1.z.array(zod_1.z.string()).optional() }).optional(),
+    postgres: zod_1.z.object({
+        enabled: zod_1.z.boolean().optional().default(false),
+        connectionString: zod_1.z.string().optional(),
+    }).optional(),
+    mysql: zod_1.z.object({
+        enabled: zod_1.z.boolean().optional().default(false),
+        connectionString: zod_1.z.string().optional(),
+    }).optional(),
+    mongodb: zod_1.z.object({
+        enabled: zod_1.z.boolean().optional().default(false),
+        connectionString: zod_1.z.string().optional(),
+        databases: zod_1.z.array(zod_1.z.string()).optional(),
+    }).optional(),
+    terraform: zod_1.z.object({ enabled: zod_1.z.boolean().optional().default(true) }).optional(),
+    sqs: zod_1.z.object({ enabled: zod_1.z.boolean().optional().default(true) }).optional(),
+    sns: zod_1.z.object({ enabled: zod_1.z.boolean().optional().default(true) }).optional(),
+    ssm: zod_1.z.object({
+        enabled: zod_1.z.boolean().optional().default(true),
+        paths: zod_1.z.array(zod_1.z.string()).optional(),
+    }).optional(),
+    secretsManager: zod_1.z.object({ enabled: zod_1.z.boolean().optional().default(true) }).optional(),
+    lambda: zod_1.z.object({ enabled: zod_1.z.boolean().optional().default(true) }).optional(),
+    rds: zod_1.z.object({ enabled: zod_1.z.boolean().optional().default(false) }).optional(),
+    cloudwatchLogs: zod_1.z.object({
+        enabled: zod_1.z.boolean().optional().default(false),
+        logGroupPrefixes: zod_1.z.array(zod_1.z.string()).optional(),
+        windowHours: zod_1.z.number().int().positive().optional().default(24),
+    }).optional(),
+    analysis: zod_1.z.object({
+        sampleSize: zod_1.z.number().int().positive().optional().default(100),
+    }).optional(),
+});
+class ConfigError extends Error {
+    details;
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+        this.name = 'ConfigError';
+    }
+}
+exports.ConfigError = ConfigError;
+function loadConfig(configPath) {
+    const resolvedPath = configPath
+        ? path.resolve(configPath)
+        : path.resolve(process.cwd(), 'infrawise.yaml');
+    if (!fs.existsSync(resolvedPath)) {
+        throw new ConfigError(`Configuration file not found at: ${resolvedPath}`, [
+            'Run `infrawise init` to generate a configuration file',
+            `Or specify a path with --config <path>`,
+        ]);
+    }
+    let rawContent;
+    try {
+        rawContent = fs.readFileSync(resolvedPath, 'utf-8');
+    }
+    catch (err) {
+        throw new ConfigError(`Unable to read configuration file: ${resolvedPath}`, [String(err)]);
+    }
+    let parsedYaml;
+    try {
+        parsedYaml = yaml.load(rawContent);
+    }
+    catch (err) {
+        throw new ConfigError(`Invalid YAML in configuration file: ${resolvedPath}`, [String(err)]);
+    }
+    const result = exports.InfrawiseConfigSchema.safeParse(parsedYaml);
+    if (!result.success) {
+        const details = result.error.errors.map((e) => `  - ${e.path.join('.')}: ${e.message}`);
+        throw new ConfigError('Configuration validation failed', details);
+    }
+    return result.data;
+}
+function generateDefaultConfig(projectName, options) {
+    const config = {
+        project: projectName,
+        aws: {
+            profile: options?.aws?.profile ?? 'default',
+            region: options?.aws?.region ?? 'us-east-1',
+        },
+        dynamodb: { enabled: options?.dynamodb?.enabled ?? true, includeTables: options?.dynamodb?.includeTables ?? [] },
+        postgres: {
+            enabled: options?.postgres?.enabled ?? false,
+            connectionString: options?.postgres?.connectionString ?? '',
+        },
+        mysql: {
+            enabled: options?.mysql?.enabled ?? false,
+            connectionString: options?.mysql?.connectionString ?? '',
+        },
+        mongodb: {
+            enabled: options?.mongodb?.enabled ?? false,
+            connectionString: options?.mongodb?.connectionString ?? '',
+            databases: options?.mongodb?.databases ?? [],
+        },
+        terraform: { enabled: options?.terraform?.enabled ?? true },
+        sqs: { enabled: options?.sqs?.enabled ?? true },
+        sns: { enabled: options?.sns?.enabled ?? true },
+        ssm: {
+            enabled: options?.ssm?.enabled ?? true,
+            paths: options?.ssm?.paths ?? [],
+        },
+        secretsManager: { enabled: options?.secretsManager?.enabled ?? true },
+        lambda: { enabled: options?.lambda?.enabled ?? true },
+        cloudwatchLogs: {
+            enabled: options?.cloudwatchLogs?.enabled ?? false,
+            logGroupPrefixes: options?.cloudwatchLogs?.logGroupPrefixes ?? [],
+            windowHours: options?.cloudwatchLogs?.windowHours ?? 24,
+        },
+        analysis: { sampleSize: options?.analysis?.sampleSize ?? 100 },
+    };
+    return yaml.dump(config, { lineWidth: 120 });
+}

package/dist/core/errors.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigError = exports.RepositoryScanError = exports.PostgresConnectionError = exports.DynamoDBError = exports.AWSConnectionError = exports.InfrawiseError = void 0;
+exports.formatError = formatError;
+class InfrawiseError extends Error {
+    reasons;
+    remediation;
+    constructor(message, reasons, remediation) {
+        super(message);
+        this.reasons = reasons;
+        this.remediation = remediation;
+        this.name = 'InfrawiseError';
+    }
+    format() {
+        const lines = [`\n${this.message}\n`];
+        if (this.reasons && this.reasons.length > 0) {
+            lines.push('Possible reasons:');
+            for (const reason of this.reasons) {
+                lines.push(`  - ${reason}`);
+            }
+            lines.push('');
+        }
+        if (this.remediation) {
+            lines.push(`Run: ${this.remediation}`);
+        }
+        return lines.join('\n');
+    }
+}
+exports.InfrawiseError = InfrawiseError;
+class AWSConnectionError extends InfrawiseError {
+    constructor(details) {
+        super('Unable to connect to AWS.', [
+            'Invalid or missing AWS credentials',
+            'Incorrect AWS profile specified',
+            'Network connectivity issues',
+            details ?? 'Unexpected AWS error',
+        ], 'infrawise doctor');
+        this.name = 'AWSConnectionError';
+    }
+}
+exports.AWSConnectionError = AWSConnectionError;
+class DynamoDBError extends InfrawiseError {
+    constructor(details) {
+        super('Unable to access DynamoDB.', [
+            'Insufficient IAM permissions (need dynamodb:ListTables, dynamodb:DescribeTable)',
+            'Wrong AWS region configured',
+            'DynamoDB endpoint not reachable',
+            details ?? 'Unexpected DynamoDB error',
+        ], 'infrawise doctor');
+        this.name = 'DynamoDBError';
+    }
+}
+exports.DynamoDBError = DynamoDBError;
+class PostgresConnectionError extends InfrawiseError {
+    constructor(details) {
+        super('Unable to connect to PostgreSQL.', [
+            'Invalid connection string',
+            'Security group restrictions',
+            'Expired credentials',
+            details ?? 'Unexpected PostgreSQL error',
+        ], 'infrawise doctor');
+        this.name = 'PostgresConnectionError';
+    }
+}
+exports.PostgresConnectionError = PostgresConnectionError;
+class RepositoryScanError extends InfrawiseError {
+    constructor(details) {
+        super('Unable to scan repository.', [
+            'Path does not exist or is not accessible',
+            'Not a valid TypeScript project',
+            'tsconfig.json not found',
+            details ?? 'Unexpected scan error',
+        ], 'infrawise doctor');
+        this.name = 'RepositoryScanError';
+    }
+}
+exports.RepositoryScanError = RepositoryScanError;
+class ConfigError extends InfrawiseError {
+    constructor(details) {
+        super('Invalid or missing configuration.', [
+            'infrawise.yaml not found in current directory',
+            'Missing required fields in configuration',
+            details ?? 'Unexpected config error',
+        ], 'infrawise init');
+        this.name = 'ConfigError';
+    }
+}
+exports.ConfigError = ConfigError;
+function formatError(err) {
+    if (err instanceof InfrawiseError) {
+        return err.format();
+    }
+    if (err instanceof Error) {
+        return `\nUnexpected error: ${err.message}\n`;
+    }
+    return `\nUnexpected error: ${String(err)}\n`;
+}

package/dist/core/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCache = exports.readCache = exports.writeCache = exports.formatError = exports.ConfigError = exports.RepositoryScanError = exports.PostgresConnectionError = exports.DynamoDBError = exports.AWSConnectionError = exports.InfrawiseError = exports.logger = exports.ConfigValidationError = exports.InfrawiseConfigSchema = exports.generateDefaultConfig = exports.loadConfig = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "generateDefaultConfig", { enumerable: true, get: function () { return config_1.generateDefaultConfig; } });
+Object.defineProperty(exports, "InfrawiseConfigSchema", { enumerable: true, get: function () { return config_1.InfrawiseConfigSchema; } });
+Object.defineProperty(exports, "ConfigValidationError", { enumerable: true, get: function () { return config_1.ConfigError; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "InfrawiseError", { enumerable: true, get: function () { return errors_1.InfrawiseError; } });
+Object.defineProperty(exports, "AWSConnectionError", { enumerable: true, get: function () { return errors_1.AWSConnectionError; } });
+Object.defineProperty(exports, "DynamoDBError", { enumerable: true, get: function () { return errors_1.DynamoDBError; } });
+Object.defineProperty(exports, "PostgresConnectionError", { enumerable: true, get: function () { return errors_1.PostgresConnectionError; } });
+Object.defineProperty(exports, "RepositoryScanError", { enumerable: true, get: function () { return errors_1.RepositoryScanError; } });
+Object.defineProperty(exports, "ConfigError", { enumerable: true, get: function () { return errors_1.ConfigError; } });
+Object.defineProperty(exports, "formatError", { enumerable: true, get: function () { return errors_1.formatError; } });
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "writeCache", { enumerable: true, get: function () { return cache_1.writeCache; } });
+Object.defineProperty(exports, "readCache", { enumerable: true, get: function () { return cache_1.readCache; } });
+Object.defineProperty(exports, "clearCache", { enumerable: true, get: function () { return cache_1.clearCache; } });

package/dist/core/logger.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const pino_1 = __importDefault(require("pino"));
+function createLogger() {
+    const isDevelopment = process.env.NODE_ENV !== 'production';
+    if (isDevelopment) {
+        return (0, pino_1.default)({
+            level: process.env.LOG_LEVEL ?? 'info',
+            transport: {
+                target: 'pino-pretty',
+                options: {
+                    colorize: true,
+                    translateTime: 'HH:MM:ss',
+                    ignore: 'pid,hostname',
+                    messageFormat: '{msg}',
+                },
+            },
+        });
+    }
+    return (0, pino_1.default)({
+        level: process.env.LOG_LEVEL ?? 'info',
+    });
+}
+exports.logger = createLogger();

package/dist/graph/index.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraph = buildGraph;
+exports.getTableNodes = getTableNodes;
+exports.getFunctionNodes = getFunctionNodes;
+exports.getIndexNodes = getIndexNodes;
+exports.getQueueNodes = getQueueNodes;
+exports.getTopicNodes = getTopicNodes;
+exports.getSecretNodes = getSecretNodes;
+exports.getParameterNodes = getParameterNodes;
+exports.getLogGroupNodes = getLogGroupNodes;
+exports.getLambdaNodes = getLambdaNodes;
+exports.getEdgesForNode = getEdgesForNode;
+exports.getOutgoingEdges = getOutgoingEdges;
+exports.getIncomingEdges = getIncomingEdges;
+exports.getScanEdges = getScanEdges;
+exports.getEdgeFrequency = getEdgeFrequency;
+function buildGraph(operations, dynamoMeta, postgresMeta, mysqlMeta = [], mongoMeta = [], servicesMeta = {}) {
+    const nodes = [];
+    const edges = [];
+    const nodeIds = new Set();
+    function addNode(node) {
+        if (!nodeIds.has(node.id)) {
+            nodes.push(node);
+            nodeIds.add(node.id);
+        }
+    }
+    // ── Database tables ──────────────────────────────────────────────────────
+    for (const table of dynamoMeta) {
+        const nodeId = `table:dynamo:${table.tableName}`;
+        addNode({ id: nodeId, type: 'table', name: table.tableName, databaseType: 'dynamodb' });
+        for (const indexName of table.indexes) {
+            const indexNodeId = `index:${table.tableName}:${indexName}`;
+            addNode({ id: indexNodeId, type: 'index', name: indexName });
+            edges.push({ from: nodeId, to: indexNodeId, type: 'uses_index' });
+        }
+    }
+    for (const table of postgresMeta) {
+        const nodeId = `table:postgres:${table.schema}.${table.table}`;
+        addNode({ id: nodeId, type: 'table', name: `${table.schema}.${table.table}`, databaseType: 'postgres' });
+        for (const indexName of table.indexes) {
+            const indexNodeId = `index:${table.schema}.${table.table}:${indexName}`;
+            addNode({ id: indexNodeId, type: 'index', name: indexName });
+            edges.push({ from: nodeId, to: indexNodeId, type: 'uses_index' });
+        }
+    }
+    for (const table of mysqlMeta) {
+        const nodeId = `table:mysql:${table.schema}.${table.table}`;
+        addNode({ id: nodeId, type: 'table', name: `${table.schema}.${table.table}`, databaseType: 'mysql' });
+        for (const indexName of table.indexes) {
+            const indexNodeId = `index:${table.schema}.${table.table}:${indexName}`;
+            addNode({ id: indexNodeId, type: 'index', name: indexName });
+            edges.push({ from: nodeId, to: indexNodeId, type: 'uses_index' });
+        }
+    }
+    for (const coll of mongoMeta) {
+        const nodeId = `table:mongodb:${coll.database}.${coll.collection}`;
+        addNode({ id: nodeId, type: 'table', name: `${coll.database}.${coll.collection}`, databaseType: 'mongodb' });
+        for (const idx of coll.indexes) {
+            if (idx.name === '_id_')
+                continue;
+            const indexNodeId = `index:${coll.database}.${coll.collection}:${idx.name}`;
+            addNode({ id: indexNodeId, type: 'index', name: idx.name });
+            edges.push({ from: nodeId, to: indexNodeId, type: 'uses_index' });
+        }
+    }
+    // ── AWS services ──────────────────────────────────────────────────────────
+    for (const q of servicesMeta.sqs ?? []) {
+        addNode({
+            id: `queue:aws:${q.name}`,
+            type: 'queue',
+            name: q.name,
+            provider: 'aws',
+            hasDLQ: q.hasDLQ,
+            encrypted: q.encrypted,
+            approximateMessages: q.approximateMessages,
+            retentionDays: q.retentionDays,
+        });
+    }
+    for (const t of servicesMeta.sns ?? []) {
+        addNode({
+            id: `topic:aws:${t.name}`,
+            type: 'topic',
+            name: t.name,
+            provider: 'aws',
+            subscriptionCount: t.subscriptionCount,
+            encrypted: t.encrypted,
+        });
+    }
+    for (const s of servicesMeta.secrets ?? []) {
+        addNode({
+            id: `secret:aws:${s.name}`,
+            type: 'secret',
+            name: s.name,
+            provider: 'aws',
+            rotationEnabled: s.rotationEnabled,
+            rotationDays: s.rotationDays,
+        });
+    }
+    for (const p of servicesMeta.ssm ?? []) {
+        addNode({
+            id: `parameter:aws:${p.name}`,
+            type: 'parameter',
+            name: p.name,
+            provider: 'aws',
+            paramType: p.type,
+            tier: p.tier,
+        });
+    }
+    for (const lg of servicesMeta.logs ?? []) {
+        addNode({
+            id: `log_group:aws:${lg.logGroupName}`,
+            type: 'log_group',
+            name: lg.logGroupName,
+            provider: 'aws',
+            retentionDays: lg.retentionDays,
+            errorCount: lg.errorCount,
+            topErrorPatterns: lg.topErrorPatterns,
+        });
+    }
+    for (const fn of servicesMeta.lambda ?? []) {
+        addNode({
+            id: `lambda:aws:${fn.name}`,
+            type: 'lambda',
+            name: fn.name,
+            runtime: fn.runtime,
+            memoryMB: fn.memoryMB,
+            timeoutSec: fn.timeoutSec,
+            envVarKeys: fn.envVarKeys,
+        });
+    }
+    for (const db of servicesMeta.rds ?? []) {
+        addNode({
+            id: `database_instance:aws:${db.dbInstanceIdentifier}`,
+            type: 'database_instance',
+            name: db.dbInstanceIdentifier,
+            provider: 'aws',
+            engine: db.engine,
+            engineVersion: db.engineVersion,
+            instanceClass: db.instanceClass,
+            publiclyAccessible: db.publiclyAccessible,
+            storageEncrypted: db.storageEncrypted,
+            backupRetentionDays: db.backupRetentionPeriod,
+            deletionProtection: db.deletionProtection,
+            multiAZ: db.multiAZ,
+        });
+    }
+    // ── Code operations (functions + edges) ───────────────────────────────────
+    for (const op of operations) {
+        const funcNodeId = `function:${op.filePath}:${op.functionName}`;
+        if (!nodeIds.has(funcNodeId)) {
+            nodes.push({ id: funcNodeId, type: 'function', name: op.functionName, file: op.filePath });
+            nodeIds.add(funcNodeId);
+        }
+        // AWS service operations create edges to service nodes
+        if (op.databaseType === 'sqs') {
+            const queueId = `queue:aws:${op.target}`;
+            addNode({ id: queueId, type: 'queue', name: op.target, provider: 'aws', hasDLQ: false, encrypted: false });
+            edges.push({ from: funcNodeId, to: queueId, type: 'publishes_to' });
+            continue;
+        }
+        if (op.databaseType === 'sns') {
+            const topicId = `topic:aws:${op.target}`;
+            addNode({ id: topicId, type: 'topic', name: op.target, provider: 'aws', encrypted: false });
+            edges.push({ from: funcNodeId, to: topicId, type: 'publishes_to' });
+            continue;
+        }
+        if (op.databaseType === 'ssm') {
+            const paramId = `parameter:aws:${op.target}`;
+            addNode({ id: paramId, type: 'parameter', name: op.target, provider: 'aws', paramType: 'String', tier: 'Standard' });
+            edges.push({ from: funcNodeId, to: paramId, type: 'reads_parameter' });
+            continue;
+        }
+        if (op.databaseType === 'secretsmanager') {
+            const secretId = `secret:aws:${op.target}`;
+            addNode({ id: secretId, type: 'secret', name: op.target, provider: 'aws', rotationEnabled: false });
+            edges.push({ from: funcNodeId, to: secretId, type: 'reads_secret' });
+            continue;
+        }
+        if (op.databaseType === 'lambda') {
+            const lambdaId = `lambda:aws:${op.target}`;
+            addNode({ id: lambdaId, type: 'lambda', name: op.target });
+            edges.push({ from: funcNodeId, to: lambdaId, type: 'triggers' });
+            continue;
+        }
+        // Database operations
+        let tableNodeId;
+        if (op.databaseType === 'dynamodb') {
+            tableNodeId = `table:dynamo:${op.target}`;
+            addNode({ id: tableNodeId, type: 'table', name: op.target, databaseType: 'dynamodb' });
+        }
+        else if (op.databaseType === 'mysql') {
+            const q = op.target.includes('.') ? op.target : `default.${op.target}`;
+            tableNodeId = `table:mysql:${q}`;
+            addNode({ id: tableNodeId, type: 'table', name: q, databaseType: 'mysql' });
+        }
+        else if (op.databaseType === 'mongodb') {
+            const q = op.target.includes('.') ? op.target : `default.${op.target}`;
+            tableNodeId = `table:mongodb:${q}`;
+            addNode({ id: tableNodeId, type: 'table', name: q, databaseType: 'mongodb' });
+        }
+        else {
+            // postgres
+            const q = op.target.includes('.') ? op.target : `public.${op.target}`;
+            tableNodeId = `table:postgres:${q}`;
+            addNode({ id: tableNodeId, type: 'table', name: q, databaseType: 'postgres' });
+        }
+        const edgeType = resolveEdgeType(op.operationType);
+        edges.push({ from: funcNodeId, to: tableNodeId, type: edgeType });
+    }
+    return { nodes, edges };
+}
+function resolveEdgeType(operationType) {
+    const op = operationType.toLowerCase();
+    if (op === 'scan' || op === 'scancommand')
+        return 'scan';
+    if (op === 'join' || op === 'joins')
+        return 'joins';
+    return 'query';
+}
+// ── Typed node selectors ─────────────────────────────────────────────────────
+function getTableNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'table');
+}
+function getFunctionNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'function');
+}
+function getIndexNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'index');
+}
+function getQueueNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'queue');
+}
+function getTopicNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'topic');
+}
+function getSecretNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'secret');
+}
+function getParameterNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'parameter');
+}
+function getLogGroupNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'log_group');
+}
+function getLambdaNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'lambda');
+}
+function getEdgesForNode(graph, nodeId) {
+    return graph.edges.filter((e) => e.from === nodeId || e.to === nodeId);
+}
+function getOutgoingEdges(graph, nodeId) {
+    return graph.edges.filter((e) => e.from === nodeId);
+}
+function getIncomingEdges(graph, nodeId) {
+    return graph.edges.filter((e) => e.to === nodeId);
+}
+function getScanEdges(graph) {
+    return graph.edges.filter((e) => e.type === 'scan');
+}
+function getEdgeFrequency(graph) {
+    const freq = new Map();
+    for (const edge of graph.edges) {
+        const key = `${edge.from}->${edge.to}`;
+        freq.set(key, (freq.get(key) ?? 0) + 1);
+    }
+    return freq;
+}