infrawise 0.1.2 → 0.2.0

package/dist/cli/commands/doctor.js

@@ -0,0 +1,338 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const core_1 = require("../../core");
+const dynamodb_1 = require("../../adapters/dynamodb");
+const postgres_1 = require("../../adapters/postgres");
+const mysql_1 = require("../../adapters/mysql");
+const mongodb_1 = require("../../adapters/mongodb");
+const aws_1 = require("../../adapters/aws");
+const logs_1 = require("../../adapters/logs");
+const utils_1 = require("../utils");
+async function runCheck(label, fn) {
+    const spin = (0, ora_1.default)({ text: chalk_1.default.dim(label), color: 'cyan' }).start();
+    const result = await fn();
+    switch (result.status) {
+        case 'pass':
+            spin.succeed(chalk_1.default.green(result.name) + chalk_1.default.dim(`  ${result.message}`));
+            break;
+        case 'fail':
+            spin.fail(chalk_1.default.red(result.name) + chalk_1.default.dim(`  ${result.message}`));
+            break;
+        case 'warn':
+            spin.warn(chalk_1.default.yellow(result.name) + chalk_1.default.dim(`  ${result.message}`));
+            break;
+        case 'skip':
+            spin.info(chalk_1.default.dim(`${result.name}  ${result.message}`));
+            break;
+    }
+    if (result.detail)
+        console.log(chalk_1.default.dim(`       ${result.detail}`));
+    return result;
+}
+async function runDoctor(options = {}) {
+    (0, utils_1.printHeader)('Infrawise Doctor');
+    const configPath = path.resolve(options.config ?? 'infrawise.yaml');
+    const results = [];
+    // Config file
+    results.push(await runCheck('Checking config file...', async () => {
+        const exists = fs.existsSync(configPath);
+        return {
+            name: 'Config file',
+            status: exists ? 'pass' : 'fail',
+            message: exists ? configPath : `Not found at ${configPath}`,
+            detail: exists ? undefined : 'Run: infrawise init',
+        };
+    }));
+    // Config valid
+    let config;
+    results.push(await runCheck('Validating config...', async () => {
+        if (!fs.existsSync(configPath))
+            return { name: 'Config validation', status: 'skip', message: 'No config file' };
+        try {
+            config = (0, core_1.loadConfig)(options.config);
+            return { name: 'Config validation', status: 'pass', message: `project: ${config.project}` };
+        }
+        catch (err) {
+            return {
+                name: 'Config validation', status: 'fail', message: 'Invalid config',
+                detail: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }));
+    // AWS credentials
+    results.push(await runCheck('Checking AWS credentials...', async () => {
+        const home = process.env.HOME ?? os.homedir();
+        const hasCreds = fs.existsSync(path.join(home, '.aws', 'credentials')) ||
+            fs.existsSync(path.join(home, '.aws', 'config'));
+        return {
+            name: 'AWS credentials',
+            status: hasCreds ? 'pass' : 'warn',
+            message: hasCreds ? 'Found' : 'Not found — may use env vars or IAM role',
+            detail: hasCreds ? undefined : 'Run: aws configure',
+        };
+    }));
+    const awsCfg = { region: config?.aws?.region, profile: config?.aws?.profile };
+    // DynamoDB
+    results.push(await runCheck('Testing DynamoDB access...', async () => {
+        if (!config)
+            return { name: 'DynamoDB', status: 'skip', message: 'No valid config' };
+        if (config.dynamodb?.enabled !== true)
+            return { name: 'DynamoDB', status: 'skip', message: 'Disabled in config' };
+        try {
+            const ok = await (0, dynamodb_1.validateDynamoAccess)(config);
+            return {
+                name: 'DynamoDB', status: ok ? 'pass' : 'warn',
+                message: ok ? `Connected (profile: ${config.aws?.profile ?? 'default'})` : 'Cannot connect',
+                detail: ok ? undefined : 'Check IAM: dynamodb:ListTables, dynamodb:DescribeTable',
+            };
+        }
+        catch (err) {
+            return { name: 'DynamoDB', status: 'warn', message: err instanceof Error ? err.message : String(err) };
+        }
+    }));
+    // SQS
+    results.push(await runCheck('Testing SQS access...', async () => {
+        if (config?.sqs?.enabled !== true)
+            return { name: 'SQS', status: 'skip', message: 'Disabled in config' };
+        try {
+            await (0, aws_1.validateSQSAccess)(awsCfg);
+            return { name: 'SQS', status: 'pass', message: 'Connected' };
+        }
+        catch (err) {
+            return {
+                name: 'SQS', status: 'warn',
+                message: err instanceof Error ? err.message : String(err),
+                detail: 'Check IAM: sqs:ListQueues, sqs:GetQueueAttributes',
+            };
+        }
+    }));
+    // SNS
+    results.push(await runCheck('Testing SNS access...', async () => {
+        if (config?.sns?.enabled !== true)
+            return { name: 'SNS', status: 'skip', message: 'Disabled in config' };
+        try {
+            await (0, aws_1.validateSNSAccess)(awsCfg);
+            return { name: 'SNS', status: 'pass', message: 'Connected' };
+        }
+        catch (err) {
+            return {
+                name: 'SNS', status: 'warn',
+                message: err instanceof Error ? err.message : String(err),
+                detail: 'Check IAM: sns:ListTopics, sns:GetTopicAttributes, sns:ListSubscriptionsByTopic',
+            };
+        }
+    }));
+    // SSM
+    results.push(await runCheck('Testing SSM Parameter Store access...', async () => {
+        if (config?.ssm?.enabled !== true)
+            return { name: 'SSM', status: 'skip', message: 'Disabled in config' };
+        try {
+            await (0, aws_1.validateSSMAccess)(awsCfg);
+            return { name: 'SSM', status: 'pass', message: 'Connected (metadata only)' };
+        }
+        catch (err) {
+            return {
+                name: 'SSM', status: 'warn',
+                message: err instanceof Error ? err.message : String(err),
+                detail: 'Check IAM: ssm:DescribeParameters',
+            };
+        }
+    }));
+    // Secrets Manager
+    results.push(await runCheck('Testing Secrets Manager access...', async () => {
+        if (config?.secretsManager?.enabled !== true)
+            return { name: 'Secrets Manager', status: 'skip', message: 'Disabled in config' };
+        try {
+            await (0, aws_1.validateSecretsAccess)(awsCfg);
+            return { name: 'Secrets Manager', status: 'pass', message: 'Connected (names/rotation only)' };
+        }
+        catch (err) {
+            return {
+                name: 'Secrets Manager', status: 'warn',
+                message: err instanceof Error ? err.message : String(err),
+                detail: 'Check IAM: secretsmanager:ListSecrets',
+            };
+        }
+    }));
+    // Lambda
+    results.push(await runCheck('Testing Lambda access...', async () => {
+        if (config?.lambda?.enabled !== true)
+            return { name: 'Lambda', status: 'skip', message: 'Disabled in config' };
+        try {
+            await (0, aws_1.validateLambdaAccess)(awsCfg);
+            return { name: 'Lambda', status: 'pass', message: 'Connected' };
+        }
+        catch (err) {
+            return {
+                name: 'Lambda', status: 'warn',
+                message: err instanceof Error ? err.message : String(err),
+                detail: 'Check IAM: lambda:ListFunctions',
+            };
+        }
+    }));
+    // CloudWatch Logs
+    results.push(await runCheck('Testing CloudWatch Logs access...', async () => {
+        if (!config?.cloudwatchLogs?.enabled)
+            return { name: 'CloudWatch Logs', status: 'skip', message: 'Not enabled in config' };
+        try {
+            await (0, logs_1.validateLogsAccess)(awsCfg);
+            return { name: 'CloudWatch Logs', status: 'pass', message: 'Connected' };
+        }
+        catch (err) {
+            return {
+                name: 'CloudWatch Logs', status: 'warn',
+                message: err instanceof Error ? err.message : String(err),
+                detail: 'Check IAM: logs:DescribeLogGroups, logs:FilterLogEvents',
+            };
+        }
+    }));
+    // PostgreSQL
+    results.push(await runCheck('Testing PostgreSQL...', async () => {
+        if (!config?.postgres?.enabled || !config.postgres.connectionString) {
+            return { name: 'PostgreSQL', status: 'skip', message: 'Not configured' };
+        }
+        try {
+            const ok = await (0, postgres_1.validatePostgresAccess)(config.postgres.connectionString);
+            return {
+                name: 'PostgreSQL', status: ok ? 'pass' : 'fail',
+                message: ok ? 'Connected' : 'Cannot connect',
+                detail: ok ? undefined : 'Check connection string and security group',
+            };
+        }
+        catch (err) {
+            return { name: 'PostgreSQL', status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    }));
+    // MySQL
+    results.push(await runCheck('Testing MySQL...', async () => {
+        if (!config?.mysql?.enabled || !config.mysql.connectionString) {
+            return { name: 'MySQL', status: 'skip', message: 'Not configured' };
+        }
+        try {
+            const ok = await (0, mysql_1.validateMySQLAccess)(config.mysql.connectionString);
+            return {
+                name: 'MySQL', status: ok ? 'pass' : 'fail',
+                message: ok ? 'Connected' : 'Cannot connect',
+                detail: ok ? undefined : 'Check connection string, host, port 3306',
+            };
+        }
+        catch (err) {
+            return { name: 'MySQL', status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    }));
+    // MongoDB
+    results.push(await runCheck('Testing MongoDB...', async () => {
+        if (!config?.mongodb?.enabled || !config.mongodb.connectionString) {
+            return { name: 'MongoDB', status: 'skip', message: 'Not configured' };
+        }
+        try {
+            const ok = await (0, mongodb_1.validateMongoAccess)(config.mongodb.connectionString);
+            return {
+                name: 'MongoDB', status: ok ? 'pass' : 'fail',
+                message: ok ? 'Connected' : 'Cannot connect',
+                detail: ok ? undefined : 'Check connection string and port 27017',
+            };
+        }
+        catch (err) {
+            return { name: 'MongoDB', status: 'fail', message: err instanceof Error ? err.message : String(err) };
+        }
+    }));
+    // Project type
+    results.push(await runCheck('Detecting project type...', async () => {
+        const hasTsConfig = fs.existsSync(path.join(process.cwd(), 'tsconfig.json'));
+        const hasPkg = fs.existsSync(path.join(process.cwd(), 'package.json'));
+        return {
+            name: 'Project type',
+            status: hasTsConfig ? 'pass' : 'warn',
+            message: hasTsConfig ? 'TypeScript' : hasPkg ? 'JavaScript (no tsconfig.json)' : 'Unknown',
+            detail: hasTsConfig ? undefined : 'Scanner works best with TypeScript projects',
+        };
+    }));
+    // IaC detection
+    results.push(await runCheck('Detecting IaC files...', async () => {
+        const cwd = process.cwd();
+        const hasTF = fs.existsSync(path.join(cwd, 'main.tf')) || fs.readdirSync(cwd).some((f) => f.endsWith('.tf'));
+        const hasCFN = fs.existsSync(path.join(cwd, 'template.yaml')) || fs.existsSync(path.join(cwd, 'template.json'));
+        const hasCDK = fs.existsSync(path.join(cwd, 'cdk.json'));
+        const hasCDKOut = fs.existsSync(path.join(cwd, 'cdk.out'));
+        const found = [];
+        if (hasTF)
+            found.push('Terraform');
+        if (hasCFN)
+            found.push('CloudFormation');
+        if (hasCDK)
+            found.push(`CDK${hasCDKOut ? ' (synthesized)' : ' (run cdk synth)'}`);
+        return {
+            name: 'IaC files',
+            status: found.length > 0 ? 'pass' : 'warn',
+            message: found.length > 0 ? found.join(', ') : 'No Terraform/CFN/CDK files detected',
+            detail: found.length === 0 ? 'IaC analysis will be skipped without TF/CFN/CDK files' : undefined,
+        };
+    }));
+    // Cache
+    results.push(await runCheck('Checking analysis cache...', async () => {
+        const cached = fs.existsSync(path.join(process.cwd(), '.infrawise', 'cache', 'graph.json'));
+        return {
+            name: 'Analysis cache',
+            status: cached ? 'pass' : 'warn',
+            message: cached ? 'Cached results found' : 'No cache — run infrawise analyze first',
+        };
+    }));
+    // Summary
+    const passed = results.filter((r) => r.status === 'pass').length;
+    const failed = results.filter((r) => r.status === 'fail').length;
+    const warned = results.filter((r) => r.status === 'warn').length;
+    console.log('');
+    console.log(chalk_1.default.dim('  ' + '─'.repeat(40)));
+    if (failed === 0) {
+        console.log(`  ${chalk_1.default.green.bold('All checks passed')}  ${chalk_1.default.dim(`${passed} passed, ${warned} warning(s)`)}`);
+    }
+    else {
+        console.log(`  ${chalk_1.default.red.bold(`${failed} check(s) failed`)}  ${chalk_1.default.dim(`${passed} passed, ${warned} warning(s)`)}`);
+    }
+    console.log('');
+    if (failed > 0)
+        process.exit(1);
+}

package/dist/cli/commands/init.js

@@ -0,0 +1,234 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const core_1 = require("../../core");
+const utils_1 = require("../utils");
+async function runInit(options = {}) {
+    const cwd = process.cwd();
+    const configPath = path.join(cwd, 'infrawise.yaml');
+    if (fs.existsSync(configPath) && !options.force) {
+        console.log(`\n  ${chalk_1.default.yellow('⚠')} ${chalk_1.default.yellow('infrawise.yaml already exists.')}  ${chalk_1.default.dim('Use --force to overwrite.')}\n`);
+        return;
+    }
+    (0, utils_1.printHeader)('Initialize Infrawise');
+    const repoType = (0, utils_1.detectRepoType)(cwd);
+    const repoName = path.basename(cwd);
+    const profiles = (0, utils_1.readAWSProfiles)();
+    const detectedRegion = (0, utils_1.detectAWSRegion)();
+    utils_1.log.success(`Repository detected`, repoName);
+    utils_1.log.success(`Type`, repoType);
+    utils_1.log.success(`AWS profiles found`, String(profiles.length));
+    console.log('');
+    // ── Core settings ──────────────────────────────────────────────────────────
+    const core = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'project',
+            message: 'Project name:',
+            default: repoName,
+        },
+        {
+            type: 'list',
+            name: 'awsProfile',
+            message: 'AWS profile:',
+            choices: profiles,
+            default: profiles[0],
+        },
+        {
+            type: 'input',
+            name: 'region',
+            message: 'AWS region:',
+            default: detectedRegion,
+        },
+    ]);
+    // ── Databases ──────────────────────────────────────────────────────────────
+    console.log('\n  ' + chalk_1.default.bold('Databases'));
+    const databases = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'dynamoEnabled',
+            message: 'Enable DynamoDB analysis?',
+            default: true,
+        },
+        {
+            type: 'input',
+            name: 'dynamoTables',
+            message: 'DynamoDB tables to include:',
+            default: '',
+            suffix: chalk_1.default.dim(' (comma-separated, blank = all)'),
+            when: (a) => a.dynamoEnabled,
+        },
+        {
+            type: 'confirm',
+            name: 'pgEnabled',
+            message: 'Enable PostgreSQL analysis?',
+            default: false,
+        },
+        {
+            type: 'input',
+            name: 'pgConnectionString',
+            message: 'PostgreSQL connection string:',
+            default: 'postgresql://localhost:5432/mydb',
+            when: (a) => a.pgEnabled,
+        },
+        {
+            type: 'confirm',
+            name: 'mysqlEnabled',
+            message: 'Enable MySQL analysis?',
+            default: false,
+        },
+        {
+            type: 'input',
+            name: 'mysqlConnectionString',
+            message: 'MySQL connection string:',
+            default: 'mysql://localhost:3306/mydb',
+            when: (a) => a.mysqlEnabled,
+        },
+        {
+            type: 'confirm',
+            name: 'mongoEnabled',
+            message: 'Enable MongoDB analysis?',
+            default: false,
+        },
+        {
+            type: 'input',
+            name: 'mongoConnectionString',
+            message: 'MongoDB connection string:',
+            default: 'mongodb://localhost:27017',
+            when: (a) => a.mongoEnabled,
+        },
+    ]);
+    // ── AWS services ───────────────────────────────────────────────────────────
+    console.log('\n  ' + chalk_1.default.bold('AWS Services'));
+    console.log(chalk_1.default.dim('  Infrawise will introspect these services — credentials from the AWS profile above.'));
+    const services = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'sqsEnabled',
+            message: 'Introspect SQS queues?',
+            default: true,
+        },
+        {
+            type: 'confirm',
+            name: 'snsEnabled',
+            message: 'Introspect SNS topics?',
+            default: true,
+        },
+        {
+            type: 'confirm',
+            name: 'ssmEnabled',
+            message: 'Introspect SSM Parameter Store? (metadata only, no values)',
+            default: true,
+        },
+        {
+            type: 'input',
+            name: 'ssmPaths',
+            message: 'SSM path prefixes to filter:',
+            default: '',
+            suffix: chalk_1.default.dim(' (comma-separated, blank = all  e.g. /myapp/prod)'),
+            when: (a) => a.ssmEnabled,
+        },
+        {
+            type: 'confirm',
+            name: 'secretsEnabled',
+            message: 'Introspect Secrets Manager? (names & rotation only, no values)',
+            default: true,
+        },
+        {
+            type: 'confirm',
+            name: 'lambdaEnabled',
+            message: 'Introspect Lambda functions?',
+            default: true,
+        },
+        {
+            type: 'confirm',
+            name: 'logsEnabled',
+            message: 'Sample CloudWatch Logs? (error patterns only, no raw logs)',
+            default: false,
+        },
+        {
+            type: 'input',
+            name: 'logGroupPrefixes',
+            message: 'CloudWatch log group prefixes:',
+            default: '',
+            suffix: chalk_1.default.dim(' (comma-separated, blank = all)'),
+            when: (a) => a.logsEnabled,
+        },
+    ]);
+    // ── Build config ───────────────────────────────────────────────────────────
+    const includeTables = databases.dynamoTables
+        ? databases.dynamoTables.split(',').map((t) => t.trim()).filter(Boolean)
+        : [];
+    const ssmPaths = services.ssmPaths
+        ? services.ssmPaths.split(',').map((p) => p.trim()).filter(Boolean)
+        : [];
+    const logGroupPrefixes = services.logGroupPrefixes
+        ? services.logGroupPrefixes.split(',').map((p) => p.trim()).filter(Boolean)
+        : [];
+    const configContent = (0, core_1.generateDefaultConfig)(core.project, {
+        aws: { profile: core.awsProfile, region: core.region },
+        dynamodb: { enabled: databases.dynamoEnabled, includeTables },
+        postgres: { enabled: databases.pgEnabled, connectionString: databases.pgConnectionString ?? '' },
+        mysql: { enabled: databases.mysqlEnabled, connectionString: databases.mysqlConnectionString ?? '' },
+        mongodb: { enabled: databases.mongoEnabled, connectionString: databases.mongoConnectionString ?? '' },
+        sqs: { enabled: services.sqsEnabled },
+        sns: { enabled: services.snsEnabled },
+        ssm: { enabled: services.ssmEnabled, paths: ssmPaths },
+        secretsManager: { enabled: services.secretsEnabled },
+        lambda: { enabled: services.lambdaEnabled },
+        cloudwatchLogs: {
+            enabled: services.logsEnabled,
+            logGroupPrefixes,
+            windowHours: 24,
+        },
+    });
+    fs.writeFileSync(configPath, configContent, 'utf-8');
+    console.log('');
+    utils_1.log.success(`Created ${chalk_1.default.bold('infrawise.yaml')}`);
+    console.log('');
+    console.log(chalk_1.default.bold('  Next steps:'));
+    utils_1.log.info(`Run ${chalk_1.default.cyan('infrawise doctor')} to validate your setup`);
+    utils_1.log.info(`Run ${chalk_1.default.cyan('infrawise analyze')} to scan your infrastructure`);
+    utils_1.log.info(`Run ${chalk_1.default.cyan('infrawise dev')} to start the MCP server`);
+    console.log('');
+}

package/dist/cli/index.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const commander_1 = require("commander");
+const utils_1 = require("./utils");
+const init_1 = require("./commands/init");
+const auth_1 = require("./commands/auth");
+const analyze_1 = require("./commands/analyze");
+const dev_1 = require("./commands/dev");
+const doctor_1 = require("./commands/doctor");
+const { version } = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../../package.json'), 'utf8'));
+const program = new commander_1.Command();
+program
+    .name('infrawise')
+    .description('CLI-first infrastructure intelligence platform — analyze your databases, AWS services, and IaC')
+    .version(version);
+program
+    .command('init')
+    .description('Detect AWS profile/region, discover DynamoDB tables, and generate infrawise.yaml')
+    .option('--force', 'Overwrite existing infrawise.yaml')
+    .action(async (options) => {
+    (0, utils_1.printBanner)();
+    await (0, init_1.runInit)({ force: options.force });
+});
+program
+    .command('auth')
+    .description('Validate and select AWS profile from ~/.aws/credentials')
+    .action(async () => {
+    (0, utils_1.printBanner)();
+    await (0, auth_1.runAuth)();
+});
+program
+    .command('analyze')
+    .description('Load config, run extractors, build graph, and run all analyzers')
+    .option('-c, --config <path>', 'Path to infrawise.yaml', 'infrawise.yaml')
+    .option('-r, --repo <path>', 'Path to repository to scan', process.cwd())
+    .option('--no-cache', 'Skip reading/writing the cache')
+    .action(async (options) => {
+    (0, utils_1.printBanner)();
+    await (0, analyze_1.runAnalyze)({
+        config: options.config !== 'infrawise.yaml' ? options.config : undefined,
+        repo: options.repo,
+        noCache: !options.cache,
+    });
+});
+program
+    .command('dev')
+    .description('Start Fastify MCP server on localhost:3000')
+    .option('-c, --config <path>', 'Path to infrawise.yaml', 'infrawise.yaml')
+    .option('-p, --port <number>', 'Port to listen on', '3000')
+    .action(async (options) => {
+    (0, utils_1.printBanner)();
+    await (0, dev_1.runDev)({
+        config: options.config !== 'infrawise.yaml' ? options.config : undefined,
+        port: parseInt(options.port, 10),
+    });
+});
+program
+    .command('doctor')
+    .description('Validate AWS access, postgres connectivity, config, and repo scan')
+    .option('-c, --config <path>', 'Path to infrawise.yaml', 'infrawise.yaml')
+    .action(async (options) => {
+    (0, utils_1.printBanner)();
+    await (0, doctor_1.runDoctor)({
+        config: options.config !== 'infrawise.yaml' ? options.config : undefined,
+    });
+});
+// Global error handling
+program.exitOverride((err) => {
+    if (err.code === 'commander.helpDisplayed' || err.code === 'commander.version') {
+        process.exit(0);
+    }
+    console.error(`\nError: ${err.message}`);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('\nUnhandled error:', reason instanceof Error ? reason.message : String(reason));
+    process.exit(1);
+});
+program.parse(process.argv);