infrawise 0.9.0 → 0.10.1

package/README.md

@@ -55,35 +55,32 @@ npm install -g infrawise
 or use without installing:
 
 ```bash
-npx infrawise init
+npx infrawise start --claude
 ```
 
 ---
 
 ## Quick start
 
-**1. Initialize in your repo**
-
 ```bash
 cd your-project
-infrawise init
+infrawise start --claude
 ```
 
-Detects your AWS profile and region, asks a few questions, writes `infrawise.yaml`. That's the only file it creates in your project.
-
-**2. Validate everything is connected**
+That's it. Infrawise will:
 
-```bash
-infrawise doctor
-```
+1. Ask a few questions and generate `infrawise.yaml` (first time only)
+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 15 MCP tools ready
 
-**3. Run analysis**
+**Every time after:**
 
 ```bash
-infrawise analyze
+claude    # no infrawise command needed — editor manages the connection
 ```
 
-Or skip this step — `infrawise dev` auto-runs analysis if no cache exists.
+Analysis is cached for 24 hours. When the cache is stale, `infrawise stdio` (spawned automatically by your editor) refreshes it at session start. File changes are detected within the session and the code graph is updated automatically.
 
 ```
 Findings (3 total)
@@ -104,60 +101,58 @@ Findings (3 total)
 
 ## Using with AI coding assistants
 
-### Step 1: Start the MCP server
+### Claude Code (recommended)
 
 ```bash
-infrawise dev
+infrawise start --claude
 ```
 
+Writes `.mcp.json` to your project root and opens Claude Code. Claude Code reads `.mcp.json` automatically on every launch and manages the `infrawise stdio` process — no server to start, no ports to configure.
+
+### Cursor
+
+```bash
+infrawise start --cursor
 ```
-  ✔ Config loaded          infrawise.yaml
-  ✔ Cached analysis loaded 42 nodes · 18 edges · 7 finding(s)
-  ✔ Server running
-
-  ┌────────────────────────────────────────────────────┐
-  │ MCP Server                                        │
-  ├────────────────────────────────────────────────────┤
-  │ POST http://localhost:3000/mcp                    │
-  │ GET  http://localhost:3000/health                 │
-  ├────────────────────────────────────────────────────┤
-  │ Tools (13 active)                                 │
-  │ get_infra_overview · get_graph_summary            │
-  │ ...                                               │
-  └────────────────────────────────────────────────────┘
-
-  Watching for file changes... Press Ctrl+C to stop
+
+Writes `.cursor/mcp.json` and opens Cursor. All 15 infrawise tools are available in Cursor's MCP panel.
+
+### Windsurf
+
+```bash
+infrawise start --windsurf
 ```
 
-### Step 2: Add to your editor settings
+Writes to `~/.codeium/windsurf/mcp_config.json` and opens Windsurf.
 
-**Claude Code** — edit `.claude/settings.json` in your repo (project-level) or `~/.claude/settings.json` (global):
+### Any editor (no flag)
 
-```json
-{
-  "mcpServers": {
-    "infrawise": {
-      "url": "http://localhost:3000/mcp"
-    }
-  }
-}
+```bash
+infrawise start
+```
+
+Writes `.mcp.json` and exits. Open whichever editor you prefer — point it at `infrawise stdio --config /path/to/infrawise.yaml` as an MCP server command.
+
+### HTTP transport (alternative)
+
+If your editor or workflow requires an HTTP MCP endpoint instead of stdio:
+
+```bash
+infrawise dev    # starts server at http://localhost:3000/mcp
 ```
 
-To let Claude Code manage the server lifecycle automatically:
+Add to your editor's MCP config:
 
 ```json
 {
   "mcpServers": {
     "infrawise": {
-      "command": "infrawise",
-      "args": ["dev"]
+      "url": "http://localhost:3000/mcp"
     }
   }
 }
 ```
 
-**Cursor** and **Windsurf** — add `http://localhost:3000/mcp` as an MCP server in editor settings.
-
 ### MCP tools
 
 | Tool                         | What it provides                                                                                            |
@@ -182,14 +177,18 @@ To let Claude Code manage the server lifecycle automatically:
 
 ## CLI reference
 
-| Command             | What it does                                                                 |
-| ------------------- | ---------------------------------------------------------------------------- |
-| `infrawise init`    | Detect AWS + repo, generate `infrawise.yaml`                                 |
-| `infrawise auth`    | Select or switch AWS profile                                                 |
-| `infrawise analyze` | Scan repo + AWS, build graph, print findings                                 |
-| `infrawise dev`     | Start MCP server — auto-analyzes if no cache, watches files for live refresh |
-| `infrawise stdio`   | Start MCP server on stdio transport (for Claude Desktop)                     |
-| `infrawise doctor`  | Validate AWS access, DB connectivity, and config                             |
+| Command                      | What it does                                                                      |
+| ---------------------------- | --------------------------------------------------------------------------------- |
+| `infrawise start`            | **Primary command** — init + analyze + write editor MCP config, then exit         |
+| `infrawise start --claude`   | Same as above, then opens Claude Code                                             |
+| `infrawise start --cursor`   | Same as above, then opens Cursor                                                  |
+| `infrawise start --windsurf` | Same as above, then opens Windsurf                                                |
+| `infrawise init`             | Generate `infrawise.yaml` only (no analysis, no editor config)                   |
+| `infrawise auth`             | Select or switch AWS profile                                                      |
+| `infrawise analyze`          | Force a full re-scan — useful after major infrastructure changes                  |
+| `infrawise dev`              | HTTP transport alternative — starts server at `localhost:3000/mcp`               |
+| `infrawise stdio`            | Stdio transport — auto-managed by editors via `.mcp.json` (rarely run directly)  |
+| `infrawise doctor`           | Validate AWS access, DB connectivity, and config                                  |
 
 ### `infrawise analyze` options
 
@@ -216,7 +215,7 @@ infrawise analyze --severity high --output report.md
 
 ## Configuration
 
-`infrawise.yaml` is generated by `infrawise init` and lives in your repo root. Every service must be explicitly `enabled: true` — infrawise never connects to anything not listed in config.
+`infrawise.yaml` is generated by `infrawise start` (or `infrawise init` to create the file only) and lives in your repo root. Every service must be explicitly `enabled: true` — infrawise never connects to anything not listed in config.
 
 Connection strings support `${ENV_VAR}` substitution so passwords never need to be committed:
 

package/dist/cli/commands/analyze.js

@@ -365,36 +365,37 @@ export async function runAnalyze(options = {}) {
         });
     }
     // ── Output ────────────────────────────────────────────────────────────────────
-    const displayFindings = minSeverity > 0
-        ? findings.filter((f) => (SEVERITY_ORDER[f.severity] ?? 0) >= minSeverity)
-        : findings;
-    console.log('');
-    if (displayFindings.length === 0) {
-        const msg = minSeverity > 0
-            ? `No ${options.severity} (or higher) severity issues found.`
-            : 'Your infrastructure looks clean.';
-        console.log(`  ${chalk.green.bold('✓ No issues found!')}  ${chalk.dim(msg)}`);
-    }
-    else {
-        const filterNote = minSeverity > 0 ? chalk.dim(` (${options.severity}+ only)`) : '';
-        console.log(chalk.bold(`  Findings`) + chalk.dim(`  ${displayFindings.length} total`) + filterNote);
-        displayFindings.forEach((f, i) => printFinding(f, i));
-        printSummaryBox(displayFindings);
-        if (displayFindings.some((f) => f.severity === 'high')) {
-            console.log(`\n  ${chalk.red.bold('Action required:')} ${chalk.red('High severity issues detected.')}`);
+    if (!options.silent) {
+        const displayFindings = minSeverity > 0
+            ? findings.filter((f) => (SEVERITY_ORDER[f.severity] ?? 0) >= minSeverity)
+            : findings;
+        console.log('');
+        if (displayFindings.length === 0) {
+            const msg = minSeverity > 0
+                ? `No ${options.severity} (or higher) severity issues found.`
+                : 'Your infrastructure looks clean.';
+            console.log(`  ${chalk.green.bold('✓ No issues found!')}  ${chalk.dim(msg)}`);
         }
-    }
-    if (options.output) {
-        const report = buildMarkdownReport(displayFindings, config.project);
-        const outPath = path.resolve(options.output);
-        fs.writeFileSync(outPath, report, 'utf8');
+        else {
+            const filterNote = minSeverity > 0 ? chalk.dim(` (${options.severity}+ only)`) : '';
+            console.log(chalk.bold(`  Findings`) + chalk.dim(`  ${displayFindings.length} total`) + filterNote);
+            displayFindings.forEach((f, i) => printFinding(f, i));
+            printSummaryBox(displayFindings);
+            if (displayFindings.some((f) => f.severity === 'high')) {
+                console.log(`\n  ${chalk.red.bold('Action required:')} ${chalk.red('High severity issues detected.')}`);
+            }
+        }
+        if (options.output) {
+            const report = buildMarkdownReport(displayFindings, config.project);
+            const outPath = path.resolve(options.output);
+            fs.writeFileSync(outPath, report, 'utf8');
+            console.log('');
+            log.success('Report saved', outPath);
+        }
+        console.log('');
+        log.dim(`Results cached in .infrawise/cache/`);
         console.log('');
-        log.success('Report saved', outPath);
     }
-    console.log('');
-    log.dim(`Results cached in .infrawise/cache/`);
-    log.info(`Run ${chalk.cyan('infrawise dev')} to explore via the MCP server`);
-    console.log('');
 }
 export async function runCodeRefresh(repoPath, config) {
     const cached = readCache('meta', 60 * 60 * 1000);

package/dist/cli/commands/init.js

@@ -21,40 +21,73 @@ export async function runInit(options = {}) {
     log.success(`AWS profiles found`, String(profiles.length));
     console.log('');
     // ── Core settings ──────────────────────────────────────────────────────────
-    const core = await inquirer.prompt([
+    const { project } = await inquirer.prompt([
         {
             type: 'input',
             name: 'project',
             message: 'Project name:',
             default: repoName,
         },
+    ]);
+    // ── Step 1: provider ───────────────────────────────────────────────────────
+    const { provider } = await inquirer.prompt([
         {
             type: 'select',
-            name: 'awsProfile',
-            message: 'AWS profile:',
+            name: 'provider',
+            message: 'Infrastructure:',
             choices: [
-                new inquirer.Separator('── no profile ──'),
-                { name: 'Environment variables  (CI/CD, real AWS)', value: '__env__' },
-                { name: 'LocalStack  (local development)', value: '__localstack__' },
-                new inquirer.Separator('── named profiles ──'),
-                ...profiles,
+                { name: 'AWS', value: 'aws' },
+                { name: 'LocalStack  (mimics AWS locally)', value: 'localstack' },
+                { name: 'Local  (no cloud — databases, queues, self-hosted services)', value: 'local' },
             ],
-            default: profiles[0],
-        },
-        {
-            type: 'input',
-            name: 'region',
-            message: 'AWS region:',
-            default: detectedRegion,
-        },
-        {
-            type: 'input',
-            name: 'endpoint',
-            message: 'LocalStack endpoint:',
-            default: 'http://localhost:4566',
-            when: (a) => a.awsProfile === '__localstack__',
         },
     ]);
+    // ── Step 2: AWS profile (aws only) ────────────────────────────────────────
+    let awsProfile = '__env__';
+    if (provider === 'aws') {
+        const answer = await inquirer.prompt([
+            {
+                type: 'select',
+                name: 'awsProfile',
+                message: 'AWS profile:',
+                choices: [
+                    { name: 'Environment variables  (CI/CD)', value: '__env__' },
+                    ...(profiles.length ? [new inquirer.Separator('── named profiles ──'), ...profiles] : []),
+                ],
+                default: profiles[0] ?? '__env__',
+            },
+        ]);
+        awsProfile = answer.awsProfile;
+    }
+    else if (provider === 'localstack') {
+        awsProfile = '__localstack__';
+    }
+    // ── Step 3: region + endpoint ─────────────────────────────────────────────
+    let region = detectedRegion;
+    let endpoint;
+    if (provider !== 'local') {
+        const regionAnswer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'region',
+                message: 'AWS region:',
+                default: detectedRegion,
+            },
+        ]);
+        region = regionAnswer.region;
+        if (provider === 'localstack') {
+            const endpointAnswer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'endpoint',
+                    message: 'LocalStack endpoint:',
+                    default: 'http://localhost:4566',
+                },
+            ]);
+            endpoint = endpointAnswer.endpoint;
+        }
+    }
+    const core = { project, awsProfile, region, endpoint };
     // ── Databases ──────────────────────────────────────────────────────────────
     console.log('\n  ' + chalk.bold('Databases'));
     console.log(chalk.dim('  Self-hosted databases (PostgreSQL, MySQL, MongoDB).'));
@@ -99,89 +132,108 @@ export async function runInit(options = {}) {
             when: (a) => a.mongoEnabled,
         },
     ]);
-    // ── AWS services ───────────────────────────────────────────────────────────
-    console.log('\n  ' + chalk.bold('AWS Services'));
-    console.log(chalk.dim('  Infrawise will introspect these services using the credentials configured above.'));
-    const services = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'dynamoEnabled',
-            message: 'Introspect DynamoDB?',
-            default: true,
-        },
-        {
-            type: 'input',
-            name: 'dynamoTables',
-            message: 'DynamoDB tables to include:',
-            default: '',
-            suffix: chalk.dim(' (comma-separated, blank = all)'),
-            when: (a) => a.dynamoEnabled,
-        },
-        {
-            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.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: 'eventbridgeEnabled',
-            message: 'Introspect EventBridge rules?',
-            default: true,
-        },
-        {
-            type: 'confirm',
-            name: 'rdsEnabled',
-            message: 'Introspect RDS instances?',
-            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.dim(' (comma-separated, blank = all)'),
-            when: (a) => a.logsEnabled,
-        },
-    ]);
+    // ── AWS services (skipped for local) ─────────────────────────────────────
+    let services;
+    if (provider === 'local') {
+        services = {
+            dynamoEnabled: false,
+            dynamoTables: '',
+            sqsEnabled: false,
+            snsEnabled: false,
+            ssmEnabled: false,
+            ssmPaths: '',
+            secretsEnabled: false,
+            lambdaEnabled: false,
+            eventbridgeEnabled: false,
+            rdsEnabled: false,
+            logsEnabled: false,
+            logGroupPrefixes: '',
+        };
+    }
+    else {
+        console.log('\n  ' + chalk.bold('AWS Services'));
+        console.log(chalk.dim('  Infrawise will introspect these services using the credentials configured above.'));
+        services = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'dynamoEnabled',
+                message: 'Introspect DynamoDB?',
+                default: true,
+            },
+            {
+                type: 'input',
+                name: 'dynamoTables',
+                message: 'DynamoDB tables to include:',
+                default: '',
+                suffix: chalk.dim(' (comma-separated, blank = all)'),
+                when: (a) => a.dynamoEnabled,
+            },
+            {
+                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.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: 'eventbridgeEnabled',
+                message: 'Introspect EventBridge rules?',
+                default: true,
+            },
+            {
+                type: 'confirm',
+                name: 'rdsEnabled',
+                message: 'Introspect RDS instances?',
+                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.dim(' (comma-separated, blank = all)'),
+                when: (a) => a.logsEnabled,
+            },
+        ]);
+    } // end else (provider !== 'local')
     // ── Build config ───────────────────────────────────────────────────────────
     const includeTables = services.dynamoTables
         ? services.dynamoTables
@@ -204,9 +256,13 @@ export async function runInit(options = {}) {
     const isLocalStack = core.awsProfile === '__localstack__';
     const isEnvVars = core.awsProfile === '__env__';
     const resolvedProfile = isLocalStack || isEnvVars ? '' : core.awsProfile;
-    const resolvedEndpoint = isLocalStack ? core.endpoint || 'http://localhost:4566' : undefined;
+    const resolvedEndpoint = isLocalStack ? (core.endpoint ?? 'http://localhost:4566') : undefined;
     const configContent = generateDefaultConfig(core.project, {
-        aws: { profile: resolvedProfile, region: core.region, endpoint: resolvedEndpoint },
+        aws: {
+            profile: resolvedProfile,
+            region: core.region ?? detectedRegion,
+            endpoint: resolvedEndpoint,
+        },
         dynamodb: { enabled: services.dynamoEnabled, includeTables },
         postgres: {
             enabled: databases.pgEnabled,
@@ -236,10 +292,11 @@ export async function runInit(options = {}) {
     fs.writeFileSync(configPath, configContent, 'utf-8');
     console.log('');
     log.success(`Created ${chalk.bold('infrawise.yaml')}`);
-    console.log('');
-    console.log(chalk.bold('  Next steps:'));
-    log.info(`Run ${chalk.cyan('infrawise doctor')} to validate your setup`);
-    log.info(`Run ${chalk.cyan('infrawise analyze')} to scan your infrastructure`);
-    log.info(`Run ${chalk.cyan('infrawise dev')} to start the MCP server`);
-    console.log('');
+    if (!options.quiet) {
+        console.log('');
+        console.log(chalk.bold('  Next steps:'));
+        log.info(`Run ${chalk.cyan('infrawise start')} to analyze and connect your editor`);
+        log.info(`Run ${chalk.cyan('infrawise doctor')} to validate your setup`);
+        console.log('');
+    }
 }

package/dist/cli/commands/start.js

@@ -0,0 +1,154 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+import { readCache, setCacheDir, formatError, loadConfig } from '../../core/index.js';
+import { log, printHeader } from '../utils.js';
+import { runInit } from './init.js';
+import { runAnalyze } from './analyze.js';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+function writeMcpJson(configAbsPath) {
+    const entry = {
+        mcpServers: {
+            infrawise: {
+                command: 'infrawise',
+                args: ['stdio', '--config', configAbsPath],
+            },
+        },
+    };
+    fs.writeFileSync('.mcp.json', JSON.stringify(entry, null, 2), 'utf-8');
+    log.success('MCP config written', '.mcp.json');
+}
+function writeCursorMcp(configAbsPath) {
+    const dir = '.cursor';
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const entry = {
+        mcpServers: {
+            infrawise: {
+                command: 'infrawise',
+                args: ['stdio', '--config', configAbsPath],
+            },
+        },
+    };
+    fs.writeFileSync(path.join(dir, 'mcp.json'), JSON.stringify(entry, null, 2), 'utf-8');
+    log.success('Cursor config written', '.cursor/mcp.json');
+}
+function writeWindsurfMcp(configAbsPath) {
+    const windsurfDir = path.join(process.env.HOME ?? '', '.codeium', 'windsurf');
+    if (!fs.existsSync(windsurfDir))
+        fs.mkdirSync(windsurfDir, { recursive: true });
+    const mcpConfigPath = path.join(windsurfDir, 'mcp_config.json');
+    let existing = {};
+    if (fs.existsSync(mcpConfigPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf-8'));
+        }
+        catch {
+            // corrupt file — overwrite cleanly
+        }
+    }
+    const servers = existing.mcpServers ?? {};
+    servers['infrawise'] = {
+        command: 'infrawise',
+        args: ['stdio', '--config', configAbsPath],
+    };
+    existing.mcpServers = servers;
+    fs.writeFileSync(mcpConfigPath, JSON.stringify(existing, null, 2), 'utf-8');
+    log.success('Windsurf config written', mcpConfigPath);
+}
+function launchEditor(editor) {
+    return new Promise((resolve) => {
+        if (editor === 'claude') {
+            console.log('');
+            console.log(chalk.dim('  Starting Claude Code...'));
+            console.log('');
+            const child = spawn('claude', [], { stdio: 'inherit' });
+            child.on('error', (err) => {
+                if (err.code === 'ENOENT') {
+                    console.error(chalk.red('\n  Error: claude CLI not found.'));
+                    console.error(chalk.dim('  Install it from https://claude.ai/code\n'));
+                }
+                resolve();
+            });
+            child.on('exit', () => resolve());
+        }
+        else {
+            const cmd = editor;
+            const args = ['.'];
+            console.log('');
+            console.log(chalk.dim(`  Opening ${editor === 'cursor' ? 'Cursor' : 'Windsurf'}...`));
+            const child = spawn(cmd, args, { detached: true, stdio: 'ignore' });
+            child.on('error', (err) => {
+                if (err.code === 'ENOENT') {
+                    console.error(chalk.red(`\n  Error: ${cmd} CLI not found. Open it manually.\n`));
+                }
+            });
+            child.unref();
+            resolve();
+        }
+    });
+}
+export async function runStart(options = {}) {
+    printHeader('Infrawise');
+    const cwd = process.cwd();
+    const configPath = options.config ?? 'infrawise.yaml';
+    const configAbsPath = path.resolve(cwd, configPath);
+    // Step 1 — create infrawise.yaml if missing
+    if (!fs.existsSync(configAbsPath)) {
+        log.warn('No infrawise.yaml found — running setup...');
+        console.log('');
+        await runInit({ quiet: true });
+        console.log('');
+    }
+    // Validate config is loadable before proceeding
+    try {
+        loadConfig(configPath);
+    }
+    catch (err) {
+        console.error(formatError(err));
+        process.exit(1);
+    }
+    setCacheDir(path.dirname(configAbsPath));
+    // Step 2 — check cache with 24h TTL, re-analyze if stale or missing
+    const cachedGraph = readCache('graph', CACHE_TTL_MS);
+    const cachedFindings = readCache('findings', CACHE_TTL_MS);
+    if (cachedGraph && cachedFindings) {
+        log.success('Analysis loaded from cache', `${cachedGraph.nodes.length} nodes · ${cachedGraph.edges.length} edges · ${cachedFindings.length} finding(s)`);
+    }
+    else {
+        const reason = (cachedGraph ?? cachedFindings) ? 'Cache is stale (>24h)' : 'No cache found';
+        log.warn(`${reason} — running analysis...`);
+        console.log('');
+        await runAnalyze({ config: options.config, silent: true });
+        console.log('');
+    }
+    // Step 3 — write editor MCP config files
+    console.log('');
+    writeMcpJson(configAbsPath);
+    if (options.cursor)
+        writeCursorMcp(configAbsPath);
+    if (options.windsurf)
+        writeWindsurfMcp(configAbsPath);
+    // Step 4 — launch editor or print instructions
+    const editor = options.claude
+        ? 'claude'
+        : options.cursor
+            ? 'cursor'
+            : options.windsurf
+                ? 'windsurf'
+                : null;
+    if (!editor) {
+        console.log('');
+        console.log(chalk.bold('  Setup complete — open your editor to start.'));
+        console.log('');
+        console.log(chalk.dim('  Claude Code:  claude'));
+        console.log(chalk.dim('  Cursor:       cursor .'));
+        console.log(chalk.dim('  Windsurf:     windsurf .'));
+        console.log('');
+        console.log(chalk.dim('  Next time just open your editor — no infrawise command needed.'));
+        console.log('');
+        return;
+    }
+    await launchEditor(editor);
+}

package/dist/cli/commands/stdio.js

@@ -1,7 +1,10 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { loadConfig, formatError, readCache } from '../../core/index.js';
+import { loadConfig, formatError, readCache, setCacheDir } from '../../core/index.js';
 import { createMcpServer, setGraphState } from '../../server/index.js';
-import { runAnalyze } from './analyze.js';
+import { runAnalyze, runCodeRefresh } from './analyze.js';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 export async function runStdio(configPath) {
     let config;
     try {
@@ -11,17 +14,60 @@ export async function runStdio(configPath) {
         process.stderr.write(formatError(err) + '\n');
         process.exit(1);
     }
-    const cachedGraph = readCache('graph');
-    const cachedFindings = readCache('findings');
+    const resolvedConfigPath = configPath ?? 'infrawise.yaml';
+    setCacheDir(path.dirname(path.resolve(resolvedConfigPath)));
+    const cachedGraph = readCache('graph', CACHE_TTL_MS);
+    const cachedFindings = readCache('findings', CACHE_TTL_MS);
     if (cachedGraph && cachedFindings) {
         setGraphState(cachedGraph, cachedFindings, config);
     }
     else {
         await runAnalyze({ config: configPath });
-        const graph = readCache('graph') ?? { nodes: [], edges: [] };
-        const findings = readCache('findings') ?? [];
+        const graph = readCache('graph', CACHE_TTL_MS) ?? { nodes: [], edges: [] };
+        const findings = readCache('findings', CACHE_TTL_MS) ?? [];
         setGraphState(graph, findings, config);
     }
+    // File watching — re-run code analysis on save (no AWS calls, instant)
+    // stderr is safe in stdio transport; stdout is reserved for MCP JSON-RPC
+    const repoPath = process.cwd();
+    const configFile = path.resolve(resolvedConfigPath);
+    let debounceTimer = null;
+    let refreshing = false;
+    try {
+        fs.watch(repoPath, { recursive: true }, (_, filename) => {
+            if (!filename)
+                return;
+            const abs = path.join(repoPath, filename);
+            if (abs === configFile)
+                return;
+            const ext = path.extname(filename);
+            if (!['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext))
+                return;
+            if (filename.includes('node_modules') || filename.startsWith('.infrawise'))
+                return;
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(async () => {
+                if (refreshing)
+                    return;
+                refreshing = true;
+                try {
+                    const { graph, findings } = await runCodeRefresh(repoPath, config);
+                    setGraphState(graph, findings, config);
+                    process.stderr.write(`infrawise: code graph refreshed (${graph.nodes.length} nodes · ${findings.length} finding(s))\n`);
+                }
+                catch {
+                    // don't break the MCP connection on watcher errors
+                }
+                finally {
+                    refreshing = false;
+                }
+            }, 2000);
+        });
+    }
+    catch {
+        // fs.watch recursive not supported on all platforms — silently skip
+    }
     const mcp = createMcpServer();
     const transport = new StdioServerTransport();
     await mcp.connect(transport);

package/dist/cli/index.js

@@ -9,15 +9,32 @@ import { runAnalyze } from './commands/analyze.js';
 import { runDev } from './commands/dev.js';
 import { runDoctor } from './commands/doctor.js';
 import { runStdio } from './commands/stdio.js';
+import { runStart } from './commands/start.js';
 const { version } = JSON.parse(readFileSync(join(import.meta.dirname, '../../package.json'), 'utf8'));
 const program = new Command();
 program
     .name('infrawise')
     .description('CLI-first infrastructure intelligence platform — analyze your databases, AWS services, and IaC')
     .version(version);
+program
+    .command('start')
+    .description('Set up infrawise and connect your editor — runs init + analyze + writes editor MCP config')
+    .option('-c, --config <path>', 'Path to infrawise.yaml', 'infrawise.yaml')
+    .option('--claude', 'Write .mcp.json and open Claude Code')
+    .option('--cursor', 'Write .cursor/mcp.json and open Cursor')
+    .option('--windsurf', 'Write Windsurf MCP config and open Windsurf')
+    .action(async (options) => {
+    printBanner();
+    await runStart({
+        config: options.config !== 'infrawise.yaml' ? options.config : undefined,
+        claude: options.claude,
+        cursor: options.cursor,
+        windsurf: options.windsurf,
+    });
+});
 program
     .command('init')
-    .description('Detect AWS profile/region, discover DynamoDB tables, and generate infrawise.yaml')
+    .description('Detect AWS profile/region, ask setup questions, and generate infrawise.yaml')
     .option('--force', 'Overwrite existing infrawise.yaml')
     .action(async (options) => {
     printBanner();
@@ -50,7 +67,7 @@ program
 });
 program
     .command('dev')
-    .description('Start Fastify MCP server on localhost:3000')
+    .description('Start MCP server over HTTP at localhost:3000 (alternative to stdio-based start)')
     .option('-c, --config <path>', 'Path to infrawise.yaml', 'infrawise.yaml')
     .option('-p, --port <number>', 'Port to listen on', '3000')
     .action(async (options) => {
@@ -62,7 +79,7 @@ program
 });
 program
     .command('stdio')
-    .description('Start MCP server on stdio transport (for Claude Desktop and Glama)')
+    .description('Start MCP server on stdio transport — used by editors via .mcp.json (auto-managed)')
     .option('-c, --config <path>', 'Path to infrawise.yaml', 'infrawise.yaml')
     .action(async (options) => {
     await runStdio(options.config !== 'infrawise.yaml' ? options.config : undefined);

package/package.json

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