infrawise 0.14.0 → 0.15.0

package/README.md

@@ -74,7 +74,7 @@ That's it. Infrawise will:
 1. Probe your environment and generate `infrawise.yaml` (first time only — asks which AWS profile to use only if you have several)
 2. Scan your AWS services, databases, and codebase
 3. Write `.mcp.json` so your editor auto-connects on every future launch
-4. Open Claude Code with all 20 MCP tools ready
+4. Open Claude Code with all 21 MCP tools ready
 
 **Every time after:**
 
@@ -117,7 +117,7 @@ Writes `.mcp.json` to your project root and opens Claude Code. Claude Code reads
 infrawise start --cursor
 ```
 
-Writes `.cursor/mcp.json` and opens Cursor. All 20 infrawise tools are available in Cursor's MCP panel.
+Writes `.cursor/mcp.json` and opens Cursor. All 21 infrawise tools are available in Cursor's MCP panel.
 
 ### Any editor (no flag)
 
@@ -153,6 +153,7 @@ Add to your editor's MCP config:
 | ---------------------------- | ----------------------------------------------------------------------------------------------------------- |
 | `get_infra_overview`         | Complete snapshot — services, counts, high-severity findings, analysis `freshness` (age + stale flag), `configured` flag |
 | `get_graph_summary`          | Full infrastructure graph — all nodes, edges, and findings                                                  |
+| `get_table_schema`           | Column-level schema for named tables/collections — types, PKs, FKs, indexes, DynamoDB keys (no row data)    |
 | `analyze_function`           | Issues in a specific function — scans, missing indexes, N+1, trigger event shapes, missing IAM permissions  |
 | `suggest_gsi`                | Exact GSI config for a DynamoDB table + attribute                                                           |
 | `postgres_index_suggestions` | Exact `CREATE INDEX` SQL for your actual table                                                              |

package/dist/adapters/db/mysql.js

@@ -28,10 +28,19 @@ export async function extractMySQLMetadata(connectionString) {
         logger.debug(`Found ${tableRows.length} MySQL table(s)`);
         // Get all columns
         const [columnRows] = await connection.execute(`
-      SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME
+      SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE, IS_NULLABLE
       FROM information_schema.columns
       WHERE TABLE_SCHEMA NOT IN (${[...SYSTEM_SCHEMAS].map(() => '?').join(', ')})
       ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
+    `, [...SYSTEM_SCHEMAS]);
+        // Get foreign keys
+        const [fkRows] = await connection.execute(`
+      SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME,
+             REFERENCED_TABLE_SCHEMA, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+      FROM information_schema.key_column_usage
+      WHERE REFERENCED_TABLE_NAME IS NOT NULL
+        AND TABLE_SCHEMA NOT IN (${[...SYSTEM_SCHEMAS].map(() => '?').join(', ')})
+      ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
     `, [...SYSTEM_SCHEMAS]);
         // Get all indexes
         const [indexRows] = await connection.execute(`
@@ -51,6 +60,7 @@ export async function extractMySQLMetadata(connectionString) {
     `, [...SYSTEM_SCHEMAS]);
         // Build lookup maps
         const columnMap = new Map();
+        const columnDetailMap = new Map();
         for (const row of columnRows) {
             const key = `${row['TABLE_SCHEMA']}.${row['TABLE_NAME']}`;
             let cols = columnMap.get(key);
@@ -59,6 +69,30 @@ export async function extractMySQLMetadata(connectionString) {
                 columnMap.set(key, cols);
             }
             cols.push(row['COLUMN_NAME']);
+            let details = columnDetailMap.get(key);
+            if (!details) {
+                details = [];
+                columnDetailMap.set(key, details);
+            }
+            details.push({
+                name: row['COLUMN_NAME'],
+                dataType: row['DATA_TYPE'],
+                nullable: row['IS_NULLABLE'] === 'YES',
+            });
+        }
+        const fkMap = new Map();
+        for (const row of fkRows) {
+            const key = `${row['TABLE_SCHEMA']}.${row['TABLE_NAME']}`;
+            let fks = fkMap.get(key);
+            if (!fks) {
+                fks = [];
+                fkMap.set(key, fks);
+            }
+            fks.push({
+                column: row['COLUMN_NAME'],
+                referencesTable: `${row['REFERENCED_TABLE_SCHEMA']}.${row['REFERENCED_TABLE_NAME']}`,
+                referencesColumn: row['REFERENCED_COLUMN_NAME'],
+            });
         }
         const indexMap = new Map();
         for (const row of indexRows) {
@@ -96,6 +130,8 @@ export async function extractMySQLMetadata(connectionString) {
                 indexes: indexMap.get(key) ?? [],
                 primaryKeys: pkMap.get(key) ?? [],
                 engine,
+                columnDetails: columnDetailMap.get(key) ?? [],
+                foreignKeys: fkMap.get(key) ?? [],
             });
         }
         return results;

package/dist/adapters/db/postgres.js

@@ -22,7 +22,7 @@ export async function extractPostgresMetadata(connectionString) {
             logger.debug(`Found ${tablesResult.rows.length} PostgreSQL table(s)`);
             // Get all columns
             const columnsResult = await client.query(`
-        SELECT table_schema, table_name, column_name
+        SELECT table_schema, table_name, column_name, data_type, is_nullable
         FROM information_schema.columns
         WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
         ORDER BY table_schema, table_name, ordinal_position
@@ -48,8 +48,29 @@ export async function extractPostgresMetadata(connectionString) {
           AND tc.table_schema NOT IN ('pg_catalog', 'information_schema')
         ORDER BY tc.table_schema, tc.table_name
       `);
-            // Build maps for columns, indexes, primary keys
+            // Get foreign keys
+            const foreignKeysResult = await client.query(`
+        SELECT
+          tc.table_schema,
+          tc.table_name,
+          kcu.column_name,
+          ccu.table_schema AS ref_schema,
+          ccu.table_name AS ref_table,
+          ccu.column_name AS ref_column
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage ccu
+          ON tc.constraint_name = ccu.constraint_name
+          AND tc.table_schema = ccu.table_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+          AND tc.table_schema NOT IN ('pg_catalog', 'information_schema')
+        ORDER BY tc.table_schema, tc.table_name
+      `);
+            // Build maps for columns, indexes, primary keys, foreign keys
             const columnMap = new Map();
+            const columnDetailMap = new Map();
             for (const row of columnsResult.rows) {
                 const key = `${row.table_schema}.${row.table_name}`;
                 let cols = columnMap.get(key);
@@ -58,6 +79,30 @@ export async function extractPostgresMetadata(connectionString) {
                     columnMap.set(key, cols);
                 }
                 cols.push(row.column_name);
+                let details = columnDetailMap.get(key);
+                if (!details) {
+                    details = [];
+                    columnDetailMap.set(key, details);
+                }
+                details.push({
+                    name: row.column_name,
+                    dataType: row.data_type,
+                    nullable: row.is_nullable === 'YES',
+                });
+            }
+            const fkMap = new Map();
+            for (const row of foreignKeysResult.rows) {
+                const key = `${row.table_schema}.${row.table_name}`;
+                let fks = fkMap.get(key);
+                if (!fks) {
+                    fks = [];
+                    fkMap.set(key, fks);
+                }
+                fks.push({
+                    column: row.column_name,
+                    referencesTable: `${row.ref_schema}.${row.ref_table}`,
+                    referencesColumn: row.ref_column,
+                });
             }
             const indexMap = new Map();
             for (const row of indexesResult.rows) {
@@ -89,6 +134,8 @@ export async function extractPostgresMetadata(connectionString) {
                     columns: columnMap.get(key) ?? [],
                     indexes: indexMap.get(key) ?? [],
                     primaryKeys: pkMap.get(key) ?? [],
+                    columnDetails: columnDetailMap.get(key) ?? [],
+                    foreignKeys: fkMap.get(key) ?? [],
                 });
             }
             return results;

package/dist/cli/commands/serve.js

@@ -11,6 +11,7 @@ const BOX_W = 52;
 const TOOL_MAP = [
     { name: 'get_infra_overview' },
     { name: 'get_graph_summary' },
+    { name: 'get_table_schema' },
     { name: 'analyze_function' },
     { name: 'suggest_gsi', service: 'dynamodb' },
     { name: 'postgres_index_suggestions', service: 'postgres' },

package/dist/graph/index.js

@@ -13,7 +13,14 @@ export function buildGraph(operations, dynamoMeta, postgresMeta, mysqlMeta = [],
     // ── Database tables ──────────────────────────────────────────────────────
     for (const table of dynamoMeta) {
         const nodeId = `table:dynamo:${table.tableName}`;
-        addNode({ id: nodeId, type: 'table', name: table.tableName, databaseType: 'dynamodb' });
+        addNode({
+            id: nodeId,
+            type: 'table',
+            name: table.tableName,
+            databaseType: 'dynamodb',
+            partitionKey: table.partitionKey,
+            sortKey: table.sortKey,
+        });
         for (const indexName of table.indexes) {
             const indexNodeId = `index:${table.tableName}:${indexName}`;
             addNode({ id: indexNodeId, type: 'index', name: indexName });
@@ -27,6 +34,9 @@ export function buildGraph(operations, dynamoMeta, postgresMeta, mysqlMeta = [],
             type: 'table',
             name: `${table.schema}.${table.table}`,
             databaseType: 'postgres',
+            columns: table.columnDetails,
+            primaryKeys: table.primaryKeys,
+            foreignKeys: table.foreignKeys,
         });
         for (const indexName of table.indexes) {
             const indexNodeId = `index:${table.schema}.${table.table}:${indexName}`;
@@ -41,6 +51,9 @@ export function buildGraph(operations, dynamoMeta, postgresMeta, mysqlMeta = [],
             type: 'table',
             name: `${table.schema}.${table.table}`,
             databaseType: 'mysql',
+            columns: table.columnDetails,
+            primaryKeys: table.primaryKeys,
+            foreignKeys: table.foreignKeys,
         });
         for (const indexName of table.indexes) {
             const indexNodeId = `index:${table.schema}.${table.table}:${indexName}`;
@@ -55,6 +68,7 @@ export function buildGraph(operations, dynamoMeta, postgresMeta, mysqlMeta = [],
             type: 'table',
             name: `${coll.database}.${coll.collection}`,
             databaseType: 'mongodb',
+            estimatedCount: coll.estimatedCount,
         });
         for (const idx of coll.indexes) {
             if (idx.name === '_id_')

package/dist/server/index.js

@@ -487,6 +487,56 @@ export function createMcpServer() {
             })),
         });
     }));
+    mcp.registerTool('get_table_schema', {
+        description: 'Returns the full schema for specific tables or collections by name: columns with data types and nullability, primary keys, foreign keys (join paths), indexes, DynamoDB partition/sort keys, and MongoDB estimated document counts. Accepts short names ("orders" matches "public.orders") and is case-insensitive. Call this after get_infra_overview when you need column-level detail to write a SQL query, DynamoDB expression, or MongoDB filter for specific tables — instead of pulling every schema with get_graph_summary. Do NOT call for a table inventory; use get_infra_overview for that. Row data is never included.',
+        inputSchema: z.object({
+            tables: z
+                .array(z.string())
+                .min(1)
+                .max(20)
+                .describe('Table or collection names to fetch schemas for'),
+        }),
+    }, logged('get_table_schema', async ({ tables }) => {
+        const tableNodes = getTableNodes(currentGraph);
+        const indexNamesFor = (nodeId) => currentGraph.edges
+            .filter((e) => e.from === nodeId && e.type === 'uses_index')
+            .map((e) => currentGraph.nodes.find((n) => n.id === e.to))
+            .filter((n) => n?.type === 'index')
+            .map((n) => n.name);
+        const results = tables.map((requested) => {
+            const lower = requested.toLowerCase();
+            const matches = tableNodes.filter((t) => {
+                const name = t.name.toLowerCase();
+                return name === lower || name.split('.').pop() === lower;
+            });
+            if (matches.length === 0) {
+                const suggestions = tableNodes
+                    .filter((t) => t.name.toLowerCase().includes(lower))
+                    .map((t) => t.name)
+                    .slice(0, 5);
+                return { requested, found: false, ...(suggestions.length ? { suggestions } : {}) };
+            }
+            return {
+                requested,
+                found: true,
+                matches: matches.map((t) => ({
+                    name: t.name,
+                    databaseType: t.databaseType,
+                    ...(t.columns ? { columns: t.columns } : {}),
+                    ...(t.primaryKeys?.length ? { primaryKeys: t.primaryKeys } : {}),
+                    ...(t.foreignKeys?.length ? { foreignKeys: t.foreignKeys } : {}),
+                    ...(t.partitionKey ? { partitionKey: t.partitionKey } : {}),
+                    ...(t.sortKey ? { sortKey: t.sortKey } : {}),
+                    ...(t.estimatedCount !== undefined ? { estimatedCount: t.estimatedCount } : {}),
+                    indexes: indexNamesFor(t.id),
+                })),
+            };
+        });
+        return toText({
+            note: 'Row data is never included.',
+            tables: results,
+        });
+    }));
     mcp.registerTool('get_cache_overview', {
         description: 'Returns all ElastiCache clusters with engine, version, node type, node count, in-transit and at-rest encryption status, replication group, and automatic failover state. Call this before writing cache client code (TLS is required when transit encryption is on — rediss:// for Redis) or when reviewing cache availability and security posture. Cached data is never read or included.',
         inputSchema: z.object({}),
@@ -614,6 +664,7 @@ export function createServer(port = 3000) {
             'get_cognito_overview',
             'get_stream_details',
             'get_cache_overview',
+            'get_table_schema',
         ],
     }));
     fastify.post('/mcp', async (request, reply) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infrawise",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "mcpName": "io.github.Sidd27/infrawise",
   "description": "CLI-first infrastructure intelligence platform — analyzes DynamoDB, PostgreSQL, MySQL, MongoDB, SQS, SNS, SSM, Secrets Manager, Lambda, S3, API Gateway, CloudWatch Logs and exposes findings as an MCP server for Claude Code",
   "keywords": [