draftify-cli 1.0.0

package/dist/repl.js

@@ -0,0 +1,1102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalAbortController = void 0;
+exports.startRepl = startRepl;
+const readline_1 = __importDefault(require("readline"));
+const stream_1 = require("stream");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const ui_1 = require("./utils/ui");
+const login_1 = require("./commands/login");
+const api_1 = require("./utils/api");
+const config_1 = require("./utils/config");
+const chats_1 = require("./utils/chats");
+const kleur_1 = require("kleur");
+// Helper to gather dynamic context from the workspace based on user prompt
+function getContextForPrompt(dir, prompt) {
+    const codeFiles = [];
+    const allPaths = [];
+    const maxPaths = 200;
+    function walk(currentDir, depth = 0) {
+        if (depth > 4 || allPaths.length >= maxPaths)
+            return;
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (allPaths.length >= maxPaths)
+                break;
+            const fullPath = path_1.default.join(currentDir, entry.name);
+            const relPath = path_1.default.relative(dir, fullPath);
+            if (entry.isDirectory()) {
+                if (!['node_modules', '.git', 'dist', 'build', '.next', '__pycache__', 'venv', 'env'].includes(entry.name)) {
+                    walk(fullPath, depth + 1);
+                }
+            }
+            else if (entry.isFile()) {
+                allPaths.push(relPath);
+            }
+        }
+    }
+    walk(dir, 0);
+    const lowercasePrompt = prompt.toLowerCase();
+    // Check if any specific workspace files are mentioned in the prompt
+    const matchedFiles = allPaths.filter(filePath => {
+        const baseName = path_1.default.basename(filePath).toLowerCase();
+        const nameWithoutExt = path_1.default.parse(baseName).name.toLowerCase();
+        const ext = path_1.default.extname(filePath).toLowerCase();
+        const validExts = [
+            '.ts', '.tsx', '.js', '.jsx', '.css', '.json', '.html',
+            '.py', '.md', '.txt', '.c', '.cpp', '.h', '.java', '.go', '.rs', '.php', '.rb', '.sh'
+        ];
+        if (!validExts.includes(ext))
+            return false;
+        // Check if the prompt contains the full filename (e.g. 'snake.py') or name without ext (e.g. 'snake')
+        return lowercasePrompt.includes(baseName) || (nameWithoutExt.length > 2 && lowercasePrompt.includes(nameWithoutExt));
+    });
+    let filesToRead = [];
+    if (matchedFiles.length > 0) {
+        // If specific files are mentioned, only load those files
+        filesToRead = matchedFiles.slice(0, 5);
+    }
+    else {
+        // Fallback: Always load the most recently modified source files to maintain context
+        const sourceFiles = allPaths.filter(filePath => {
+            const ext = path_1.default.extname(filePath).toLowerCase();
+            return ['.ts', '.tsx', '.js', '.jsx', '.py', '.c', '.cpp', '.java', '.go', '.rs', '.css', '.html'].includes(ext);
+        });
+        const filesWithStats = sourceFiles.map(filePath => {
+            const fullPath = path_1.default.resolve(dir, filePath);
+            try {
+                const stats = fs_1.default.statSync(fullPath);
+                return { path: filePath, mtime: stats.mtimeMs };
+            }
+            catch {
+                return { path: filePath, mtime: 0 };
+            }
+        });
+        // Sort by last modified time (descending)
+        filesWithStats.sort((a, b) => b.mtime - a.mtime);
+        filesToRead = filesWithStats.slice(0, 3).map(f => f.path);
+    }
+    // Load the contents of selected files
+    for (const filePath of filesToRead) {
+        const fullPath = path_1.default.resolve(dir, filePath);
+        try {
+            ui_1.ui.fileRead(filePath);
+            const content = fs_1.default.readFileSync(fullPath, 'utf-8');
+            if (content.length < 50000) { // Limit to 50KB per file
+                codeFiles.push({ path: filePath, content });
+            }
+        }
+        catch {
+            // Ignore unreadable files
+        }
+    }
+    let structureStr = allPaths.join('\n');
+    if (allPaths.length >= maxPaths) {
+        structureStr += '\n... (and more files omitted)';
+    }
+    let combinedCode = `--- PROJECT DIRECTORY STRUCTURE ---\n${structureStr}\n\n`;
+    if (codeFiles.length > 0) {
+        combinedCode += `--- ATTACHED FILE CONTENTS ---\n`;
+        combinedCode += codeFiles.map(f => `--- File: ${f.path} ---\n${f.content}\n`).join('\n');
+    }
+    return {
+        fileName: codeFiles.length > 0 ? codeFiles[0].path : "workspace_context",
+        code: combinedCode
+    };
+}
+function askSimpleQuestion(questionText) {
+    return new Promise((resolve) => {
+        process.stdout.write(questionText);
+        const isRaw = process.stdin.isRaw;
+        process.stdin.setRawMode(false);
+        const onData = (data) => {
+            process.stdin.off('data', onData);
+            process.stdin.setRawMode(isRaw);
+            resolve(data.toString().trim());
+        };
+        process.stdin.on('data', onData);
+    });
+}
+let lastSigintTime = 0;
+exports.globalAbortController = null;
+const backgroundProcesses = [];
+function cleanupBackgroundProcesses() {
+    if (backgroundProcesses.length === 0)
+        return;
+    for (const proc of backgroundProcesses) {
+        try {
+            if (process.platform === "win32") {
+                const { execSync } = require('child_process');
+                execSync(`taskkill /pid ${proc.pid} /f /t`, { stdio: 'ignore' });
+            }
+            else {
+                process.kill(-proc.pid, 'SIGKILL');
+            }
+        }
+        catch (e) {
+            try {
+                proc.kill('SIGKILL');
+            }
+            catch (err) { }
+        }
+    }
+    backgroundProcesses.length = 0;
+}
+process.on('exit', cleanupBackgroundProcesses);
+// Catch global SIGINT for when readline is NOT active (e.g. during API call)
+process.on('SIGINT', () => {
+    if (exports.globalAbortController) {
+        exports.globalAbortController.abort();
+        exports.globalAbortController = null;
+        return;
+    }
+    const now = Date.now();
+    if (now - lastSigintTime < 2000) {
+        cleanupBackgroundProcesses();
+        console.log("\nGoodbye!");
+        process.exit(0);
+    }
+    else {
+        lastSigintTime = now;
+        console.log("\nPress Ctrl+C again to exit.");
+    }
+});
+// Ensure keypress events are emitted on stdin globally
+readline_1.default.emitKeypressEvents(process.stdin);
+function getInteractiveInput(promptText, commands) {
+    return new Promise((resolve) => {
+        process.stdout.write("\x1b[1 q");
+        const inputStream = new stream_1.PassThrough();
+        const isRaw = process.stdin.isRaw;
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume(); // Crucial: forces the stream to resume flowing data after being paused
+        let isPasting = false;
+        let pasteLines = 0;
+        let accumulatedLines = [];
+        let pasteTimeout = null;
+        const rl = readline_1.default.createInterface({
+            input: inputStream,
+            output: process.stdout,
+            prompt: promptText,
+            completer: (line) => {
+                if (line.startsWith("/")) {
+                    const hits = commands.filter((c) => c.startsWith(line));
+                    return [hits.length ? hits : commands, line];
+                }
+                return [[], line];
+            }
+        });
+        const onData = (data) => {
+            const str = data.toString('utf-8');
+            // Detect Alt+Enter or Esc+Enter (which sends \x1b\r) or CSI u Shift+Enter (\x1b[13;2u)
+            if (str === '\x1b\r' || str === '\x1b\n' || str === '\x1b[13;2u') {
+                // User pressed Alt+Enter or Shift+Enter
+                accumulatedLines.push(rl.line);
+                rl.write(null, { ctrl: true, name: 'u' }); // Clear current line in readline
+                process.stdout.write('\n' + ' '.repeat(promptText.length));
+                return; // Do not pass to readline, avoiding a submit
+            }
+            // Paste detection: if data contains multiple lines in one chunk
+            if (str.length > 5 && (str.includes('\n') || str.includes('\r'))) {
+                isPasting = true;
+                const matches = str.match(/\r?\n/g);
+                if (matches) {
+                    pasteLines += matches.length;
+                }
+            }
+            inputStream.write(data);
+        };
+        process.stdin.on('data', onData);
+        rl.prompt();
+        const onKeypress = () => {
+            const line = rl.line;
+            process.stdout.write(`\x1b[s\x1b[K\x1b[u`);
+            if (line.startsWith("/") && line.length > 0) {
+                const hits = commands.filter((c) => c.startsWith(line));
+                if (hits.length >= 1 && hits[0] !== line) {
+                    const remaining = hits[0].slice(line.length);
+                    process.stdout.write(`\x1b[s\x1b[90m${remaining}\x1b[0m\x1b[u`);
+                }
+            }
+        };
+        const keypressHandler = (str, key) => {
+            const line = rl.line;
+            // Alt+Enter or Shift+Enter manual interception
+            if ((key && key.name === 'return' && key.shift) || (key && key.sequence === '\x1b\r')) {
+                // This doesn't trigger 'line' in readline if we intercept it, but readline still saw it.
+            }
+            if (key && key.name === 'right' && line.startsWith("/")) {
+                const hits = commands.filter((c) => c.startsWith(line));
+                if (hits.length >= 1 && hits[0] !== line) {
+                    const remaining = hits[0].slice(line.length);
+                    rl.write(remaining);
+                    return;
+                }
+            }
+            setTimeout(onKeypress, 0);
+        };
+        process.stdin.on('keypress', keypressHandler);
+        rl.on('line', (line) => {
+            accumulatedLines.push(line);
+            // Handle explicit line continuation using backslash
+            if (line.trimEnd().endsWith('\\')) {
+                accumulatedLines[accumulatedLines.length - 1] = line.trimEnd().slice(0, -1);
+                rl.setPrompt(' '.repeat(promptText.length));
+                rl.prompt();
+                return;
+            }
+            if (isPasting) {
+                // If we are pasting, we don't submit immediately.
+                // We wait for the chunk to finish processing.
+                if (pasteTimeout)
+                    clearTimeout(pasteTimeout);
+                pasteTimeout = setTimeout(() => {
+                    isPasting = false; // Paste finished
+                    if (pasteLines > 1) {
+                        process.stdout.write(`\n\x1b[90m[${pasteLines} lines pasted...]\x1b[0m\n`);
+                    }
+                    pasteLines = 0;
+                    rl.setPrompt(' '.repeat(promptText.length));
+                    rl.prompt(); // Provide a prompt for them to press enter again to submit
+                }, 400);
+                return;
+            }
+            // If they just press Enter on an empty line while there are accumulated lines, 
+            // we assume they want to submit the pasted content.
+            // Wait, if it wasn't a paste, and they just pressed Enter, we submit.
+            process.stdin.off('data', onData);
+            process.stdin.off('keypress', keypressHandler);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(isRaw);
+            }
+            process.stdin.pause();
+            process.stdout.write(`\x1b[s\x1b[K\x1b[u`);
+            // Clean up empty line at the end if it was from submitting a paste
+            if (accumulatedLines.length > 1 && accumulatedLines[accumulatedLines.length - 1] === "") {
+                accumulatedLines.pop();
+            }
+            const inputStr = accumulatedLines.join('\n').trim();
+            rl.close();
+            resolve(inputStr);
+        });
+        rl.on('SIGINT', () => {
+            process.stdin.off('data', onData);
+            process.stdin.off('keypress', keypressHandler);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(isRaw);
+            }
+            process.stdin.pause();
+            process.stdout.write(`\x1b[s\x1b[K\x1b[u`);
+            rl.close();
+            const now = Date.now();
+            if (now - lastSigintTime < 2000) {
+                console.log("\nGoodbye!");
+                process.exit(0);
+            }
+            else {
+                lastSigintTime = now;
+                console.log("\nPress Ctrl+C again to exit.");
+                resolve(null);
+            }
+        });
+    });
+}
+async function startRepl(initialUsername) {
+    // Prevent Node.js from exiting when stdin listeners are temporarily removed
+    setInterval(() => { }, 1000000);
+    const repoName = path_1.default.basename(process.cwd());
+    let currentModel = (0, config_1.getModel)();
+    let username = initialUsername;
+    let plan = "Draftify Scale";
+    const profile = await (0, api_1.getUserProfile)();
+    if (profile) {
+        username = profile.username;
+        plan = profile.plan;
+    }
+    const renderWelcome = () => {
+        console.clear();
+        ui_1.ui.welcomeScreen(repoName, currentModel, username, plan, (0, config_1.getThinkingLevel)());
+    };
+    renderWelcome();
+    let conversationHistory = [];
+    let currentSessionId = Date.now().toString();
+    let autoPrompt = "";
+    let alwaysAllowCommands = false;
+    const loop = async () => {
+        while (true) {
+            let inputLine = "";
+            if (autoPrompt) {
+                inputLine = autoPrompt;
+                autoPrompt = "";
+                ui_1.ui.info(`Answers automatically sent to the AI.`);
+            }
+            else {
+                const commandsList = ['/new-chat', '/chats', '/skills', '/model', '/thinking-level', '/login', '/logout', '/help', '/exit', '/quit'];
+                ui_1.ui.divider();
+                let answer = await getInteractiveInput((0, kleur_1.dim)("> "), commandsList);
+                ui_1.ui.divider();
+                if (answer === null)
+                    continue;
+                inputLine = answer.trim();
+            }
+            if (!inputLine)
+                continue;
+            const cmdLower = inputLine.split(" ")[0].toLowerCase();
+            const token = (0, config_1.getToken)();
+            if (!token && cmdLower !== "/login" && cmdLower !== "/exit" && cmdLower !== "/quit") {
+                ui_1.ui.error("You are not logged in! Please use the /login command to continue.");
+                continue;
+            }
+            // 1. Slash commands (/)
+            if (inputLine.startsWith("/")) {
+                const parts = inputLine.split(" ");
+                const cmd = parts[0].slice(1).toLowerCase();
+                if (cmd === "exit" || cmd === "quit") {
+                    ui_1.ui.success("Goodbye!");
+                    process.exit(0);
+                }
+                else if (cmd === "clear" || cmd === "new-chat") {
+                    conversationHistory = [];
+                    currentSessionId = Date.now().toString(); // Reset session ID for a new chat
+                    ui_1.ui.success("New chat started! Conversation history cleared.");
+                }
+                else if (cmd === "login") {
+                    const newUsername = await (0, login_1.loginCommand)();
+                    const p = await (0, api_1.getUserProfile)();
+                    if (p) {
+                        username = p.username;
+                        plan = p.plan;
+                    }
+                    else {
+                        username = newUsername;
+                    }
+                    conversationHistory = [];
+                    currentSessionId = Date.now().toString();
+                    renderWelcome();
+                }
+                else if (cmd === "logout") {
+                    (0, config_1.saveConfig)({ token: "" });
+                    username = undefined;
+                    plan = "Draftify Scale";
+                    conversationHistory = [];
+                    currentSessionId = Date.now().toString();
+                    renderWelcome();
+                    ui_1.ui.success("Successfully logged out. Use the /login command to log back in.");
+                }
+                else if (cmd === "skills") {
+                    const { MultiSelect } = require('enquirer');
+                    const { getAvailableSkills } = require('./utils/skills');
+                    try {
+                        const availableSkills = getAvailableSkills();
+                        if (availableSkills.length === 0) {
+                            ui_1.ui.info("No skills found in .agents/skills directories (neither globally nor locally).");
+                            continue;
+                        }
+                        const currentSkills = (0, config_1.getSkills)();
+                        const prompt = new MultiSelect({
+                            name: 'skills',
+                            message: 'Toggle Draftify Skills (Space to select, Enter to save):',
+                            choices: availableSkills.map((s) => ({
+                                name: s.name,
+                                value: s.name,
+                                message: `${s.name} ${(0, kleur_1.dim)(`(${s.source})`)}`
+                            })),
+                            initial: currentSkills
+                        });
+                        const answer = await prompt.run();
+                        (0, config_1.setSkills)(answer);
+                        ui_1.ui.success(`Skills saved: ${answer.join(', ') || 'None enabled'}`);
+                    }
+                    catch (e) {
+                        ui_1.ui.info("Skill selection aborted.");
+                    }
+                }
+                else if (cmd === "help") {
+                    ui_1.ui.header("Available commands:");
+                    console.log(`  ${(0, kleur_1.cyan)("/new-chat")}  - Start a new chat, clear history`);
+                    console.log(`  ${(0, kleur_1.cyan)("/chats")}     - List and load previous chats`);
+                    console.log(`  ${(0, kleur_1.cyan)("/skills")}    - Manage and configure skills`);
+                    console.log(`  ${(0, kleur_1.cyan)("/model")}     - Switch model (e.g., /model Opus 4.8-level)`);
+                    console.log(`  ${(0, kleur_1.cyan)("/thinking-level")} - Adjust the AI's thinking process depth`);
+                    console.log(`  ${(0, kleur_1.cyan)("/login")}     - Log in to your Draftify account`);
+                    console.log(`  ${(0, kleur_1.cyan)("/logout")}    - Log out of your account`);
+                    console.log(`  ${(0, kleur_1.cyan)("/help")}      - List commands`);
+                    console.log(`  ${(0, kleur_1.cyan)("/clear")}     - Clear the terminal screen`);
+                    console.log(`  ${(0, kleur_1.cyan)("/exit")}      - Exit the CLI`);
+                    console.log(`  ${(0, kleur_1.cyan)("!")}${(0, kleur_1.dim)("<command>")}  - Run a system command in the terminal (e.g., !npm run build)\n`);
+                }
+                else if (cmd === "clear") {
+                    renderWelcome();
+                }
+                else if (cmd === "chats") {
+                    const chats = (0, chats_1.loadChats)();
+                    if (chats.length === 0) {
+                        ui_1.ui.info("No saved chats found.");
+                        continue;
+                    }
+                    const { Select } = require('enquirer');
+                    try {
+                        const prompt = new Select({
+                            name: 'chat',
+                            message: 'Select a previous conversation:',
+                            choices: [
+                                ...chats.map((c, idx) => ({
+                                    name: c.id,
+                                    message: `[${c.model}] ${c.title} (${new Date(c.updatedAt).toLocaleString()})`
+                                })),
+                                { name: 'cancel', message: 'Cancel' }
+                            ]
+                        });
+                        const choiceId = await prompt.run();
+                        if (choiceId !== 'cancel') {
+                            const selected = chats.find(c => c.id === choiceId);
+                            currentSessionId = selected.id;
+                            conversationHistory = selected.history;
+                            currentModel = selected.model;
+                            (0, config_1.setModel)(currentModel);
+                            renderWelcome();
+                            ui_1.ui.success(`Conversation successfully loaded: "${selected.title}"`);
+                        }
+                        else {
+                            ui_1.ui.info("Loading aborted.");
+                        }
+                    }
+                    catch (e) {
+                        ui_1.ui.info("Loading aborted.");
+                    }
+                }
+                else if (cmd === "model") {
+                    const newModel = parts.slice(1).join(" ").trim();
+                    if (newModel) {
+                        currentModel = newModel;
+                        (0, config_1.setModel)(currentModel);
+                        ui_1.ui.success(`Model changed to ${currentModel}`);
+                    }
+                    else {
+                        const { Select } = require('enquirer');
+                        try {
+                            const prompt = new Select({
+                                name: 'model',
+                                message: 'Select the model to use:',
+                                choices: [
+                                    'Opus 4.8-level',
+                                    'Opus 4.7-level',
+                                    'Opus 4.6-level',
+                                    'Sonnet 4.6-level',
+                                    'Haiku 4.5-level',
+                                    { name: 'Cancel', message: 'Cancel' }
+                                ]
+                            });
+                            const answer = await prompt.run();
+                            if (answer !== 'Cancel') {
+                                currentModel = answer;
+                                (0, config_1.setModel)(currentModel);
+                                renderWelcome();
+                                ui_1.ui.success(`Model updated to: ${currentModel}`);
+                            }
+                            else {
+                                ui_1.ui.info("Model selection aborted.");
+                            }
+                        }
+                        catch (e) {
+                            ui_1.ui.info("Model selection aborted.");
+                        }
+                    }
+                }
+                else if (cmd === "thinking-level") {
+                    const { Select } = require('enquirer');
+                    try {
+                        const prompt = new Select({
+                            name: 'level',
+                            message: 'Select Thinking Level:',
+                            choices: [
+                                { name: 'Adaptive', message: 'Adaptive - Auto-detect (best)' },
+                                { name: 'Low', message: 'Low - Ultra-fast' },
+                                { name: 'Medium', message: 'Medium - Balanced' },
+                                { name: 'High', message: 'High - Deep logic' },
+                                { name: 'Cancel', message: 'Cancel' }
+                            ]
+                        });
+                        const answer = await prompt.run();
+                        if (answer !== 'Cancel') {
+                            (0, config_1.setThinkingLevel)(answer);
+                            renderWelcome();
+                            ui_1.ui.success(`Thinking level updated to: ${answer}`);
+                        }
+                        else {
+                            ui_1.ui.info("Thinking level selection aborted.");
+                        }
+                    }
+                    catch (e) {
+                        ui_1.ui.info("Thinking level selection aborted.");
+                    }
+                }
+                else {
+                    ui_1.ui.error(`Unknown command: /${cmd}`);
+                }
+                continue;
+            }
+            // 2. Shell commands (!)
+            if (inputLine.startsWith("!")) {
+                const shellCmd = inputLine.slice(1).trim();
+                if (!shellCmd) {
+                    ui_1.ui.error("No shell command provided.");
+                    continue;
+                }
+                try {
+                    ui_1.ui.step(`Running: ${shellCmd}`);
+                    const outputData = await new Promise((resolve, reject) => {
+                        const { spawn } = require('child_process');
+                        const child = spawn(shellCmd, {
+                            cwd: process.cwd(),
+                            shell: true
+                        });
+                        let outputBuffer = "";
+                        child.stdout.on('data', (data) => {
+                            const str = data.toString();
+                            outputBuffer += str;
+                            process.stdout.write((0, kleur_1.dim)(str));
+                        });
+                        child.stderr.on('data', (data) => {
+                            const str = data.toString();
+                            outputBuffer += str;
+                            process.stderr.write((0, kleur_1.dim)(str));
+                        });
+                        child.on('close', (code) => {
+                            if (code === 0) {
+                                resolve(outputBuffer);
+                            }
+                            else {
+                                reject(outputBuffer || `Process exited with code ${code}`);
+                            }
+                        });
+                        child.on('error', (err) => {
+                            reject(err.message);
+                        });
+                    });
+                    conversationHistory.push({
+                        role: "user",
+                        content: `Executed shell command: ${shellCmd}\nOutput:\n${outputData}`
+                    });
+                    ui_1.ui.success("Command executed and output added to context.");
+                }
+                catch (err) {
+                    ui_1.ui.error(`Command failed:\n${err}`);
+                    conversationHistory.push({
+                        role: "user",
+                        content: `Executed shell command: ${shellCmd}\nFailed with error:\n${err}`
+                    });
+                }
+                continue;
+            }
+            // 3. AI Chat Prompt (default)
+            async function applyFileOperations(result) {
+                let displayResult = result;
+                const isSafePath = (targetPath) => {
+                    const relative = path_1.default.relative(process.cwd(), targetPath);
+                    return !relative.startsWith('..') && !path_1.default.isAbsolute(relative);
+                };
+                const createRegex = /<FILE_CREATE\s+path="([^"]+)">([\s\S]*?)<\/FILE_CREATE>/g;
+                let match;
+                while ((match = createRegex.exec(result)) !== null) {
+                    const filePath = match[1];
+                    const fullPath = path_1.default.resolve(process.cwd(), filePath);
+                    if (!isSafePath(fullPath)) {
+                        ui_1.ui.error(`Security error: Cannot create file outside workspace (${filePath})`);
+                        displayResult = displayResult.replace(match[0], `\n[Blocked: ${filePath} is outside workspace]\n`);
+                        continue;
+                    }
+                    // Remove leading/trailing newlines that the LLM might have added immediately inside the tag, 
+                    // but preserve the rest. A simple trim is usually enough, but let's be safe.
+                    const content = match[2].replace(/^\n|\n$/g, '');
+                    try {
+                        fs_1.default.mkdirSync(path_1.default.dirname(fullPath), { recursive: true });
+                        fs_1.default.writeFileSync(fullPath, content, 'utf-8');
+                        ui_1.ui.fileSuccess("Created", filePath);
+                        displayResult = displayResult.replace(match[0], '');
+                    }
+                    catch (e) {
+                        ui_1.ui.error(`Failed to create ${filePath}: ${e.message}`);
+                    }
+                }
+                const modifyRegex = /<FILE_MODIFY\s+path="([^"]+)">([\s\S]*?)<\/FILE_MODIFY>/g;
+                while ((match = modifyRegex.exec(result)) !== null) {
+                    const filePath = match[1];
+                    const block = match[2];
+                    const fullPath = path_1.default.resolve(process.cwd(), filePath);
+                    if (!isSafePath(fullPath)) {
+                        ui_1.ui.error(`Security error: Cannot modify file outside workspace (${filePath})`);
+                        displayResult = displayResult.replace(match[0], `[Blocked: ${filePath} is outside workspace]`);
+                        continue;
+                    }
+                    if (fs_1.default.existsSync(fullPath)) {
+                        let fileContent = fs_1.default.readFileSync(fullPath, 'utf-8');
+                        const searchBlockRegex = /<<<<<<< SEARCH\n([\s\S]*?)\n=======\n([\s\S]*?)\n>>>>>>>/g;
+                        let diffMatch;
+                        let diffApplied = false;
+                        let hasDiffBlocks = false;
+                        while ((diffMatch = searchBlockRegex.exec(block)) !== null) {
+                            hasDiffBlocks = true;
+                            let search = diffMatch[1];
+                            let replace = diffMatch[2];
+                            // Normalize CRLF to LF for reliable string matching
+                            let normalizedFile = fileContent.replace(/\r\n/g, '\n');
+                            search = search.replace(/\r\n/g, '\n');
+                            replace = replace.replace(/\r\n/g, '\n');
+                            if (normalizedFile.includes(search)) {
+                                fileContent = normalizedFile.replace(search, replace);
+                                diffApplied = true;
+                            }
+                            else {
+                                // Fallback: try stripping leading/trailing empty lines/whitespace from the search block
+                                const trimmedSearch = search.trim();
+                                if (trimmedSearch && normalizedFile.includes(trimmedSearch)) {
+                                    fileContent = normalizedFile.replace(trimmedSearch, replace.trim());
+                                    diffApplied = true;
+                                }
+                                else {
+                                    ui_1.ui.error(`Could not apply diff to ${filePath}: SEARCH block not exactly matched.`);
+                                }
+                            }
+                        }
+                        if (hasDiffBlocks && diffApplied) {
+                            fs_1.default.writeFileSync(fullPath, fileContent, 'utf-8');
+                            ui_1.ui.fileSuccess("Modified", filePath);
+                            displayResult = displayResult.replace(match[0], '');
+                        }
+                        else if (!hasDiffBlocks) {
+                            ui_1.ui.error(`Invalid FILE_MODIFY block for ${filePath}`);
+                        }
+                        else {
+                            displayResult = displayResult.replace(match[0], `[Failed to modify: ${filePath} - SEARCH block mismatch]`);
+                        }
+                    }
+                    else {
+                        ui_1.ui.error(`Cannot modify ${filePath}: File not found.`);
+                    }
+                }
+                const deleteRegex = /<FILE_DELETE\s+path="([^"]+)"\s*\/>/g;
+                while ((match = deleteRegex.exec(result)) !== null) {
+                    const filePath = match[1];
+                    const fullPath = path_1.default.resolve(process.cwd(), filePath);
+                    if (!isSafePath(fullPath)) {
+                        ui_1.ui.error(`Security error: Cannot delete file outside workspace (${filePath})`);
+                        displayResult = displayResult.replace(match[0], `[Blocked: ${filePath} is outside workspace]`);
+                        continue;
+                    }
+                    if (fs_1.default.existsSync(fullPath)) {
+                        try {
+                            fs_1.default.unlinkSync(fullPath);
+                            ui_1.ui.fileSuccess("Deleted", filePath);
+                            displayResult = displayResult.replace(match[0], '');
+                        }
+                        catch (e) {
+                            ui_1.ui.error(`Failed to delete ${filePath}: ${e.message}`);
+                        }
+                    }
+                }
+                const commandsToRun = [];
+                const runRegex = /<RUN_COMMAND>([\s\S]*?)<\/RUN_COMMAND>/g;
+                while ((match = runRegex.exec(result)) !== null) {
+                    commandsToRun.push(match[1].trim());
+                    displayResult = displayResult.replace(match[0], '');
+                }
+                const filesToReadAuto = [];
+                const readRegex = /<READ_FILE\s+path="([^"]+)"\s*\/>/g;
+                while ((match = readRegex.exec(result)) !== null) {
+                    filesToReadAuto.push(match[1]);
+                    displayResult = displayResult.replace(match[0], '');
+                }
+                const dirsToListAuto = [];
+                const listRegex = /<LIST_DIR\s+path="([^"]+)"\s*\/>/g;
+                while ((match = listRegex.exec(result)) !== null) {
+                    dirsToListAuto.push(match[1]);
+                    displayResult = displayResult.replace(match[0], '');
+                }
+                // Clean up any remaining excessive newlines from the LLM output around the tags
+                return {
+                    cleanResult: displayResult.replace(/\n\s*\n\s*\n/g, '\n\n').trim(),
+                    commandsToRun,
+                    filesToReadAuto,
+                    dirsToListAuto
+                };
+            }
+            exports.globalAbortController = new AbortController();
+            let spinner = null;
+            try {
+                // Dynamically gather context based on the current request
+                const dynamicCtx = getContextForPrompt(process.cwd(), inputLine);
+                const requestPayloadFileName = dynamicCtx.fileName;
+                const requestPayloadCode = dynamicCtx.code;
+                let currentStreamedText = "";
+                let finalPrompt = inputLine;
+                let activeSkillsData = [];
+                const activeSkillNames = (0, config_1.getSkills)();
+                if (activeSkillNames.length > 0) {
+                    const { getAvailableSkills } = require('./utils/skills');
+                    const allAvailable = getAvailableSkills();
+                    activeSkillsData = allAvailable.filter((s) => activeSkillNames.includes(s.name));
+                }
+                const activeActions = new Set();
+                spinner = (0, ui_1.createSpinner)("Thinking...").start();
+                const rawResult = await (0, api_1.refactorCodeApi)(requestPayloadFileName, requestPayloadCode, finalPrompt, conversationHistory, currentModel, activeSkillsData, (0, config_1.getThinkingLevel)(), (chunk) => {
+                    currentStreamedText += chunk;
+                    // Find the last opened tag that hasn't been closed yet
+                    const createMatch = currentStreamedText.match(/<FILE_CREATE\s+path="([^"]+)"[^>]*>(?![\s\S]*<\/FILE_CREATE>)/);
+                    const modifyMatch = currentStreamedText.match(/<FILE_MODIFY\s+path="([^"]+)"[^>]*>(?![\s\S]*<\/FILE_MODIFY>)/);
+                    const deleteMatch = currentStreamedText.match(/<FILE_DELETE\s+path="([^"]+)"/);
+                    if (createMatch) {
+                        const filePath = createMatch[1];
+                        const actionKey = `create:${filePath}`;
+                        if (!activeActions.has(actionKey)) {
+                            activeActions.add(actionKey);
+                            spinner.stop();
+                            ui_1.ui.fileCreate(filePath);
+                            spinner.start();
+                        }
+                        spinner.setPrefix(`Creating ${filePath}...`);
+                    }
+                    else if (modifyMatch) {
+                        const filePath = modifyMatch[1];
+                        const actionKey = `modify:${filePath}`;
+                        if (!activeActions.has(actionKey)) {
+                            activeActions.add(actionKey);
+                            spinner.stop();
+                            ui_1.ui.fileModify(filePath);
+                            spinner.start();
+                        }
+                        spinner.setPrefix(`Modifying ${filePath}...`);
+                    }
+                    else if (deleteMatch) {
+                        const filePath = deleteMatch[1];
+                        const actionKey = `delete:${filePath}`;
+                        if (!activeActions.has(actionKey)) {
+                            activeActions.add(actionKey);
+                            spinner.stop();
+                            ui_1.ui.fileDelete(filePath);
+                            spinner.start();
+                        }
+                        spinner.setPrefix(`Deleting ${filePath}...`);
+                    }
+                    else if (currentStreamedText.length > 10) {
+                        spinner.setPrefix("Analyzing...");
+                    }
+                }, exports.globalAbortController.signal);
+                spinner.stop();
+                const { cleanResult, commandsToRun, filesToReadAuto, dirsToListAuto } = await applyFileOperations(rawResult);
+                // --- PARSE CLARIFICATION QUESTIONS ---
+                let finalDisplayResult = cleanResult;
+                let questions = [];
+                const questionMatch = cleanResult.match(/<ASK_QUESTIONS>([\s\S]*?)<\/ASK_QUESTIONS>/);
+                if (questionMatch) {
+                    try {
+                        questions = JSON.parse(questionMatch[1].trim());
+                        finalDisplayResult = cleanResult.replace(questionMatch[0], '').trim();
+                    }
+                    catch (e) { }
+                }
+                // --- TOKEN OPTIMIZATION ---
+                // Optimize the user input (especially autonomous file reads & command outputs)
+                let tokenOptimizedInput = inputLine;
+                if (tokenOptimizedInput.includes("I executed your file system requests. Here are the results:")) {
+                    tokenOptimizedInput = tokenOptimizedInput
+                        .replace(/File: ([^\n]+)\n```[\s\S]*?```/g, 'File: $1\n[File content read and processed]')
+                        .replace(/Directory contents of ([^\n]+):\n[\s\S]*?(?=\n\n|\r?\n\r?\n|$)/g, 'Directory contents of $1:\n[Directory listed]');
+                }
+                if (tokenOptimizedInput.includes("I ran the commands you requested. Here are the results:")) {
+                    tokenOptimizedInput = tokenOptimizedInput
+                        .replace(/Command: ([^\n]+)\nOutput:\n[\s\S]*?(?=\n\n|\r?\n\r?\n|$)/g, 'Command: $1\n[Command output omitted from history]')
+                        .replace(/Command: ([^\n]+)\nFailed with error:\n[\s\S]*?(?=\n\n|\r?\n\r?\n|$)/g, 'Command: $1\n[Command failure output omitted from history]');
+                }
+                if (tokenOptimizedInput.startsWith("Executed shell command:")) {
+                    tokenOptimizedInput = tokenOptimizedInput
+                        .replace(/Output:\n[\s\S]*/, 'Output:\n[Shell output omitted from history]')
+                        .replace(/Failed with error:\n[\s\S]*/, 'Failed with error:\n[Shell error output omitted from history]');
+                }
+                // We strip out the huge code blocks from the AI's response before saving to history,
+                // because the files are already updated on disk. Re-sending them eats massive tokens!
+                const tokenOptimizedResult = finalDisplayResult
+                    .replace(/<FILE_MODIFY([\s\S]*?)>([\s\S]*?)<\/FILE_MODIFY>/g, '<FILE_MODIFY$1>[Content modified on disk]</FILE_MODIFY>')
+                    .replace(/<FILE_CREATE([\s\S]*?)>([\s\S]*?)<\/FILE_CREATE>/g, '<FILE_CREATE$1>[Content created on disk]</FILE_CREATE>')
+                    .replace(/<RUN_COMMAND([\s\S]*?)>([\s\S]*?)<\/RUN_COMMAND>/g, '<RUN_COMMAND$1>[Command execution parsed]</RUN_COMMAND>');
+                conversationHistory.push({ role: "user", content: tokenOptimizedInput });
+                conversationHistory.push({ role: "assistant", content: tokenOptimizedResult });
+                // Keep only the last 6 messages (3 turns) to prevent infinite token growth
+                if (conversationHistory.length > 6) {
+                    conversationHistory = conversationHistory.slice(conversationHistory.length - 6);
+                }
+                // Save session locally
+                const firstUserMsg = conversationHistory.find(h => h.role === "user")?.content || inputLine;
+                (0, chats_1.updateChatSession)(currentSessionId, firstUserMsg, currentModel, conversationHistory);
+                if (finalDisplayResult) {
+                    ui_1.ui.box("Draftify AI", finalDisplayResult.split("\n"));
+                }
+                // --- INTERACTIVE MENU FOR QUESTIONS ---
+                if (questions.length > 0) {
+                    const { Select, Input } = require('enquirer');
+                    let answers = [];
+                    for (const q of questions) {
+                        console.log("");
+                        const prompt = new Select({
+                            name: 'answer',
+                            message: q.question,
+                            choices: [...q.options, "Provide a custom answer..."]
+                        });
+                        let answer = await prompt.run();
+                        if (answer === "Provide a custom answer...") {
+                            const customPrompt = new Input({
+                                message: 'Type your answer:'
+                            });
+                            answer = await customPrompt.run();
+                        }
+                        answers.push(`- Question: ${q.question}\n  Answer: ${answer}`);
+                    }
+                    let promptAdditions = [];
+                    if (autoPrompt)
+                        promptAdditions.push(autoPrompt);
+                    promptAdditions.push("My answers to the questions:\n" + answers.join("\n"));
+                    autoPrompt = promptAdditions.join("\n\n");
+                }
+                // --- AUTONOMOUS FILE SYSTEM EXPLORATION ---
+                let autoExplorationOutputs = [];
+                const isSafePathLocal = (targetPath) => {
+                    const relative = path_1.default.relative(process.cwd(), targetPath);
+                    return !relative.startsWith('..') && !path_1.default.isAbsolute(relative);
+                };
+                for (const dirPath of dirsToListAuto) {
+                    const fullPath = path_1.default.resolve(process.cwd(), dirPath);
+                    if (!isSafePathLocal(fullPath)) {
+                        autoExplorationOutputs.push(`Security error: Cannot list directory outside workspace (${dirPath})`);
+                        ui_1.ui.error(`Blocked attempt to list outside workspace: ${dirPath}`);
+                        continue;
+                    }
+                    try {
+                        if (fs_1.default.existsSync(fullPath)) {
+                            const items = fs_1.default.readdirSync(fullPath, { withFileTypes: true });
+                            const list = items.map((item) => `${item.isDirectory() ? '[DIR]' : '[FILE]'} ${item.name}`).join('\n');
+                            autoExplorationOutputs.push(`Directory contents of ${dirPath}:\n${list}`);
+                            ui_1.ui.info(`Silently listed directory: ${dirPath}`);
+                        }
+                        else {
+                            autoExplorationOutputs.push(`Directory ${dirPath} not found.`);
+                        }
+                    }
+                    catch (e) {
+                        autoExplorationOutputs.push(`Failed to list ${dirPath}: ${e.message}`);
+                    }
+                }
+                for (const filePath of filesToReadAuto) {
+                    const fullPath = path_1.default.resolve(process.cwd(), filePath);
+                    if (!isSafePathLocal(fullPath)) {
+                        autoExplorationOutputs.push(`Security error: Cannot read file outside workspace (${filePath})`);
+                        ui_1.ui.error(`Blocked attempt to read outside workspace: ${filePath}`);
+                        continue;
+                    }
+                    try {
+                        if (fs_1.default.existsSync(fullPath)) {
+                            const content = fs_1.default.readFileSync(fullPath, 'utf-8');
+                            autoExplorationOutputs.push(`File: ${filePath}\n\`\`\`\n${content}\n\`\`\``);
+                            ui_1.ui.info(`Silently read: ${filePath}`);
+                        }
+                        else {
+                            autoExplorationOutputs.push(`File ${filePath} not found.`);
+                        }
+                    }
+                    catch (e) {
+                        autoExplorationOutputs.push(`Failed to read ${filePath}: ${e.message}`);
+                    }
+                }
+                if (autoExplorationOutputs.length > 0) {
+                    let promptAdditions = autoPrompt ? [autoPrompt] : [];
+                    promptAdditions.push(`I executed your file system requests. Here are the results:\n${autoExplorationOutputs.join('\n\n')}`);
+                    autoPrompt = promptAdditions.join("\n\n");
+                }
+                // --- EXECUTE COMMANDS ---
+                if (commandsToRun.length > 0) {
+                    let commandOutputs = [];
+                    let userAbortedEverything = false;
+                    for (const cmdToRun of commandsToRun) {
+                        let runIt = alwaysAllowCommands;
+                        let runInBackground = false;
+                        const isLongRunning = /dev|start|server|watch|nodemon|vite|next|host/i.test(cmdToRun);
+                        if (!runIt) {
+                            const { Select } = require('enquirer');
+                            try {
+                                const choices = [
+                                    { name: 'yes', message: 'Yes (foreground)' }
+                                ];
+                                if (isLongRunning) {
+                                    choices.push({ name: 'background', message: 'Yes (background - keep terminal free)' });
+                                }
+                                else {
+                                    choices.push({ name: 'background', message: 'Run in background' });
+                                }
+                                choices.push({ name: 'no', message: 'No' });
+                                choices.push({ name: 'always', message: 'Always allow for this session' });
+                                const prompt = new Select({
+                                    name: 'allow',
+                                    message: `Draftify AI wants to run: ${cmdToRun}\nAllow execution?`,
+                                    choices: choices
+                                });
+                                const answer = await prompt.run();
+                                if (answer === 'yes')
+                                    runIt = true;
+                                if (answer === 'background') {
+                                    runIt = true;
+                                    runInBackground = true;
+                                }
+                                if (answer === 'always') {
+                                    runIt = true;
+                                    alwaysAllowCommands = true;
+                                }
+                            }
+                            catch (e) {
+                                runIt = false;
+                                userAbortedEverything = true;
+                            }
+                        }
+                        else {
+                            if (isLongRunning) {
+                                runInBackground = true;
+                            }
+                        }
+                        if (userAbortedEverything) {
+                            ui_1.ui.info(`Command execution aborted by user.`);
+                            break;
+                        }
+                        if (runIt) {
+                            if (runInBackground) {
+                                ui_1.ui.step(`Starting in background: ${cmdToRun}`);
+                                try {
+                                    const { spawn } = require('child_process');
+                                    const child = spawn(cmdToRun, {
+                                        cwd: process.cwd(),
+                                        shell: true,
+                                        detached: process.platform !== 'win32'
+                                    });
+                                    backgroundProcesses.push(child);
+                                    let outputBuffer = "";
+                                    const onData = (data) => {
+                                        const str = data.toString();
+                                        outputBuffer += str;
+                                        process.stdout.write((0, kleur_1.dim)(str));
+                                    };
+                                    child.stdout.on('data', onData);
+                                    child.stderr.on('data', onData);
+                                    let hasExited = false;
+                                    let exitCode = null;
+                                    child.on('close', (code) => {
+                                        hasExited = true;
+                                        exitCode = code;
+                                    });
+                                    // Let it initialize for 1.5 seconds, displaying standard log output
+                                    await new Promise((resolve) => setTimeout(resolve, 1500));
+                                    // Detach listeners from stdout so log lines don't garble CLI prompt
+                                    child.stdout.off('data', onData);
+                                    child.stderr.off('data', onData);
+                                    if (hasExited) {
+                                        ui_1.ui.error(`Background process failed immediately with exit code ${exitCode}.`);
+                                        commandOutputs.push(`Command: ${cmdToRun}\nFailed immediately with code ${exitCode}\nOutput:\n${outputBuffer}`);
+                                    }
+                                    else {
+                                        ui_1.ui.success(`Process is running in background (PID: ${child.pid}).`);
+                                        commandOutputs.push(`Command: ${cmdToRun}\nStarted in background and is running.`);
+                                    }
+                                }
+                                catch (err) {
+                                    ui_1.ui.error(`Failed to start background process:\n${err}`);
+                                    commandOutputs.push(`Command: ${cmdToRun}\nFailed to start in background: ${err}`);
+                                }
+                            }
+                            else {
+                                ui_1.ui.step(`Running: ${cmdToRun}`);
+                                try {
+                                    const outputData = await new Promise((resolve, reject) => {
+                                        const { spawn } = require('child_process');
+                                        const child = spawn(cmdToRun, {
+                                            cwd: process.cwd(),
+                                            shell: true,
+                                            signal: exports.globalAbortController?.signal
+                                        });
+                                        let outputBuffer = "";
+                                        child.stdout.on('data', (data) => {
+                                            const str = data.toString();
+                                            outputBuffer += str;
+                                            process.stdout.write((0, kleur_1.dim)(str));
+                                        });
+                                        child.stderr.on('data', (data) => {
+                                            const str = data.toString();
+                                            outputBuffer += str;
+                                            process.stderr.write((0, kleur_1.dim)(str));
+                                        });
+                                        child.on('close', (code) => {
+                                            if (code === 0) {
+                                                resolve(outputBuffer);
+                                            }
+                                            else {
+                                                reject(outputBuffer || `Process exited with code ${code}`);
+                                            }
+                                        });
+                                        child.on('error', (err) => {
+                                            if (err.name === 'AbortError') {
+                                                reject("Command aborted by user.");
+                                            }
+                                            else {
+                                                reject(err.message);
+                                            }
+                                        });
+                                    });
+                                    commandOutputs.push(`Command: ${cmdToRun}\nOutput:\n${outputData}`);
+                                    ui_1.ui.success(`Command executed successfully.`);
+                                }
+                                catch (err) {
+                                    ui_1.ui.error(`Command failed:\n${err}`);
+                                    commandOutputs.push(`Command: ${cmdToRun}\nFailed with error:\n${err}`);
+                                }
+                            }
+                        }
+                        else {
+                            ui_1.ui.error(`Command execution denied: ${cmdToRun}`);
+                            commandOutputs.push(`Command: ${cmdToRun}\nUser denied execution.`);
+                        }
+                    }
+                    if (commandOutputs.length > 0 && !userAbortedEverything) {
+                        let promptAdditions = autoPrompt ? [autoPrompt] : [];
+                        promptAdditions.push(`I ran the commands you requested. Here are the results:\n${commandOutputs.join('\n\n')}`);
+                        autoPrompt = promptAdditions.join("\n\n");
+                    }
+                    else if (userAbortedEverything) {
+                        autoPrompt = ""; // Clear any queued prompts
+                    }
+                }
+            }
+            catch (err) {
+                if (spinner)
+                    spinner.stop();
+                if (err.name === "AbortError" || err.message === "terminated") {
+                    ui_1.ui.info("Generation cancelled.");
+                }
+                else {
+                    ui_1.ui.error(err.message || String(err));
+                }
+            }
+            finally {
+                exports.globalAbortController = null;
+            }
+        }
+    };
+    // Start the loop
+    await loop();
+}