@elyracode/coding-agent 0.9.1 → 0.9.3

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);
@@ -3031,8 +3055,8 @@ export class InteractiveMode {
         this.ui.requestRender();
     }
     showPackageUpdateNotification(packages) {
-        const action = theme.fg("accent", `${APP_NAME} update`);
-        const updateInstruction = theme.fg("muted", "Package updates are available. Run ") + action;
+        const action = theme.fg("accent", "/update");
+        const updateInstruction = theme.fg("muted", "Extension updates are available. Type ") + action;
         const packageLines = packages.map((pkg) => `- ${pkg}`).join("\n");
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
@@ -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);
                 },
@@ -3528,71 +3556,114 @@ export class InteractiveMode {
         }
     }
     async handleInAppUpdate() {
-        // If no update detected yet, check now
+        if (process.env.ELYRA_OFFLINE) {
+            this.showStatus("Updates are disabled in offline mode.");
+            return;
+        }
+        this.chatContainer.addChild(new Spacer(1));
+        const statusText = new Text(theme.fg("dim", "Checking for updates..."), 1, 0);
+        this.chatContainer.addChild(statusText);
+        this.ui.requestRender();
+        // Check for an Elyra version update (populates this._availableUpdate).
         if (!this._availableUpdate) {
             await this.checkForVersionUpdate();
         }
-        if (!this._availableUpdate) {
-            this.showStatus(`Already on latest version (${this.version})`);
+        const elyraUpdate = this._availableUpdate;
+        // Check for installed-extension updates.
+        const packageManager = new DefaultPackageManager({
+            cwd: this.sessionManager.getCwd(),
+            agentDir: getAgentDir(),
+            settingsManager: this.settingsManager,
+        });
+        let extensionUpdates = [];
+        try {
+            extensionUpdates = await packageManager.checkForAvailableUpdates();
+        }
+        catch {
+            // Best-effort: a failed extension check shouldn't block an Elyra update.
+        }
+        if (!elyraUpdate && extensionUpdates.length === 0) {
+            statusText.setText(theme.fg("dim", `Already up to date (Elyra ${this.version}, all extensions current)`));
+            this.ui.requestRender();
             return;
         }
-        const { latest, current } = this._availableUpdate;
-        // Get the self-update command for this installation
-        const settingsManager = this.settingsManager;
-        const npmCommand = settingsManager.getGlobalSettings().npmCommand;
-        const selfUpdateCommand = getSelfUpdateCommand(PACKAGE_NAME, npmCommand);
-        if (!selfUpdateCommand) {
-            this.showError(`Cannot self-update this installation. Run manually:\n  ${theme.fg("accent", `npm install -g ${PACKAGE_NAME}`)}`);
+        // If an Elyra update is available, make sure we can actually self-update.
+        let selfUpdateCommand;
+        if (elyraUpdate) {
+            const npmCommand = this.settingsManager.getGlobalSettings().npmCommand;
+            selfUpdateCommand = getSelfUpdateCommand(PACKAGE_NAME, npmCommand);
+            if (!selfUpdateCommand) {
+                statusText.setText(theme.fg("error", `Cannot self-update this installation. Update Elyra manually: npm install -g ${PACKAGE_NAME}`));
+                this.ui.requestRender();
+                // We can still update extensions below.
+            }
+        }
+        // Nothing actionable: Elyra can't self-update and there are no extension updates.
+        if (extensionUpdates.length === 0 && !(elyraUpdate && selfUpdateCommand)) {
             return;
         }
-        // Show progress
-        this.chatContainer.addChild(new Spacer(1));
-        const updateText = new Text(theme.fg("accent", `Updating ${current} \u2192 ${latest}...`), 1, 0);
-        this.chatContainer.addChild(updateText);
+        // Announce what is being updated.
+        const parts = [];
+        if (elyraUpdate && selfUpdateCommand)
+            parts.push(`Elyra ${elyraUpdate.current} \u2192 ${elyraUpdate.latest}`);
+        if (extensionUpdates.length > 0) {
+            parts.push(`${extensionUpdates.length} extension${extensionUpdates.length === 1 ? "" : "s"}`);
+        }
+        statusText.setText(theme.fg("accent", `Updating ${parts.join(" and ")}...`));
         this.ui.requestRender();
-        try {
-            // Run each step of the update command
-            for (const step of selfUpdateCommand.steps ?? [selfUpdateCommand]) {
-                await new Promise((resolve, reject) => {
-                    const child = spawn(step.command, step.args, {
-                        stdio: ["ignore", "pipe", "pipe"],
-                        shell: process.platform === "win32",
-                    });
-                    let stderr = "";
-                    child.stderr?.on("data", (data) => {
-                        stderr += data.toString();
-                    });
-                    child.on("close", (code) => {
-                        if (code === 0)
-                            resolve();
-                        else
-                            reject(new Error(stderr.trim() || `Exit code ${code}`));
-                    });
-                    child.on("error", reject);
-                });
+        // 1. Update extensions while Elyra is still running.
+        if (extensionUpdates.length > 0) {
+            try {
+                await packageManager.update();
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.showError(`Extension update failed: ${msg}`);
             }
-            // Success — show message and restart
-            updateText.setText(theme.fg("accent", `Updated to ${latest}. Restarting...`));
-            this.ui.requestRender();
-            // Brief pause so the user sees the message
-            await new Promise((r) => setTimeout(r, 500));
-            // Restart: stop TUI, then exec the same command
-            this.stop();
-            await this.runtimeHost.dispose();
-            // Re-exec elyra with the same arguments
-            const args = process.argv.slice(1);
-            const child = spawn(process.argv[0], args, {
-                stdio: "inherit",
-                shell: false,
-            });
-            child.on("close", (code) => {
-                process.exit(code ?? 0);
-            });
         }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.showError(`Update failed: ${msg}\n\nRun manually: ${selfUpdateCommand.display}`);
+        // 2. Self-update Elyra if a newer version is available and updatable.
+        if (elyraUpdate && selfUpdateCommand) {
+            try {
+                for (const step of selfUpdateCommand.steps ?? [selfUpdateCommand]) {
+                    await new Promise((resolve, reject) => {
+                        const child = spawn(step.command, step.args, {
+                            stdio: ["ignore", "pipe", "pipe"],
+                            shell: process.platform === "win32",
+                        });
+                        let stderr = "";
+                        child.stderr?.on("data", (data) => {
+                            stderr += data.toString();
+                        });
+                        child.on("close", (code) => {
+                            if (code === 0)
+                                resolve();
+                            else
+                                reject(new Error(stderr.trim() || `Exit code ${code}`));
+                        });
+                        child.on("error", reject);
+                    });
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.showError(`Elyra update failed: ${msg}\n\nRun manually: ${selfUpdateCommand.display}`);
+                return;
+            }
         }
+        // 3. Restart so the new Elyra and/or updated extensions load fresh.
+        statusText.setText(theme.fg("accent", "Updated. Restarting..."));
+        this.ui.requestRender();
+        await new Promise((r) => setTimeout(r, 500));
+        this.stop();
+        await this.runtimeHost.dispose();
+        const args = process.argv.slice(1);
+        const child = spawn(process.argv[0], args, {
+            stdio: "inherit",
+            shell: false,
+        });
+        child.on("close", (code) => {
+            process.exit(code ?? 0);
+        });
     }
     handleGoalCommand(args) {
         // No args = show or clear goal
@@ -3771,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`,
@@ -3904,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`
@@ -4973,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) => {