orient-cli 0.2.0 → 0.2.1

package/node_modules/@orient-cli/coding-agent/dist/modes/interactive/interactive-mode.js

@@ -8,7 +8,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { CombinedAutocompleteProvider, Container, fuzzyFilter, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TruncatedText, TUI, visibleWidth, } from "@orient-cli/tui";
 import { spawn, spawnSync } from "child_process";
-import { APP_NAME, getAgentDir, getAuthPath, getDebugLogPath, getShareViewerUrl, getUpdateInstruction, VERSION, } from "../../config.js";
+import { APP_NAME, CONFIG_DIR_NAME, getAgentDir, getAuthPath, getDebugLogPath, getShareViewerUrl, getUpdateInstruction, VERSION, } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
@@ -1668,6 +1668,7 @@ export class InteractiveMode {
         this.defaultEditor.onAction("app.clear", () => this.handleCtrlC());
         this.defaultEditor.onCtrlD = () => this.handleCtrlD();
         this.defaultEditor.onAction("app.suspend", () => this.handleCtrlZ());
+        this.defaultEditor.onAction("app.mode.toggle", () => this.handleModeToggle());
         this.defaultEditor.onAction("app.thinking.cycle", () => this.cycleThinkingLevel());
         this.defaultEditor.onAction("app.model.cycleForward", () => this.cycleModel("forward"));
         this.defaultEditor.onAction("app.model.cycleBackward", () => this.cycleModel("backward"));
@@ -2450,6 +2451,111 @@ export class InteractiveMode {
         }
         this.ui.requestRender();
     }
+    /**
+     * Handle shift+tab — toggle between Plan and Execute sub-modes.
+     *
+     * This is the ORIENT dual-mode UX borrowed from openclaude
+     * (Gitlawb/openclaude) and anomalyco/opencode. Both reference
+     * projects bind shift+tab (or a permission-mode cycle) to flip
+     * between a read-only "plan" agent state and an edit-capable
+     * "execute" state. ORIENT follows the same convention.
+     *
+     * Semantics (plan-execute mode only):
+     *   - `idle`      → `planning`  (first press — starts drafting)
+     *   - `planning`  → `executing` (approves the current plan, like /execute)
+     *   - `executing` → `planning`  (revises — same as /plan.revise)
+     *
+     * State lives at `.orient-cli/plan-state.json` at the project
+     * root, so reading / writing from interactive-mode here stays in
+     * sync with the orient extension's /plan /execute commands. The
+     * two entry points manipulate the same on-disk source of truth.
+     *
+     * In ORIENT framework mode, shift+tab is a no-op with a helpful
+     * message — phase transitions are explicit (/orient.transition
+     * and /orient.<phase>), not shortcut-driven.
+     */
+    handleModeToggle() {
+        const cwd = this.sessionManager.getCwd();
+        const configDirName = CONFIG_DIR_NAME; // ".orient-cli"
+        const configDir = path.join(cwd, configDirName);
+        const modeFile = path.join(configDir, "mode");
+        const stateFile = path.join(configDir, "plan-state.json");
+        // Read the current product mode. Default is plan-execute.
+        let mode = "plan-execute";
+        try {
+            if (fs.existsSync(modeFile)) {
+                const raw = fs.readFileSync(modeFile, "utf-8").trim();
+                if (raw === "orient" || raw === "plan-execute")
+                    mode = raw;
+            }
+        }
+        catch {
+            // Fall through — treat unreadable file as plan-execute default.
+        }
+        if (mode === "orient") {
+            this.showStatus("shift+tab is a Plan/Execute shortcut; in ORIENT framework mode, use /orient.<phase> to transition. Switch modes with /orient.mode plan-execute.");
+            return;
+        }
+        let session = {
+            state: "idle",
+            goal: "",
+            updatedAt: new Date().toISOString(),
+            steps: [],
+            currentStepIndex: -1,
+        };
+        try {
+            if (fs.existsSync(stateFile)) {
+                const parsed = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
+                if (parsed && typeof parsed === "object")
+                    session = { ...session, ...parsed };
+            }
+        }
+        catch {
+            // Corrupt state file → reset to idle.
+        }
+        const before = session.state;
+        let after;
+        switch (session.state) {
+            case "planning":
+                after = "executing";
+                break;
+            case "executing":
+                after = "planning";
+                break;
+            default:
+                // idle → planning
+                after = "planning";
+                break;
+        }
+        session.state = after;
+        session.updatedAt = new Date().toISOString();
+        try {
+            fs.mkdirSync(configDir, { recursive: true });
+            fs.writeFileSync(stateFile, JSON.stringify(session, null, 2), "utf-8");
+        }
+        catch (err) {
+            this.showError(`Failed to persist mode toggle: ${err.message}`);
+            return;
+        }
+        // Update the status bar and log a one-line banner in chat.
+        // The extension's session_start hook handles the system-reminder
+        // injection on the next user turn; here we just change state +
+        // surface the change visually so the user sees the flip immediately.
+        const statusText = after === "planning" ? "plan" : "execute";
+        this.showStatus(`Mode: ${before} → ${after}`);
+        this.chatContainer.addChild(new Spacer(1));
+        const bannerText = after === "planning"
+            ? theme.fg("accent", "▣ Plan mode") +
+                theme.fg("muted", " — agent will draft into .orient-cli/plans/current.md without editing any other file. Type /execute or press shift+tab again to approve.")
+            : theme.fg("accent", "▶ Execute mode") +
+                theme.fg("muted", " — agent will read the plan and walk its steps. Press shift+tab to revise the plan.");
+        this.chatContainer.addChild(new Text(bannerText, 1, 0));
+        this.ui.requestRender();
+        // Track the transition in the footer status namespace so the
+        // orient extension's next session_start can read it back. This
+        // is the same channel ctx.ui.setStatus() uses from extensions.
+        this.footerDataProvider.setExtensionStatus("orient", statusText);
+    }
     cycleThinkingLevel() {
         const newLevel = this.session.cycleThinkingLevel();
         if (newLevel === undefined) {