flanders 0.0.1

package/lib/commands/Implement.js

@@ -0,0 +1,696 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Implement = void 0;
+const ClaudeSession_1 = require("../ClaudeSession");
+const fsUtils_1 = require("../fsUtils");
+const Git_1 = require("../Git");
+const PlanFile_1 = require("../PlanFile");
+const prompts_1 = require("../prompts");
+const ScriptRunner_1 = require("../ScriptRunner");
+const BottomBlock_1 = require("../ui/BottomBlock");
+const formatters_1 = require("../ui/formatters");
+const Workspace_1 = require("../Workspace");
+const MAX_ITER = 5;
+class LineBufferedBlock {
+    _block;
+    _stdoutBuf = "";
+    _stderrBuf = "";
+    constructor(_block) {
+        this._block = _block;
+    }
+    write(text) {
+        this._stdoutBuf += text;
+        const idx = this._stdoutBuf.lastIndexOf("\n");
+        if (idx !== -1) {
+            this._block.writeAbove(this._stdoutBuf.slice(0, idx + 1));
+            this._stdoutBuf = this._stdoutBuf.slice(idx + 1);
+        }
+    }
+    writeError(text) {
+        this._stderrBuf += text;
+        const idx = this._stderrBuf.lastIndexOf("\n");
+        if (idx !== -1) {
+            this._block.writeAbove(this._stderrBuf.slice(0, idx + 1));
+            this._stderrBuf = this._stderrBuf.slice(idx + 1);
+        }
+    }
+    flush() {
+        if (this._stdoutBuf) {
+            this._block.writeAbove(this._stdoutBuf);
+            this._stdoutBuf = "";
+        }
+        if (this._stderrBuf) {
+            this._block.writeAbove(this._stderrBuf);
+            this._stderrBuf = "";
+        }
+    }
+}
+class Implement {
+    _options;
+    _contexts;
+    _disposed = false;
+    _contractList = [];
+    _ruleList = [];
+    _workspace = null;
+    _block = null;
+    _buffered;
+    _currentWorkerSessionId = null;
+    _currentPrepSessionId = null;
+    _activeSession = null;
+    _activeScript = null;
+    _currentIndexLabel = "";
+    _currentIteration = 0;
+    _currentTask = null;
+    _taskStartedAt = 0;
+    _taskRateLimitMs = 0;
+    _taskRateLimitStartedAt = null;
+    _taskTokens = { it: 0, ot: 0 };
+    _runPromise;
+    constructor(rawArgs, _options, _contexts) {
+        this._options = _options;
+        this._contexts = _contexts;
+        this._runPromise = this._run(rawArgs);
+        this._runPromise.catch(() => { });
+    }
+    result() {
+        return this._runPromise;
+    }
+    async _run(rawArgs) {
+        const block = new BottomBlock_1.BottomBlock({
+            write: text => this._contexts.output.write(text),
+            columns: () => this._contexts.output.columns(),
+            onResize: listener => this._contexts.output.onResize(listener)
+        }, this._contexts.time);
+        this._block = block;
+        block.mount();
+        this._buffered = new LineBufferedBlock(block);
+        try {
+            const positional = [];
+            let noGitFlag = false;
+            for (const arg of rawArgs) {
+                if (arg === "--no-git") {
+                    noGitFlag = true;
+                }
+                else if (arg.startsWith("-")) {
+                    this._buffered.writeError(`Unknown flag: ${arg}\n`);
+                    this._finalizeBlock("Failed");
+                    return 1;
+                }
+                else {
+                    positional.push(arg);
+                }
+            }
+            const planPath = await this._selectPlan(positional);
+            if (this._disposed) {
+                this._finalizeBlock("Interrupted");
+                return 1;
+            }
+            if (!planPath) {
+                this._finalizeBlock("Failed");
+                return 1;
+            }
+            const plan = await PlanFile_1.PlanFile.load(planPath, this._contexts.fs);
+            const initialParse = plan.parse();
+            if (initialParse.malformed.length > 0) {
+                this._buffered.writeError(`Plan ${planPath} contains malformed checkbox lines:\n`);
+                for (const m of initialParse.malformed) {
+                    this._buffered.writeError(`  line ${m.line}: ${m.raw}\n`);
+                }
+                this._finalizeBlock("Failed");
+                return 1;
+            }
+            if (initialParse.tasks.length === 0) {
+                this._buffered.writeError(`Plan ${planPath} has no task lines.\n`);
+                this._finalizeBlock("Failed");
+                return 1;
+            }
+            const totalTasks = initialParse.tasks.length;
+            const planTotals = plan.planTotals();
+            if (initialParse.tasks.every(t => t.done)) {
+                this._block.setHeader({ indexLabel: `${totalTasks}/${totalTasks}` });
+                this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t } });
+                this._buffered.write("tasks completed\n");
+                this._finalizeBlock("Done");
+                return 0;
+            }
+            this._block.setHeader({ indexLabel: `0/${totalTasks}` });
+            this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t } });
+            let gitActive = false;
+            if (!noGitFlag) {
+                if (await (0, Git_1.isGitAvailable)(this._contexts.script, this._contexts.time)) {
+                    gitActive = await (0, Git_1.isInsideWorkTree)(this._contexts.script, this._contexts.time, this._options.projectRoot);
+                }
+            }
+            if (gitActive) {
+                const pending = await (0, Git_1.countPendingChangesExcept)(this._contexts.script, this._contexts.time, this._options.projectRoot, planPath);
+                if (pending > 0) {
+                    this._buffered.writeError("Working tree has uncommitted changes. Please commit or stash them before re-running.\n");
+                    this._finalizeBlock("Failed");
+                    return 1;
+                }
+            }
+            const contractFiles = await (0, fsUtils_1.listFilesRecursive)(this._contexts.fs, (0, fsUtils_1.joinPath)(this._options.projectRoot, "contracts"));
+            this._contractList = contractFiles.map(f => `contracts/${f}`);
+            const ruleFiles = await (0, fsUtils_1.listFilesRecursive)(this._contexts.fs, (0, fsUtils_1.joinPath)(this._options.projectRoot, "rules"));
+            this._ruleList = ruleFiles.map(f => `rules/${f}`);
+            this._workspace = new Workspace_1.Workspace(this._contexts.fs, this._contexts.platform);
+            const wsPaths = await this._workspace.setup();
+            await this._detectBuildAndTest(wsPaths);
+            if (this._disposed) {
+                this._finalizeBlock("Interrupted");
+                return 1;
+            }
+            for (;;) {
+                if (this._disposed) {
+                    this._finalizeBlock("Interrupted");
+                    return 1;
+                }
+                const open = plan.nextOpenTask();
+                if (!open) {
+                    break;
+                }
+                const refreshed = plan.parse();
+                const completedSoFar = refreshed.tasks.filter(t => t.done).length;
+                const indexLabel = `${completedSoFar + 1}/${totalTasks}`;
+                const taskOk = await this._runTask(plan, open, wsPaths, indexLabel, completedSoFar, gitActive);
+                if (this._disposed) {
+                    this._finalizeBlock("Interrupted");
+                    return 1;
+                }
+                if (!taskOk) {
+                    this._finalizeBlock("Hard stop");
+                    return 1;
+                }
+            }
+            this._buffered.write("all tasks completed\n");
+            this._finalizeBlock("Done");
+            return 0;
+        }
+        catch (e) {
+            if (!this._disposed) {
+                this._buffered.writeError(`${e instanceof Error ? e.message : String(e)}\n`);
+            }
+            this._finalizeBlock(this._disposed ? "Interrupted" : "Failed");
+            return 1;
+        }
+    }
+    async _selectPlan(rawArgs) {
+        const plansFolder = (0, fsUtils_1.joinPath)(this._options.projectRoot, "plans");
+        if (rawArgs.length > 0) {
+            const arg = rawArgs.length === 1 ? rawArgs[0] : rawArgs.join(" ");
+            const direct = arg;
+            if (await this._contexts.fs.exists(direct)) {
+                return direct;
+            }
+            const inFolder = (0, fsUtils_1.joinPath)(plansFolder, arg);
+            if (await this._contexts.fs.exists(inFolder)) {
+                return inFolder;
+            }
+            this._buffered.writeError(`Plan file not found: ${arg}\n`);
+            return null;
+        }
+        const files = await (0, fsUtils_1.listFilesRecursive)(this._contexts.fs, plansFolder);
+        if (files.length === 0) {
+            this._buffered.writeError(`No plan files found in ${plansFolder}.\n`);
+            return null;
+        }
+        if (files.length === 1) {
+            return (0, fsUtils_1.joinPath)(plansFolder, files[0]);
+        }
+        return await this._promptPlanChoice(plansFolder, files);
+    }
+    _askOutput() {
+        return {
+            write: text => this._buffered.write(text),
+            writeError: text => this._buffered.writeError(text),
+            columns: () => this._contexts.output.columns(),
+            rows: () => this._contexts.output.rows(),
+            onResize: listener => this._contexts.output.onResize(listener)
+        };
+    }
+    async _promptPlanChoice(plansFolder, files) {
+        const askOutput = this._askOutput();
+        for (;;) {
+            if (this._disposed) {
+                return null;
+            }
+            const [answer] = await this._contexts.ask.askChoices([{
+                    header: "Plan file",
+                    question: `Multiple plans found in ${plansFolder}. Which one do you want to implement?`,
+                    options: files.map(f => ({ label: f })),
+                    multiSelect: false
+                }], askOutput);
+            if (this._disposed) {
+                return null;
+            }
+            if (answer && answer.picked.length > 0) {
+                return (0, fsUtils_1.joinPath)(plansFolder, answer.picked[0].label);
+            }
+            this._buffered.writeError("Please pick one of the listed plans by its number.\n");
+        }
+    }
+    async _detectBuildAndTest(ws) {
+        const prompt = prompts_1.prompts.detectBuildAndTest
+            .split("<BUILD_SCRIPT_PATH>").join(ws.buildScript)
+            .split("<TEST_SCRIPT_PATH>").join(ws.testScript)
+            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
+        await this._runClaude(prompt);
+    }
+    _setActivity(activity) {
+        if (!this._currentTask)
+            return;
+        this._block.setHeader({
+            indexLabel: this._currentIndexLabel,
+            iteration: this._currentIteration,
+            activity,
+            taskNumber: this._currentTask.taskNumber || undefined,
+            title: this._currentTask.title
+        });
+    }
+    _activeSeconds() {
+        return Math.max(0, Math.floor((this._contexts.time.now() - this._taskStartedAt - this._taskRateLimitMs) / 1000));
+    }
+    async _persistMetrics(plan, line) {
+        try {
+            await plan.updateMetrics(line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+        }
+        catch (e) {
+            this._buffered.writeError(`metrics persist failed: ${this._stringifyError(e)}\n`);
+        }
+    }
+    _updateMetrics(plan) {
+        if (!this._currentTask || this._taskRateLimitStartedAt !== null)
+            return;
+        const planTotals = plan.planTotals();
+        this._block.setMetrics({
+            task: { tokens: this._taskTokens.it + this._taskTokens.ot, seconds: this._activeSeconds() },
+            plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t }
+        });
+    }
+    async _runTask(plan, task, ws, indexLabel, taskIndex, gitActive) {
+        this._currentTask = task;
+        this._currentIndexLabel = indexLabel;
+        this._currentWorkerSessionId = null;
+        this._currentPrepSessionId = null;
+        this._taskStartedAt = this._contexts.time.now();
+        this._taskRateLimitMs = 0;
+        this._taskRateLimitStartedAt = null;
+        this._taskTokens = { it: 0, ot: 0 };
+        this._updateMetrics(plan);
+        const prepOk = await this._prepStage(plan, task, ws, taskIndex);
+        if (this._disposed) {
+            return false;
+        }
+        if (!prepOk) {
+            return false;
+        }
+        let iteration = 0;
+        for (;;) {
+            iteration++;
+            this._currentIteration = iteration;
+            if (iteration > MAX_ITER) {
+                this._workspace.preserveOnDispose();
+                this._buffered.writeError(`Hard stop: task at line ${task.line} ("${task.title}") exceeded ${MAX_ITER} iterations. Inspect logs at ${ws.root}.\n`);
+                return false;
+            }
+            if (this._disposed) {
+                return false;
+            }
+            this._setActivity("implementing");
+            const workerOk = await this._workerStage(plan, task, ws, iteration);
+            if (this._disposed) {
+                return false;
+            }
+            if (!workerOk) {
+                continue;
+            }
+            this._setActivity("building");
+            const buildOk = await this._buildStage(plan, task.line, ws, iteration);
+            if (this._disposed) {
+                return false;
+            }
+            if (!buildOk) {
+                continue;
+            }
+            this._setActivity("testing");
+            const testOk = await this._testStage(plan, task.line, ws, iteration);
+            if (this._disposed) {
+                return false;
+            }
+            if (!testOk) {
+                continue;
+            }
+            this._setActivity("reviewing");
+            const reviewOk = await this._reviewerStage(plan, task, ws, iteration);
+            if (this._disposed) {
+                return false;
+            }
+            if (!reviewOk) {
+                continue;
+            }
+            await plan.markDone(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+            if (gitActive) {
+                const commitMessage = task.taskNumber ? `${task.taskNumber} ${task.title}` : task.title;
+                const gitOutput = {
+                    write: text => this._buffered.write(text),
+                    writeError: text => this._buffered.writeError(text),
+                    columns: () => this._contexts.output.columns(),
+                    rows: () => this._contexts.output.rows(),
+                    onResize: listener => this._contexts.output.onResize(listener)
+                };
+                const addResult = await (0, Git_1.addAll)(this._contexts.script, this._contexts.time, gitOutput, this._options.projectRoot);
+                if (addResult.code !== 0) {
+                    await this._writeErrorLog(ws, `git add -A failed (exit ${addResult.code})\n--- stdout ---\n${addResult.stdout}\n--- stderr ---\n${addResult.stderr}`);
+                    await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+                    continue;
+                }
+                const commitResult = await (0, Git_1.commit)(this._contexts.script, this._contexts.time, gitOutput, this._options.projectRoot, commitMessage);
+                if (commitResult.code !== 0) {
+                    await this._writeErrorLog(ws, `git commit failed (exit ${commitResult.code})\n--- stdout ---\n${commitResult.stdout}\n--- stderr ---\n${commitResult.stderr}`);
+                    await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+                    continue;
+                }
+            }
+            const planTotals = plan.planTotals();
+            const snapshot = (0, formatters_1.formatSnapshotBlock)(indexLabel, iteration, task.taskNumber || undefined, task.title, this._taskTokens.it + this._taskTokens.ot, this._activeSeconds(), planTotals.it + planTotals.ot, planTotals.t, this._contexts.output.columns());
+            this._block.writeAbove(snapshot);
+            this._updateMetrics(plan);
+            return true;
+        }
+    }
+    async _prepStage(plan, task, ws, taskIndex) {
+        const prompt = prompts_1.prompts.prep
+            .split("<PLAN_PATH>").join(plan.path)
+            .split("<TASK_LINE>").join(String(task.line))
+            .split("<TASK_TITLE>").join(task.title)
+            .split("<CONTRACT_LIST>").join(this._formatPathList(this._contractList))
+            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
+        try {
+            const { result, capturedOutput } = await this._runClaude(prompt);
+            this._taskTokens.it += result.inputTokens;
+            this._taskTokens.ot += result.outputTokens;
+            await this._persistMetrics(plan, task.line);
+            this._updateMetrics(plan);
+            await this._writeLog(ws.prepLog(taskIndex), capturedOutput);
+            if (result.sessionId === null) {
+                this._workspace.preserveOnDispose();
+                await this._writeErrorLog(ws, `prep returned no session id for task at line ${task.line} ("${task.title}")`);
+                this._buffered.writeError(`Hard stop: prep for task at line ${task.line} ("${task.title}") returned no session id. Inspect logs at ${ws.root}.\n`);
+                return false;
+            }
+            this._currentPrepSessionId = result.sessionId;
+            return true;
+        }
+        catch (e) {
+            await this._persistMetrics(plan, task.line);
+            this._updateMetrics(plan);
+            this._workspace.preserveOnDispose();
+            await this._writeErrorLog(ws, `prep stage failed: ${this._stringifyError(e)}`);
+            this._buffered.writeError(`Hard stop: prep for task at line ${task.line} ("${task.title}") failed. Inspect logs at ${ws.root}.\n`);
+            return false;
+        }
+    }
+    async _workerStage(plan, task, ws, iteration) {
+        let prompt = prompts_1.prompts.worker
+            .split("<PLAN_PATH>").join(plan.path)
+            .split("<TASK_LINE>").join(String(task.line))
+            .split("<TASK_TITLE>").join(task.title)
+            .split("<BUILD_SCRIPT_PATH>").join(ws.buildScript)
+            .split("<TEST_SCRIPT_PATH>").join(ws.testScript)
+            .split("<CONTRACT_LIST>").join(this._formatPathList(this._contractList))
+            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
+        if (iteration > 1) {
+            const briefing = prompts_1.prompts.previousIterationBriefing
+                .split("<ITERATION>").join(String(iteration))
+                .split("<ERROR_LOG_PATH>").join(ws.errorLog);
+            prompt = `${prompt}\n\n${briefing}`;
+        }
+        if (iteration === 1 && this._currentPrepSessionId === null) {
+            throw new Error(`Worker iteration 1 for task at line ${task.line} ("${task.title}") requires a prep session id but none was captured`);
+        }
+        try {
+            const { result, capturedOutput } = iteration === 1
+                ? await this._runClaude(prompt, null, this._currentPrepSessionId)
+                : await this._runClaude(prompt, this._currentWorkerSessionId);
+            if (result.sessionId !== null) {
+                this._currentWorkerSessionId = result.sessionId;
+            }
+            this._taskTokens.it += result.inputTokens;
+            this._taskTokens.ot += result.outputTokens;
+            await this._persistMetrics(plan, task.line);
+            this._updateMetrics(plan);
+            await this._writeLog(ws.workerLog(iteration), capturedOutput);
+            return true;
+        }
+        catch (e) {
+            await this._persistMetrics(plan, task.line);
+            this._updateMetrics(plan);
+            await this._writeErrorLog(ws, `worker stage failed: ${this._stringifyError(e)}`);
+            return false;
+        }
+    }
+    async _buildStage(plan, taskLine, ws, iteration) {
+        if (!(await (0, fsUtils_1.isNonEmptyFile)(this._contexts.fs, ws.buildScript))) {
+            return true;
+        }
+        const result = await this._runScript(ws.buildScript);
+        if (result === null) {
+            return false;
+        }
+        await this._persistMetrics(plan, taskLine);
+        this._updateMetrics(plan);
+        await this._writeLog(ws.buildLog(iteration), `--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`);
+        if (result.code !== 0) {
+            await this._writeErrorLog(ws, `build stage failed (exit ${result.code})\n--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`);
+            return false;
+        }
+        return true;
+    }
+    async _testStage(plan, taskLine, ws, iteration) {
+        if (!(await (0, fsUtils_1.isNonEmptyFile)(this._contexts.fs, ws.testScript))) {
+            return true;
+        }
+        const result = await this._runScript(ws.testScript);
+        if (result === null) {
+            return false;
+        }
+        await this._persistMetrics(plan, taskLine);
+        this._updateMetrics(plan);
+        await this._writeLog(ws.testLog(iteration), `--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`);
+        if (result.code !== 0) {
+            await this._writeErrorLog(ws, `test stage failed (exit ${result.code})\n--- stdout ---\n${result.stdout}\n--- stderr ---\n${result.stderr}`);
+            return false;
+        }
+        return true;
+    }
+    async _reviewerStage(plan, task, ws, iteration) {
+        if (this._currentPrepSessionId === null) {
+            throw new Error(`Reviewer for task at line ${task.line} ("${task.title}") requires a prep session id but none was captured`);
+        }
+        const prompt = prompts_1.prompts.reviewer
+            .split("<PLAN_PATH>").join(plan.path)
+            .split("<TASK_LINE>").join(String(task.line))
+            .split("<TASK_TITLE>").join(task.title)
+            .split("<CONTRACT_LIST>").join(this._formatPathList(this._contractList))
+            .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
+        try {
+            const { result, capturedOutput } = await this._runClaude(prompt, null, this._currentPrepSessionId);
+            this._taskTokens.it += result.inputTokens;
+            this._taskTokens.ot += result.outputTokens;
+            await this._persistMetrics(plan, task.line);
+            this._updateMetrics(plan);
+            const verdict = this._parseReviewVerdict(result.text);
+            await this._writeLog(ws.reviewerLog(iteration), verdict.pass
+                ? `${capturedOutput}\n\nVerdict: PASS`
+                : `${capturedOutput}\n\nVerdict: FAIL ${verdict.reason}`);
+            if (verdict.pass) {
+                return true;
+            }
+            await this._writeErrorLog(ws, `reviewer rejected: ${verdict.reason}`);
+            return false;
+        }
+        catch (e) {
+            await this._persistMetrics(plan, task.line);
+            this._updateMetrics(plan);
+            await this._writeErrorLog(ws, `reviewer stage failed: ${this._stringifyError(e)}`);
+            return false;
+        }
+    }
+    _parseReviewVerdict(text) {
+        const trimmed = text.trim();
+        const lines = trimmed.split(/\r?\n/);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (!line) {
+                continue;
+            }
+            if (/^pass$/i.test(line)) {
+                return { pass: true, reason: "" };
+            }
+            const failMatch = /^fail\b\s*(.*)$/i.exec(line);
+            if (failMatch) {
+                return { pass: false, reason: failMatch[1].trim() };
+            }
+            break;
+        }
+        return { pass: false, reason: `unrecognized reviewer verdict: ${trimmed}` };
+    }
+    _formatPathList(items) {
+        if (items.length === 0) {
+            return "(none)";
+        }
+        return items.join("\n");
+    }
+    async _runClaude(prompt, initialSessionId, forkFromSessionId) {
+        if (this._disposed) {
+            throw new Error("Implement disposed");
+        }
+        let capturedOutput = "";
+        const capturingOutput = {
+            write: (text) => {
+                capturedOutput += text;
+                this._buffered.write(text);
+            },
+            writeError: (text) => {
+                capturedOutput += text;
+                this._buffered.writeError(text);
+            },
+            columns: () => this._contexts.output.columns(),
+            rows: () => this._contexts.output.rows(),
+            onResize: listener => this._contexts.output.onResize(listener)
+        };
+        const session = new ClaudeSession_1.ClaudeSession({
+            prompt,
+            cwd: this._options.projectRoot,
+            ...(initialSessionId != null ? { initialSessionId } : null),
+            ...(forkFromSessionId != null ? { forkFromSessionId } : null),
+            onLongWaitStart: (kind, endTimeMs) => {
+                if (this._disposed)
+                    return;
+                if (this._currentTask !== null) {
+                    this._taskRateLimitStartedAt = this._contexts.time.now();
+                }
+                this._block.setFooter({ kind: "waiting", waitKind: kind, endTime: endTimeMs });
+            },
+            onLongWaitEnd: () => {
+                if (this._taskRateLimitStartedAt !== null) {
+                    this._taskRateLimitMs += this._contexts.time.now() - this._taskRateLimitStartedAt;
+                    this._taskRateLimitStartedAt = null;
+                }
+                if (this._disposed)
+                    return;
+                this._block.setFooter({ kind: "working" });
+            }
+        }, {
+            claude: this._contexts.claude,
+            time: this._contexts.time,
+            output: capturingOutput,
+            ask: this._contexts.ask
+        });
+        const running = { session };
+        this._activeSession = running;
+        try {
+            const result = await session.run();
+            return { result, capturedOutput };
+        }
+        finally {
+            if (this._activeSession === running) {
+                this._activeSession = null;
+            }
+            await session.dispose();
+        }
+    }
+    async _runScript(scriptPath) {
+        if (this._disposed) {
+            return null;
+        }
+        const isBat = scriptPath.toLowerCase().endsWith(".bat");
+        const command = isBat ? "cmd.exe" : "sh";
+        const args = isBat ? ["/c", scriptPath] : [scriptPath];
+        const script = new ScriptRunner_1.ScriptRunner({
+            command,
+            args,
+            cwd: this._options.projectRoot,
+            onStdout: chunk => this._buffered.write(chunk),
+            onStderr: chunk => this._buffered.writeError(chunk)
+        }, this._contexts.script, this._contexts.time);
+        const running = { script };
+        this._activeScript = running;
+        try {
+            return await script.result();
+        }
+        catch (e) {
+            this._buffered.writeError(`${this._stringifyError(e)}\n`);
+            return { code: -1, stdout: "", stderr: this._stringifyError(e) };
+        }
+        finally {
+            if (this._activeScript === running) {
+                this._activeScript = null;
+            }
+            await script.dispose();
+        }
+    }
+    async _writeLog(path, content) {
+        try {
+            await this._contexts.fs.writeFile(path, content);
+        }
+        catch {
+        }
+    }
+    async _writeErrorLog(ws, content) {
+        await this._writeLog(ws.errorLog, content);
+    }
+    _stringifyError(e) {
+        if (e instanceof Error) {
+            return e.stack ?? e.message;
+        }
+        return String(e);
+    }
+    _finalizeBlock(label) {
+        if (!this._block || this._block.isFinalized())
+            return;
+        this._buffered.flush();
+        this._block.finalize(label);
+    }
+    async dispose() {
+        if (this._disposed) {
+            try {
+                await this._runPromise;
+            }
+            catch {
+            }
+            return;
+        }
+        this._disposed = true;
+        const activeSession = this._activeSession?.session;
+        const activeScript = this._activeScript?.script;
+        this._activeSession = null;
+        this._activeScript = null;
+        const closers = [];
+        if (activeSession) {
+            closers.push(activeSession.dispose());
+        }
+        if (activeScript) {
+            closers.push(activeScript.dispose());
+        }
+        await Promise.allSettled(closers);
+        try {
+            await this._runPromise;
+        }
+        catch {
+        }
+        if (this._block) {
+            this._finalizeBlock("Interrupted");
+            const block = this._block;
+            this._block = null;
+            block.dispose();
+        }
+        if (this._workspace) {
+            const ws = this._workspace;
+            this._workspace = null;
+            await ws.dispose();
+        }
+    }
+}
+exports.Implement = Implement;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Implement.js","sourceRoot":"","sources":["../../src/commands/Implement.ts"],"names":[],"mappings":"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"}