@build-astron-co/nimbus 0.4.1 → 0.4.3

package/dist/src/commands/aws-terraform.js

@@ -247,18 +247,24 @@ async function generateStep(ctx) {
         // Derive components from discovered resources
         const resourceTypes = (ctx.resources ?? []).map(r => r.type);
         const components = [];
-        if (resourceTypes.some(t => t.includes('VPC') || t.includes('Subnet')))
+        if (resourceTypes.some(t => t.includes('VPC') || t.includes('Subnet'))) {
             components.push('vpc');
-        if (resourceTypes.some(t => t.includes('EC2') || t.includes('Instance')))
+        }
+        if (resourceTypes.some(t => t.includes('EC2') || t.includes('Instance'))) {
             components.push('ec2');
-        if (resourceTypes.some(t => t.includes('S3')))
+        }
+        if (resourceTypes.some(t => t.includes('S3'))) {
             components.push('s3');
-        if (resourceTypes.some(t => t.includes('RDS')))
+        }
+        if (resourceTypes.some(t => t.includes('RDS'))) {
             components.push('rds');
-        if (resourceTypes.some(t => t.includes('EKS')))
+        }
+        if (resourceTypes.some(t => t.includes('EKS'))) {
             components.push('eks');
-        if (components.length === 0)
+        }
+        if (components.length === 0) {
             components.push('vpc', 's3');
+        }
         const generatedProject = await generateTerraformProject({
             projectName: 'infrastructure',
             provider: 'aws',
@@ -279,12 +285,15 @@ async function generateStep(ctx) {
         };
         ui.stopSpinnerSuccess(`Generated ${Object.keys(fileMap).length} file(s)`);
         // Add starter kit files if requested
-        if (ctx.includeReadme)
+        if (ctx.includeReadme) {
             fileMap['README.md'] = generateReadme(summary);
-        if (ctx.includeGitignore)
+        }
+        if (ctx.includeGitignore) {
             fileMap['.gitignore'] = generateGitignore();
-        if (ctx.includeMakefile)
+        }
+        if (ctx.includeMakefile) {
             fileMap['Makefile'] = generateMakefile();
+        }
         return {
             success: true,
             data: {
@@ -557,18 +566,24 @@ async function runNonInteractive(options) {
     try {
         const resourceTypes = (resources ?? []).map(r => r.type);
         const components = [];
-        if (resourceTypes.some(t => t.includes('VPC') || t.includes('Subnet')))
+        if (resourceTypes.some(t => t.includes('VPC') || t.includes('Subnet'))) {
             components.push('vpc');
-        if (resourceTypes.some(t => t.includes('EC2') || t.includes('Instance')))
+        }
+        if (resourceTypes.some(t => t.includes('EC2') || t.includes('Instance'))) {
             components.push('ec2');
-        if (resourceTypes.some(t => t.includes('S3')))
+        }
+        if (resourceTypes.some(t => t.includes('S3'))) {
             components.push('s3');
-        if (resourceTypes.some(t => t.includes('RDS')))
+        }
+        if (resourceTypes.some(t => t.includes('RDS'))) {
             components.push('rds');
-        if (resourceTypes.some(t => t.includes('EKS')))
+        }
+        if (resourceTypes.some(t => t.includes('EKS'))) {
             components.push('eks');
-        if (components.length === 0)
+        }
+        if (components.length === 0) {
             components.push('vpc', 's3');
+        }
         const generatedProject = await generateTerraformProject({
             projectName: 'infrastructure',
             provider: 'aws',
@@ -594,12 +609,15 @@ async function runNonInteractive(options) {
         if (!fs.existsSync(outputPath)) {
             fs.mkdirSync(outputPath, { recursive: true });
         }
-        if (options.includeStarterKit || options.includeReadme)
+        if (options.includeStarterKit || options.includeReadme) {
             files['README.md'] = generateReadme(summary);
-        if (options.includeStarterKit || options.includeGitignore)
+        }
+        if (options.includeStarterKit || options.includeGitignore) {
             files['.gitignore'] = generateGitignore();
-        if (options.includeStarterKit || options.includeMakefile)
+        }
+        if (options.includeStarterKit || options.includeMakefile) {
             files['Makefile'] = generateMakefile();
+        }
         for (const [fileName, content] of Object.entries(files)) {
             const filePath = path.join(outputPath, fileName);
             await writeFile(filePath, content, 'utf-8');

package/dist/src/commands/completions.js

@@ -83,7 +83,7 @@ export function dynamicComplete(prevWord, _currWord) {
         suggestions = getHelmReleases();
     }
     if (suggestions.length > 0) {
-        process.stdout.write(suggestions.join('\n') + '\n');
+        process.stdout.write(`${suggestions.join('\n')}\n`);
     }
 }
 const FLAGS = [

package/dist/src/commands/config.js

@@ -91,12 +91,13 @@ export async function configSetCommand(options) {
         ];
         if (!knownModels.includes(value)) {
             ui.warning(`"${value}" is not a recognized Nimbus model ID.`);
-            ui.info('Known models: ' + knownModels.slice(0, 6).join(', '));
+            ui.info(`Known models: ${knownModels.slice(0, 6).join(', ')}`);
             if (!options.nonInteractive) {
                 const { confirm: confirmPrompt } = await import('../wizard/prompts');
                 const proceed = await confirmPrompt({ message: 'Set this model anyway?', defaultValue: false });
-                if (!proceed)
+                if (!proceed) {
                     return;
+                }
             }
         }
     }

package/dist/src/commands/connect-github.js

@@ -0,0 +1,92 @@
+/**
+ * Connect GitHub Command
+ *
+ * Runs the GitHub Device Flow OAuth independently of the main login wizard.
+ * This allows users to link their GitHub identity at any time without
+ * reconfiguring their LLM provider.
+ *
+ * Usage: nimbus connect github
+ */
+import { ui } from '../wizard';
+import { authStore, GitHubDeviceFlow, completeGitHubAuth, } from '../auth';
+/**
+ * Run the GitHub Device Flow and save the identity to authStore on success.
+ * Exits cleanly on failure without asking the user to continue — callers can
+ * retry by running `nimbus connect github` again.
+ */
+export async function connectGitHubCommand() {
+    ui.newLine();
+    ui.section('Connect GitHub Identity');
+    // Check if already authenticated
+    const existing = authStore.getIdentity();
+    if (existing) {
+        ui.info(`Already connected as: ${existing.username}`);
+        const { confirm } = await import('../wizard');
+        const reauth = await confirm({
+            message: 'Reconnect with a different GitHub account?',
+            defaultValue: false,
+        });
+        if (!reauth) {
+            return true;
+        }
+    }
+    ui.newLine();
+    ui.info('Starting GitHub Device Flow authentication...');
+    ui.newLine();
+    try {
+        const deviceFlow = new GitHubDeviceFlow();
+        // Request device code
+        ui.startSpinner({ message: 'Requesting authorization code...' });
+        const deviceCode = await deviceFlow.requestDeviceCode();
+        ui.stopSpinnerSuccess('Authorization code received');
+        // Display the code for the user to enter in their browser
+        ui.newLine();
+        ui.box({
+            title: 'GitHub Authorization',
+            content: [
+                `Open ${deviceCode.verification_uri} in your browser`,
+                'and enter this code:',
+                '',
+                `    ${deviceCode.user_code}`,
+                '',
+                'Waiting for authorization...',
+            ],
+            style: 'rounded',
+            borderColor: 'yellow',
+            padding: 1,
+        });
+        ui.newLine();
+        // Poll for the access token
+        ui.startSpinner({ message: 'Waiting for authorization...' });
+        const accessToken = await deviceFlow.waitForAuthorization(() => {
+            // Called on each poll — no-op here
+        });
+        ui.stopSpinnerSuccess('Authorization successful');
+        // Fetch the user profile
+        ui.startSpinner({ message: 'Fetching user profile...' });
+        const identity = await completeGitHubAuth(accessToken);
+        ui.stopSpinnerSuccess(`Connected as ${identity.username}${identity.name ? ` (${identity.name})` : ''}`);
+        // Persist the identity
+        authStore.setIdentity(identity);
+        ui.newLine();
+        ui.success('GitHub identity linked successfully.');
+        ui.newLine();
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ui.stopSpinnerFail(`GitHub authentication failed: ${message}`);
+        ui.newLine();
+        ui.error(`Could not complete GitHub Device Flow: ${message}`);
+        ui.print('');
+        ui.print('Possible causes:');
+        ui.print('  • The OAuth app may not have Device Flow enabled.');
+        ui.print('    Visit github.com/settings/developers to check your OAuth App settings.');
+        ui.print('  • The authorization timed out (codes expire after ~15 minutes).');
+        ui.print('');
+        ui.print('Run `nimbus connect github` again to retry.');
+        ui.newLine();
+        return false;
+    }
+}
+export default connectGitHubCommand;

package/dist/src/commands/cost/index.js

@@ -92,7 +92,7 @@ function runInfracostBreakdown(directory) {
         });
         return JSON.parse(result);
     }
-    catch (error) {
+    catch (_error) {
         return null;
     }
 }
@@ -523,8 +523,9 @@ export async function costDiffCommand(path1, path2, opts = {}) {
         ui.newLine();
         // Per-project breakdown
         for (const project of data.projects ?? []) {
-            if ((project.diffTotalMonthlyCost ?? 0) === 0)
+            if ((project.diffTotalMonthlyCost ?? 0) === 0) {
                 continue;
+            }
             ui.print(`  ${ui.bold(project.name)}: ${formatChange(project.diffTotalMonthlyCost, data.currency)}/mo`);
             for (const resource of (project.resources ?? []).slice(0, 10)) {
                 ui.print(`    ${resource.name.slice(0, 50).padEnd(50)} ${formatCurrency(resource.monthlyCost, data.currency)}/mo`);

package/dist/src/commands/deploy.js

@@ -114,10 +114,12 @@ export async function deployCommand(args) {
     else {
         const planResult = run('terraform', ['plan', '-out=nimbus-deploy.tfplan', '-no-color'], { cwd });
         // Always print plan output so the user can review it
-        if (planResult.stdout)
-            process.stdout.write(planResult.stdout + '\n');
-        if (planResult.stderr)
-            process.stderr.write(planResult.stderr + '\n');
+        if (planResult.stdout) {
+            process.stdout.write(`${planResult.stdout}\n`);
+        }
+        if (planResult.stderr) {
+            process.stderr.write(`${planResult.stderr}\n`);
+        }
         if (planResult.status !== 0) {
             fail('terraform plan failed. Fix the errors above before deploying.');
             process.exit(1);
@@ -149,10 +151,12 @@ export async function deployCommand(args) {
         // ------------------------------------------------------------------
         banner(String(step++), totalSteps, 'Applying infrastructure changes...');
         const applyResult = run('terraform', ['apply', '-auto-approve', '-no-color', 'nimbus-deploy.tfplan'], { cwd });
-        if (applyResult.stdout)
-            process.stdout.write(applyResult.stdout + '\n');
-        if (applyResult.stderr)
-            process.stderr.write(applyResult.stderr + '\n');
+        if (applyResult.stdout) {
+            process.stdout.write(`${applyResult.stdout}\n`);
+        }
+        if (applyResult.stderr) {
+            process.stderr.write(`${applyResult.stderr}\n`);
+        }
         // Clean up plan file regardless of success/failure
         try {
             const { unlinkSync } = await import('node:fs');
@@ -188,8 +192,9 @@ export async function deployCommand(args) {
             for (const deployment of deployments) {
                 // deployment looks like "deployment.apps/my-app"
                 const rolloutResult = run('kubectl', ['rollout', 'status', deployment, '--timeout=120s', ...nsArgs], { cwd });
-                if (rolloutResult.stdout)
-                    process.stdout.write(rolloutResult.stdout + '\n');
+                if (rolloutResult.stdout) {
+                    process.stdout.write(`${rolloutResult.stdout}\n`);
+                }
                 if (rolloutResult.status !== 0) {
                     warn(`Rollout timeout or error for ${deployment}: ${rolloutResult.stderr.trim()}`);
                     warn('Pods may still be coming up. Check with: kubectl get pods');

package/dist/src/commands/doctor.js

@@ -74,7 +74,7 @@ async function checkLLMProvider(options) {
         }
     }
     // Check credentials file
-    const credentialsFile = path.join(os.homedir(), '.nimbus', 'credentials.json');
+    const credentialsFile = path.join(os.homedir(), '.nimbus', 'auth.json');
     let hasStoredCredentials = false;
     try {
         await fs.access(credentialsFile);
@@ -342,7 +342,7 @@ async function checkCoreServices(options) {
         });
     }
     // Check LLM credentials
-    const credFile = path.join(os.homedir(), '.nimbus', 'credentials.json');
+    const credFile = path.join(os.homedir(), '.nimbus', 'auth.json');
     let llmStatus = 'not configured';
     let llmDetails;
     try {
@@ -419,8 +419,9 @@ async function checkToolServices(options) {
             }
             catch {
                 const match = output.match(/[\d]+\.[\d]+\.[\d]+/);
-                if (match)
+                if (match) {
                     version = match[0];
+                }
             }
             results.push({ name: tool.name, version, available: true });
         }
@@ -906,8 +907,9 @@ async function checkKubeConfig() {
     try {
         const { stdout: ctx } = await execAsync2('kubectl config current-context', { timeout: 5_000 });
         const context = ctx.trim();
-        if (!context)
+        if (!context) {
             return { name: 'Kubernetes Reachability', passed: true, message: 'kubectl: no active context' };
+        }
         try {
             await execAsync2('kubectl cluster-info --request-timeout=3s', { timeout: 8_000 });
             try {
@@ -1103,7 +1105,7 @@ export async function runStartupChecks() {
             const { join } = await import('node:path');
             const { homedir } = await import('node:os');
             const { readFileSync, existsSync } = await import('node:fs');
-            const credsFile = join(homedir(), '.nimbus', 'credentials.json');
+            const credsFile = join(homedir(), '.nimbus', 'auth.json');
             if (existsSync(credsFile)) {
                 const creds = JSON.parse(readFileSync(credsFile, 'utf-8'));
                 if (Object.keys(creds.providers ?? {}).length === 0) {
@@ -1245,8 +1247,9 @@ export async function doctorCommand(options = {}) {
                 details: r.details,
             })),
         }, null, 2));
-        if (!allPassed)
+        if (!allPassed) {
             process.exit(1);
+        }
         return;
     }
     // Summary

package/dist/src/commands/drift/index.js

@@ -305,8 +305,9 @@ export async function driftScanCommand(opts = {}) {
     // Find terraform directories up to depth 3
     const tfDirs = [];
     function walk(dir, depth) {
-        if (depth > 3)
+        if (depth > 3) {
             return;
+        }
         try {
             if (fsSync.existsSync(pathMod.join(dir, '.terraform')) || fsSync.readdirSync(dir).some(f => f.endsWith('.tf'))) {
                 tfDirs.push(dir);

package/dist/src/commands/export.js

@@ -31,7 +31,7 @@ export async function exportCommand(options = {}) {
         const sm = SessionManager.getInstance();
         const sessions = sm.list();
         // Find the target session
-        let targetSession = sessions.find(s => options.sessionId && (s.id === options.sessionId || s.id.startsWith(options.sessionId))) ?? sessions[0];
+        const targetSession = sessions.find(s => options.sessionId && (s.id === options.sessionId || s.id.startsWith(options.sessionId))) ?? sessions[0];
         if (!targetSession) {
             console.error('No sessions found. Run "nimbus chat" first to create a session.');
             process.exit(1);
@@ -50,10 +50,12 @@ export async function exportCommand(options = {}) {
             role: m.role,
             content: Array.isArray(m.content)
                 ? m.content.map((b) => {
-                    if (typeof b === 'string')
+                    if (typeof b === 'string') {
                         return b;
-                    if (b && typeof b === 'object' && 'text' in b)
+                    }
+                    if (b && typeof b === 'object' && 'text' in b) {
                         return b.text;
+                    }
                     return '';
                 }).join('')
                 : String(m.content ?? ''),

package/dist/src/commands/generate-terraform.js

@@ -6,6 +6,9 @@
  * Usage: nimbus generate terraform [options]
  */
 import { logger } from '../utils';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
 import { createWizard, ui, select, multiSelect, confirm, input, pathInput, } from '../wizard';
 import { generateTerraformProject } from '../generator/terraform';
 // ---- Cloud CLI helpers (replace microservice REST calls) ----
@@ -58,6 +61,65 @@ function validateAzureSubscription(subscriptionId) {
         return { valid: false, error: e.message?.slice(0, 100) };
     }
 }
+// ---------------------------------------------------------------------------
+// Cloud provider auto-detection helpers
+// ---------------------------------------------------------------------------
+/**
+ * Detect cloud providers from environment variables and credential files.
+ * Returns a list of detected provider names (aws | gcp | azure).
+ */
+async function detectCloudProviders() {
+    const detected = [];
+    // AWS
+    if (process.env.AWS_ACCESS_KEY_ID ||
+        process.env.AWS_PROFILE ||
+        fs.existsSync(path.join(os.homedir(), '.aws', 'credentials'))) {
+        detected.push('aws');
+    }
+    // GCP
+    if (process.env.GOOGLE_APPLICATION_CREDENTIALS ||
+        process.env.GCLOUD_PROJECT ||
+        fs.existsSync(path.join(os.homedir(), '.config', 'gcloud', 'application_default_credentials.json'))) {
+        detected.push('gcp');
+    }
+    // Azure
+    if (process.env.AZURE_SUBSCRIPTION_ID ||
+        process.env.ARM_CLIENT_ID ||
+        fs.existsSync(path.join(os.homedir(), '.azure', 'accessTokens.json'))) {
+        detected.push('azure');
+    }
+    return detected;
+}
+/**
+ * Scan .tf files in the current directory for provider declarations.
+ * Looks for: provider "google" {, provider "aws" {, provider "azurerm" {
+ */
+function scanTfFilesForProviders() {
+    const detected = new Set();
+    try {
+        const tfFiles = fs
+            .readdirSync(process.cwd(), { recursive: true, withFileTypes: true })
+            .filter(e => e.isFile() && e.name.endsWith('.tf'))
+            .map(e => path.join(e.parentPath ?? e.path ?? process.cwd(), e.name));
+        for (const file of tfFiles.slice(0, 50)) {
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                if (/provider\s+["']aws["']/i.test(content)) {
+                    detected.add('aws');
+                }
+                if (/provider\s+["']google["']/i.test(content)) {
+                    detected.add('gcp');
+                }
+                if (/provider\s+["']azurerm["']/i.test(content)) {
+                    detected.add('azure');
+                }
+            }
+            catch { /* skip unreadable files */ }
+        }
+    }
+    catch { /* non-critical */ }
+    return [...detected];
+}
 /**
  * Run the generate terraform command
  */
@@ -82,17 +144,38 @@ export async function generateTerraformCommand(options = {}) {
         await runConversational(options);
         return;
     }
+    // Auto-detect cloud provider from environment + local .tf files
+    let autoDetectedProvider = options.provider;
+    if (!autoDetectedProvider) {
+        const [envDetected, tfDetected] = await Promise.all([
+            detectCloudProviders(),
+            Promise.resolve(scanTfFilesForProviders()),
+        ]);
+        // Merge and deduplicate (tf file declarations take priority)
+        const allDetected = [...new Set([...tfDetected, ...envDetected])];
+        if (allDetected.length === 1) {
+            autoDetectedProvider = allDetected[0];
+            ui.info(`Detected: ${autoDetectedProvider} from environment — continuing...`);
+        }
+        else if (allDetected.length > 1) {
+            // Show list with detected ones pre-marked; user selects one
+            ui.info(`Detected multiple providers: ${allDetected.join(', ')}`);
+            // Will fall through to the wizard's provider selection step with a pre-populated default
+            autoDetectedProvider = allDetected[0];
+        }
+    }
     // Interactive wizard mode
     const steps = createWizardSteps();
     const wizard = createWizard({
         title: 'nimbus generate terraform',
         description: 'Generate Terraform from your cloud infrastructure',
         initialContext: {
-            provider: 'aws',
+            provider: autoDetectedProvider ?? 'aws',
             awsProfile: options.profile,
             awsRegions: options.regions,
             servicesToScan: options.services,
             outputPath: options.output,
+            yes: options.yes,
         },
         steps,
         onEvent: event => {
@@ -234,6 +317,11 @@ function createWizardSteps() {
  * Step 1: Provider Selection
  */
 async function providerSelectionStep(ctx) {
+    // --yes: accept the detected/default provider without prompting
+    if (ctx.yes && ctx.provider) {
+        ui.info(`Provider: ${ctx.provider} (--yes)`);
+        return { success: true, data: { provider: ctx.provider } };
+    }
     const provider = await select({
         message: 'Select cloud provider:',
         options: [
@@ -708,7 +796,21 @@ async function discoveryStep(ctx) {
 /**
  * Step 5: Generation Options
  */
-async function generationOptionsStep(_ctx) {
+async function generationOptionsStep(ctx) {
+    // --yes: use defaults without prompting
+    if (ctx.yes) {
+        ui.info('Generation options: defaults accepted (--yes)');
+        return {
+            success: true,
+            data: {
+                importMethod: 'both',
+                includeReadme: true,
+                includeGitignore: true,
+                includeMakefile: true,
+                includeGithubActions: true,
+            },
+        };
+    }
     // Import method
     const importMethod = await select({
         message: 'How should imports be generated?',
@@ -752,6 +854,12 @@ async function generationOptionsStep(_ctx) {
  * Step 6: Output Location
  */
 async function outputLocationStep(ctx) {
+    // --yes: accept the default output path without prompting
+    if (ctx.yes) {
+        const outputPath = ctx.outputPath || './terraform-infrastructure';
+        ui.info(`Output path: ${outputPath} (--yes)`);
+        return { success: true, data: { outputPath, savePreferences: false } };
+    }
     const outputPath = await pathInput('Where should the Terraform files be saved?', ctx.outputPath || './terraform-infrastructure');
     if (!outputPath) {
         return { success: false, error: 'Output path is required' };

package/dist/src/commands/import.js

@@ -267,7 +267,7 @@ function discoverAwsResources(resourceType, region) {
             }
         }
     }
-    catch (error) {
+    catch (_error) {
         // AWS CLI not available or not authenticated
     }
     return resources;
@@ -348,7 +348,7 @@ function discoverGcpResources(resourceType, project) {
             }
         }
     }
-    catch (error) {
+    catch (_error) {
         // gcloud CLI not available or not authenticated
     }
     return resources;
@@ -427,7 +427,7 @@ function discoverAzureResources(resourceType, subscription) {
             }
         }
     }
-    catch (error) {
+    catch (_error) {
         // az CLI not available or not authenticated
     }
     return resources;

package/dist/src/commands/incident.js

@@ -29,8 +29,9 @@ function parseIncidentInput(input) {
  */
 async function fetchPagerDutyDetails(incidentId) {
     const token = process.env.PD_API_TOKEN;
-    if (!token)
+    if (!token) {
         return null;
+    }
     try {
         const curlCmd = `curl -sf -H "Authorization: Token token=${token}" -H "Accept: application/vnd.pagerduty+json;version=2" "https://api.pagerduty.com/incidents/${incidentId}"`;
         const output = execSync(curlCmd, { encoding: 'utf-8', timeout: 10_000 });
@@ -68,8 +69,9 @@ function getRecentHelmHistory(serviceName) {
             encoding: 'utf-8', timeout: 10_000,
         });
         const history = JSON.parse(out);
-        if (history.length === 0)
+        if (history.length === 0) {
             return '';
+        }
         const lines = history.map(h => `  Rev ${h.revision}: ${h.chart} [${h.status}] ${h.updated} — ${h.description}`);
         return `\nRecent Helm releases for ${serviceName}:\n${lines.join('\n')}`;
     }
@@ -83,8 +85,9 @@ function getRecentHelmHistory(serviceName) {
 function getRecentPodLogs(serviceName) {
     try {
         const out = execSync(`kubectl logs -l app=${serviceName} --tail=50 --since=30m --all-containers 2>/dev/null | head -c 4096`, { encoding: 'utf-8', timeout: 15_000 });
-        if (!out.trim())
+        if (!out.trim()) {
             return '';
+        }
         return `\nRecent pod logs (last 30m, ${serviceName}):\n${out.trim()}`;
     }
     catch {
@@ -130,11 +133,13 @@ export async function incidentCommand(incidentInput, options = {}) {
     if (serviceName) {
         contextParts.push(`\n## Detected Service: ${serviceName}`);
         const helmHistory = getRecentHelmHistory(serviceName);
-        if (helmHistory)
+        if (helmHistory) {
             contextParts.push(helmHistory);
+        }
         const podLogs = getRecentPodLogs(serviceName);
-        if (podLogs)
+        if (podLogs) {
             contextParts.push(podLogs);
+        }
     }
     contextParts.push('\n## Your Task\nHelp resolve this incident. Start by diagnosing root cause from the context above, then suggest and (with permission) execute remediation steps.');
     const initialPrompt = contextParts.join('\n');