infrawise 0.5.0 → 0.7.0

package/README.md

@@ -1,11 +1,9 @@
 # Infrawise
 
-<table><tr>
-<td><a href="https://www.npmjs.com/package/infrawise"><img src="https://img.shields.io/npm/v/infrawise" alt="npm version"></a></td>
-<td><a href="https://github.com/Sidd27/infrawise/actions/workflows/npm-publish.yml"><img src="https://github.com/Sidd27/infrawise/actions/workflows/npm-publish.yml/badge.svg" alt="Publish to npm"></a></td>
-<td><a href="https://github.com/Sidd27/infrawise/actions/workflows/ci.yml"><img src="https://github.com/Sidd27/infrawise/actions/workflows/ci.yml/badge.svg" alt="CI"></a></td>
-<td><a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a></td>
-</tr></table>
+[![npm version](https://img.shields.io/npm/v/infrawise)](https://www.npmjs.com/package/infrawise)
+[![Publish to npm](https://github.com/Sidd27/infrawise/actions/workflows/npm-publish.yml/badge.svg)](https://github.com/Sidd27/infrawise/actions/workflows/npm-publish.yml)
+[![CI](https://github.com/Sidd27/infrawise/actions/workflows/ci.yml/badge.svg)](https://github.com/Sidd27/infrawise/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
 **Understand your infrastructure, not just your code.**
 
@@ -17,6 +15,8 @@ It statically analyzes your codebase, cloud infrastructure, and database schemas
 
 ## Why this exists
 
+New software developers don't write wrong code. Claude Code writes wrong code and they ship it. Infrawise is the only thing standing between Claude Code's generated output and a production incident.
+
 AI coding assistants can read your source files but have no deterministic knowledge of your infrastructure. They do not know which GSIs exist, how tables are partitioned, which functions already trigger scans, or where indexes are missing. So they guess.
 
 Infrawise replaces guessing with infrastructure-aware context.
@@ -161,7 +161,7 @@ To let Claude Code manage the server lifecycle automatically:
 |---|---|
 | `get_infra_overview` | Complete snapshot — all services, counts, and high-severity findings |
 | `get_graph_summary` | Full infrastructure graph — all nodes, edges, and findings |
-| `analyze_function` | Issues in a specific function — scans, missing indexes, N+1 |
+| `analyze_function` | Issues in a specific function — scans, missing indexes, N+1, trigger event shapes |
 | `suggest_gsi` | Exact GSI config for a DynamoDB table + attribute |
 | `postgres_index_suggestions` | Exact `CREATE INDEX` SQL for your actual table |
 | `suggest_mongo_index` | Exact `createIndex` command for a MongoDB collection + field |
@@ -170,7 +170,8 @@ To let Claude Code manage the server lifecycle automatically:
 | `get_topic_details` | SNS topics — subscription counts and protocols |
 | `get_secrets_overview` | Secrets Manager — names and rotation status (values never included) |
 | `get_parameter_overview` | SSM Parameter Store — names, types, tiers (values never included) |
-| `get_lambda_overview` | Lambda functions — runtime, memory, timeout, env var key names |
+| `get_lambda_overview` | Lambda functions — runtime, memory, timeout, triggers (SQS/DynamoDB/Kinesis/EventBridge), env var key names |
+| `get_eventbridge_details` | EventBridge rules — name, state, schedule/event pattern, target functions |
 | `get_log_errors` | CloudWatch error patterns and counts (no raw log messages) |
 
 ---
@@ -241,6 +242,12 @@ secretsManager:
 
 lambda:
   enabled: true
+  includeFunctions:           # omit to include all functions
+    - processOrders
+    - generateReport
+
+eventbridge:
+  enabled: true
 
 rds:
   enabled: false
@@ -314,7 +321,8 @@ Works from AWS APIs, database schema introspection, and IaC files — no depende
 | SQS | Missing DLQs, unencrypted queues, large backlogs |
 | Kafka (kafkajs) | Producer/consumer topic mapping from code |
 | Secrets Manager | Missing secret rotation |
-| Lambda | Default memory (128 MB), high timeouts |
+| Lambda | Default memory (128 MB), high timeouts, triggers (SQS/DynamoDB/Kinesis/EventBridge), missing DLQ on trigger source |
+| EventBridge | Rules, schedules, event patterns, target Lambda functions |
 | 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 |
@@ -422,6 +430,8 @@ src/
 
 ## Roadmap
 
+Feature roadmap is tracked in the [GitHub Project](https://github.com/users/Sidd27/projects/1). Priorities, complexity, and virality scores are visible there. Feature requests and upvotes welcome.
+
 ### Planned
 - Runtime tracing integration
 - Incremental analysis for large monorepos
@@ -437,6 +447,12 @@ src/
 
 ---
 
+## Demo
+
+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.
+
+---
+
 ## Contributing
 
 ### Prerequisites
@@ -483,18 +499,14 @@ export class MyAnalyzer implements Analyzer {
 
 ### Releasing
 
-The git tag is the source of truth. The version in root `package.json` and the tag must always match.
-
 ```bash
 pnpm release patch    # 0.1.2 → 0.1.3  (bug fixes)
 pnpm release minor    # 0.1.2 → 0.2.0  (new features, backwards compatible)
 pnpm release major    # 0.1.2 → 1.0.0  (breaking changes)
 pnpm release 1.5.0    # explicit version
-
-git push origin main v1.2.3
 ```
 
-`pnpm release` bumps the version, tags, and creates a draft GitHub release with notes generated from commit messages. Push the tag, then publish the draft on GitHub to trigger npm publish.
+Bumps `package.json`, commits, tags, pushes, and creates a draft GitHub release with notes from commit messages. Then publish the draft on GitHub to trigger npm publish.
 
 ### PR checklist
 

package/dist/adapters/aws.js

@@ -1,54 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractSQSMetadata = extractSQSMetadata;
-exports.validateSQSAccess = validateSQSAccess;
-exports.extractSNSMetadata = extractSNSMetadata;
-exports.validateSNSAccess = validateSNSAccess;
-exports.extractSSMMetadata = extractSSMMetadata;
-exports.validateSSMAccess = validateSSMAccess;
-exports.extractSecretsMetadata = extractSecretsMetadata;
-exports.validateSecretsAccess = validateSecretsAccess;
-exports.extractLambdaMetadata = extractLambdaMetadata;
-exports.validateLambdaAccess = validateLambdaAccess;
-exports.extractRDSMetadata = extractRDSMetadata;
-exports.validateRDSAccess = validateRDSAccess;
-const client_sqs_1 = require("@aws-sdk/client-sqs");
-const client_sns_1 = require("@aws-sdk/client-sns");
-const client_ssm_1 = require("@aws-sdk/client-ssm");
-const client_secrets_manager_1 = require("@aws-sdk/client-secrets-manager");
-const client_lambda_1 = require("@aws-sdk/client-lambda");
-const client_rds_1 = require("@aws-sdk/client-rds");
-const credential_providers_1 = require("@aws-sdk/credential-providers");
-const core_1 = require("../core");
+import { SQSClient, ListQueuesCommand, GetQueueAttributesCommand, } from '@aws-sdk/client-sqs';
+import { SNSClient, ListTopicsCommand, GetTopicAttributesCommand, ListSubscriptionsByTopicCommand, } from '@aws-sdk/client-sns';
+import { SSMClient, DescribeParametersCommand, } from '@aws-sdk/client-ssm';
+import { SecretsManagerClient, ListSecretsCommand, } from '@aws-sdk/client-secrets-manager';
+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 { fromIni } from '@aws-sdk/credential-providers';
+import { logger } from '../core/index.js';
 function clientConfig(cfg) {
     const region = cfg.region ?? 'us-east-1';
     const base = { region };
     if (cfg.endpoint)
         base.endpoint = cfg.endpoint;
     if (cfg.profile)
-        base.credentials = (0, credential_providers_1.fromIni)({ profile: cfg.profile });
-    else if (cfg.endpoint)
-        base.credentials = {
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? 'test',
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? 'test',
-        };
+        base.credentials = fromIni({ profile: cfg.profile });
     return base;
 }
 // ─── SQS ─────────────────────────────────────────────────────────────────────
-async function extractSQSMetadata(cfg = {}) {
-    const client = new client_sqs_1.SQSClient(clientConfig(cfg));
+export async function extractSQSMetadata(cfg = {}) {
+    const client = new SQSClient(clientConfig(cfg));
     const queues = [];
     try {
         let nextToken;
         const queueUrls = [];
         do {
-            const res = await client.send(new client_sqs_1.ListQueuesCommand({ NextToken: nextToken, MaxResults: 1000 }));
+            const res = await client.send(new ListQueuesCommand({ NextToken: nextToken, MaxResults: 1000 }));
             queueUrls.push(...(res.QueueUrls ?? []));
             nextToken = res.NextToken;
         } while (nextToken);
         for (const url of queueUrls) {
             try {
-                const attrs = await client.send(new client_sqs_1.GetQueueAttributesCommand({
+                const attrs = await client.send(new GetQueueAttributesCommand({
                     QueueUrl: url,
                     AttributeNames: [
                         'QueueArn', 'VisibilityTimeout', 'MessageRetentionPeriod',
@@ -79,35 +61,35 @@ async function extractSQSMetadata(cfg = {}) {
                 });
             }
             catch (err) {
-                core_1.logger.warn(`SQS attrs failed for ${url}: ${err instanceof Error ? err.message : String(err)}`);
+                logger.warn(`SQS attrs failed for ${url}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
     }
     catch (err) {
-        core_1.logger.warn(`SQS list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`SQS list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return queues;
 }
-async function validateSQSAccess(cfg = {}) {
-    await new client_sqs_1.SQSClient(clientConfig(cfg)).send(new client_sqs_1.ListQueuesCommand({ MaxResults: 1 }));
+export async function validateSQSAccess(cfg = {}) {
+    await new SQSClient(clientConfig(cfg)).send(new ListQueuesCommand({ MaxResults: 1 }));
 }
 // ─── SNS ─────────────────────────────────────────────────────────────────────
-async function extractSNSMetadata(cfg = {}) {
-    const client = new client_sns_1.SNSClient(clientConfig(cfg));
+export async function extractSNSMetadata(cfg = {}) {
+    const client = new SNSClient(clientConfig(cfg));
     const topics = [];
     try {
         let nextToken;
         const topicArns = [];
         do {
-            const res = await client.send(new client_sns_1.ListTopicsCommand({ NextToken: nextToken }));
+            const res = await client.send(new ListTopicsCommand({ NextToken: nextToken }));
             topicArns.push(...(res.Topics ?? []).map((t) => t.TopicArn ?? '').filter(Boolean));
             nextToken = res.NextToken;
         } while (nextToken);
         for (const arn of topicArns) {
             try {
                 const [attrsRes, subsRes] = await Promise.all([
-                    client.send(new client_sns_1.GetTopicAttributesCommand({ TopicArn: arn })),
-                    client.send(new client_sns_1.ListSubscriptionsByTopicCommand({ TopicArn: arn })),
+                    client.send(new GetTopicAttributesCommand({ TopicArn: arn })),
+                    client.send(new ListSubscriptionsByTopicCommand({ TopicArn: arn })),
                 ]);
                 const attrs = attrsRes.Attributes ?? {};
                 const subs = subsRes.Subscriptions ?? [];
@@ -115,34 +97,36 @@ async function extractSNSMetadata(cfg = {}) {
                     name: arn.split(':').pop() ?? arn,
                     arn,
                     encrypted: !!attrs['KmsMasterKeyId'],
-                    subscriptionCount: subs.length,
+                    subscriptionCount: parseInt(attrs['SubscriptionsConfirmed'] ?? '0', 10),
                     subscriptionProtocols: [...new Set(subs.map((s) => s.Protocol ?? 'unknown'))],
                 });
             }
             catch (err) {
-                core_1.logger.warn(`SNS attrs failed for ${arn}: ${err instanceof Error ? err.message : String(err)}`);
+                logger.warn(`SNS attrs failed for ${arn}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
     }
     catch (err) {
-        core_1.logger.warn(`SNS list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`SNS list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return topics;
 }
-async function validateSNSAccess(cfg = {}) {
-    await new client_sns_1.SNSClient(clientConfig(cfg)).send(new client_sns_1.ListTopicsCommand({}));
+export async function validateSNSAccess(cfg = {}) {
+    await new SNSClient(clientConfig(cfg)).send(new ListTopicsCommand({}));
 }
 // ─── SSM Parameter Store ──────────────────────────────────────────────────────
-async function extractSSMMetadata(cfg = {}) {
-    const client = new client_ssm_1.SSMClient(clientConfig(cfg));
+export async function extractSSMMetadata(cfg = {}) {
+    const client = new SSMClient(clientConfig(cfg));
     const parameters = [];
     try {
         let nextToken;
         do {
-            const res = await client.send(new client_ssm_1.DescribeParametersCommand({
+            const res = await client.send(new DescribeParametersCommand({
                 NextToken: nextToken,
                 MaxResults: 50,
-                // Only metadata — GetParameter/GetParameters would return values
+                ParameterFilters: cfg.paths?.length
+                    ? [{ Key: 'Path', Values: cfg.paths, Option: 'Recursive' }]
+                    : undefined,
             }));
             for (const p of res.Parameters ?? []) {
                 parameters.push({
@@ -158,22 +142,22 @@ async function extractSSMMetadata(cfg = {}) {
         } while (nextToken && parameters.length < 500);
     }
     catch (err) {
-        core_1.logger.warn(`SSM list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`SSM list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return parameters;
 }
-async function validateSSMAccess(cfg = {}) {
-    await new client_ssm_1.SSMClient(clientConfig(cfg)).send(new client_ssm_1.DescribeParametersCommand({ MaxResults: 1 }));
+export async function validateSSMAccess(cfg = {}) {
+    await new SSMClient(clientConfig(cfg)).send(new DescribeParametersCommand({ MaxResults: 1 }));
 }
 // ─── Secrets Manager ──────────────────────────────────────────────────────────
-async function extractSecretsMetadata(cfg = {}) {
-    const client = new client_secrets_manager_1.SecretsManagerClient(clientConfig(cfg));
+export async function extractSecretsMetadata(cfg = {}) {
+    const client = new SecretsManagerClient(clientConfig(cfg));
     const secrets = [];
     try {
         let nextToken;
         do {
             // ListSecrets never returns secret values
-            const res = await client.send(new client_secrets_manager_1.ListSecretsCommand({ NextToken: nextToken, MaxResults: 100 }));
+            const res = await client.send(new ListSecretsCommand({ NextToken: nextToken, MaxResults: 100 }));
             for (const s of res.SecretList ?? []) {
                 secrets.push({
                     name: s.Name ?? '',
@@ -189,24 +173,114 @@ async function extractSecretsMetadata(cfg = {}) {
         } while (nextToken && secrets.length < 200);
     }
     catch (err) {
-        core_1.logger.warn(`Secrets Manager list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`Secrets Manager list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return secrets;
 }
-async function validateSecretsAccess(cfg = {}) {
-    await new client_secrets_manager_1.SecretsManagerClient(clientConfig(cfg)).send(new client_secrets_manager_1.ListSecretsCommand({ MaxResults: 1 }));
+export async function validateSecretsAccess(cfg = {}) {
+    await new SecretsManagerClient(clientConfig(cfg)).send(new ListSecretsCommand({ MaxResults: 1 }));
 }
 // ─── Lambda ───────────────────────────────────────────────────────────────────
-async function extractLambdaMetadata(cfg = {}) {
-    const client = new client_lambda_1.LambdaClient(clientConfig(cfg));
+const EVENT_SHAPES = {
+    sqs: 'event.Records[0].body',
+    dynamodb: 'event.Records[0].dynamodb.NewImage',
+    kinesis: 'event.Records[0].kinesis.data  // base64',
+    msk: 'event.records[topic][0].value  // base64',
+    sns: 'event.Records[0].Sns.Message',
+    s3: 'event.Records[0].s3.object.key',
+    eventbridge: 'event.detail',
+    unknown: 'event  // unknown trigger type',
+};
+function triggerFromArn(arn, batchSize, state) {
+    let type = 'unknown';
+    if (arn.includes(':sqs:'))
+        type = 'sqs';
+    else if (arn.includes(':dynamodb:'))
+        type = 'dynamodb';
+    else if (arn.includes(':kinesis:'))
+        type = 'kinesis';
+    else if (arn.includes(':kafka:') || arn.toLowerCase().includes('msk'))
+        type = 'msk';
+    else if (arn.includes(':sns:'))
+        type = 'sns';
+    else if (arn.includes(':s3:'))
+        type = 's3';
+    const sourceName = arn.split(':').pop() ?? arn;
+    return { type, sourceArn: arn, sourceName, eventShape: EVENT_SHAPES[type], batchSize, state };
+}
+async function fetchAllEventSourceMappings(cfg) {
+    const client = new LambdaClient(clientConfig(cfg));
+    const triggerMap = new Map();
+    try {
+        let marker;
+        do {
+            const res = await client.send(new ListEventSourceMappingsCommand({ Marker: marker, MaxItems: 100 }));
+            for (const m of res.EventSourceMappings ?? []) {
+                if (!m.FunctionArn || !m.EventSourceArn)
+                    continue;
+                const trigger = triggerFromArn(m.EventSourceArn, m.BatchSize, m.State);
+                const existing = triggerMap.get(m.FunctionArn) ?? [];
+                existing.push(trigger);
+                triggerMap.set(m.FunctionArn, existing);
+            }
+            marker = res.NextMarker;
+        } while (marker);
+    }
+    catch (err) {
+        logger.warn(`Event source mappings fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return triggerMap;
+}
+export async function extractEventBridgeMetadata(cfg = {}) {
+    const client = new EventBridgeClient(clientConfig(cfg));
+    const rules = [];
+    try {
+        let nextToken;
+        do {
+            const res = await client.send(new ListRulesCommand({ NextToken: nextToken, Limit: 100 }));
+            for (const rule of res.Rules ?? []) {
+                if (!rule.Name)
+                    continue;
+                try {
+                    const targetsRes = await client.send(new ListTargetsByRuleCommand({ Rule: rule.Name }));
+                    const targetArns = (targetsRes.Targets ?? []).map((t) => t.Arn ?? '').filter(Boolean);
+                    rules.push({
+                        name: rule.Name,
+                        arn: rule.Arn ?? '',
+                        state: rule.State ?? 'UNKNOWN',
+                        scheduleExpression: rule.ScheduleExpression,
+                        eventPattern: rule.EventPattern,
+                        targetArns,
+                    });
+                }
+                catch (err) {
+                    logger.warn(`EventBridge targets fetch failed for ${rule.Name}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            nextToken = res.NextToken;
+        } while (nextToken && rules.length < 500);
+    }
+    catch (err) {
+        logger.warn(`EventBridge list failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return rules;
+}
+export async function validateEventBridgeAccess(cfg = {}) {
+    await new EventBridgeClient(clientConfig(cfg)).send(new ListRulesCommand({ Limit: 1 }));
+}
+export async function extractLambdaMetadata(cfg = {}, includeFunctions) {
+    const client = new LambdaClient(clientConfig(cfg));
     const functions = [];
     try {
         let marker;
         do {
-            const res = await client.send(new client_lambda_1.ListFunctionsCommand({ Marker: marker, MaxItems: 50 }));
+            const res = await client.send(new ListFunctionsCommand({ Marker: marker, MaxItems: 50 }));
             for (const fn of res.Functions ?? []) {
+                const name = fn.FunctionName ?? '';
+                if (includeFunctions?.length && !includeFunctions.includes(name))
+                    continue;
                 functions.push({
-                    name: fn.FunctionName ?? '',
+                    name,
                     arn: fn.FunctionArn ?? '',
                     runtime: fn.Runtime,
                     handler: fn.Handler,
@@ -215,27 +289,33 @@ async function extractLambdaMetadata(cfg = {}) {
                     lastModified: fn.LastModified,
                     envVarKeys: Object.keys(fn.Environment?.Variables ?? {}),
                     layers: (fn.Layers ?? []).map((l) => l.Arn ?? '').filter(Boolean),
+                    triggers: [],
                 });
             }
             marker = res.NextMarker;
         } while (marker && functions.length < 200);
+        // Fetch all event source mappings in one paginated call and attach to functions
+        const triggerMap = await fetchAllEventSourceMappings(cfg);
+        for (const fn of functions) {
+            fn.triggers = triggerMap.get(fn.arn) ?? [];
+        }
     }
     catch (err) {
-        core_1.logger.warn(`Lambda list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`Lambda list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return functions;
 }
-async function validateLambdaAccess(cfg = {}) {
-    await new client_lambda_1.LambdaClient(clientConfig(cfg)).send(new client_lambda_1.ListFunctionsCommand({ MaxItems: 1 }));
+export async function validateLambdaAccess(cfg = {}) {
+    await new LambdaClient(clientConfig(cfg)).send(new ListFunctionsCommand({ MaxItems: 1 }));
 }
 // ─── RDS ─────────────────────────────────────────────────────────────────────
-async function extractRDSMetadata(cfg = {}) {
-    const client = new client_rds_1.RDSClient(clientConfig(cfg));
+export async function extractRDSMetadata(cfg = {}) {
+    const client = new RDSClient(clientConfig(cfg));
     const instances = [];
     try {
         let marker;
         do {
-            const res = await client.send(new client_rds_1.DescribeDBInstancesCommand({ Marker: marker, MaxRecords: 100 }));
+            const res = await client.send(new DescribeDBInstancesCommand({ Marker: marker, MaxRecords: 100 }));
             for (const db of res.DBInstances ?? []) {
                 instances.push({
                     dbInstanceIdentifier: db.DBInstanceIdentifier ?? '',
@@ -254,10 +334,10 @@ async function extractRDSMetadata(cfg = {}) {
         } while (marker && instances.length < 200);
     }
     catch (err) {
-        core_1.logger.warn(`RDS list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`RDS list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return instances;
 }
-async function validateRDSAccess(cfg = {}) {
-    await new client_rds_1.RDSClient(clientConfig(cfg)).send(new client_rds_1.DescribeDBInstancesCommand({ MaxRecords: 20 }));
+export async function validateRDSAccess(cfg = {}) {
+    await new RDSClient(clientConfig(cfg)).send(new DescribeDBInstancesCommand({ MaxRecords: 20 }));
 }

package/dist/adapters/dynamodb.js

@@ -1,11 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractDynamoMetadata = extractDynamoMetadata;
-exports.validateDynamoAccess = validateDynamoAccess;
-exports.probeDynamoAccess = probeDynamoAccess;
-const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const credential_providers_1 = require("@aws-sdk/credential-providers");
-const core_1 = require("../core");
+import { DynamoDBClient, ListTablesCommand, DescribeTableCommand, } from '@aws-sdk/client-dynamodb';
+import { fromIni } from '@aws-sdk/credential-providers';
+import { DynamoDBError, logger } from '../core/index.js';
 function createDynamoClient(config) {
     const region = config.aws?.region ?? 'us-east-1';
     const profile = config.aws?.profile;
@@ -14,13 +9,8 @@ function createDynamoClient(config) {
     if (endpoint)
         clientConfig.endpoint = endpoint;
     if (profile)
-        clientConfig.credentials = (0, credential_providers_1.fromIni)({ profile });
-    else if (endpoint)
-        clientConfig.credentials = {
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? 'test',
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? 'test',
-        };
-    return new client_dynamodb_1.DynamoDBClient(clientConfig);
+        clientConfig.credentials = fromIni({ profile });
+    return new DynamoDBClient(clientConfig);
 }
 function parseTableDescription(desc) {
     const tableName = desc.TableName ?? 'unknown';
@@ -47,7 +37,7 @@ async function listAllTables(client) {
     const tableNames = [];
     let lastEvaluatedTableName;
     do {
-        const command = new client_dynamodb_1.ListTablesCommand({
+        const command = new ListTablesCommand({
             ExclusiveStartTableName: lastEvaluatedTableName,
             Limit: 100,
         });
@@ -59,7 +49,7 @@ async function listAllTables(client) {
     } while (lastEvaluatedTableName);
     return tableNames;
 }
-async function extractDynamoMetadata(config) {
+export async function extractDynamoMetadata(config) {
     const client = createDynamoClient(config);
     const includeTables = config.dynamodb?.includeTables;
     let tableNames;
@@ -67,43 +57,43 @@ async function extractDynamoMetadata(config) {
         const allTables = await listAllTables(client);
         if (includeTables && includeTables.length > 0) {
             tableNames = allTables.filter((name) => includeTables.includes(name));
-            core_1.logger.debug(`Filtered to ${tableNames.length} tables from config`);
+            logger.debug(`Filtered to ${tableNames.length} tables from config`);
         }
         else {
             tableNames = allTables;
         }
-        core_1.logger.debug(`Found ${tableNames.length} DynamoDB table(s)`);
+        logger.debug(`Found ${tableNames.length} DynamoDB table(s)`);
     }
     catch (err) {
-        throw new core_1.DynamoDBError(err instanceof Error ? err.message : 'Failed to list DynamoDB tables');
+        throw new DynamoDBError(err instanceof Error ? err.message : 'Failed to list DynamoDB tables');
     }
     const results = [];
     for (const tableName of tableNames) {
         try {
-            const command = new client_dynamodb_1.DescribeTableCommand({ TableName: tableName });
+            const command = new DescribeTableCommand({ TableName: tableName });
             const response = await client.send(command);
             if (response.Table) {
                 results.push(parseTableDescription(response.Table));
-                core_1.logger.debug(`Described table: ${tableName}`);
+                logger.debug(`Described table: ${tableName}`);
             }
         }
         catch (err) {
-            core_1.logger.warn(`Failed to describe table ${tableName}: ${err instanceof Error ? err.message : String(err)}`);
+            logger.warn(`Failed to describe table ${tableName}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     return results;
 }
-async function validateDynamoAccess(config) {
+export async function validateDynamoAccess(config) {
     const client = createDynamoClient(config);
     try {
-        await client.send(new client_dynamodb_1.ListTablesCommand({ Limit: 1 }));
+        await client.send(new ListTablesCommand({ Limit: 1 }));
         return true;
     }
     catch {
         return false;
     }
 }
-async function probeDynamoAccess(config) {
+export async function probeDynamoAccess(config) {
     const client = createDynamoClient(config);
-    await client.send(new client_dynamodb_1.ListTablesCommand({ Limit: 1 }));
+    await client.send(new ListTablesCommand({ Limit: 1 }));
 }

package/dist/adapters/logs.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractLogsMetadata = extractLogsMetadata;
-exports.validateLogsAccess = validateLogsAccess;
-const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs");
-const credential_providers_1 = require("@aws-sdk/credential-providers");
-const core_1 = require("../core");
+import { CloudWatchLogsClient, DescribeLogGroupsCommand, FilterLogEventsCommand, } from '@aws-sdk/client-cloudwatch-logs';
+import { fromIni } from '@aws-sdk/credential-providers';
+import { logger } from '../core/index.js';
 // Hard caps to prevent context bloat
 const MAX_LOG_GROUPS = 50;
 const MAX_EVENTS_PER_GROUP = 50;
@@ -14,12 +10,7 @@ function clientConfig(cfg) {
     if (cfg.endpoint)
         base.endpoint = cfg.endpoint;
     if (cfg.profile)
-        base.credentials = (0, credential_providers_1.fromIni)({ profile: cfg.profile });
-    else if (cfg.endpoint)
-        base.credentials = {
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? 'test',
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? 'test',
-        };
+        base.credentials = fromIni({ profile: cfg.profile });
     return base;
 }
 // Strip UUIDs, timestamps, numbers → group similar messages by pattern
@@ -44,8 +35,8 @@ function topPatterns(messages, limit = 5) {
         .slice(0, limit)
         .map(([pattern, count]) => ({ pattern, count }));
 }
-async function extractLogsMetadata(cfg = {}) {
-    const client = new client_cloudwatch_logs_1.CloudWatchLogsClient(clientConfig(cfg));
+export async function extractLogsMetadata(cfg = {}) {
+    const client = new CloudWatchLogsClient(clientConfig(cfg));
     const windowMs = (cfg.windowHours ?? 24) * 60 * 60 * 1000;
     const startTime = Date.now() - windowMs;
     const summaries = [];
@@ -56,7 +47,7 @@ async function extractLogsMetadata(cfg = {}) {
         for (const prefix of prefixes) {
             let nextToken;
             do {
-                const res = await client.send(new client_cloudwatch_logs_1.DescribeLogGroupsCommand({
+                const res = await client.send(new DescribeLogGroupsCommand({
                     nextToken,
                     limit: Math.min(50, MAX_LOG_GROUPS - logGroups.length),
                     ...(prefix ? { logGroupNamePrefix: prefix } : {}),
@@ -73,7 +64,7 @@ async function extractLogsMetadata(cfg = {}) {
         }
     }
     catch (err) {
-        core_1.logger.warn(`CloudWatch Logs discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`CloudWatch Logs discovery failed: ${err instanceof Error ? err.message : String(err)}`);
         return summaries;
     }
     // Sample errors from each group — patterns only, never raw messages for unrelated groups
@@ -85,7 +76,7 @@ async function extractLogsMetadata(cfg = {}) {
             if (errorMessages.length + warnMessages.length >= MAX_EVENTS_PER_GROUP)
                 break;
             try {
-                const res = await client.send(new client_cloudwatch_logs_1.FilterLogEventsCommand({
+                const res = await client.send(new FilterLogEventsCommand({
                     logGroupName: lg.name,
                     filterPattern,
                     startTime,
@@ -119,9 +110,9 @@ async function extractLogsMetadata(cfg = {}) {
             lastErrorTime,
         });
     }
-    core_1.logger.debug(`CloudWatch Logs: sampled ${summaries.length} log group(s)`);
+    logger.debug(`CloudWatch Logs: sampled ${summaries.length} log group(s)`);
     return summaries;
 }
-async function validateLogsAccess(cfg = {}) {
-    await new client_cloudwatch_logs_1.CloudWatchLogsClient(clientConfig(cfg)).send(new client_cloudwatch_logs_1.DescribeLogGroupsCommand({ limit: 1 }));
+export async function validateLogsAccess(cfg = {}) {
+    await new CloudWatchLogsClient(clientConfig(cfg)).send(new DescribeLogGroupsCommand({ limit: 1 }));
 }