infrawise 0.13.2 → 0.15.0

package/README.md

@@ -12,6 +12,8 @@ Infrawise gives AI coding assistants deterministic infrastructure awareness.
 
 It statically analyzes your codebase, cloud infrastructure, and database schemas, then exposes that context through MCP so tools like Claude Code can understand your actual tables, indexes, query patterns, and service relationships instead of guessing from source files alone.
 
+![infrawise start --claude, then Claude Code answers an SQS handler question with the exact event shape and queue risks pulled live from infrawise](https://raw.githubusercontent.com/Sidd27/infrawise/main/docs/demo/gifs/mcp.gif)
+
 ---
 
 ## Why this exists
@@ -72,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 16 MCP tools ready
+4. Open Claude Code with all 21 MCP tools ready
 
 **Every time after:**
 
@@ -115,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 16 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)
 
@@ -151,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                                                              |
@@ -165,6 +168,10 @@ Add to your editor's MCP config:
 | `get_eventbridge_details`    | EventBridge rules — name, state, schedule/event pattern, target functions                                   |
 | `get_s3_overview`            | S3 buckets — versioning, encryption, public access, event notifications                                     |
 | `get_log_errors`             | CloudWatch error patterns and counts (no raw log messages)                                                  |
+| `get_stack_outputs`          | Stack outputs and cross-stack exports parsed from local IaC files (Terraform outputs, CFN/CDK Outputs)      |
+| `get_cognito_overview`       | Cognito user pools — MFA config, app client auth flows, OAuth settings, token validity (secrets never included) |
+| `get_stream_details`         | Kinesis streams (shards, retention, capacity mode) and MSK clusters (state, Kafka version, brokers)          |
+| `get_cache_overview`         | ElastiCache clusters — engine, encryption in transit/at rest, replication group, failover (data never read)  |
 
 ---
 
@@ -301,6 +308,22 @@ s3:
 apiGateway:
   enabled: false
 
+cognito:
+  enabled: false
+
+kinesis:
+  enabled: false
+
+msk:
+  enabled: false
+
+elasticache:
+  enabled: false
+
+runtimeSignals:
+  enabled: false # Lambda throttles/errors + queue age via CloudWatch metrics
+  windowHours: 24
+
 cloudwatchLogs:
   enabled: false
   logGroupPrefixes: []
@@ -374,7 +397,11 @@ Works from AWS APIs, database schema introspection, and IaC files — no depende
 | API Gateway                      | REST, HTTP, and WebSocket APIs — routes, methods, Lambda integrations                                             |
 | RDS                              | Publicly accessible, no backups, unencrypted, no deletion protection, single-AZ                                    |
 | CloudWatch Logs                  | Log groups with no retention policy                                                                                |
-| Terraform / CloudFormation / CDK | IaC drift vs deployed state                                                                                        |
+| Cognito                          | User pools and app client config — auth flows, OAuth settings, token validity, client secret presence              |
+| Kinesis / MSK                    | Streams (shards, retention, capacity mode) and MSK clusters (state, Kafka version, brokers)                        |
+| ElastiCache                      | Missing in-transit encryption, single-node clusters with no replication                                            |
+| Runtime signals (opt-in)         | Lambda throttling/errors and stale queue messages from CloudWatch metrics                                          |
+| Terraform / CloudFormation / CDK | IaC drift vs deployed state; stack outputs and cross-stack exports                                                 |
 
 ### Code correlation analysis (TypeScript / JavaScript)
 
@@ -446,7 +473,7 @@ src/
     aws/        DynamoDB, S3, Lambda, SQS/SNS/SSM/Secrets/EventBridge/RDS/APIGateway, CloudWatch
     db/         PostgreSQL, MySQL, MongoDB
     iac/        Terraform, CDK, CloudFormation (local file parsing)
-  analyzers/    29 rule-based analyzers
+  analyzers/    34 rule-based analyzers
   context/      Repository scanner (ts-morph AST)
   server/       Fastify MCP server (@modelcontextprotocol/sdk, Streamable HTTP)
   cli/          CLI commands (Commander.js)
@@ -473,6 +500,8 @@ Feature roadmap is tracked in the [GitHub Project](https://github.com/users/Sidd
 
 The `demo/localstack/` directory runs infrawise against real AWS APIs emulated locally via [LocalStack](https://localstack.cloud) — an open-source tool that spins up a full AWS environment in Docker so you can test AWS integrations at zero cost, with no real AWS account needed. See [`demo/localstack/README.md`](demo/localstack/README.md) for setup instructions.
 
+![infrawise analyze running against the LocalStack demo and reporting the high-severity findings](https://raw.githubusercontent.com/Sidd27/infrawise/main/docs/demo/gifs/analyze.gif)
+
 ---
 
 ## Contributing

package/dist/adapters/aws/index.js

@@ -2,3 +2,4 @@ export * from './services.js';
 export * from './dynamodb.js';
 export * from './logs.js';
 export * from './s3.js';
+export * from './metrics.js';

package/dist/adapters/aws/metrics.js

@@ -0,0 +1,94 @@
+import { CloudWatchClient, GetMetricDataCommand } from '@aws-sdk/client-cloudwatch';
+import { clientConfig } from './services.js';
+import { logger } from '../../core/index.js';
+export async function extractRuntimeSignals(cfg, lambdaNames, queueNames, windowHours = 24) {
+    const lambdas = new Map();
+    const queues = new Map();
+    if (lambdaNames.length === 0 && queueNames.length === 0)
+        return { lambdas, queues };
+    const client = new CloudWatchClient(clientConfig(cfg));
+    const end = new Date();
+    const start = new Date(end.getTime() - windowHours * 3600 * 1000);
+    const period = windowHours * 3600;
+    // Metric names live in Dimensions; query Ids are positional because function/queue
+    // names may contain characters GetMetricData Ids do not allow.
+    const queries = [];
+    lambdaNames.forEach((name, i) => {
+        queries.push({
+            Id: `lt${i}`,
+            MetricStat: {
+                Metric: {
+                    Namespace: 'AWS/Lambda',
+                    MetricName: 'Throttles',
+                    Dimensions: [{ Name: 'FunctionName', Value: name }],
+                },
+                Period: period,
+                Stat: 'Sum',
+            },
+        }, {
+            Id: `le${i}`,
+            MetricStat: {
+                Metric: {
+                    Namespace: 'AWS/Lambda',
+                    MetricName: 'Errors',
+                    Dimensions: [{ Name: 'FunctionName', Value: name }],
+                },
+                Period: period,
+                Stat: 'Sum',
+            },
+        });
+    });
+    queueNames.forEach((name, i) => {
+        queries.push({
+            Id: `qa${i}`,
+            MetricStat: {
+                Metric: {
+                    Namespace: 'AWS/SQS',
+                    MetricName: 'ApproximateAgeOfOldestMessage',
+                    Dimensions: [{ Name: 'QueueName', Value: name }],
+                },
+                Period: period,
+                Stat: 'Maximum',
+            },
+        });
+    });
+    try {
+        for (let i = 0; i < queries.length; i += 500) {
+            const chunk = queries.slice(i, i + 500);
+            let nextToken;
+            do {
+                const res = await client.send(new GetMetricDataCommand({
+                    StartTime: start,
+                    EndTime: end,
+                    MetricDataQueries: chunk,
+                    NextToken: nextToken,
+                }));
+                for (const r of res.MetricDataResults ?? []) {
+                    const id = r.Id ?? '';
+                    const value = r.Values?.[0] ?? 0;
+                    const idx = parseInt(id.slice(2), 10);
+                    if (Number.isNaN(idx))
+                        continue;
+                    if (id.startsWith('lt')) {
+                        const e = lambdas.get(lambdaNames[idx]) ?? { throttles: 0, errors: 0 };
+                        e.throttles = value;
+                        lambdas.set(lambdaNames[idx], e);
+                    }
+                    else if (id.startsWith('le')) {
+                        const e = lambdas.get(lambdaNames[idx]) ?? { throttles: 0, errors: 0 };
+                        e.errors = value;
+                        lambdas.set(lambdaNames[idx], e);
+                    }
+                    else if (id.startsWith('qa')) {
+                        queues.set(queueNames[idx], { oldestMessageAgeSec: value });
+                    }
+                }
+                nextToken = res.NextToken;
+            } while (nextToken);
+        }
+    }
+    catch (err) {
+        logger.warn(`Runtime signals fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return { lambdas, queues };
+}

package/dist/adapters/aws/services.js

@@ -7,10 +7,14 @@ import { SecretsManagerClient, ListSecretsCommand } from '@aws-sdk/client-secret
 import { LambdaClient, ListFunctionsCommand, ListEventSourceMappingsCommand, } from '@aws-sdk/client-lambda';
 import { EventBridgeClient, ListRulesCommand, ListTargetsByRuleCommand, } from '@aws-sdk/client-eventbridge';
 import { RDSClient, DescribeDBInstancesCommand } from '@aws-sdk/client-rds';
+import { KinesisClient, ListStreamsCommand, DescribeStreamSummaryCommand, } from '@aws-sdk/client-kinesis';
+import { KafkaClient, ListClustersV2Command } from '@aws-sdk/client-kafka';
+import { ElastiCacheClient, DescribeCacheClustersCommand, DescribeReplicationGroupsCommand, } from '@aws-sdk/client-elasticache';
+import { CognitoIdentityProviderClient, ListUserPoolsCommand, ListUserPoolClientsCommand, DescribeUserPoolClientCommand, DescribeUserPoolCommand, } from '@aws-sdk/client-cognito-identity-provider';
 import { IAMClient, ListAttachedRolePoliciesCommand, GetPolicyCommand, GetPolicyVersionCommand, ListRolePoliciesCommand, GetRolePolicyCommand, } from '@aws-sdk/client-iam';
 import { fromIni } from '@aws-sdk/credential-providers';
 import { logger } from '../../core/index.js';
-function clientConfig(cfg) {
+export function clientConfig(cfg) {
     const region = cfg.region ?? 'us-east-1';
     const base = { region };
     if (cfg.profile)
@@ -420,6 +424,198 @@ export async function extractLambdaMetadata(cfg = {}, includeFunctions) {
 export async function validateLambdaAccess(cfg = {}) {
     await new LambdaClient(clientConfig(cfg)).send(new ListFunctionsCommand({ MaxItems: 1 }));
 }
+// ─── Kinesis ─────────────────────────────────────────────────────────────────
+export async function extractKinesisMetadata(cfg = {}) {
+    const client = new KinesisClient(clientConfig(cfg));
+    const streams = [];
+    try {
+        let nextToken;
+        const names = [];
+        do {
+            const res = await client.send(new ListStreamsCommand({ NextToken: nextToken }));
+            names.push(...(res.StreamNames ?? []));
+            nextToken = res.NextToken;
+        } while (nextToken);
+        for (const name of names) {
+            try {
+                const res = await client.send(new DescribeStreamSummaryCommand({ StreamName: name }));
+                const d = res.StreamDescriptionSummary;
+                if (!d)
+                    continue;
+                streams.push({
+                    name,
+                    arn: d.StreamARN ?? '',
+                    status: d.StreamStatus ?? 'UNKNOWN',
+                    shardCount: d.OpenShardCount,
+                    retentionHours: d.RetentionPeriodHours,
+                    encrypted: d.EncryptionType === 'KMS',
+                    mode: d.StreamModeDetails?.StreamMode ?? 'PROVISIONED',
+                });
+            }
+            catch (err) {
+                logger.warn(`Kinesis describe failed for ${name}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    catch (err) {
+        logger.warn(`Kinesis list failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return streams;
+}
+// ─── MSK ─────────────────────────────────────────────────────────────────────
+export async function extractMSKMetadata(cfg = {}) {
+    const client = new KafkaClient(clientConfig(cfg));
+    const clusters = [];
+    try {
+        let nextToken;
+        do {
+            const res = await client.send(new ListClustersV2Command({ NextToken: nextToken }));
+            for (const c of res.ClusterInfoList ?? []) {
+                if (!c.ClusterName)
+                    continue;
+                clusters.push({
+                    name: c.ClusterName,
+                    arn: c.ClusterArn ?? '',
+                    state: c.State ?? 'UNKNOWN',
+                    clusterType: c.ClusterType ?? 'PROVISIONED',
+                    kafkaVersion: c.Provisioned?.CurrentBrokerSoftwareInfo?.KafkaVersion,
+                    brokerNodes: c.Provisioned?.NumberOfBrokerNodes,
+                });
+            }
+            nextToken = res.NextToken;
+        } while (nextToken);
+    }
+    catch (err) {
+        logger.warn(`MSK list failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return clusters;
+}
+// ─── ElastiCache ─────────────────────────────────────────────────────────────
+export async function extractElastiCacheMetadata(cfg = {}) {
+    const client = new ElastiCacheClient(clientConfig(cfg));
+    const clusters = [];
+    try {
+        const failoverByGroup = new Map();
+        try {
+            let marker;
+            do {
+                const res = await client.send(new DescribeReplicationGroupsCommand({ Marker: marker }));
+                for (const g of res.ReplicationGroups ?? []) {
+                    if (g.ReplicationGroupId) {
+                        failoverByGroup.set(g.ReplicationGroupId, g.AutomaticFailover ?? 'disabled');
+                    }
+                }
+                marker = res.Marker;
+            } while (marker);
+        }
+        catch {
+            /* replication groups are optional context */
+        }
+        let marker;
+        do {
+            const res = await client.send(new DescribeCacheClustersCommand({ Marker: marker }));
+            for (const c of res.CacheClusters ?? []) {
+                if (!c.CacheClusterId)
+                    continue;
+                clusters.push({
+                    id: c.CacheClusterId,
+                    engine: c.Engine ?? 'unknown',
+                    engineVersion: c.EngineVersion ?? '',
+                    nodeType: c.CacheNodeType ?? '',
+                    numNodes: c.NumCacheNodes ?? 0,
+                    transitEncryption: c.TransitEncryptionEnabled ?? false,
+                    atRestEncryption: c.AtRestEncryptionEnabled ?? false,
+                    replicationGroupId: c.ReplicationGroupId,
+                    automaticFailover: c.ReplicationGroupId
+                        ? failoverByGroup.get(c.ReplicationGroupId)
+                        : undefined,
+                });
+            }
+            marker = res.Marker;
+        } while (marker);
+    }
+    catch (err) {
+        logger.warn(`ElastiCache list failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return clusters;
+}
+// ─── Cognito ─────────────────────────────────────────────────────────────────
+export async function extractCognitoMetadata(cfg = {}) {
+    const client = new CognitoIdentityProviderClient(clientConfig(cfg));
+    const pools = [];
+    try {
+        let nextToken;
+        const poolRefs = [];
+        do {
+            const res = await client.send(new ListUserPoolsCommand({ MaxResults: 60, NextToken: nextToken }));
+            for (const p of res.UserPools ?? []) {
+                if (p.Id && p.Name)
+                    poolRefs.push({ id: p.Id, name: p.Name });
+            }
+            nextToken = res.NextToken;
+        } while (nextToken);
+        for (const ref of poolRefs) {
+            try {
+                const poolRes = await client.send(new DescribeUserPoolCommand({ UserPoolId: ref.id }));
+                const clients = [];
+                let clientToken;
+                do {
+                    const clientsRes = await client.send(new ListUserPoolClientsCommand({
+                        UserPoolId: ref.id,
+                        MaxResults: 60,
+                        NextToken: clientToken,
+                    }));
+                    for (const c of clientsRes.UserPoolClients ?? []) {
+                        if (!c.ClientId)
+                            continue;
+                        try {
+                            const detail = await client.send(new DescribeUserPoolClientCommand({ UserPoolId: ref.id, ClientId: c.ClientId }));
+                            const d = detail.UserPoolClient;
+                            if (!d)
+                                continue;
+                            clients.push({
+                                clientName: d.ClientName ?? c.ClientName ?? '',
+                                clientId: c.ClientId,
+                                authFlows: d.ExplicitAuthFlows ?? [],
+                                oauthFlows: d.AllowedOAuthFlows ?? [],
+                                oauthScopes: d.AllowedOAuthScopes ?? [],
+                                callbackUrls: d.CallbackURLs ?? [],
+                                generatesSecret: !!d.ClientSecret,
+                                accessTokenValidity: d.AccessTokenValidity,
+                                idTokenValidity: d.IdTokenValidity,
+                                refreshTokenValidity: d.RefreshTokenValidity,
+                                tokenValidityUnits: d.TokenValidityUnits
+                                    ? {
+                                        accessToken: d.TokenValidityUnits.AccessToken,
+                                        idToken: d.TokenValidityUnits.IdToken,
+                                        refreshToken: d.TokenValidityUnits.RefreshToken,
+                                    }
+                                    : undefined,
+                            });
+                        }
+                        catch {
+                            /* skip client on describe failure */
+                        }
+                    }
+                    clientToken = clientsRes.NextToken;
+                } while (clientToken);
+                pools.push({
+                    name: ref.name,
+                    id: ref.id,
+                    mfaConfiguration: poolRes.UserPool?.MfaConfiguration,
+                    clients,
+                });
+            }
+            catch (err) {
+                logger.warn(`Cognito describe failed for ${ref.name}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    catch (err) {
+        logger.warn(`Cognito list failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return pools;
+}
 // ─── RDS ─────────────────────────────────────────────────────────────────────
 export async function extractRDSMetadata(cfg = {}) {
     const client = new RDSClient(clientConfig(cfg));

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;