@elyracode/coding-agent 0.9.0 → 0.9.2

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

@@ -40,6 +40,7 @@ import { CountdownTimer } from "./components/countdown-timer.js";
 import { CustomEditor } from "./components/custom-editor.js";
 import { CustomMessageComponent } from "./components/custom-message.js";
 import { DaxnutsComponent } from "./components/daxnuts.js";
+import { DiffViewerComponent } from "./components/diff-viewer.js";
 import { DynamicBorder } from "./components/dynamic-border.js";
 import { EarendilAnnouncementComponent } from "./components/earendil-announcement.js";
 import { ExtensionEditorComponent } from "./components/extension-editor.js";
@@ -2027,9 +2028,9 @@ export class InteractiveMode {
                 this.handleCostCommand();
                 return;
             }
-            if (text === "/diff") {
+            if (text === "/diff" || text.startsWith("/diff ")) {
                 this.editor.setText("");
-                await this.handleDiffCommand();
+                await this.handleDiffCommand(text.slice("/diff".length).trim());
                 return;
             }
             if (text === "/pin" || text.startsWith("/pin ")) {
@@ -3030,8 +3031,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)));
@@ -3259,6 +3260,7 @@ export class InteractiveMode {
                 smartRouting: this.settingsManager.getSmartRouting(),
                 codebaseMemory: this.settingsManager.getCodebaseMemory(),
                 autoSkills: this.settingsManager.getAutoSkills(),
+                diffInEditor: this.settingsManager.getDiffInEditor(),
                 doubleEscapeAction: this.settingsManager.getDoubleEscapeAction(),
                 treeFilterMode: this.settingsManager.getTreeFilterMode(),
                 showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
@@ -3352,6 +3354,9 @@ export class InteractiveMode {
                 onAutoSkillsChange: (enabled) => {
                     this.settingsManager.setAutoSkills(enabled);
                 },
+                onDiffInEditorChange: (enabled) => {
+                    this.settingsManager.setDiffInEditor(enabled);
+                },
                 onQuietStartupChange: (enabled) => {
                     this.settingsManager.setQuietStartup(enabled);
                 },
@@ -3523,71 +3528,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
@@ -3765,7 +3813,7 @@ export class InteractiveMode {
             `  ${theme.fg("muted", "/model")}       Switch model`,
             `  ${theme.fg("muted", "/theme")}       Switch theme`,
             `  ${theme.fg("muted", "/cost")}        Token usage and cost`,
-            `  ${theme.fg("muted", "/diff")}        Show uncommitted changes`,
+            `  ${theme.fg("muted", "/diff")}        Show changes (--session, --cached, or <path>)`,
             `  ${theme.fg("muted", "/pin <path>")}  Pin file to context`,
             `  ${theme.fg("muted", "/memory")}      View project memory`,
             `  ${theme.fg("muted", "/blueprint")}   Apply session template`,
@@ -3799,25 +3847,136 @@ export class InteractiveMode {
         this.chatContainer.addChild(new Text(info, 1, 0));
         this.ui.requestRender();
     }
-    async handleDiffCommand() {
+    async handleDiffCommand(args) {
         const cwd = this.sessionManager.getCwd();
+        // Parse flags and an optional path filter from the argument string.
+        const tokens = args.split(/\s+/).filter(Boolean);
+        let sessionMode = false;
+        let cachedMode = false;
+        let editorMode = false;
+        let inlineMode = false;
+        const pathArgs = [];
+        for (const token of tokens) {
+            if (token === "--session" || token === "-s")
+                sessionMode = true;
+            else if (token === "--cached" || token === "--staged")
+                cachedMode = true;
+            else if (token === "--editor" || token === "-e")
+                editorMode = true;
+            else if (token === "--inline")
+                inlineMode = true;
+            else
+                pathArgs.push(token);
+        }
+        // Respect the diffInEditor preference unless an explicit flag overrides it.
+        if (!editorMode && !inlineMode && this.settingsManager.getDiffInEditor()) {
+            editorMode = true;
+        }
+        const runGit = (gitArgs) => {
+            const result = spawnSync("git", gitArgs, {
+                cwd,
+                encoding: "utf-8",
+                maxBuffer: 32 * 1024 * 1024,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            if (result.status !== 0 && result.error)
+                throw result.error;
+            return result.stdout ?? "";
+        };
         try {
-            const { execSync } = await import("node:child_process");
-            const diff = execSync("git diff", { cwd, encoding: "utf-8", maxBuffer: 1024 * 1024 });
+            // Verify this is a git repository up front for a clear error.
+            const insideRepo = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+                cwd,
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            if (insideRepo.status !== 0) {
+                this.showError("Not a git repository.");
+                return;
+            }
+            let diff = "";
+            let title;
+            const pathSpec = pathArgs.length > 0 ? ["--", ...pathArgs] : [];
+            if (sessionMode) {
+                // Diff the working tree against the session's first checkpoint, so the
+                // user sees only what the agent changed during this session.
+                const baseline = this.session.getSessionBaselineRef();
+                if (!baseline) {
+                    this.showStatus("No session baseline yet (the agent hasn't taken a turn, or this isn't a git repo).");
+                    return;
+                }
+                diff = runGit(["diff", baseline, ...pathSpec]);
+                title = "Changes This Session";
+            }
+            else if (cachedMode) {
+                diff = runGit(["diff", "--cached", ...pathSpec]);
+                title = "Staged Changes";
+            }
+            else {
+                diff = runGit(["diff", ...pathSpec]);
+                title = "Uncommitted Changes";
+                // Include untracked files (not shown by plain `git diff`) when not
+                // filtering by an explicit path.
+                if (pathArgs.length === 0) {
+                    const untracked = runGit(["ls-files", "--others", "--exclude-standard"]).split("\n").filter(Boolean);
+                    if (untracked.length > 0) {
+                        diff += `\n${untracked.map((f) => `+ (untracked) ${f}`).join("\n")}`;
+                    }
+                }
+            }
             if (!diff.trim()) {
-                this.showStatus("No uncommitted changes");
+                this.showStatus(pathArgs.length > 0 ? `No changes in ${pathArgs.join(", ")}` : "No changes");
                 return;
             }
-            this.chatContainer.addChild(new Spacer(1));
-            this.chatContainer.addChild(new DynamicBorder());
-            this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "Uncommitted Changes")), 1, 0));
-            this.chatContainer.addChild(new Spacer(1));
-            this.chatContainer.addChild(new Markdown(`\`\`\`diff\n${diff}\n\`\`\``, 1, 1, this.getMarkdownThemeWithSettings()));
-            this.chatContainer.addChild(new DynamicBorder());
-            this.ui.requestRender();
+            // Open the diff directly in the user's editor when requested or preferred.
+            if (editorMode) {
+                this.openTextInExternalEditor(diff, ".diff");
+                return;
+            }
+            // Default: show the scrollable in-TUI diff viewer.
+            const diffText = diff;
+            this.showSelector((done) => {
+                const viewer = new DiffViewerComponent(this.ui, diffText, title, {
+                    onOpenEditor: () => this.openTextInExternalEditor(diffText, ".diff"),
+                    onClose: done,
+                });
+                return { component: viewer, focus: viewer };
+            });
         }
         catch {
-            this.showError("Failed to run git diff. Is this a git repository?");
+            this.showError("Failed to run git diff.");
+        }
+    }
+    /**
+     * 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`
+     * controls the temp file extension so editors apply the right syntax highlighting.
+     */
+    openTextInExternalEditor(content, suffix) {
+        const editorCmd = process.env.VISUAL || process.env.EDITOR;
+        if (!editorCmd) {
+            this.showWarning("No editor configured. Set $VISUAL or $EDITOR environment variable.");
+            return;
+        }
+        const tmpFile = path.join(os.tmpdir(), `elyra-diff-${Date.now()}${suffix}`);
+        try {
+            fs.writeFileSync(tmpFile, content, "utf-8");
+            this.ui.stop();
+            const [editor, ...editorArgs] = editorCmd.split(" ");
+            spawnSync(editor, [...editorArgs, tmpFile], {
+                stdio: "inherit",
+                shell: process.platform === "win32",
+            });
+        }
+        finally {
+            try {
+                fs.unlinkSync(tmpFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            this.ui.start();
+            this.ui.requestRender(true);
         }
     }
     handlePinCommand(filePath) {