ft-scout 3.0.6 → 3.0.7

package/bin/src/commands/agent.js

@@ -1,9 +1,9 @@
 import fs from 'fs';
 import path from 'path';
-import { spinner, text, isCancel, select } from '@clack/prompts';
+import { spinner, text, isCancel, select, confirm } from '@clack/prompts';
 import chalk from 'chalk';
 import { simpleGit } from 'simple-git';
-import { generateMultiCodeFix, identifyTargetFiles, analyzeCommandError } from '../engine/llm.js';
+import { generateMultiCodeFix, identifyTargetFiles, analyzeCommandError, generateCodeScanReport, generateFeaturePlan, generateCodeFile, askRepoQuestion, } from '../engine/llm.js';
 import { loadContext, recordHistoryAction, getDirectoryFiles } from '../utils/config.js';
 import { renderMarkdown, safeNote } from '../utils/markdown.js';
 import { normalizeLanguage } from '../utils/language.js';
@@ -12,136 +12,575 @@ import { handleUndo } from './undo.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 const execAsync = promisify(exec);
+const FT_DIR = path.join(process.cwd(), '.ft');
+const SCAN_CACHE = path.join(FT_DIR, 'scan-report.json');
+export function saveScanReport(issues) {
+    if (fs.existsSync(FT_DIR)) {
+        fs.writeFileSync(SCAN_CACHE, JSON.stringify(issues, null, 2));
+    }
+}
+export function loadScanReport() {
+    if (!fs.existsSync(SCAN_CACHE))
+        return [];
+    try {
+        return JSON.parse(fs.readFileSync(SCAN_CACHE, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+export function findTargetFilesFromPrompt(userPrompt, specifiedFile, filesList) {
+    const norm = (p) => p.replace(/\\/g, '/').toLowerCase().trim();
+    if (specifiedFile && specifiedFile.trim()) {
+        const raw = specifiedFile.trim();
+        const splitItems = raw.split(',').map((s) => s.trim()).filter(Boolean);
+        const matchedFromFlag = [];
+        for (const item of splitItems) {
+            const normItem = norm(item);
+            const isExplicitExtPattern = item.startsWith('*') ||
+                item.startsWith('.') ||
+                (item.length <= 10 && !item.includes('/') && !item.includes('\\') && !filesList.some((f) => norm(f) === normItem || path.basename(norm(f)) === normItem));
+            if (isExplicitExtPattern) {
+                const cleanExt = normItem.replace(/^(\*|\.)+/, '');
+                if (cleanExt) {
+                    const extFiles = filesList.filter((f) => norm(f).endsWith(`.${cleanExt}`));
+                    matchedFromFlag.push(...extFiles);
+                }
+                continue;
+            }
+            const exact = filesList.find((f) => norm(f) === normItem);
+            if (exact) {
+                matchedFromFlag.push(exact);
+                continue;
+            }
+            const suffixMatches = filesList.filter((f) => norm(f).endsWith('/' + normItem));
+            if (suffixMatches.length > 0) {
+                matchedFromFlag.push(...suffixMatches);
+                continue;
+            }
+            const baseMatches = filesList.filter((f) => path.basename(norm(f)) === path.basename(normItem));
+            if (baseMatches.length > 0) {
+                matchedFromFlag.push(...baseMatches);
+                continue;
+            }
+            matchedFromFlag.push(item);
+        }
+        if (matchedFromFlag.length > 0) {
+            return Array.from(new Set(matchedFromFlag));
+        }
+    }
+    const rawWords = userPrompt.split(/\s+/).map((w) => w.replace(/["'(),;:!]/g, '').trim());
+    const cleanPromptWords = rawWords.map((w) => w.toLowerCase());
+    const lowerPrompt = userPrompt.toLowerCase();
+    const matchedByName = [];
+    for (const word of rawWords) {
+        if (word && word.includes('.')) {
+            const fullP = path.resolve(process.cwd(), word);
+            if (fs.existsSync(fullP) && fs.statSync(fullP).isFile()) {
+                const relP = path.relative(process.cwd(), fullP).replace(/\\/g, '/');
+                matchedByName.push(relP);
+            }
+        }
+    }
+    for (const f of filesList) {
+        const normF = norm(f);
+        const base = path.basename(normF);
+        if (lowerPrompt.includes(normF) ||
+            cleanPromptWords.includes(normF) ||
+            (base.includes('.') && (lowerPrompt.includes(base) || cleanPromptWords.includes(base)))) {
+            matchedByName.push(f);
+        }
+    }
+    if (matchedByName.length > 0) {
+        return Array.from(new Set(matchedByName));
+    }
+    const bulkExtMatch = lowerPrompt.match(/(?:all|\*|in|from|for|across|every)?\s*(?:\*|\.)?([a-zA-Z0-9]{1,10})\s+files?\b|\*\.([a-zA-Z0-9]{1,10})/i);
+    if (bulkExtMatch) {
+        const ext = (bulkExtMatch[1] || bulkExtMatch[2])?.toLowerCase();
+        if (ext) {
+            const extFiles = filesList.filter((f) => norm(f).endsWith(`.${ext}`));
+            if (extFiles.length > 0) {
+                return Array.from(new Set(extFiles));
+            }
+        }
+    }
+    return [];
+}
 export async function handleAgent(goalInput, options) {
     const existingContext = loadContext();
     const targetLang = normalizeLanguage(options?.lang) || normalizeLanguage(existingContext?.language);
     const cwd = process.cwd();
     const filesList = getDirectoryFiles(cwd);
     const projectName = existingContext?.projectName || path.basename(cwd) || 'Codebase';
-    let finalGoal = goalInput || options?.goal;
-    if (!finalGoal || !finalGoal.trim()) {
-        const userGoalInput = await text({
-            message: chalk.bold('What high-level goal or task should Scout autonomously solve?'),
-            placeholder: 'e.g. Add validation for email input and ensure npm test passes',
-            validate: (val) => (!val || !val.trim() ? 'Please state your goal' : undefined),
-        });
-        if (isCancel(userGoalInput)) {
-            safeNote(chalk.yellow('Agent task cancelled.'), '🤖 Scout Agent');
-            return;
+    let initialGoal = goalInput || options?.goal;
+    let isFirstRun = true;
+    const welcomeBanner = `
+${chalk.bold.cyan('🤖 Scout Autonomous AI Agent Session Active')} ${targetLang ? `(${targetLang})` : ''}
+${chalk.dim('Type your goal, task, or question. Press Ctrl+C or type "exit" to quit.')}
+  `.trim();
+    safeNote(welcomeBanner, '🤖 Scout Agent Session');
+    while (true) {
+        let rawGoal = undefined;
+        if (isFirstRun && (initialGoal || options?.scan || options?.add || options?.plan || options?.run || options?.create || options?.issue)) {
+            rawGoal = initialGoal;
+            isFirstRun = false;
         }
-        finalGoal = userGoalInput.trim();
-    }
-    const s = spinner();
-    s.start(`🤖 Scout Agent initializing autonomous workflow for: "${finalGoal}"...`);
-    // Step 1: File Identification
-    const targetFiles = await identifyTargetFiles(finalGoal, projectName, filesList, targetLang, options?.native);
-    if (targetFiles.length === 0) {
-        s.stop(chalk.yellow('No target files identified for this goal.'));
-        safeNote(chalk.yellow(`Scout could not identify specific files needing modification for goal: "${finalGoal}".\nPlease refine your request or specify target files.`), '⚠️ Agent File Selection');
-        return;
-    }
-    s.message(`Target files identified: ${targetFiles.join(', ')}`);
-    const targetFilesMap = {};
-    const backups = [];
-    const normKey = (p) => p.replace(/\\/g, '/').replace(/^\.\//, '').trim();
-    for (const tf of targetFiles) {
-        const fullPath = path.resolve(cwd, tf);
-        if (fs.existsSync(fullPath)) {
-            const content = fs.readFileSync(fullPath, 'utf-8');
-            targetFilesMap[normKey(tf)] = content;
-            backups.push({ filePath: normKey(tf), originalContent: content });
+        else {
+            isFirstRun = false;
+            const userGoalInput = await text({
+                message: chalk.bold('Agent Prompt:'),
+                placeholder: 'Ask question, fix bug, run command, scan issues, create file... (Ctrl+C / exit to quit)',
+                validate: (val) => (!val || !val.trim() ? 'Please enter a prompt or Ctrl+C / exit to quit' : undefined),
+            });
+            if (isCancel(userGoalInput)) {
+                safeNote(chalk.yellow('Exiting Scout Agent session. Goodbye!'), '👋 Scout Agent Ended');
+                break;
+            }
+            const trimmedInput = userGoalInput.trim();
+            if (['exit', 'quit', 'q', ':q'].includes(trimmedInput.toLowerCase())) {
+                safeNote(chalk.yellow('Exiting Scout Agent session. Goodbye!'), '👋 Scout Agent Ended');
+                break;
+            }
+            rawGoal = trimmedInput;
         }
-    }
-    // Step 2: Code Modification
-    s.message('Applying initial code modifications...');
-    let fixResult = await generateMultiCodeFix(finalGoal, projectName, filesList, targetFilesMap, targetLang, options?.native, (completed, total, file) => {
-        s.message(`Modifying files (${completed}/${total}): ${file}...`);
-    });
-    const modifiedFiles = [];
-    for (const item of fixResult.files) {
-        if (item.fixedCode !== undefined) {
-            const k = normKey(item.targetFile);
-            const fullPath = path.resolve(cwd, k);
-            const orig = targetFilesMap[k] ?? '';
-            const normalizedFixed = item.fixedCode.replace(/\r\n/g, '\n').trim();
-            const normalizedOrig = orig.replace(/\r\n/g, '\n').trim();
-            if (normalizedFixed !== normalizedOrig) {
-                fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-                fs.writeFileSync(fullPath, item.fixedCode, 'utf-8');
-                modifiedFiles.push(k);
+        if (!rawGoal || !rawGoal.trim()) {
+            continue;
+        }
+        const goalLower = rawGoal.toLowerCase().trim();
+        // -------------------------------------------------------------
+        // Mode 0: Q&A / Read-Only Question & File Content Inspection Mode
+        // -------------------------------------------------------------
+        const isQuestionIntent = /^(?:what|how|why|where|who|explain|show|read|display|tell|describe|list|is|does|can|could|view)\b/i.test(goalLower) ||
+            /\b(?:what's|whats|content of|code of|show code|read file|display file|explain code|how does|purpose of|wanna show|wanna see)\b/i.test(goalLower) ||
+            /\?\s*$/.test(goalLower);
+        const isActionIntent = Boolean(options?.create) ||
+            Boolean(options?.file) ||
+            Boolean(options?.issue) ||
+            Boolean(options?.run) ||
+            Boolean(options?.scan) ||
+            Boolean(options?.add) ||
+            Boolean(options?.plan) ||
+            /^(?:create|generate|make|build|fix|refactor|update|change|delete|remove|modify|patch|run|exec)\b/i.test(goalLower);
+        if (isQuestionIntent && !isActionIntent) {
+            const s = spinner();
+            s.start('🤖 Scout Agent analyzing query & inspecting codebase...');
+            const matchedFiles = findTargetFilesFromPrompt(rawGoal, undefined, filesList);
+            let readfileOutput = '';
+            if (matchedFiles.length > 0) {
+                for (const f of matchedFiles.slice(0, 3)) {
+                    const fullP = path.resolve(cwd, f);
+                    if (fs.existsSync(fullP) && fs.statSync(fullP).isFile()) {
+                        const fileContent = fs.readFileSync(fullP, 'utf-8');
+                        readfileOutput += `### 📄 File: \`${f}\`\n\`\`\`ts\n${fileContent.slice(0, 8000)}${fileContent.length > 8000 ? '\n... (truncated)' : ''}\n\`\`\`\n\n`;
+                    }
+                }
+            }
+            let manifestContent = '';
+            const pkgPath = path.join(cwd, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                try {
+                    manifestContent = fs.readFileSync(pkgPath, 'utf-8');
+                }
+                catch { }
             }
+            const aiAnswer = await askRepoQuestion(rawGoal + (readfileOutput ? `\n\nReferenced File Content:\n${readfileOutput}` : ''), projectName, filesList, manifestContent, [], { language: targetLang, native: options?.native });
+            s.stop('Query analysis complete.');
+            const outputMd = readfileOutput ? `${readfileOutput}### 💡 AI Explanation & Answer\n${aiAnswer}` : aiAnswer;
+            safeNote(renderMarkdown(outputMd), '📖 Scout Agent Q&A Response');
+            continue;
         }
-    }
-    // Step 3: Autonomous Verification & Self-Healing Loop
-    let verifyCommand = options?.verifyCmd;
-    if (!verifyCommand) {
-        const pkgPath = path.join(cwd, 'package.json');
-        if (fs.existsSync(pkgPath)) {
+        // -------------------------------------------------------------
+        // Mode 1: Codebase Scan Mode
+        // -------------------------------------------------------------
+        const isScanIntent = options?.scan || /\b(?:scan|bug scan|scan codebase|check for bugs|find bugs|security scan)\b/i.test(goalLower);
+        if (isScanIntent) {
+            const s = spinner();
+            s.start('🤖 Scout Agent: Performing read-only bug & vulnerability scan...');
+            let codeSample = '';
+            const pkgPath = path.join(cwd, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                codeSample += fs.readFileSync(pkgPath, 'utf-8').slice(0, 1000) + '\n';
+            }
+            const issues = await generateCodeScanReport(projectName, filesList, codeSample);
+            saveScanReport(issues);
+            s.stop('Bug scan complete.');
+            const severityBadge = (sev) => {
+                switch (sev.toLowerCase()) {
+                    case 'high':
+                        return chalk.bgRed.white.bold(' HIGH ');
+                    case 'medium':
+                        return chalk.bgYellow.black.bold(' MEDIUM ');
+                    default:
+                        return chalk.bgBlue.white.bold(' LOW ');
+                }
+            };
+            const reportLines = issues.map((iss) => `${chalk.bold.cyan(`[Issue #${iss.id}]`)} ${severityBadge(iss.severity)} ${chalk.bold(iss.title)}\n` +
+                `  • File: ${chalk.yellow(iss.file)}\n` +
+                `  • Detail: ${iss.description}`);
+            safeNote(`Found ${issues.length} potential issues matching past hotfix patterns:\n\n` +
+                reportLines.join('\n\n') +
+                `\n\n${chalk.bold.green('💡 How to Auto-Fix Any Issue with Agent:')}\n` +
+                `  • Auto-fix Issue #${issues[0]?.id || 1}: ${chalk.bold.cyan(`scout agent --issue ${issues[0]?.id || 1}`)}\n` +
+                `  • Custom prompt auto-fix: ${chalk.bold.cyan('scout agent "Fix null check in src/index.ts"')}`, '🔍 Scout Agent Bug Scan');
+            continue;
+        }
+        // -------------------------------------------------------------
+        // Mode 2: Feature Roadmap Plan Mode
+        // -------------------------------------------------------------
+        const addMatch = rawGoal ? (rawGoal.match(/^(?:plan|roadmap|feasibility|design|architect)\s+(.+)/i) || rawGoal.match(/^add\s+feature\s+(.+)/i)) : undefined;
+        const addIdea = options?.add || options?.plan || (addMatch ? addMatch[1] : undefined);
+        if (addIdea && !options?.create && !rawGoal?.match(/^(?:create|generate|make|build)\s+/i)) {
+            const s = spinner();
+            s.start(`🤖 Scout Agent: Evaluating feasibility & generating roadmap for "${chalk.cyan(addIdea)}"...`);
+            const plan = await generateFeaturePlan(addIdea, projectName, filesList, targetLang, options?.native);
+            s.stop('Feasibility assessment & roadmap complete.');
+            safeNote(renderMarkdown(plan), `🚀 Feature Implementation Roadmap: "${addIdea}"`);
+            continue;
+        }
+        // -------------------------------------------------------------
+        // Mode 3: Run Command Execution & Auto-Fix Mode (--run)
+        // -------------------------------------------------------------
+        const runMatch = rawGoal ? rawGoal.match(/^(?:run|exec|execute|terminal)\s+["']?([^"']+)["']?$/i) : undefined;
+        const runCmdInput = options?.run || (runMatch ? runMatch[1] : undefined);
+        if (runCmdInput) {
+            const fullCommand = Array.isArray(runCmdInput) ? runCmdInput.join(' ') : runCmdInput;
+            safeNote(`Running command: ${chalk.bold.cyan(fullCommand)}\n${chalk.dim('Working directory: ' + cwd)}`, '⚡ Scout Shell Execution');
+            const runSpinner = spinner();
+            runSpinner.start(`Executing \`${fullCommand}\`...`);
+            const outputBuffers = [];
+            const exitCode = await new Promise((resolve) => {
+                const proc = exec(fullCommand, { cwd });
+                proc.stdout?.on('data', (data) => {
+                    const str = data.toString();
+                    outputBuffers.push(str);
+                    process.stdout.write(str);
+                });
+                proc.stderr?.on('data', (data) => {
+                    const str = data.toString();
+                    outputBuffers.push(str);
+                    process.stderr.write(str);
+                });
+                proc.on('close', (code) => {
+                    resolve(code ?? 0);
+                });
+                proc.on('error', (err) => {
+                    outputBuffers.push(`Process Error: ${err.message}`);
+                    resolve(1);
+                });
+            });
+            const fullOutput = outputBuffers.join('');
+            if (exitCode === 0) {
+                runSpinner.stop(chalk.green(`Command \`${fullCommand}\` executed successfully (Exit Code 0).`));
+                safeNote(`${chalk.green('✓')} Process completed with exit code 0.`, '✅ Execution Successful');
+                continue;
+            }
+            runSpinner.stop(chalk.red(`Command \`${fullCommand}\` failed with exit code ${exitCode}.`));
+            const diagSpinner = spinner();
+            diagSpinner.start('Scout AI is analyzing process failure output...');
+            const analysis = await analyzeCommandError(fullCommand, exitCode, fullOutput, projectName, filesList, targetLang, options?.native);
+            diagSpinner.stop(chalk.yellow('Failure diagnosis complete.'));
+            const diagMarkdown = `
+### 🔴 Process Failure Diagnosis
+Command: \`${fullCommand}\` (Exit Code ${exitCode})
+
+### 🔍 Root Cause Analysis
+${analysis.rootCause}
+
+### 💡 Suggested Fix
+${analysis.suggestedFix}
+${analysis.targetFileToFix ? `\n### 🎯 Suspected File\n\`${analysis.targetFileToFix}\`` : ''}
+      `.trim();
+            safeNote(renderMarkdown(diagMarkdown), '⚠️ Scout AI Failure Diagnosis');
+            const shouldFix = await confirm({
+                message: chalk.bold('Would you like Scout Agent to auto-fix the failing code automatically?'),
+                initialValue: true,
+            });
+            if (!isCancel(shouldFix) && shouldFix) {
+                rawGoal = `Fix runtime/build error from command \`${fullCommand}\`. Cause: ${analysis.rootCause}`;
+                options = { ...options, file: analysis.targetFileToFix };
+            }
+            else {
+                continue;
+            }
+        }
+        // -------------------------------------------------------------
+        // Mode 4: Create File Generation Mode (--create)
+        // -------------------------------------------------------------
+        const createMatch = rawGoal ? rawGoal.match(/(?:create|generate|make|build)\s+(?:a\s+)?(?:new\s+)?(?:file\s+)?([a-zA-Z0-9_\-./]+\.[a-zA-Z0-9]+)\b/i) : undefined;
+        const targetCreateFile = options?.create || (createMatch && !createMatch[1]?.includes('package.json') ? createMatch[1] : undefined);
+        if (targetCreateFile) {
+            const targetFilePath = targetCreateFile.trim();
+            let finalPrompt = rawGoal;
+            if (!finalPrompt || !finalPrompt.trim()) {
+                const userPromptInput = await text({
+                    message: chalk.bold(`What should Scout generate inside ${chalk.cyan(targetFilePath)}?`),
+                    placeholder: 'e.g. Create a utility module with functions for string formatting and timestamp parsing',
+                    validate: (val) => (!val || !val.trim() ? 'Please provide a prompt describing the file requirements' : undefined),
+                });
+                if (isCancel(userPromptInput)) {
+                    safeNote(chalk.yellow('File creation operation cancelled.'), '✨ Scout File Creation');
+                    continue;
+                }
+                finalPrompt = userPromptInput.trim();
+            }
+            const resolvedPath = path.resolve(cwd, targetFilePath);
+            const fileExists = fs.existsSync(resolvedPath);
+            const originalContent = fileExists ? fs.readFileSync(resolvedPath, 'utf-8') : '__FT_WAS_NEW__';
+            const git = simpleGit();
+            const isRepo = await git.checkIsRepo();
+            let currentBranch = 'main';
+            if (isRepo) {
+                try {
+                    const branchSummary = await git.branch();
+                    currentBranch = branchSummary.current || 'main';
+                }
+                catch { }
+            }
+            const s = spinner();
+            s.start(`🤖 Scout Agent: Generating code for ${targetFilePath}...`);
+            let genResult;
+            try {
+                genResult = await generateCodeFile(targetFilePath, finalPrompt, projectName, filesList, targetLang, options?.native);
+            }
+            catch (err) {
+                s.stop(chalk.red('Failed to generate code file.'));
+                safeNote(chalk.red(`Error: ${err?.message || String(err)}`), '⚠️ Code Generation Error');
+                continue;
+            }
+            const parentDir = path.dirname(resolvedPath);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
             try {
-                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-                if (pkg.scripts?.test && pkg.scripts.test !== 'echo "Error: no test specified" && exit 1') {
-                    verifyCommand = 'npm test';
+                fs.writeFileSync(resolvedPath, genResult.code, 'utf-8');
+            }
+            catch (writeErr) {
+                s.stop(chalk.red('Failed to write generated code to disk.'));
+                safeNote(chalk.red(`Write error: ${writeErr?.message || String(writeErr)}`), '⚠️ File Write Error');
+                continue;
+            }
+            recordHistoryAction({
+                command: `scout agent --create "${targetFilePath}" "${finalPrompt}"`,
+                description: `Scout created file ${targetFilePath}`,
+                previousBranch: currentBranch,
+                affectedFiles: [targetFilePath],
+                backups: [{ filePath: targetFilePath, originalContent }],
+            });
+            s.stop(chalk.green(`File ${targetFilePath} created successfully!`));
+            const teardownContent = `
+### 📄 Created File
+\`${targetFilePath}\`
+
+### 💡 Description & Overview
+${genResult.description}
+
+### 💻 Preview
+\`\`\`
+${genResult.code.slice(0, 500)}${genResult.code.length > 500 ? '\n... (truncated)' : ''}
+\`\`\`
+      `.trim();
+            safeNote(renderMarkdown(teardownContent), '✨ Scout File Creation Teardown');
+            if (options?.yes || !process.stdout.isTTY) {
+                safeNote(`${chalk.green('✓')} Saved ${chalk.bold.cyan(targetFilePath)} on branch ${chalk.bold.green(currentBranch)}.\n` +
+                    `💡 ${chalk.dim('You can revert this creation anytime by running:')} ${chalk.cyan('scout undo')}`, '✅ Creation Confirmed');
+                continue;
+            }
+            const actionChoice = await select({
+                message: chalk.bold('Review Scout Agent\'s generated file. What would you like to do?'),
+                options: [
+                    { value: 'keep', label: '✅ Keep File', hint: `Retain the newly created file directly on current branch (${currentBranch})` },
+                    { value: 'pr', label: '🔀 Create Pull Request', hint: 'Push created file to a new branch & open a Pull Request' },
+                    { value: 'revert', label: '↩️ Revert / Delete File', hint: 'Remove the created file immediately' },
+                ],
+            });
+            if (isCancel(actionChoice) || actionChoice === 'revert') {
+                const revSpinner = spinner();
+                revSpinner.start('Reverting Scout Agent\'s file creation...');
+                await handleUndo();
+                revSpinner.stop('Creation reverted successfully.');
+                continue;
+            }
+            if (actionChoice === 'pr') {
+                const prSpinner = spinner();
+                prSpinner.start('Creating Pull Request...');
+                const prRes = await createPullRequest({
+                    branchPrefix: 'create',
+                    title: `feat: Add ${targetFilePath}`,
+                    affectedFiles: [targetFilePath],
+                    commitMessage: `feat: Create ${targetFilePath}`,
+                });
+                prSpinner.stop('Pull Request workflow processed.');
+                safeNote(`${chalk.green('✓')} ${prRes.message}\n` +
+                    `💡 ${chalk.dim('You remain on active branch:')} ${chalk.cyan(currentBranch)}`, '🔀 Pull Request Status');
+                continue;
+            }
+            safeNote(`${chalk.green('✓')} Saved ${chalk.bold.cyan(targetFilePath)} on branch ${chalk.bold.green(currentBranch)}.\n` +
+                `💡 ${chalk.dim('You can revert this creation anytime by running:')} ${chalk.cyan('scout undo')}`, '✅ Creation Confirmed');
+            continue;
+        }
+        // -------------------------------------------------------------
+        // Mode 5: Autonomous Agent Loop & Code Fix Mode (Default)
+        // -------------------------------------------------------------
+        let finalGoal = rawGoal;
+        let specifiedTargetFile = options?.file;
+        if (!finalGoal && options?.issue) {
+            const report = loadScanReport();
+            const issueId = Number(options.issue);
+            const targetIssue = report.find((i) => i.id === issueId) || report[0];
+            if (targetIssue) {
+                finalGoal = `Fix issue #${targetIssue.id}: ${targetIssue.title} — ${targetIssue.description}`;
+                specifiedTargetFile = targetIssue.file;
+            }
+        }
+        if (!finalGoal || !finalGoal.trim()) {
+            safeNote(chalk.yellow('No active goal specified.'), '🤖 Scout Agent');
+            continue;
+        }
+        // File Identification
+        let targetFiles = [];
+        if (specifiedTargetFile) {
+            targetFiles = findTargetFilesFromPrompt(finalGoal, specifiedTargetFile, filesList);
+            if (targetFiles.length === 0 && fs.existsSync(path.resolve(cwd, specifiedTargetFile))) {
+                targetFiles = [specifiedTargetFile];
+            }
+        }
+        if (targetFiles.length === 0) {
+            targetFiles = findTargetFilesFromPrompt(finalGoal, undefined, filesList);
+        }
+        if (targetFiles.length === 0) {
+            const sIdentify = spinner();
+            sIdentify.start(`🤖 Scout Agent initializing autonomous workflow for: "${finalGoal}"...`);
+            const aiMatched = await identifyTargetFiles(finalGoal, projectName, filesList, targetLang, options?.native);
+            sIdentify.stop('Target files identified.');
+            if (aiMatched.length > 0) {
+                targetFiles = aiMatched;
+            }
+        }
+        if (targetFiles.length === 0) {
+            let possibleNewFile = undefined;
+            if (specifiedTargetFile && specifiedTargetFile.trim()) {
+                const clean = specifiedTargetFile.trim();
+                if (!clean.startsWith('.') && !clean.startsWith('*') && clean.includes('.')) {
+                    possibleNewFile = clean;
                 }
-                else if (pkg.scripts?.build) {
-                    verifyCommand = 'npm run build';
+            }
+            if (possibleNewFile) {
+                await handleAgent(finalGoal, { ...options, create: possibleNewFile });
+                continue;
+            }
+            safeNote(chalk.yellow(`Scout Agent could not identify specific files needing modification for goal: "${finalGoal}".\nPlease refine your request or specify target files with --file.`), '⚠️ Agent File Selection');
+            continue;
+        }
+        const s = spinner();
+        s.start(`🤖 Scout Agent processing: "${finalGoal}" across file(s): ${targetFiles.join(', ')}...`);
+        const targetFilesMap = {};
+        const backups = [];
+        const normKey = (p) => p.replace(/\\/g, '/').replace(/^\.\//, '').trim();
+        for (const tf of targetFiles) {
+            const fullPath = path.resolve(cwd, tf);
+            if (fs.existsSync(fullPath)) {
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                targetFilesMap[normKey(tf)] = content;
+                backups.push({ filePath: normKey(tf), originalContent: content });
+            }
+        }
+        // Code Modification
+        s.message('Applying initial code modifications...');
+        let fixResult = await generateMultiCodeFix(finalGoal, projectName, filesList, targetFilesMap, targetLang, options?.native, (completed, total, file) => {
+            s.message(`Modifying files (${completed}/${total}): ${file}...`);
+        });
+        const modifiedFiles = [];
+        for (const item of fixResult.files) {
+            if (item.fixedCode !== undefined) {
+                const k = normKey(item.targetFile);
+                const fullPath = path.resolve(cwd, k);
+                const orig = targetFilesMap[k] ?? '';
+                const normalizedFixed = item.fixedCode.replace(/\r\n/g, '\n').trim();
+                const normalizedOrig = orig.replace(/\r\n/g, '\n').trim();
+                if (normalizedFixed !== normalizedOrig) {
+                    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+                    fs.writeFileSync(fullPath, item.fixedCode, 'utf-8');
+                    modifiedFiles.push(k);
                 }
             }
-            catch { }
         }
-    }
-    let verificationSuccess = true;
-    let attempts = 0;
-    const maxAttempts = options?.maxRetries || 3;
-    if (verifyCommand) {
-        s.message(`Running verification command: \`${verifyCommand}\`...`);
-        while (attempts < maxAttempts) {
-            attempts++;
-            try {
-                await execAsync(verifyCommand, { cwd });
-                verificationSuccess = true;
-                s.message(`Verification command \`${verifyCommand}\` passed!`);
-                break;
+        // Autonomous Verification & Self-Healing Loop
+        let verifyCommand = options?.verifyCmd;
+        if (!verifyCommand) {
+            const cmdInPromptMatch = finalGoal.match(/(?:deploy|verify|test|run|build)(?:\s+(?:by\s+running|with|using|and\s+run|via))?\s+['"`]([^'"`]+)['"`]/i) ||
+                finalGoal.match(/(?:deploy|verify|test|run)\s+(?:by\s+running|with|using)\s+(.+?)(?:$|\!|\.|\,)/i);
+            if (cmdInPromptMatch && cmdInPromptMatch[1]) {
+                verifyCommand = cmdInPromptMatch[1].trim();
             }
-            catch (cmdErr) {
-                verificationSuccess = false;
-                const output = (cmdErr.stdout || '') + '\n' + (cmdErr.stderr || '');
-                s.message(`Attempt ${attempts}/${maxAttempts}: Command failed. Diagnosing & self-healing...`);
-                const diagnosis = await analyzeCommandError(verifyCommand, cmdErr.code || 1, output, projectName, filesList, targetLang, options?.native);
-                const fileToFix = diagnosis.targetFileToFix || targetFiles[0] || filesList[0] || '';
-                if (fileToFix && fs.existsSync(path.resolve(cwd, fileToFix))) {
-                    const currentContent = fs.readFileSync(path.resolve(cwd, fileToFix), 'utf-8');
-                    const healPrompt = `Fix error running \`${verifyCommand}\`: ${diagnosis.rootCause}. Suggestion: ${diagnosis.suggestedFix}`;
-                    const healedRes = await generateMultiCodeFix(healPrompt, projectName, filesList, { [fileToFix]: currentContent }, targetLang, options?.native);
-                    if (healedRes.files[0]?.fixedCode) {
-                        fs.writeFileSync(path.resolve(cwd, fileToFix), healedRes.files[0].fixedCode, 'utf-8');
-                        if (!modifiedFiles.includes(fileToFix))
-                            modifiedFiles.push(fileToFix);
+        }
+        if (!verifyCommand) {
+            const pkgPath = path.join(cwd, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                try {
+                    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                    if (pkg.scripts?.test && pkg.scripts.test !== 'echo "Error: no test specified" && exit 1') {
+                        verifyCommand = 'npm test';
+                    }
+                    else if (pkg.scripts?.build) {
+                        verifyCommand = 'npm run build';
                     }
                 }
+                catch { }
             }
         }
-    }
-    const git = simpleGit();
-    const isRepo = await git.checkIsRepo();
-    let currentBranch = 'main';
-    if (isRepo) {
-        try {
-            const branchSummary = await git.branch();
-            currentBranch = branchSummary.current || 'main';
-        }
-        catch { }
-    }
-    if (modifiedFiles.length > 0) {
-        recordHistoryAction({
-            command: `scout agent "${finalGoal}"`,
-            description: `Scout agent completed goal on ${modifiedFiles.length} file(s)`,
-            previousBranch: currentBranch,
-            affectedFiles: modifiedFiles,
-            backups,
-        });
-    }
-    s.stop(chalk.green(`🤖 Scout Agent workflow completed for: "${finalGoal}"!`));
-    const teardownMd = `
+        let verificationSuccess = true;
+        let attempts = 0;
+        const maxAttempts = options?.maxRetries || 3;
+        if (verifyCommand) {
+            s.message(`Running verification command: \`${verifyCommand}\`...`);
+            while (attempts < maxAttempts) {
+                attempts++;
+                try {
+                    await execAsync(verifyCommand, { cwd });
+                    verificationSuccess = true;
+                    s.message(`Verification command \`${verifyCommand}\` passed!`);
+                    break;
+                }
+                catch (cmdErr) {
+                    verificationSuccess = false;
+                    const output = (cmdErr.stdout || '') + '\n' + (cmdErr.stderr || '');
+                    s.message(`Attempt ${attempts}/${maxAttempts}: Command failed. Diagnosing & self-healing...`);
+                    const diagnosis = await analyzeCommandError(verifyCommand, cmdErr.code || 1, output, projectName, filesList, targetLang, options?.native);
+                    const fileToFix = diagnosis.targetFileToFix || targetFiles[0] || filesList[0] || '';
+                    if (fileToFix && fs.existsSync(path.resolve(cwd, fileToFix))) {
+                        const currentContent = fs.readFileSync(path.resolve(cwd, fileToFix), 'utf-8');
+                        const healPrompt = `Fix error running \`${verifyCommand}\`: ${diagnosis.rootCause}. Suggestion: ${diagnosis.suggestedFix}`;
+                        const healedRes = await generateMultiCodeFix(healPrompt, projectName, filesList, { [fileToFix]: currentContent }, targetLang, options?.native);
+                        if (healedRes.files[0]?.fixedCode) {
+                            fs.writeFileSync(path.resolve(cwd, fileToFix), healedRes.files[0].fixedCode, 'utf-8');
+                            if (!modifiedFiles.includes(fileToFix))
+                                modifiedFiles.push(fileToFix);
+                        }
+                    }
+                }
+            }
+        }
+        const git = simpleGit();
+        const isRepo = await git.checkIsRepo();
+        let currentBranch = 'main';
+        if (isRepo) {
+            try {
+                const branchSummary = await git.branch();
+                currentBranch = branchSummary.current || 'main';
+            }
+            catch { }
+        }
+        if (modifiedFiles.length > 0) {
+            recordHistoryAction({
+                command: `scout agent "${finalGoal}"`,
+                description: `Scout agent completed goal on ${modifiedFiles.length} file(s)`,
+                previousBranch: currentBranch,
+                affectedFiles: modifiedFiles,
+                backups,
+            });
+        }
+        s.stop(chalk.green(`🤖 Scout Agent workflow completed for: "${finalGoal}"!`));
+        const teardownMd = `
 ### 🎯 Agent Goal
 ${finalGoal}
 
@@ -156,45 +595,46 @@ ${fixResult.howFixed}
 
 ### ✅ Verification Status
 ${verifyCommand ? (verificationSuccess ? `\`${verifyCommand}\` PASSED 🎉` : `\`${verifyCommand}\` FAILED (max retries reached) ⚠️`) : 'No automated verification script detected'}
-  `.trim();
-    safeNote(renderMarkdown(teardownMd), '🤖 Scout Agent Autonomous Teardown');
-    if (modifiedFiles.length === 0)
-        return;
-    if (options?.yes || !process.stdout.isTTY) {
-        safeNote(`${chalk.green('✓')} Agent changes retained on ${modifiedFiles.length} file(s) (Branch: ${chalk.bold.green(currentBranch)}).\n` +
-            `💡 ${chalk.dim('You can revert anytime by running:')} ${chalk.cyan('scout undo')}`, '✅ Agent Fix Confirmed');
-        return;
-    }
-    const actionChoice = await select({
-        message: chalk.bold('Review Scout Agent result. What would you like to do?'),
-        options: [
-            { value: 'keep', label: '✅ Keep Changes', hint: `Retain agent changes on current branch (${currentBranch})` },
-            { value: 'pr', label: '🔀 Create Pull Request', hint: 'Push fix to a new branch & open a Pull Request' },
-            { value: 'revert', label: '↩️ Revert Changes', hint: 'Restore original code immediately' },
-        ],
-    });
-    if (actionChoice === 'revert') {
-        const revSpinner = spinner();
-        revSpinner.start('Reverting Agent changes...');
-        await handleUndo();
-        revSpinner.stop('Changes reverted successfully.');
-        return;
-    }
-    if (actionChoice === 'pr') {
-        const prSpinner = spinner();
-        prSpinner.start('Creating Pull Request...');
-        const prRes = await createPullRequest({
-            branchPrefix: 'agent',
-            title: finalGoal,
-            affectedFiles: modifiedFiles,
-            commitMessage: `feat: ${finalGoal}`,
+    `.trim();
+        safeNote(renderMarkdown(teardownMd), '🤖 Scout Agent Autonomous Teardown');
+        if (modifiedFiles.length === 0)
+            continue;
+        if (options?.yes || !process.stdout.isTTY) {
+            safeNote(`${chalk.green('✓')} Agent changes retained on ${modifiedFiles.length} file(s) (Branch: ${chalk.bold.green(currentBranch)}).\n` +
+                `💡 ${chalk.dim('You can revert anytime by running:')} ${chalk.cyan('scout undo')}`, '✅ Agent Fix Confirmed');
+            continue;
+        }
+        const actionChoice = await select({
+            message: chalk.bold('Review Scout Agent result. What would you like to do?'),
+            options: [
+                { value: 'keep', label: '✅ Keep Changes', hint: `Retain agent changes on current branch (${currentBranch})` },
+                { value: 'pr', label: '🔀 Create Pull Request', hint: 'Push fix to a new branch & open a Pull Request' },
+                { value: 'revert', label: '↩️ Revert Changes', hint: 'Restore original code immediately' },
+            ],
         });
-        prSpinner.stop('Pull Request workflow processed.');
-        safeNote(`${chalk.green('✓')} ${prRes.message}\n` +
-            `💡 ${chalk.dim('You remain on active branch:')} ${chalk.cyan(currentBranch)}`, '🔀 Pull Request Status');
-        return;
+        if (actionChoice === 'revert') {
+            const revSpinner = spinner();
+            revSpinner.start('Reverting Agent changes...');
+            await handleUndo();
+            revSpinner.stop('Changes reverted successfully.');
+            continue;
+        }
+        if (actionChoice === 'pr') {
+            const prSpinner = spinner();
+            prSpinner.start('Creating Pull Request...');
+            const prRes = await createPullRequest({
+                branchPrefix: 'agent',
+                title: finalGoal,
+                affectedFiles: modifiedFiles,
+                commitMessage: `feat: ${finalGoal}`,
+            });
+            prSpinner.stop('Pull Request workflow processed.');
+            safeNote(`${chalk.green('✓')} ${prRes.message}\n` +
+                `💡 ${chalk.dim('You remain on active branch:')} ${chalk.cyan(currentBranch)}`, '🔀 Pull Request Status');
+            continue;
+        }
+        safeNote(`${chalk.green('✓')} Agent changes retained on ${modifiedFiles.length} file(s) (Branch: ${chalk.bold.green(currentBranch)}).\n` +
+            `💡 ${chalk.dim('You can revert these changes anytime by running:')} ${chalk.cyan('scout undo')}`, '✅ Agent Workflow Finished');
     }
-    safeNote(`${chalk.green('✓')} Agent changes retained on ${modifiedFiles.length} file(s) (Branch: ${chalk.bold.green(currentBranch)}).\n` +
-        `💡 ${chalk.dim('You can revert these changes anytime by running:')} ${chalk.cyan('scout undo')}`, '✅ Agent Workflow Finished');
 }
 //# sourceMappingURL=agent.js.map