infrawise 0.5.0 → 0.7.0

package/dist/core/index.js

@@ -1,22 +1,4 @@
-"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; } });
+export { loadConfig, generateDefaultConfig, InfrawiseConfigSchema, ConfigError as ConfigValidationError } from './config.js';
+export { logger } from './logger.js';
+export { InfrawiseError, AWSConnectionError, DynamoDBError, PostgresConnectionError, RepositoryScanError, ConfigError, formatError, } from './errors.js';
+export { writeCache, readCache, clearCache } from './cache.js';

package/dist/core/logger.js

@@ -1,14 +1,8 @@
-"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"));
+import pino from 'pino';
 function createLogger() {
     const isDevelopment = process.env.NODE_ENV !== 'production';
     if (isDevelopment) {
-        return (0, pino_1.default)({
+        return pino({
             level: process.env.LOG_LEVEL ?? 'info',
             transport: {
                 target: 'pino-pretty',
@@ -21,8 +15,8 @@ function createLogger() {
             },
         });
     }
-    return (0, pino_1.default)({
+    return pino({
         level: process.env.LOG_LEVEL ?? 'info',
     });
 }
-exports.logger = createLogger();
+export const logger = createLogger();

package/dist/graph/index.js

@@ -1,21 +1,4 @@
-"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 = {}) {
+export function buildGraph(operations, dynamoMeta, postgresMeta, mysqlMeta = [], mongoMeta = [], servicesMeta = {}) {
     const nodes = [];
     const edges = [];
     const nodeIds = new Set();
@@ -119,15 +102,69 @@ function buildGraph(operations, dynamoMeta, postgresMeta, mysqlMeta = [], mongoM
         });
     }
     for (const fn of servicesMeta.lambda ?? []) {
+        const lambdaId = `lambda:aws:${fn.name}`;
         addNode({
-            id: `lambda:aws:${fn.name}`,
+            id: lambdaId,
             type: 'lambda',
             name: fn.name,
             runtime: fn.runtime,
             memoryMB: fn.memoryMB,
             timeoutSec: fn.timeoutSec,
             envVarKeys: fn.envVarKeys,
+            triggers: fn.triggers,
         });
+        // Add trigger edges from source → lambda (only for enabled/active mappings)
+        for (const trigger of fn.triggers ?? []) {
+            if (trigger.state && trigger.state !== 'Enabled')
+                continue;
+            let sourceId;
+            if (trigger.type === 'sqs') {
+                sourceId = `queue:aws:${trigger.sourceName}`;
+                addNode({ id: sourceId, type: 'queue', name: trigger.sourceName, provider: 'aws', hasDLQ: false, encrypted: false });
+            }
+            else if (trigger.type === 'dynamodb') {
+                sourceId = `table:dynamo:${trigger.sourceName}`;
+                addNode({ id: sourceId, type: 'table', name: trigger.sourceName, databaseType: 'dynamodb' });
+            }
+            else if (trigger.type === 'kinesis') {
+                sourceId = `queue:aws:${trigger.sourceName}`;
+                addNode({ id: sourceId, type: 'queue', name: trigger.sourceName, provider: 'aws', hasDLQ: false, encrypted: false });
+            }
+            else {
+                continue;
+            }
+            edges.push({ from: sourceId, to: lambdaId, type: 'triggers' });
+        }
+    }
+    for (const rule of servicesMeta.eventbridge ?? []) {
+        const ruleId = `eventbridge_rule:aws:${rule.name}`;
+        addNode({
+            id: ruleId,
+            type: 'eventbridge_rule',
+            name: rule.name,
+            state: rule.state,
+            scheduleExpression: rule.scheduleExpression,
+            eventPattern: rule.eventPattern,
+        });
+        for (const targetArn of rule.targetArns) {
+            const fnName = targetArn.split(':').pop() ?? '';
+            const lambdaId = `lambda:aws:${fnName}`;
+            if (!nodeIds.has(lambdaId))
+                continue;
+            edges.push({ from: ruleId, to: lambdaId, type: 'triggers' });
+            const lambdaNodeRef = nodes.find((n) => n.id === lambdaId);
+            if (lambdaNodeRef && lambdaNodeRef.type === 'lambda') {
+                const trigger = {
+                    type: 'eventbridge',
+                    sourceArn: rule.arn,
+                    sourceName: rule.name,
+                    eventShape: 'event.detail',
+                    ruleName: rule.name,
+                    eventPattern: rule.scheduleExpression ?? rule.eventPattern ?? '',
+                };
+                lambdaNodeRef.triggers = [...(lambdaNodeRef.triggers ?? []), trigger];
+            }
+        }
     }
     for (const db of servicesMeta.rds ?? []) {
         addNode({
@@ -226,46 +263,49 @@ function resolveEdgeType(operationType) {
     return 'query';
 }
 // ── Typed node selectors ─────────────────────────────────────────────────────
-function getTableNodes(graph) {
+export function getTableNodes(graph) {
     return graph.nodes.filter((n) => n.type === 'table');
 }
-function getFunctionNodes(graph) {
+export function getFunctionNodes(graph) {
     return graph.nodes.filter((n) => n.type === 'function');
 }
-function getIndexNodes(graph) {
+export function getIndexNodes(graph) {
     return graph.nodes.filter((n) => n.type === 'index');
 }
-function getQueueNodes(graph) {
+export function getQueueNodes(graph) {
     return graph.nodes.filter((n) => n.type === 'queue');
 }
-function getTopicNodes(graph) {
+export function getTopicNodes(graph) {
     return graph.nodes.filter((n) => n.type === 'topic');
 }
-function getSecretNodes(graph) {
+export function getSecretNodes(graph) {
     return graph.nodes.filter((n) => n.type === 'secret');
 }
-function getParameterNodes(graph) {
+export function getParameterNodes(graph) {
     return graph.nodes.filter((n) => n.type === 'parameter');
 }
-function getLogGroupNodes(graph) {
+export function getLogGroupNodes(graph) {
     return graph.nodes.filter((n) => n.type === 'log_group');
 }
-function getLambdaNodes(graph) {
+export function getLambdaNodes(graph) {
     return graph.nodes.filter((n) => n.type === 'lambda');
 }
-function getEdgesForNode(graph, nodeId) {
+export function getEventBridgeRuleNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'eventbridge_rule');
+}
+export function getEdgesForNode(graph, nodeId) {
     return graph.edges.filter((e) => e.from === nodeId || e.to === nodeId);
 }
-function getOutgoingEdges(graph, nodeId) {
+export function getOutgoingEdges(graph, nodeId) {
     return graph.edges.filter((e) => e.from === nodeId);
 }
-function getIncomingEdges(graph, nodeId) {
+export function getIncomingEdges(graph, nodeId) {
     return graph.edges.filter((e) => e.to === nodeId);
 }
-function getScanEdges(graph) {
+export function getScanEdges(graph) {
     return graph.edges.filter((e) => e.type === 'scan');
 }
-function getEdgeFrequency(graph) {
+export function getEdgeFrequency(graph) {
     const freq = new Map();
     for (const edge of graph.edges) {
         const key = `${edge.from}->${edge.to}`;

package/dist/server/index.js

@@ -1,31 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.currentFindings = exports.currentGraph = void 0;
-exports.setGraphState = setGraphState;
-exports.createMcpServer = createMcpServer;
-exports.createServer = createServer;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const fastify_1 = __importDefault(require("fastify"));
-const cors_1 = __importDefault(require("@fastify/cors"));
-const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-const zod_1 = require("zod");
-const core_1 = require("../core");
-const { version } = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../../package.json'), 'utf8'));
-const analyzers_1 = require("../analyzers");
-const graph_1 = require("../graph");
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { z } from 'zod';
+import { logger } from '../core/index.js';
+const { version } = JSON.parse(readFileSync(join(import.meta.dirname, '../../package.json'), 'utf8'));
+import { summarizeFindings } from '../analyzers/index.js';
+import { getTableNodes, getFunctionNodes, getQueueNodes, getTopicNodes, getSecretNodes, getParameterNodes, getLogGroupNodes, getLambdaNodes, getEventBridgeRuleNodes, getScanEdges, getOutgoingEdges, } from '../graph/index.js';
 // ── State ────────────────────────────────────────────────────────────────────
 let currentGraph = { nodes: [], edges: [] };
-exports.currentGraph = currentGraph;
 let currentFindings = [];
-exports.currentFindings = currentFindings;
-function setGraphState(graph, findings) {
-    exports.currentGraph = currentGraph = graph;
-    exports.currentFindings = currentFindings = findings;
+export function setGraphState(graph, findings, _config) {
+    currentGraph = graph;
+    currentFindings = findings;
 }
 // ── Helpers ──────────────────────────────────────────────────────────────────
 function toText(data) {
@@ -34,25 +23,25 @@ function toText(data) {
 function logged(name, fn) {
     return async (args) => {
         const hasArgs = Object.keys(args).length > 0;
-        core_1.logger.info(`→ ${name}${hasArgs ? `  ${JSON.stringify(args)}` : ''}`);
+        logger.info(`→ ${name}${hasArgs ? `  ${JSON.stringify(args)}` : ''}`);
         return fn(args);
     };
 }
 // ── MCP Server ────────────────────────────────────────────────────────────────
-function createMcpServer() {
-    const mcp = new mcp_js_1.McpServer({ name: 'infrawise', version });
+export function createMcpServer() {
+    const mcp = new McpServer({ name: 'infrawise', version });
     mcp.registerTool('get_infra_overview', {
         description: 'Returns a complete snapshot of all infrastructure: databases, queues, topics, secrets, parameters, log groups, lambdas, and all findings. Start here for a full picture.',
-        inputSchema: zod_1.z.object({}),
+        inputSchema: z.object({}),
     }, logged('get_infra_overview', async () => {
-        const tables = (0, graph_1.getTableNodes)(currentGraph);
-        const queues = (0, graph_1.getQueueNodes)(currentGraph);
-        const topics = (0, graph_1.getTopicNodes)(currentGraph);
-        const secrets = (0, graph_1.getSecretNodes)(currentGraph);
-        const parameters = (0, graph_1.getParameterNodes)(currentGraph);
-        const logGroups = (0, graph_1.getLogGroupNodes)(currentGraph);
-        const lambdas = (0, graph_1.getLambdaNodes)(currentGraph);
-        const functions = (0, graph_1.getFunctionNodes)(currentGraph);
+        const tables = getTableNodes(currentGraph);
+        const queues = getQueueNodes(currentGraph);
+        const topics = getTopicNodes(currentGraph);
+        const secrets = getSecretNodes(currentGraph);
+        const parameters = getParameterNodes(currentGraph);
+        const logGroups = getLogGroupNodes(currentGraph);
+        const lambdas = getLambdaNodes(currentGraph);
+        const functions = getFunctionNodes(currentGraph);
         return toText({
             summary: {
                 tables: tables.length, functions: functions.length,
@@ -60,7 +49,7 @@ function createMcpServer() {
                 secrets: secrets.length, parameters: parameters.length,
                 logGroups: logGroups.length, lambdas: lambdas.length,
                 totalNodes: currentGraph.nodes.length, totalEdges: currentGraph.edges.length,
-                findings: (0, analyzers_1.summarizeFindings)(currentFindings),
+                findings: summarizeFindings(currentFindings),
             },
             databases: tables.map((t) => ({ name: t.name, type: t.databaseType })),
             queues: queues.map((q) => ({ name: q.name, hasDLQ: q.hasDLQ, encrypted: q.encrypted, approximateMessages: q.approximateMessages })),
@@ -74,34 +63,41 @@ function createMcpServer() {
     }));
     mcp.registerTool('get_graph_summary', {
         description: 'Returns the full infrastructure graph (all nodes and edges) plus findings summary.',
-        inputSchema: zod_1.z.object({}),
+        inputSchema: z.object({}),
     }, logged('get_graph_summary', async () => toText({
         nodes: currentGraph.nodes,
         edges: currentGraph.edges,
         findings: currentFindings,
         summary: {
             totalNodes: currentGraph.nodes.length, totalEdges: currentGraph.edges.length,
-            tables: (0, graph_1.getTableNodes)(currentGraph).length, functions: (0, graph_1.getFunctionNodes)(currentGraph).length,
-            queues: (0, graph_1.getQueueNodes)(currentGraph).length, scans: (0, graph_1.getScanEdges)(currentGraph).length,
-            ...(0, analyzers_1.summarizeFindings)(currentFindings),
+            tables: getTableNodes(currentGraph).length, functions: getFunctionNodes(currentGraph).length,
+            queues: getQueueNodes(currentGraph).length, scans: getScanEdges(currentGraph).length,
+            ...summarizeFindings(currentFindings),
         },
     })));
     mcp.registerTool('analyze_function', {
-        description: 'Analyze a specific function for all infrastructure issues: DB queries, queue publishing, secret access, etc.',
-        inputSchema: zod_1.z.object({ function: zod_1.z.string().describe('Function name to analyze') }),
+        description: 'Analyze a specific function for all infrastructure issues: DB queries, queue publishing, secret access, trigger event shapes, etc.',
+        inputSchema: z.object({ function: z.string().describe('Function name to analyze') }),
     }, logged('analyze_function', async ({ function: functionName }) => {
         const funcNode = currentGraph.nodes.find((n) => n.type === 'function' && n.name === functionName);
-        if (!funcNode) {
+        // Also check if there's a Lambda node with this name (for AWS-deployed functions)
+        const lambdaNode = currentGraph.nodes.find((n) => n.type === 'lambda' && n.name === functionName);
+        if (!funcNode && !lambdaNode) {
             return toText({ function: functionName, found: false, issues: [], recommendations: [`Function "${functionName}" not found in the analyzed codebase.`] });
         }
-        const outEdges = (0, graph_1.getOutgoingEdges)(currentGraph, funcNode.id);
+        const outEdges = funcNode ? getOutgoingEdges(currentGraph, funcNode.id) : [];
         const relatedFindings = currentFindings.filter((f) => {
             const meta = f.metadata;
             return meta?.functionName === functionName || String(meta?.callerFunctions ?? '').includes(functionName);
         });
+        const allTriggers = lambdaNode?.type === 'lambda' ? (lambdaNode.triggers ?? []) : [];
         return toText({
             function: functionName, found: true,
-            file: funcNode.type === 'function' ? funcNode.file : undefined,
+            file: funcNode?.type === 'function' ? funcNode.file : undefined,
+            triggers: allTriggers.map((t) => ({
+                type: t.type, source: t.sourceName, eventShape: t.eventShape,
+                ...(t.ruleName ? { ruleName: t.ruleName, eventPattern: t.eventPattern } : {}),
+            })),
             accesses: outEdges.map((e) => {
                 const target = currentGraph.nodes.find((n) => n.id === e.to);
                 return { targetId: e.to, edgeType: e.type, targetName: target && 'name' in target ? target.name : e.to, targetType: target?.type };
@@ -112,13 +108,14 @@ function createMcpServer() {
     }));
     mcp.registerTool('suggest_gsi', {
         description: 'Get GSI suggestions for a DynamoDB table and attribute',
-        inputSchema: zod_1.z.object({
-            table: zod_1.z.string().describe('DynamoDB table name'),
-            attribute: zod_1.z.string().describe('Attribute to create the GSI on'),
+        inputSchema: z.object({
+            table: z.string().describe('DynamoDB table name'),
+            attribute: z.string().describe('Attribute to create the GSI on'),
         }),
     }, logged('suggest_gsi', async ({ table: tableName, attribute }) => {
         const sanitizedAttr = attribute.replace(/[^a-zA-Z0-9_]/g, '_');
-        const indexName = `${tableName}-${sanitizedAttr}-index`;
+        const sanitizedTable = tableName.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const indexName = `${sanitizedTable}-${sanitizedAttr}-index`;
         const tableNode = currentGraph.nodes.find((n) => n.type === 'table' && n.databaseType === 'dynamodb' && 'name' in n && n.name === tableName);
         return toText({
             table: tableName, attribute, found: !!tableNode,
@@ -129,9 +126,9 @@ function createMcpServer() {
     }));
     mcp.registerTool('postgres_index_suggestions', {
         description: 'Get PostgreSQL index suggestions for a table column',
-        inputSchema: zod_1.z.object({
-            table: zod_1.z.string().describe('PostgreSQL table name'),
-            column: zod_1.z.string().describe('Column name to index'),
+        inputSchema: z.object({
+            table: z.string().describe('PostgreSQL table name'),
+            column: z.string().describe('Column name to index'),
         }),
     }, logged('postgres_index_suggestions', async ({ table: tableName, column }) => {
         const sanitizedCol = column.replace(/[^a-zA-Z0-9_]/g, '_');
@@ -139,33 +136,37 @@ function createMcpServer() {
         const indexName = `idx_${sanitizedTable}_${sanitizedCol}`;
         return toText({
             table: tableName, column,
-            recommendation: `CREATE INDEX CONCURRENTLY ${indexName} ON ${tableName} (${column});`,
+            recommendation: `CREATE INDEX CONCURRENTLY ${indexName} ON ${sanitizedTable} (${sanitizedCol});`,
             rationale: `An index on "${column}" eliminates sequential scans when filtering on this column.`,
             notes: ['Use CONCURRENTLY to avoid locking the table', 'Run ANALYZE after creation',
-                `Partial index: CREATE INDEX CONCURRENTLY ${indexName}_partial ON ${tableName} (${column}) WHERE ${column} IS NOT NULL;`],
+                `Partial index: CREATE INDEX CONCURRENTLY ${indexName}_partial ON ${sanitizedTable} (${sanitizedCol}) WHERE ${sanitizedCol} IS NOT NULL;`],
         });
     }));
     mcp.registerTool('suggest_mongo_index', {
         description: 'Get index suggestions for a MongoDB collection field',
-        inputSchema: zod_1.z.object({
-            collection: zod_1.z.string().describe('MongoDB collection name'),
-            field: zod_1.z.string().describe('Field name to index'),
+        inputSchema: z.object({
+            collection: z.string().describe('MongoDB collection name'),
+            field: z.string().describe('Field name to index'),
         }),
-    }, logged('suggest_mongo_index', async ({ collection, field }) => toText({
-        collection, field,
-        recommendation: `db.${collection}.createIndex({ ${field}: 1 })`,
-        rationale: `An index on "${field}" eliminates full collection scans when filtering on this field.`,
-        notes: [
-            `Compound: db.${collection}.createIndex({ ${field}: 1, otherField: 1 })`,
-            `Text: db.${collection}.createIndex({ ${field}: "text" })`,
-            `Verify: db.${collection}.explain("executionStats").find({ ${field}: value })`,
-        ],
-    })));
+    }, logged('suggest_mongo_index', async ({ collection, field }) => {
+        const sanitizedCollection = collection.replace(/[^a-zA-Z0-9_]/g, '_');
+        const sanitizedField = field.replace(/[^a-zA-Z0-9_.]/g, '_');
+        return toText({
+            collection, field,
+            recommendation: `db.${sanitizedCollection}.createIndex({ ${sanitizedField}: 1 })`,
+            rationale: `An index on "${field}" eliminates full collection scans when filtering on this field.`,
+            notes: [
+                `Compound: db.${sanitizedCollection}.createIndex({ ${sanitizedField}: 1, otherField: 1 })`,
+                `Text: db.${sanitizedCollection}.createIndex({ ${sanitizedField}: "text" })`,
+                `Verify: db.${sanitizedCollection}.explain("executionStats").find({ ${sanitizedField}: value })`,
+            ],
+        });
+    }));
     mcp.registerTool('mysql_index_suggestions', {
         description: 'Get MySQL index suggestions for a table column',
-        inputSchema: zod_1.z.object({
-            table: zod_1.z.string().describe('MySQL table name'),
-            column: zod_1.z.string().describe('Column name to index'),
+        inputSchema: z.object({
+            table: z.string().describe('MySQL table name'),
+            column: z.string().describe('Column name to index'),
         }),
     }, logged('mysql_index_suggestions', async ({ table: tableName, column }) => {
         const sanitizedCol = column.replace(/[^a-zA-Z0-9_]/g, '_');
@@ -173,17 +174,17 @@ function createMcpServer() {
         const indexName = `idx_${sanitizedTable}_${sanitizedCol}`;
         return toText({
             table: tableName, column,
-            recommendation: `ALTER TABLE ${tableName} ADD INDEX ${indexName} (${column});`,
+            recommendation: `ALTER TABLE ${sanitizedTable} ADD INDEX ${indexName} (${sanitizedCol});`,
             rationale: `An index on "${column}" eliminates full table scans when filtering on this column.`,
             notes: ['MySQL InnoDB adds indexes online (no full lock for 5.6+)', 'EXPLAIN SELECT ... to verify after adding',
-                `Composite: ALTER TABLE ${tableName} ADD INDEX idx_composite (${column}, other_column);`],
+                `Composite: ALTER TABLE ${sanitizedTable} ADD INDEX idx_composite (${sanitizedCol}, other_column);`],
         });
     }));
     mcp.registerTool('get_queue_details', {
         description: 'Returns all SQS queues with DLQ status, encryption, message counts, and retention.',
-        inputSchema: zod_1.z.object({}),
+        inputSchema: z.object({}),
     }, logged('get_queue_details', async () => {
-        const queues = (0, graph_1.getQueueNodes)(currentGraph);
+        const queues = getQueueNodes(currentGraph);
         const queueFindings = currentFindings.filter((f) => f.metadata?.queueName);
         return toText({
             total: queues.length,
@@ -196,16 +197,16 @@ function createMcpServer() {
     }));
     mcp.registerTool('get_topic_details', {
         description: 'Returns all SNS topics with subscription counts and protocols.',
-        inputSchema: zod_1.z.object({}),
+        inputSchema: z.object({}),
     }, logged('get_topic_details', async () => {
-        const topics = (0, graph_1.getTopicNodes)(currentGraph);
+        const topics = getTopicNodes(currentGraph);
         return toText({ total: topics.length, topics: topics.map((t) => ({ name: t.name, provider: t.provider, subscriptionCount: t.subscriptionCount, encrypted: t.encrypted })) });
     }));
     mcp.registerTool('get_secrets_overview', {
         description: 'Returns all Secrets Manager secrets: names, rotation status. Secret VALUES are never included.',
-        inputSchema: zod_1.z.object({}),
+        inputSchema: z.object({}),
     }, logged('get_secrets_overview', async () => {
-        const secrets = (0, graph_1.getSecretNodes)(currentGraph);
+        const secrets = getSecretNodes(currentGraph);
         const secretFindings = currentFindings.filter((f) => f.metadata?.secretName);
         return toText({
             total: secrets.length, note: 'Secret values are never included in this response.',
@@ -217,34 +218,55 @@ function createMcpServer() {
     }));
     mcp.registerTool('get_parameter_overview', {
         description: 'Returns all SSM Parameter Store parameters: names, types, tiers. Parameter VALUES are never included.',
-        inputSchema: zod_1.z.object({}),
+        inputSchema: z.object({}),
     }, logged('get_parameter_overview', async () => {
-        const parameters = (0, graph_1.getParameterNodes)(currentGraph);
+        const parameters = getParameterNodes(currentGraph);
         return toText({
             total: parameters.length, note: 'Parameter values are never included in this response.',
             parameters: parameters.map((p) => ({ name: p.name, provider: p.provider, type: p.paramType, tier: p.tier })),
         });
     }));
     mcp.registerTool('get_lambda_overview', {
-        description: 'Returns all Lambda functions: runtime, memory, timeout, env var key names (values never included).',
-        inputSchema: zod_1.z.object({}),
+        description: 'Returns all Lambda functions: runtime, memory, timeout, env var key names (values never included), and known event source triggers with correct handler event shapes.',
+        inputSchema: z.object({}),
     }, logged('get_lambda_overview', async () => {
-        const lambdas = (0, graph_1.getLambdaNodes)(currentGraph);
+        const lambdas = getLambdaNodes(currentGraph);
         const lambdaFindings = currentFindings.filter((f) => f.metadata?.functionName);
         return toText({
             total: lambdas.length, note: 'Environment variable values are never included.',
             lambdas: lambdas.map((l) => ({
                 name: l.name, runtime: l.runtime, memoryMB: l.memoryMB, timeoutSec: l.timeoutSec,
                 envVarCount: l.envVarKeys?.length ?? 0, envVarKeys: l.envVarKeys,
+                triggers: (l.triggers ?? []).map((t) => ({ type: t.type, source: t.sourceName, eventShape: t.eventShape, state: t.state })),
                 findings: lambdaFindings.filter((f) => f.metadata.functionName === l.name).map((f) => ({ severity: f.severity, issue: f.issue })),
             })),
         });
     }));
+    mcp.registerTool('get_eventbridge_details', {
+        description: 'Returns all EventBridge rules: name, state, schedule expression or event pattern, and target Lambda functions.',
+        inputSchema: z.object({}),
+    }, logged('get_eventbridge_details', async () => {
+        const rules = getEventBridgeRuleNodes(currentGraph);
+        return toText({
+            total: rules.length,
+            rules: rules.map((r) => ({
+                name: r.name,
+                state: r.state,
+                scheduleExpression: r.scheduleExpression,
+                eventPattern: r.eventPattern,
+                targets: currentGraph.edges
+                    .filter((e) => e.from === r.id && e.type === 'triggers')
+                    .map((e) => currentGraph.nodes.find((n) => n.id === e.to))
+                    .filter(Boolean)
+                    .map((n) => n && 'name' in n ? n.name : ''),
+            })),
+        });
+    }));
     mcp.registerTool('get_log_errors', {
         description: 'Returns recent error patterns from CloudWatch log groups. Returns pattern counts and frequencies — never raw log messages.',
-        inputSchema: zod_1.z.object({ logGroup: zod_1.z.string().describe('Filter to a specific log group name (optional)').optional() }),
+        inputSchema: z.object({ logGroup: z.string().describe('Filter to a specific log group name (optional)').optional() }),
     }, logged('get_log_errors', async ({ logGroup: filterName }) => {
-        const logGroups = (0, graph_1.getLogGroupNodes)(currentGraph).filter((lg) => !filterName || lg.name.includes(filterName));
+        const logGroups = getLogGroupNodes(currentGraph).filter((lg) => !filterName || lg.name.includes(filterName));
         return toText({
             note: 'Only error patterns and counts are returned — no raw log messages.',
             windowHours: 24,
@@ -254,9 +276,9 @@ function createMcpServer() {
     return mcp;
 }
 // ── Fastify server ────────────────────────────────────────────────────────────
-function createServer(port = 3000) {
-    const fastify = (0, fastify_1.default)({ logger: false });
-    fastify.register(cors_1.default, { origin: true });
+export function createServer(port = 3000) {
+    const fastify = Fastify({ logger: false });
+    fastify.register(cors, { origin: true });
     const mcp = createMcpServer();
     fastify.get('/health', async () => ({
         status: 'ok', version,
@@ -265,7 +287,7 @@ function createServer(port = 3000) {
         findings: currentFindings.length,
     }));
     fastify.post('/mcp', async (request, reply) => {
-        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
         reply.raw.on('close', () => transport.close());
         await mcp.connect(transport);
         await transport.handleRequest(request.raw, reply.raw, request.body);
@@ -276,12 +298,13 @@ function createServer(port = 3000) {
         start: async () => {
             try {
                 await fastify.listen({ port, host: '0.0.0.0' });
-                core_1.logger.info(`Infrawise MCP server running at http://localhost:${port}`);
+                logger.info(`Infrawise MCP server running at http://localhost:${port}`);
             }
             catch (e) {
-                core_1.logger.error(`Failed to start server: ${e instanceof Error ? e.message : String(e)}`);
+                logger.error(`Failed to start server: ${e instanceof Error ? e.message : String(e)}`);
                 process.exit(1);
             }
         },
     };
 }
+export { currentGraph, currentFindings };

package/dist/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};