@elyracode/coding-agent 0.9.2 → 0.9.4

package/dist/modes/interactive/interactive-mode.js

@@ -6,7 +6,7 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getProviders, } from "@elyracode/ai";
+import { completeSimple, getProviders, } from "@elyracode/ai";
 import { CombinedAutocompleteProvider, Container, fuzzyFilter, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TUI, visibleWidth, } from "@elyracode/tui";
 import { spawn, spawnSync } from "child_process";
 import { APP_NAME, APP_TITLE, getAgentDir, getAuthPath, getBlueprintsDir, getDebugLogPath, getDocsPath, getProjectBlueprintsDir, getProjectSnippetsDir, getSelfUpdateCommand, getShareViewerUrl, getSnippetsDir, PACKAGE_NAME, VERSION, } from "../../config.js";
@@ -85,6 +85,20 @@ function isDeadTerminalError(error) {
     return code !== undefined && DEAD_TERMINAL_ERROR_CODES.has(code);
 }
 const ANTHROPIC_SUBSCRIPTION_AUTH_WARNING = "Anthropic subscription auth is active. Third-party harness usage draws from extra usage and is billed per token, not your Claude plan limits. Manage extra usage at https://claude.ai/settings/usage.";
+const REVIEW_SYSTEM_PROMPT = `You are a senior software engineer doing a focused code review of a diff. You did not write this code and have no prior context, so judge it on its own merits.
+
+Review for, in priority order:
+1. Correctness and bugs (logic errors, off-by-one, null/undefined, race conditions, incorrect edge-case handling)
+2. Security (injection, unsafe input handling, leaked secrets, missing authz/validation)
+3. Error handling and resource cleanup
+4. Clarity and maintainability
+
+Rules:
+- Be specific: reference the file and the exact change. Quote the relevant line when useful.
+- Be concise. Prioritize the few things that matter; skip nitpicks unless nothing else is wrong.
+- If the diff looks correct and well done, say so plainly rather than inventing problems.
+- Do not restate the whole diff. Only report findings.
+- Format as a short Markdown list grouped by severity (Critical / Important / Minor), and end with a one-line overall assessment.`;
 function isAnthropicSubscriptionAuthKey(apiKey) {
     return typeof apiKey === "string" && apiKey.startsWith("sk-ant-oat");
 }
@@ -2033,6 +2047,16 @@ export class InteractiveMode {
                 await this.handleDiffCommand(text.slice("/diff".length).trim());
                 return;
             }
+            if (text === "/review" || text.startsWith("/review ")) {
+                this.editor.setText("");
+                await this.handleReviewCommand(text.slice("/review".length).trim());
+                return;
+            }
+            if (text === "/bisect" || text.startsWith("/bisect ")) {
+                this.editor.setText("");
+                await this.handleBisectCommand(text.slice("/bisect".length).trim());
+                return;
+            }
             if (text === "/pin" || text.startsWith("/pin ")) {
                 this.editor.setText("");
                 this.handlePinCommand(text.startsWith("/pin ") ? text.slice(5).trim() : undefined);
@@ -3260,6 +3284,7 @@ export class InteractiveMode {
                 smartRouting: this.settingsManager.getSmartRouting(),
                 codebaseMemory: this.settingsManager.getCodebaseMemory(),
                 autoSkills: this.settingsManager.getAutoSkills(),
+                autoExtensions: this.settingsManager.getAutoExtensions(),
                 diffInEditor: this.settingsManager.getDiffInEditor(),
                 doubleEscapeAction: this.settingsManager.getDoubleEscapeAction(),
                 treeFilterMode: this.settingsManager.getTreeFilterMode(),
@@ -3354,6 +3379,9 @@ export class InteractiveMode {
                 onAutoSkillsChange: (enabled) => {
                     this.settingsManager.setAutoSkills(enabled);
                 },
+                onAutoExtensionsChange: (enabled) => {
+                    this.settingsManager.setAutoExtensions(enabled);
+                },
                 onDiffInEditorChange: (enabled) => {
                     this.settingsManager.setDiffInEditor(enabled);
                 },
@@ -3814,6 +3842,8 @@ export class InteractiveMode {
             `  ${theme.fg("muted", "/theme")}       Switch theme`,
             `  ${theme.fg("muted", "/cost")}        Token usage and cost`,
             `  ${theme.fg("muted", "/diff")}        Show changes (--session, --cached, or <path>)`,
+            `  ${theme.fg("muted", "/review")}      Get a second-opinion code review of your changes`,
+            `  ${theme.fg("muted", "/bisect <cmd>")} Find which turn broke things (git bisect over checkpoints)`,
             `  ${theme.fg("muted", "/pin <path>")}  Pin file to context`,
             `  ${theme.fg("muted", "/memory")}      View project memory`,
             `  ${theme.fg("muted", "/blueprint")}   Apply session template`,
@@ -3947,6 +3977,247 @@ export class InteractiveMode {
             this.showError("Failed to run git diff.");
         }
     }
+    /**
+     * /review — ask a model for a fresh, independent critique of the current
+     * changes. By default reviews uncommitted changes; --session scopes to what
+     * the agent changed this session. An optional path filters the diff.
+     */
+    async handleReviewCommand(args) {
+        const cwd = this.sessionManager.getCwd();
+        const tokens = args.split(/\s+/).filter(Boolean);
+        let sessionMode = false;
+        const pathArgs = [];
+        for (const token of tokens) {
+            if (token === "--session" || token === "-s")
+                sessionMode = true;
+            else
+                pathArgs.push(token);
+        }
+        const runGit = (gitArgs) => {
+            const result = spawnSync("git", gitArgs, {
+                cwd,
+                encoding: "utf-8",
+                maxBuffer: 32 * 1024 * 1024,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            return result.stdout ?? "";
+        };
+        const inside = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (inside.status !== 0) {
+            this.showError("Not a git repository.");
+            return;
+        }
+        const pathSpec = pathArgs.length > 0 ? ["--", ...pathArgs] : [];
+        let diff;
+        if (sessionMode) {
+            const baseline = this.session.getSessionBaselineRef();
+            if (!baseline) {
+                this.showStatus("No session changes to review yet (the agent hasn't modified files this session).");
+                return;
+            }
+            diff = runGit(["diff", baseline, ...pathSpec]);
+        }
+        else {
+            diff = runGit(["diff", "HEAD", ...pathSpec]);
+            if (!diff.trim())
+                diff = runGit(["diff", ...pathSpec]);
+        }
+        if (!diff.trim()) {
+            this.showStatus("No changes to review.");
+            return;
+        }
+        const model = this.session.model;
+        if (!model) {
+            this.showError("No model selected. Use /model to choose one first.");
+            return;
+        }
+        // Cap very large diffs so the review request stays within limits.
+        const MAX_DIFF_CHARS = 60_000;
+        const truncated = diff.length > MAX_DIFF_CHARS;
+        const diffForReview = truncated ? `${diff.slice(0, MAX_DIFF_CHARS)}\n... (diff truncated)` : diff;
+        const scopeLabel = sessionMode ? "this session's changes" : "uncommitted changes";
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new DynamicBorder());
+        this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", `Code Review \u2014 ${scopeLabel}`)), 1, 0));
+        const loader = new BorderedLoader(this.ui, theme, `Reviewing with ${model.name}...`, { cancellable: false });
+        this.chatContainer.addChild(loader);
+        this.ui.requestRender();
+        const finishLoader = () => {
+            loader.dispose();
+            this.chatContainer.removeChild(loader);
+        };
+        try {
+            const apiKey = await this.session.modelRegistry.getApiKeyForProvider(model.provider);
+            const context = {
+                systemPrompt: REVIEW_SYSTEM_PROMPT,
+                messages: [
+                    {
+                        role: "user",
+                        content: `Review the following diff and report your findings.\n\n\`\`\`diff\n${diffForReview}\n\`\`\``,
+                        timestamp: Date.now(),
+                    },
+                ],
+            };
+            const result = await completeSimple(model, context, apiKey ? { apiKey } : undefined);
+            const reviewText = result.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n")
+                .trim();
+            finishLoader();
+            if (!reviewText) {
+                this.chatContainer.addChild(new Text(theme.fg("muted", "The reviewer returned no findings."), 1, 0));
+            }
+            else {
+                this.chatContainer.addChild(new Markdown(reviewText, 1, 1, this.getMarkdownThemeWithSettings()));
+                if (truncated) {
+                    this.chatContainer.addChild(new Text(theme.fg("muted", "(Diff was large and truncated for review.)"), 1, 0));
+                }
+            }
+            this.chatContainer.addChild(new DynamicBorder());
+            this.ui.requestRender();
+        }
+        catch (error) {
+            finishLoader();
+            const msg = error instanceof Error ? error.message : String(error);
+            this.chatContainer.addChild(new Text(theme.fg("error", `Review failed: ${msg}`), 1, 0));
+            this.chatContainer.addChild(new DynamicBorder());
+            this.ui.requestRender();
+        }
+    }
+    /**
+     * /bisect — binary-search the session's checkpoints to find which agent turn
+     * introduced a problem, like `git bisect` but over the agent's own steps.
+     *
+     * With a command argument it runs automatically (exit 0 = good, non-zero =
+     * bad), like `git bisect run`. Without one, it asks you to mark each step
+     * good or bad after testing manually. The working tree is always restored at
+     * the end.
+     */
+    async handleBisectCommand(command) {
+        const points = this.session.getRewindPoints();
+        if (points.length < 2) {
+            this.showStatus("Not enough checkpoints to bisect. Checkpoints are created as the agent runs.");
+            return;
+        }
+        const snapshot = this.session.createWorkingTreeSnapshot();
+        if (!snapshot) {
+            this.showError("Not a git repository — /bisect needs git checkpoints.");
+            return;
+        }
+        const cwd = this.sessionManager.getCwd();
+        const describe = (i) => `${i + 1}/${points.length}: ${points[i].text.replace(/\n/g, " ").slice(0, 60)}`;
+        const runCommand = () => new Promise((resolve) => {
+            const child = spawn("sh", ["-c", command], {
+                cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                timeout: 120_000,
+            });
+            child.on("close", (code) => resolve(code ?? 1));
+            child.on("error", () => resolve(1));
+        });
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new DynamicBorder());
+        const title = command ? `Bisecting with: ${command}` : "Bisecting (test each checkpoint manually)";
+        this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", title)), 1, 0));
+        const status = new Text(theme.fg("muted", "Preparing..."), 1, 0);
+        this.chatContainer.addChild(status);
+        this.ui.requestRender();
+        // Ask whether a step is good. Returns true=good, false=bad, undefined=abort.
+        const askGoodBad = async (index) => {
+            if (command) {
+                status.setText(theme.fg("muted", `Testing checkpoint ${describe(index)}...`));
+                this.ui.requestRender();
+                await new Promise((r) => setTimeout(r, 16));
+                const code = await runCommand();
+                return code === 0;
+            }
+            const choice = await this.showExtensionSelector(`Restored files to checkpoint ${describe(index)}.\nTest now (in another terminal), then choose:`, ["Good (works here)", "Bad (broken here)", "Abort"]);
+            if (!choice || choice === "Abort")
+                return undefined;
+            return choice.startsWith("Good");
+        };
+        let aborted = false;
+        let culpritIndex;
+        try {
+            // In automated mode, verify the current state is actually bad first.
+            if (command) {
+                status.setText(theme.fg("muted", "Checking current state..."));
+                this.ui.requestRender();
+                await new Promise((r) => setTimeout(r, 16));
+                if ((await runCommand()) === 0) {
+                    status.setText(theme.fg("muted", "Current state passes the command — nothing to bisect."));
+                    this.chatContainer.addChild(new DynamicBorder());
+                    this.ui.requestRender();
+                    return;
+                }
+            }
+            // lo = known good, hi = known bad. Find the first bad checkpoint in (lo, hi].
+            let lo = 0;
+            let hi = points.length - 1;
+            // Establish that the earliest checkpoint is good.
+            const earliestRestore = this.session.restoreFilesToCheckpoint(points[0].entryId);
+            if (!earliestRestore.ok) {
+                this.showError(`Bisect failed to restore checkpoint: ${earliestRestore.error}`);
+                aborted = true;
+            }
+            else {
+                const earliestGood = await askGoodBad(0);
+                if (earliestGood === undefined) {
+                    aborted = true;
+                }
+                else if (!earliestGood) {
+                    status.setText(theme.fg("muted", "The earliest checkpoint is already bad — the cause predates this session."));
+                    this.chatContainer.addChild(new DynamicBorder());
+                    this.ui.requestRender();
+                    aborted = true;
+                }
+            }
+            while (!aborted && hi - lo > 1) {
+                const mid = Math.floor((lo + hi) / 2);
+                const restore = this.session.restoreFilesToCheckpoint(points[mid].entryId);
+                if (!restore.ok) {
+                    this.showError(`Bisect failed to restore checkpoint: ${restore.error}`);
+                    aborted = true;
+                    break;
+                }
+                const good = await askGoodBad(mid);
+                if (good === undefined) {
+                    aborted = true;
+                    break;
+                }
+                if (good)
+                    lo = mid;
+                else
+                    hi = mid;
+            }
+            if (!aborted)
+                culpritIndex = hi;
+        }
+        finally {
+            const restored = this.session.restoreFilesToSnapshot(snapshot);
+            if (!restored.ok) {
+                this.showError(`Bisect could not restore your working tree: ${restored.error}`);
+            }
+        }
+        if (aborted) {
+            status.setText(theme.fg("muted", "Bisect stopped. Your working tree was restored."));
+            this.chatContainer.addChild(new DynamicBorder());
+            this.ui.requestRender();
+            return;
+        }
+        if (culpritIndex !== undefined) {
+            const culprit = points[culpritIndex];
+            status.setText(`${theme.fg("success", "First bad checkpoint:")} ${theme.fg("accent", culprit.text.replace(/\n/g, " ").slice(0, 80))}`);
+            this.chatContainer.addChild(new Text(theme.fg("muted", "The change introduced at this turn is the likely culprit. Use /rewind to return here."), 1, 0));
+            this.chatContainer.addChild(new DynamicBorder());
+            this.ui.requestRender();
+        }
+    }
     /**
      * Open read-only text content in the user's external editor ($VISUAL/$EDITOR).
      * Suspends the TUI while the editor runs, then restores it. The `suffix`
@@ -5016,6 +5287,7 @@ export class InteractiveMode {
             "@elyracode/laravel -- Deep Laravel understanding: models, routes, architecture analysis",
             "@elyracode/btw -- Side conversations: ask questions in parallel without affecting the main session",
             "@elyracode/youtrack -- YouTrack: issues, comments, tags, links, projects, time tracking",
+            "@elyracode/semantic-index -- Semantic code search: find code by meaning via local embeddings",
         ];
         this.showSelector((done) => {
             const selector = new ExtensionSelectorComponent("Install Extension", packages, (selected) => {