ft-scout 1.0.9 → 1.1.0

package/bin/src/commands/history.js

@@ -0,0 +1,20 @@
+import chalk from 'chalk';
+import { loadHistory } from '../utils/config.js';
+import { safeNote } from '../utils/markdown.js';
+export async function handleHistory() {
+    const history = loadHistory();
+    if (history.length === 0) {
+        safeNote(chalk.yellow('No recorded FT actions found in this repository yet.\nCommands like `ft fix` and configuration updates will log history entries here.'), ' FrontTerrain Execution History');
+        return;
+    }
+    const logLines = history.map((item, idx) => {
+        const timeStr = new Date(item.timestamp).toLocaleString();
+        return (`${chalk.bold.cyan(`#${history.length - idx}`)} ${chalk.bold.green(item.command)} ${chalk.dim(`(${timeStr})`)}\n` +
+            ` • ${item.description}\n` +
+            (item.branchName ? ` • Branch: ${chalk.yellow(item.branchName)}\n` : '') +
+            (item.affectedFiles && item.affectedFiles.length > 0 ? ` • Files: ${chalk.dim(item.affectedFiles.join(', '))}` : ''));
+    });
+    safeNote(logLines.join('\n\n') +
+        `\n\n${chalk.dim('Run `ft undo` to revert the last action performed by Scout.')}`, ' FrontTerrain Execution History');
+}
+//# sourceMappingURL=history.js.map

package/bin/src/commands/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","sourceRoot":"","sources":["history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,MAAM,CAAC,KAAK,UAAU,aAAa;IAC/B,MAAM,OAAO,GAAG,WAAW,EAAE,CAAC;IAE9B,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,QAAQ,CACJ,KAAK,CAAC,MAAM,CAAC,uIAAuI,CAAC,EACrJ,iCAAiC,CACpC,CAAC;QACF,OAAO;IACX,CAAC;IAED,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;QACvC,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,cAAc,EAAE,CAAC;QAC1D,OAAO,CACH,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,OAAO,GAAG,CAAC,IAAI;YACjH,MAAM,IAAI,CAAC,WAAW,IAAI;YAC1B,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;YACxE,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CACvH,CAAC;IACN,CAAC,CAAC,CAAC;IAEH,QAAQ,CACJ,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;QACrB,OAAO,KAAK,CAAC,GAAG,CAAC,6DAA6D,CAAC,EAAE,EACjF,iCAAiC,CACpC,CAAC;AACN,CAAC"}

package/bin/src/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["init.ts"],"names":[],"mappings":"AAsFA,wBAAsB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,iBAkMhD"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["init.ts"],"names":[],"mappings":"AAuOA,wBAAsB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,iBA+ZjJ"}

package/bin/src/commands/init.js

@@ -1,11 +1,99 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import { spinner, note, password, isCancel } from '@clack/prompts';
+import { spinner, note, password, isCancel, text, select, confirm } from '@clack/prompts';
 import chalk from 'chalk';
 import { simpleGit } from 'simple-git';
-import { generateRepoSummary } from '../engine/llm.js';
-import { saveContext } from '../utils/config.js';
+import { generateRepoSummary, askRepoQuestion } from '../engine/llm.js';
+import { saveContext, loadContext, saveScanReport } from '../utils/config.js';
+import { renderMarkdown, formatInlineMarkdown, safeNote } from '../utils/markdown.js';
+import { normalizeLanguage, getLanguageInstruction } from '../utils/language.js';
+function detectPackageManager(dir) {
+    if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs.existsSync(path.join(dir, 'yarn.lock')))
+        return 'yarn';
+    if (fs.existsSync(path.join(dir, 'bun.lockb')) || fs.existsSync(path.join(dir, 'bun.lock')))
+        return 'bun';
+    if (fs.existsSync(path.join(dir, 'package-lock.json')))
+        return 'npm';
+    if (fs.existsSync(path.join(dir, 'Cargo.lock')))
+        return 'cargo';
+    if (fs.existsSync(path.join(dir, 'poetry.lock')))
+        return 'poetry';
+    if (fs.existsSync(path.join(dir, 'Pipfile')))
+        return 'pipenv';
+    if (fs.existsSync(path.join(dir, 'build.gradle')) || fs.existsSync(path.join(dir, 'gradlew')))
+        return 'gradle';
+    return 'npm';
+}
+function detectWorkspaces(dir) {
+    const workspaces = [];
+    const checks = [
+        { file: 'pnpm-workspace.yaml', type: 'pnpm Workspaces' },
+        { file: 'turbo.json', type: 'Turborepo' },
+        { file: 'lerna.json', type: 'Lerna Monorepo' },
+        { file: 'nx.json', type: 'Nx Workspace' },
+    ];
+    for (const c of checks) {
+        if (fs.existsSync(path.join(dir, c.file))) {
+            workspaces.push(c.type);
+        }
+    }
+    const pkgJsonPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+            if (pkg.workspaces) {
+                if (Array.isArray(pkg.workspaces)) {
+                    pkg.workspaces.forEach((w) => workspaces.push(`package (${w})`));
+                }
+                else if (pkg.workspaces.packages && Array.isArray(pkg.workspaces.packages)) {
+                    pkg.workspaces.packages.forEach((w) => workspaces.push(`package (${w})`));
+                }
+            }
+        }
+        catch { }
+    }
+    // Check common subdirectories
+    const subDirs = ['apps', 'packages', 'services', 'modules', 'libs'];
+    for (const sub of subDirs) {
+        const subPath = path.join(dir, sub);
+        if (fs.existsSync(subPath) && fs.statSync(subPath).isDirectory()) {
+            try {
+                const contents = fs.readdirSync(subPath).filter((f) => {
+                    const p = path.join(subPath, f);
+                    return fs.statSync(p).isDirectory() && !f.startsWith('.');
+                });
+                if (contents.length > 0) {
+                    workspaces.push(`${sub}/ (${contents.length} packages: ${contents.slice(0, 3).join(', ')}${contents.length > 3 ? '...' : ''})`);
+                }
+            }
+            catch { }
+        }
+    }
+    const isMonorepo = workspaces.length > 0;
+    return { isMonorepo, workspaces: Array.from(new Set(workspaces)) };
+}
+async function bootstrapEnvironmentFile(dir) {
+    const envPath = path.join(dir, '.env');
+    if (fs.existsSync(envPath))
+        return false;
+    const exampleCandidates = ['.env.example', '.env.template', '.env.local.example', '.env.sample', 'env.example'];
+    for (const candidate of exampleCandidates) {
+        const examplePath = path.join(dir, candidate);
+        if (fs.existsSync(examplePath)) {
+            try {
+                const content = fs.readFileSync(examplePath, 'utf-8');
+                fs.writeFileSync(envPath, content);
+                note(chalk.green(`Auto-created ${chalk.bold('.env')} from ${chalk.bold(candidate)}.\nPlease update any API keys or secrets in .env before running services.`), ' Environment Auto-Setup');
+                return true;
+            }
+            catch { }
+        }
+    }
+    return false;
+}
 function extractNpmPackageName(target) {
     if (target.startsWith('npm:')) {
         return target.slice(4).trim();
@@ -18,7 +106,8 @@ function extractNpmPackageName(target) {
         /^git@/i.test(target) ||
         target.includes('github.com') ||
         target.includes('gitlab.com') ||
-        target.endsWith('.git');
+        target.endsWith('.git') ||
+        (/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+$/.test(target) && !target.startsWith('@'));
     if (!isGitOrFile) {
         if (/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i.test(target)) {
             return target;
@@ -59,8 +148,9 @@ async function getNpmRepoUrl(pkgName) {
     }
 }
 function cleanGitHubUrl(targetUrl) {
-    if (targetUrl.includes('github.com')) {
-        const match = targetUrl.match(/github\.com\/([^/]+(?:\/[^/]+)+)/i);
+    const trimmed = targetUrl.trim();
+    if (trimmed.includes('github.com')) {
+        const match = trimmed.match(/github\.com\/([^/]+(?:\/[^/]+)+)/i);
         if (match && match[1]) {
             let parts = match[1].split('/').filter(Boolean);
             const branchIndex = parts.findIndex((p) => ['tree', 'blob', 'src'].includes(p.toLowerCase()));
@@ -75,11 +165,67 @@ function cleanGitHubUrl(targetUrl) {
             }
         }
     }
-    return targetUrl;
+    // Short format: owner/repo (e.g. facebook/react)
+    if (/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+$/.test(trimmed) && !trimmed.startsWith('@')) {
+        const parts = trimmed.split('/');
+        if (parts.length === 2 && parts[0] && parts[1]) {
+            const owner = parts[0];
+            const repo = parts[1].replace(/\.git$/i, '');
+            return `https://github.com/${owner}/${repo}.git`;
+        }
+    }
+    return trimmed;
 }
-export async function handleInit(repoUrl) {
+async function isPublicRepo(gitUrl) {
+    if (!gitUrl.startsWith('https://') && !gitUrl.startsWith('http://')) {
+        return false;
+    }
+    try {
+        const cleanUrl = gitUrl.replace(/\.git$/i, '');
+        const smartHttpEndpoint = `${cleanUrl}.git/info/refs?service=git-upload-pack`;
+        const res = await fetch(smartHttpEndpoint, {
+            method: 'GET',
+            headers: {
+                'User-Agent': 'git/2.39.0',
+            },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (res.status === 200) {
+            return true;
+        }
+    }
+    catch { }
+    if (gitUrl.includes('github.com')) {
+        try {
+            const match = gitUrl.match(/github\.com\/([^/]+)\/([^/]+)/i);
+            if (match && match[1] && match[2]) {
+                const owner = match[1];
+                const repo = match[2].replace(/\.git$/i, '');
+                const apiRes = await fetch(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`, {
+                    headers: {
+                        'User-Agent': 'FrontTerrain-CLI',
+                        'Accept': 'application/vnd.github.v3+json',
+                    },
+                    signal: AbortSignal.timeout(5000),
+                });
+                if (apiRes.ok) {
+                    const data = (await apiRes.json());
+                    if (data && data.private === false) {
+                        return true;
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    return false;
+}
+export async function handleInit(repoUrl, options) {
     const s = spinner();
     let targetDir = process.cwd();
+    const existingContext = loadContext();
+    const targetLang = normalizeLanguage(options?.lang) || normalizeLanguage(existingContext?.language);
+    const langDisplay = targetLang ? getLanguageInstruction(targetLang, options?.native).displayName : undefined;
     if (repoUrl && repoUrl.trim()) {
         const rawTarget = repoUrl.trim();
         const resolvedPath = path.resolve(rawTarget);
@@ -93,98 +239,191 @@ export async function handleInit(repoUrl) {
                 /^git@/i.test(rawTarget) ||
                 rawTarget.includes('github.com') ||
                 rawTarget.includes('gitlab.com') ||
-                rawTarget.endsWith('.git');
+                rawTarget.endsWith('.git') ||
+                (/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+$/.test(rawTarget) && !rawTarget.startsWith('@'));
             if (npmPkgName && !isGitUrl) {
                 s.start(`Resolving npm package repository (${chalk.cyan(npmPkgName)})...`);
                 const resolvedUrl = await getNpmRepoUrl(npmPkgName);
                 if (!resolvedUrl) {
                     s.stop(chalk.red(`Failed to resolve npm package repository.`));
-                    note(chalk.red(`The specified repository is private or does not exist.`), '❌ Invalid Target');
+                    note(chalk.red(`The specified repository is private or does not exist.`), ' Invalid Target');
                     return;
                 }
                 gitTargetUrl = cleanGitHubUrl(resolvedUrl);
                 s.stop(`Resolved npm package to repository ${chalk.cyan(gitTargetUrl)}.`);
             }
-            s.start(`Cloning remote repository (${chalk.cyan(gitTargetUrl)})...`);
             const repoName = path.basename(gitTargetUrl, '.git') || 'cloned-repo';
-            const tempParent = path.join(os.tmpdir(), 'ft-scout-repos');
-            targetDir = path.join(tempParent, `${repoName}-${Date.now()}`);
-            if (!fs.existsSync(tempParent)) {
-                fs.mkdirSync(tempParent, { recursive: true });
+            if (process.stdout.isTTY) {
+                const cloneChoice = await select({
+                    message: chalk.bold(`Where would you like to clone ${chalk.cyan(repoName)}?`),
+                    options: [
+                        { value: 'root', label: ' Root Repo (Current Directory)', hint: `Clone inside current directory: ./${repoName}` },
+                        { value: 'temp', label: ' Temp (Temporary Folder)', hint: 'Clone to OS temporary directory (isolated sandbox)' },
+                        { value: 'custom', label: '️ Input Yourself (Custom Path)', hint: 'Specify your own custom folder destination' },
+                    ],
+                });
+                if (isCancel(cloneChoice)) {
+                    note(chalk.yellow('Clone operation cancelled.'), ' Init Cancelled');
+                    return;
+                }
+                if (cloneChoice === 'root') {
+                    targetDir = path.resolve(process.cwd(), repoName);
+                }
+                else if (cloneChoice === 'custom') {
+                    const customPath = await text({
+                        message: 'Enter custom folder path to clone into:',
+                        placeholder: `./${repoName} or C:\\projects\\${repoName}`,
+                        validate: (val) => (!val || !val.trim() ? 'Path cannot be empty' : undefined),
+                    });
+                    if (isCancel(customPath)) {
+                        note(chalk.yellow('Clone operation cancelled.'), ' Init Cancelled');
+                        return;
+                    }
+                    targetDir = path.resolve(process.cwd(), customPath.trim());
+                }
+                else {
+                    const tempParent = path.join(os.tmpdir(), 'scout-repos');
+                    targetDir = path.join(tempParent, `${repoName}-${Date.now()}`);
+                }
             }
+            else {
+                const tempParent = path.join(os.tmpdir(), 'scout-repos');
+                targetDir = path.join(tempParent, `${repoName}-${Date.now()}`);
+            }
+            if (!fs.existsSync(path.dirname(targetDir))) {
+                fs.mkdirSync(path.dirname(targetDir), { recursive: true });
+            }
+            s.start(`Cloning remote repository (${chalk.cyan(gitTargetUrl)}) to ${chalk.cyan(targetDir)}...`);
             const git = simpleGit();
             try {
                 await git.clone(gitTargetUrl, targetDir, ['--depth', '1']);
                 s.stop(`Remote repository cloned successfully.`);
             }
             catch (err) {
-                s.stop(chalk.yellow(`Initial clone failed (repository may be private or require authentication).`));
-                // Interactive login / token prompt for private repos
-                if (gitTargetUrl.startsWith('https://')) {
-                    const tokenInput = await password({
-                        message: 'Enter your GitHub / GitLab Personal Access Token (PAT) to access this private repository:',
-                        mask: '*',
-                        validate: (val) => (!val || !val.trim() ? 'Token cannot be empty' : undefined),
-                    });
-                    if (!isCancel(tokenInput) && typeof tokenInput === 'string' && tokenInput.trim()) {
-                        const cleanToken = tokenInput.trim();
-                        // Inject token into URL: https://<token>@github.com/...
-                        const authenticatedUrl = gitTargetUrl.replace(/^https:\/\//i, `https://${cleanToken}@`);
-                        const retrySpinner = spinner();
-                        retrySpinner.start(`Retrying clone with provided token...`);
-                        try {
-                            if (fs.existsSync(targetDir)) {
-                                fs.rmSync(targetDir, { recursive: true, force: true });
+                const isPublic = await isPublicRepo(gitTargetUrl);
+                if (isPublic) {
+                    // Retry without depth if initial clone failed for a public repo
+                    try {
+                        if (fs.existsSync(targetDir)) {
+                            fs.rmSync(targetDir, { recursive: true, force: true });
+                        }
+                        await git.clone(gitTargetUrl, targetDir);
+                        s.stop(`Remote repository cloned successfully.`);
+                    }
+                    catch (retryErr) {
+                        s.stop(chalk.red(`Failed to clone public repository.`));
+                        note(chalk.red(`Could not clone public repository (${gitTargetUrl}).\n` +
+                            `Git Error: ${retryErr?.message || err?.message || 'Unknown git clone error'}\n\n` +
+                            `Please check your network connection or verify the repository URL.`), ' Clone Failed');
+                        return;
+                    }
+                }
+                else {
+                    s.stop(chalk.yellow(`Initial clone failed (repository may be private or require authentication).`));
+                    // Interactive login / token prompt for private repos ONLY
+                    if (gitTargetUrl.startsWith('https://')) {
+                        const tokenInput = await password({
+                            message: 'Enter your GitHub / GitLab Personal Access Token (PAT) to access this private repository:',
+                            mask: '*',
+                            validate: (val) => (!val || !val.trim() ? 'Token cannot be empty' : undefined),
+                        });
+                        if (!isCancel(tokenInput) && typeof tokenInput === 'string' && tokenInput.trim()) {
+                            const cleanToken = tokenInput.trim();
+                            const encodedToken = encodeURIComponent(cleanToken);
+                            // Inject encoded token into URL: https://<token>@github.com/...
+                            const authenticatedUrl = gitTargetUrl.replace(/^https:\/\//i, `https://${encodedToken}@`);
+                            const retrySpinner = spinner();
+                            retrySpinner.start(`Retrying clone with provided token...`);
+                            try {
+                                if (fs.existsSync(targetDir)) {
+                                    fs.rmSync(targetDir, { recursive: true, force: true });
+                                }
+                                await git.clone(authenticatedUrl, targetDir, ['--depth', '1']);
+                                retrySpinner.stop(chalk.green(`Remote repository cloned successfully!`));
+                            }
+                            catch (retryErr) {
+                                retrySpinner.stop(chalk.red(`Authentication failed with the provided token.`));
+                                note(chalk.red(`Could not clone repository with the provided token.\n` +
+                                    `Error details: ${retryErr?.message || 'Authentication error'}\n\n` +
+                                    `Alternative options:\n` +
+                                    ` • Use SSH: ${chalk.cyan('scout init git@github.com:owner/repo.git')}\n` +
+                                    ` • Or clone locally first: ${chalk.cyan('scout init ./my-repo-folder')}`), ' Authentication Failed');
+                                return;
                             }
-                            await git.clone(authenticatedUrl, targetDir, ['--depth', '1']);
-                            retrySpinner.stop(chalk.green(`Remote repository cloned successfully!`));
                         }
-                        catch (retryErr) {
-                            retrySpinner.stop(chalk.red(`Authentication failed with the provided token.`));
-                            note(chalk.red(`Could not clone repository with the provided token.\n` +
-                                `Please check that your token has repo read permissions.\n\n` +
-                                `Alternative options:\n` +
-                                ` • Use SSH: ${chalk.cyan('ft-scout init git@github.com:owner/repo.git')}\n` +
-                                ` • Or clone locally first: ${chalk.cyan('ft-scout init ./my-repo-folder')}`), '❌ Authentication Failed');
+                        else {
+                            note(chalk.yellow('Login cancelled. Repository initialization aborted.'), ' Clone Cancelled');
                             return;
                         }
                     }
                     else {
-                        note(chalk.yellow('Login cancelled. Repository initialization aborted.'), '❌ Clone Cancelled');
+                        note(chalk.red(`The specified repository is private or does not exist.\n\n` +
+                            chalk.bold(' How to access private repositories:') + '\n' +
+                            ` • Use SSH URL: ${chalk.cyan('scout init git@github.com:owner/repo.git')}\n` +
+                            ` • Or use PAT Token URL: ${chalk.cyan('scout init https://<TOKEN>@github.com/owner/repo.git')}\n` +
+                            ` • Or clone locally first and run: ${chalk.cyan('scout init ./my-repo-folder')}`), ' Clone Error');
                         return;
                     }
                 }
-                else {
-                    note(chalk.red(`The specified repository is private or does not exist.\n\n` +
-                        chalk.bold('🔒 How to access private repositories:') + '\n' +
-                        ` • Use SSH URL: ${chalk.cyan('ft-scout init git@github.com:owner/repo.git')}\n` +
-                        ` • Or use PAT Token URL: ${chalk.cyan('ft-scout init https://<TOKEN>@github.com/owner/repo.git')}\n` +
-                        ` • Or clone locally first and run: ${chalk.cyan('ft-scout init ./my-repo-folder')}`), '❌ Clone Error');
-                    return;
-                }
             }
         }
     }
-    s.start(`Analyzing repository at ${chalk.cyan(targetDir)}...`);
+    const pkgManager = detectPackageManager(targetDir);
+    const workspaceInfo = detectWorkspaces(targetDir);
+    await bootstrapEnvironmentFile(targetDir);
+    s.start(`Analyzing repository at ${chalk.cyan(targetDir)}${langDisplay ? ` (Language: ${chalk.bold.yellow(langDisplay)})` : ''}...`);
+    // Perform quick pre-flight fragility scan for .ft/scan-report.json
+    try {
+        const git = simpleGit(targetDir);
+        const rawLog = await git.raw(['log', '-n', '100', '--name-only', '--format=COMMIT:%H %s']);
+        const fileStats = {};
+        const logLines = rawLog.split('\n');
+        let currentIsHotfix = false;
+        for (const rawLine of logLines) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            if (line.startsWith('COMMIT:')) {
+                currentIsHotfix = /fix|bug|hotfix|patch/i.test(line);
+            }
+            else if (currentIsHotfix) {
+                fileStats[line] = (fileStats[line] || 0) + 1;
+            }
+        }
+        const scanReport = Object.entries(fileStats).map(([file, hotfixes]) => ({
+            file,
+            hotfixes,
+            riskLevel: hotfixes >= 3 ? 'HIGH' : hotfixes >= 1 ? 'MEDIUM' : 'LOW',
+        }));
+        if (scanReport.length > 0) {
+            saveScanReport(scanReport);
+        }
+    }
+    catch { }
     // Scan file tree up to 2 levels deep
-    const getFiles = (dir, depth = 2) => {
+    const ignoredDirs = new Set([
+        'node_modules', '.git', 'dist', 'build', '.dart_tool', '.next', 'out', 'vendor',
+        'target', 'bin', 'obj', 'coverage', '.ft', '.vscode', '.idea', 'tmp', 'temp',
+        'venv', '.venv', '__pycache__', '.turbo', '.cache'
+    ]);
+    const getFiles = (dir, currentDepth = 2) => {
         let results = [];
         try {
             const list = fs.readdirSync(dir);
             for (const file of list) {
-                if (['node_modules', '.git', 'dist', 'build', '.dart_tool', '.next', 'out', 'vendor'].includes(file))
+                if (ignoredDirs.has(file) || (file.startsWith('.') && file !== '.github'))
                     continue;
                 const fullPath = path.join(dir, file);
-                const relPath = path.relative(dir, fullPath);
+                const relPath = path.relative(targetDir, fullPath);
                 const stat = fs.statSync(fullPath);
                 if (stat.isDirectory()) {
-                    results.push(relPath + '/');
-                    if (depth > 1) {
-                        results = results.concat(getFiles(fullPath, depth - 1));
+                    results.push(relPath.replace(/\\/g, '/') + '/');
+                    if (currentDepth > 1) {
+                        results = results.concat(getFiles(fullPath, currentDepth - 1));
                     }
                 }
                 else {
-                    results.push(relPath);
+                    results.push(relPath.replace(/\\/g, '/'));
                 }
             }
         }
@@ -208,33 +447,123 @@ export async function handleInit(repoUrl) {
             projectName = path.basename(rawTarget, '.git');
         }
     }
-    const aiInsight = await generateRepoSummary(projectName, filesList, manifestContent || '{}');
-    // Save context into local .ft folder
-    saveContext({
-        projectName,
-        repoUrl: repoUrl?.trim() || undefined,
-        targetDir,
-        stack: aiInsight.summary,
-        entryPoint: aiInsight.entryPoint,
-        painPoints: aiInsight.painPoints,
-        readOrder: aiInsight.readOrder,
-        createdAt: new Date().toISOString(),
-    });
+    const aiInsight = await generateRepoSummary(projectName, filesList, manifestContent || '{}', targetLang, options?.native);
+    // Save context into local .ft folder (only if not skipSave)
+    if (!options?.skipSave) {
+        saveContext({
+            projectName,
+            repoUrl: repoUrl?.trim() || undefined,
+            targetDir,
+            stack: aiInsight.summary,
+            entryPoint: aiInsight.entryPoint,
+            painPoints: aiInsight.painPoints,
+            readOrder: aiInsight.readOrder,
+            createdAt: new Date().toISOString(),
+            language: targetLang,
+            packageManager: pkgManager,
+            isMonorepo: workspaceInfo.isMonorepo,
+            workspaces: workspaceInfo.workspaces,
+            architectureDiagram: aiInsight.architectureDiagram,
+        });
+    }
     s.stop('Repository analysis complete.');
+    const cleanedPainPoints = (aiInsight.painPoints || [])
+        .map((p) => p.trim())
+        .filter((p) => p.length > 5 && !/^[,\s.\-[\]:]+$/.test(p));
+    const cleanedReadOrder = (aiInsight.readOrder || [])
+        .map((r) => r.trim())
+        .filter((r) => r.length > 5 && !/^[,\s.\-[\]:]+$/.test(r));
+    const painPointsToDisplay = cleanedPainPoints.length > 0 ? cleanedPainPoints : [
+        ' [Subsystem Dependency]: Verify API keys or external proxy authentication service connectivity.',
+        ' [Environment Requirements]: Ensure runtime dependencies match system execution requirements.'
+    ];
+    const readOrderToDisplay = cleanedReadOrder.length > 0 ? cleanedReadOrder : [
+        'package.json -> Core manifest defining build targets and dependency graph',
+        'src/index.ts -> Primary router establishing CLI hooks and command workflow'
+    ];
+    // Format workspace & package manager details
+    const workspaceStr = workspaceInfo.isMonorepo
+        ? `\nWorkspace Type: ${chalk.bold.magenta('Monorepo')} (${workspaceInfo.workspaces.join(', ')})`
+        : '';
+    const archDiagramStr = aiInsight.architectureDiagram
+        ? `\n\n${chalk.bold.blue('️ Subsystem Architecture Flow:')}\n${chalk.dim(aiInsight.architectureDiagram)}`
+        : '';
     // Print repository summary
-    note(`Project Name: ${chalk.bold.green(projectName)}
-Location: ${chalk.dim(targetDir)}
+    safeNote(`Project Name: ${chalk.bold.green(projectName)}
+Location: ${chalk.dim(targetDir)}${langDisplay ? `\nLanguage: ${chalk.bold.yellow(langDisplay)}` : ''}
+Package Manager: ${chalk.bold.cyan(pkgManager.toUpperCase())}${workspaceStr}
 
-${chalk.bold.magenta('🚀 Architectural Executive Summary & Stack:')}
-${chalk.yellow(aiInsight.summary)}
+${chalk.bold.magenta(' Architectural Executive Summary & Stack:')}
+${renderMarkdown(aiInsight.summary)}${archDiagramStr}
 
-${chalk.bold.cyan('📌 Main Entry Point:')}
+${chalk.bold.cyan(' Main Entry Point:')}
 ${chalk.cyan(aiInsight.entryPoint)}
 
-${chalk.bold.red('🔥 Known Architectural Risks & Hotspots:')}
-${aiInsight.painPoints.map((p) => ` • ${p}`).join('\n\n')}
+${chalk.bold.red(' Known Architectural Risks & Hotspots:')}
+${painPointsToDisplay.map((p) => ` • ${formatInlineMarkdown(p)}`).join('\n\n')}
 
-${chalk.bold.green('🧭 Strategic Onboarding Read Order:')}
-${aiInsight.readOrder.map((r, idx) => ` ${idx + 1}. ${r}`).join('\n')}`, '⚡ FrontTerrain Codebase Teardown (YC Pitch Edition)');
+${chalk.bold.green(' Strategic Onboarding Read Order:')}
+${readOrderToDisplay.map((r, idx) => ` ${idx + 1}. ${formatInlineMarkdown(r)}`).join('\n')}`, ' FrontTerrain Codebase Teardown.');
+    if (options?.ask) {
+        const { speakText, listenSpeechToText, promptInteractionMode } = await import('../engine/voiceEngine.js');
+        const modeChoice = await promptInteractionMode();
+        const isAudioMode = modeChoice === 'audio';
+        safeNote(chalk.cyan(`Interactive AI Q&A session active${targetLang ? ` (${targetLang})` : ''} [${isAudioMode ? ' Audio Mode' : ' Text Mode'}].\nAsk any question about this codebase. Press Ctrl+C to exit at any time.`), ' Interactive Q&A Mode');
+        const chatHistory = [];
+        while (true) {
+            let qText = '';
+            if (isAudioMode) {
+                safeNote(chalk.cyan(' Listening to your microphone for repository query...'), ' Scout Audio Interaction');
+                const transcript = await listenSpeechToText();
+                if (transcript && transcript.trim()) {
+                    qText = transcript.trim();
+                    safeNote(` Voice Question: "${chalk.bold.green(qText)}"`, ' Scout STT Input');
+                }
+                else {
+                    safeNote(chalk.yellow('No speech transcript detected or listener timed out.'), ' Scout Voice Input');
+                    continue;
+                }
+            }
+            else {
+                const query = await text({
+                    message: chalk.bold('Ask a query about this repository:'),
+                    placeholder: 'e.g. How does authentication work? (Ctrl+C to exit)',
+                    validate: (value) => {
+                        if (!value || !value.trim())
+                            return 'Query cannot be empty';
+                        return undefined;
+                    },
+                });
+                if (isCancel(query)) {
+                    safeNote(chalk.yellow('Exiting interactive session. Goodbye!'), ' Q&A Ended');
+                    break;
+                }
+                qText = query.trim();
+            }
+            if (['exit', 'quit', 'q'].includes(qText.toLowerCase())) {
+                safeNote(chalk.yellow('Exiting interactive session. Goodbye!'), ' Q&A Ended');
+                break;
+            }
+            const askSpinner = spinner();
+            const isWebNeeded = options?.web ||
+                /^\/(web|internet|search)\b/i.test(qText) ||
+                /\b(search the web|internet|online docs|latest docs|web search)\b/i.test(qText);
+            if (isWebNeeded) {
+                askSpinner.start('Searching internet & analyzing codebase context...');
+            }
+            else {
+                askSpinner.start('Analyzing codebase');
+            }
+            const answer = await askRepoQuestion(qText, projectName, filesList, manifestContent || '{}', chatHistory, { useWeb: options?.web, language: targetLang, native: options?.native });
+            askSpinner.stop('Response:');
+            const formattedAnswer = renderMarkdown(answer);
+            safeNote(formattedAnswer, ` ${qText}`);
+            if (isAudioMode) {
+                await speakText(answer);
+            }
+            chatHistory.push({ role: 'user', content: qText });
+            chatHistory.push({ role: 'assistant', content: answer });
+        }
+    }
 }
 //# sourceMappingURL=init.js.map