@mtayfur/opencode-prompt-enhancer 0.0.17 → 0.0.19

package/dist/plugins/prompt-enhancer.js

@@ -0,0 +1,859 @@
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { use as _$use } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+
+import { useTerminalDimensions } from "@opentui/solid";
+import { Show, createMemo, createSignal } from "solid-js";
+import { ENHANCER_SYSTEM_PROMPT } from "./enhancer-system-prompt";
+const MAX_RECENT_MESSAGES = 3;
+const MAX_CHANGED_FILES = 25;
+const MAX_PROMPT_PREVIEW_LENGTH = 250;
+const ENHANCEMENT_TIMEOUT_MS = 60_000;
+const ENHANCEMENT_ANIMATION_INTERVAL_MS = 250;
+const TOAST_DURATION_MS = 3_000;
+const ENHANCEMENT_CANCELED_MESSAGE = "Prompt enhancement canceled.";
+const ENHANCEMENT_ANIMATION_FRAMES = ["Enhancing prompt", "Enhancing prompt.", "Enhancing prompt..", "Enhancing prompt..."];
+const DIALOG_TITLE = "Enhance Prompt";
+const DIALOG_WIDTH_RATIO = 0.60;
+const DIALOG_MAX_WIDTH = 120;
+const DIALOG_MIN_WIDTH = 40;
+const DIALOG_SCREEN_MARGIN_X = 4;
+const DIALOG_SCREEN_MARGIN_Y = 4;
+const DIALOG_HEIGHT = 24;
+const DIALOG_PADDING_X = 2;
+const DIALOG_PADDING_Y = 1;
+const DIALOG_TEXTAREA_RESERVED_HEIGHT = 7;
+const DIALOG_TEXTAREA_VERTICAL_PADDING = 2;
+const DIALOG_BACKDROP_COLOR = "#000000";
+const DIALOG_BACKDROP_OPACITY = 0.65;
+const DIALOG_PLACEHOLDER = "Describe the task...";
+const DIALOG_HINT = "Enter to enhance • Shift+Enter for newline • Esc to cancel";
+const TOAST_TITLE = "Prompt enhancer";
+function parseEnhancementInput(input) {
+  const match = input.trimEnd().match(/^(\/[A-Za-z0-9][A-Za-z0-9._:-]*(?:\/[A-Za-z0-9][A-Za-z0-9._:-]*)*)(?:(?: +|\n)([\s\S]*))?$/);
+  if (!match) return {
+    draft: input.trim()
+  };
+  return {
+    command: match[1],
+    draft: match[2]?.trim() ?? ""
+  };
+}
+function formatEnhancedInput(input, enhancedDraft) {
+  return input.command ? `${input.command} ${enhancedDraft}` : enhancedDraft;
+}
+function parseModelString(value) {
+  if (!value) return undefined;
+  const trimmed = value.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash <= 0 || slash === trimmed.length - 1) return undefined;
+  return {
+    providerID: trimmed.slice(0, slash),
+    modelID: trimmed.slice(slash + 1)
+  };
+}
+function isSessionRoute(route) {
+  return route.name === "session";
+}
+function extractVisibleText(parts) {
+  return parts.filter(part => part.type === "text" && !part.ignored).map(part => part.text).join("").trim();
+}
+function resolveEnhancerModel(api, options) {
+  const override = typeof options?.model === "string" ? parseModelString(options.model) : undefined;
+  if (override) return override;
+  return parseModelString(api.state.config.small_model || api.state.config.model);
+}
+function clonePromptInfo(prompt) {
+  return {
+    input: prompt.input,
+    mode: prompt.mode,
+    parts: prompt.parts.map(part => ({
+      ...part
+    }))
+  };
+}
+function nextPromptInfo(prompt, input) {
+  return {
+    input,
+    mode: prompt.mode,
+    parts: prompt.parts.filter(part => part.type !== "text").map(part => ({
+      ...part
+    }))
+  };
+}
+function samePromptInfo(left, right) {
+  return left.input === right.input && left.mode === right.mode && JSON.stringify(left.parts) === JSON.stringify(right.parts);
+}
+function errorFromReason(reason, fallbackMessage) {
+  return reason instanceof Error ? reason : new Error(fallbackMessage);
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+async function withRequestTimeout(signal, timeoutMs, run) {
+  const controller = new AbortController();
+  const timeoutMessage = `Prompt enhancement timed out after ${Math.floor(timeoutMs / 1000)} seconds.`;
+  const onAbort = () => controller.abort(signal.reason);
+  const timeout = setTimeout(() => controller.abort(new Error(timeoutMessage)), timeoutMs);
+  if (signal.aborted) {
+    controller.abort(signal.reason);
+  } else {
+    signal.addEventListener("abort", onAbort, {
+      once: true
+    });
+  }
+  try {
+    return await run(controller.signal);
+  } catch (error) {
+    if (controller.signal.aborted && !signal.aborted) {
+      throw errorFromReason(controller.signal.reason, timeoutMessage);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+function samePromptTarget(left, right) {
+  if (!left || !right || left.name !== right.name) return false;
+  if (left.name === "session" && right.name === "session") {
+    return left.sessionID === right.sessionID;
+  }
+  return true;
+}
+function isPromptHandleActive(api, state, handle) {
+  const route = api.route.current;
+  const target = handle.target;
+  if (target.name === "home") {
+    if (route.name !== "home") return false;
+  } else if (!isSessionRoute(route) || route.params.sessionID !== target.sessionID) {
+    return false;
+  }
+  if (api.state.path.directory !== handle.directory) return false;
+  if (handle.ref) {
+    return state.promptRef === handle.ref && samePromptTarget(state.promptTarget, handle.target);
+  }
+  return true;
+}
+function bindPromptRef(state, target, forwarded, ref) {
+  if (ref) {
+    state.promptRef = ref;
+    state.promptTarget = target;
+  } else if (samePromptTarget(state.promptTarget, target)) {
+    state.promptRef = undefined;
+    state.promptTarget = undefined;
+  }
+  forwarded?.(ref);
+}
+async function applyPromptUpdate(api, state, handle, update, signal) {
+  if (!isPromptHandleActive(api, state, handle)) return false;
+  const promptRef = handle.ref;
+  if (promptRef) {
+    promptRef.set(update.createPromptInfo(promptRef.current));
+    if (update.refAction === "focus") promptRef.focus();else promptRef.blur();
+    return true;
+  }
+  const requestOptions = {
+    signal,
+    throwOnError: true
+  };
+  await api.client.tui.clearPrompt({
+    directory: handle.directory
+  }, requestOptions);
+  if (update.fallbackInput) {
+    await api.client.tui.appendPrompt({
+      directory: handle.directory,
+      text: update.fallbackInput
+    }, requestOptions);
+  }
+  return true;
+}
+function clearPrompt(api, state, handle, signal, template) {
+  return applyPromptUpdate(api, state, handle, {
+    fallbackInput: "",
+    createPromptInfo: current => nextPromptInfo(template ?? current, ""),
+    refAction: "blur"
+  }, signal);
+}
+function writePrompt(api, state, handle, input, signal, template) {
+  return applyPromptUpdate(api, state, handle, {
+    fallbackInput: input,
+    createPromptInfo: current => nextPromptInfo(template ?? current, input),
+    refAction: "focus"
+  }, signal);
+}
+function restorePrompt(api, state, handle, prompt, signal) {
+  return applyPromptUpdate(api, state, handle, {
+    fallbackInput: prompt.input,
+    createPromptInfo: () => clonePromptInfo(prompt),
+    refAction: "focus"
+  }, signal);
+}
+function restoreEnhancementPrompt(api, state, enhancement, signal) {
+  return enhancement.originalPrompt ? restorePrompt(api, state, enhancement.handle, enhancement.originalPrompt, signal) : writePrompt(api, state, enhancement.handle, enhancement.input, signal);
+}
+async function cancelActiveEnhancement(api, state, signal) {
+  const active = state.activeEnhancement;
+  if (!state.enhancing || !active) return false;
+  active.canceled = true;
+  active.stopAnimation?.();
+  active.controller.abort(new Error(ENHANCEMENT_CANCELED_MESSAGE));
+  return restoreEnhancementPrompt(api, state, active, signal);
+}
+function startEnhancementAnimation(api, state, handle, template) {
+  const promptRef = handle.ref;
+  if (!promptRef) return () => {};
+  let frame = 0;
+  let stopped = false;
+  const render = () => {
+    if (stopped) return;
+    if (!isPromptHandleActive(api, state, handle)) {
+      stopped = true;
+      return;
+    }
+    promptRef.set(nextPromptInfo(template ?? promptRef.current, ENHANCEMENT_ANIMATION_FRAMES[frame]));
+    frame = (frame + 1) % ENHANCEMENT_ANIMATION_FRAMES.length;
+  };
+  render();
+  const interval = setInterval(render, ENHANCEMENT_ANIMATION_INTERVAL_MS);
+  return () => {
+    stopped = true;
+    clearInterval(interval);
+  };
+}
+function gatherContext(api) {
+  const sections = [];
+  const dir = api.state.path.directory;
+  sections.push(`Working directory: ${dir}`);
+  const branch = api.state.vcs?.branch;
+  if (branch) {
+    sections.push(`Current branch: ${branch}`);
+  }
+  const route = api.route.current;
+  if (isSessionRoute(route)) {
+    const sessionID = route.params.sessionID;
+    const messages = api.state.session.messages(sessionID);
+    const userMessages = messages.filter(message => message.role === "user");
+    const recent = userMessages.slice(-MAX_RECENT_MESSAGES).reverse();
+    if (recent.length > 0) {
+      const prompts = [];
+      for (const msg of recent) {
+        const text = extractVisibleText(api.state.part(msg.id));
+        if (text) {
+          prompts.push(text.length > MAX_PROMPT_PREVIEW_LENGTH ? `${text.slice(0, MAX_PROMPT_PREVIEW_LENGTH)}...` : text);
+        }
+      }
+      if (prompts.length > 0) {
+        sections.push(`Recent user prompts in this session (newest first):\n${prompts.map((p, i) => `${i + 1}. ${p}`).join("\n")}`);
+      }
+    }
+    const diff = api.state.session.diff(sessionID);
+    if (diff.length > 0) {
+      const files = diff.slice(0, MAX_CHANGED_FILES).map(f => `  @${f.file}`);
+      sections.push(`Files changed in session:\n${files.join("\n")}`);
+    }
+  }
+  return sections.join("\n\n");
+}
+async function enhanceWithModel(api, options, input, signal) {
+  const directory = api.state.path.directory;
+  const model = resolveEnhancerModel(api, options);
+  const context = gatherContext(api);
+  const userMessage = [`--- CONTEXT ---\n${context}\n---`, `--- DRAFT ---\n${input}\n---`].join("\n\n");
+  const created = await api.client.session.create({
+    directory,
+    title: `Prompt Enhancer ${Math.random().toString(36).slice(2, 8)}`,
+    permission: [{
+      permission: "*",
+      action: "deny",
+      pattern: "*"
+    }]
+  }, {
+    signal,
+    throwOnError: true
+  });
+  const tempSessionID = created.data?.id;
+  if (!tempSessionID) throw new Error("Failed to start prompt enhancer.");
+  try {
+    const response = await withRequestTimeout(signal, ENHANCEMENT_TIMEOUT_MS, requestSignal => api.client.session.prompt({
+      sessionID: tempSessionID,
+      directory,
+      model,
+      system: ENHANCER_SYSTEM_PROMPT,
+      parts: [{
+        type: "text",
+        text: userMessage
+      }]
+    }, {
+      signal: requestSignal,
+      throwOnError: true
+    }));
+    const parts = response.data?.parts;
+    if (!parts) throw new Error("Enhancer returned no response.");
+    const enhanced = extractVisibleText(parts);
+    if (!enhanced) throw new Error("Enhancer returned no text.");
+    return enhanced;
+  } finally {
+    void api.client.session.abort({
+      sessionID: tempSessionID,
+      directory
+    }).catch(() => {}).then(() => api.client.session.delete({
+      sessionID: tempSessionID,
+      directory
+    })).catch(() => {});
+  }
+}
+function renderEnhanceDialog(api, dialog) {
+  const theme = api.theme.current;
+  const terminal = useTerminalDimensions();
+  const screenWidth = createMemo(() => Math.max(1, terminal().width));
+  const screenHeight = createMemo(() => Math.max(1, terminal().height));
+  const panelWidth = createMemo(() => {
+    const width = screenWidth();
+    const availableWidth = Math.max(1, width - DIALOG_SCREEN_MARGIN_X);
+    const minWidth = Math.min(DIALOG_MIN_WIDTH, availableWidth);
+    const maxWidth = Math.min(DIALOG_MAX_WIDTH, availableWidth);
+    return clamp(Math.floor(width * DIALOG_WIDTH_RATIO), minWidth, maxWidth);
+  });
+  const panelHeight = createMemo(() => {
+    const availableHeight = Math.max(1, screenHeight() - DIALOG_SCREEN_MARGIN_Y);
+    return Math.min(DIALOG_HEIGHT, availableHeight);
+  });
+  const textareaBoxHeight = createMemo(() => Math.max(1, panelHeight() - DIALOG_TEXTAREA_RESERVED_HEIGHT));
+  const textareaHeight = createMemo(() => Math.max(1, textareaBoxHeight() - DIALOG_TEXTAREA_VERTICAL_PADDING));
+  let dialogInput;
+  return (() => {
+    var _el$ = _$createElement("box"),
+      _el$2 = _$createElement("box"),
+      _el$3 = _$createElement("box"),
+      _el$4 = _$createElement("text"),
+      _el$6 = _$createElement("box"),
+      _el$7 = _$createElement("textarea"),
+      _el$8 = _$createElement("text");
+    _$insertNode(_el$, _el$2);
+    _$insertNode(_el$, _el$3);
+    _$setProp(_el$, "position", "absolute");
+    _$setProp(_el$, "top", 0);
+    _$setProp(_el$, "left", 0);
+    _$setProp(_el$, "justifyContent", "center");
+    _$setProp(_el$, "alignItems", "center");
+    _$setProp(_el$2, "position", "absolute");
+    _$setProp(_el$2, "top", 0);
+    _$setProp(_el$2, "left", 0);
+    _$setProp(_el$2, "backgroundColor", "#000000");
+    _$setProp(_el$2, "opacity", 0.65);
+    _$insertNode(_el$3, _el$4);
+    _$insertNode(_el$3, _el$6);
+    _$insertNode(_el$3, _el$8);
+    _$setProp(_el$3, "flexDirection", "column");
+    _$setProp(_el$3, "gap", 1);
+    _$setProp(_el$3, "paddingX", 2);
+    _$setProp(_el$3, "paddingY", 1);
+    _$setProp(_el$3, "border", true);
+    _$insertNode(_el$4, _$createTextNode(`Enhance Prompt`));
+    _$insertNode(_el$6, _el$7);
+    _$setProp(_el$6, "border", true);
+    _$setProp(_el$6, "flexDirection", "column");
+    _$setProp(_el$6, "paddingX", 1);
+    _$setProp(_el$6, "paddingY", 1);
+    _$use(node => {
+      dialogInput = node;
+      if (!node) return;
+      node.cursorOffset = node.plainText.length;
+      queueMicrotask(() => {
+        if (dialogInput === node) node.focus();
+      });
+    }, _el$7);
+    _$setProp(_el$7, "width", "100%");
+    _$setProp(_el$7, "placeholder", "Describe the task...");
+    _$setProp(_el$7, "wrapMode", "word");
+    _$setProp(_el$7, "keyBindings", [{
+      name: "return",
+      action: "submit"
+    }, {
+      name: "linefeed",
+      action: "submit"
+    }, {
+      name: "return",
+      shift: true,
+      action: "newline"
+    }, {
+      name: "linefeed",
+      shift: true,
+      action: "newline"
+    }]);
+    _$setProp(_el$7, "onKeyDown", key => {
+      if (key.name === "escape" || key.ctrl && key.name === "c") dialog.onCancel();
+    });
+    _$setProp(_el$7, "onSubmit", () => dialog.onConfirm(dialogInput?.plainText ?? ""));
+    _$insertNode(_el$8, _$createTextNode(`Enter to enhance • Shift+Enter for newline • Esc to cancel`));
+    _$effect(_p$ => {
+      var _v$ = screenWidth(),
+        _v$2 = screenHeight(),
+        _v$3 = screenWidth(),
+        _v$4 = screenHeight(),
+        _v$5 = panelWidth(),
+        _v$6 = panelHeight(),
+        _v$7 = theme.backgroundPanel,
+        _v$8 = theme.border,
+        _v$9 = theme.borderActive,
+        _v$0 = textareaBoxHeight(),
+        _v$1 = textareaHeight(),
+        _v$10 = dialog.initialValue,
+        _v$11 = theme.text,
+        _v$12 = theme.textMuted,
+        _v$13 = theme.backgroundPanel,
+        _v$14 = theme.backgroundPanel,
+        _v$15 = theme.text,
+        _v$16 = theme.primary,
+        _v$17 = theme.textMuted;
+      _v$ !== _p$.e && (_p$.e = _$setProp(_el$, "width", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$, "height", _v$2, _p$.t));
+      _v$3 !== _p$.a && (_p$.a = _$setProp(_el$2, "width", _v$3, _p$.a));
+      _v$4 !== _p$.o && (_p$.o = _$setProp(_el$2, "height", _v$4, _p$.o));
+      _v$5 !== _p$.i && (_p$.i = _$setProp(_el$3, "width", _v$5, _p$.i));
+      _v$6 !== _p$.n && (_p$.n = _$setProp(_el$3, "height", _v$6, _p$.n));
+      _v$7 !== _p$.s && (_p$.s = _$setProp(_el$3, "backgroundColor", _v$7, _p$.s));
+      _v$8 !== _p$.h && (_p$.h = _$setProp(_el$3, "borderColor", _v$8, _p$.h));
+      _v$9 !== _p$.r && (_p$.r = _$setProp(_el$6, "borderColor", _v$9, _p$.r));
+      _v$0 !== _p$.d && (_p$.d = _$setProp(_el$6, "height", _v$0, _p$.d));
+      _v$1 !== _p$.l && (_p$.l = _$setProp(_el$7, "height", _v$1, _p$.l));
+      _v$10 !== _p$.u && (_p$.u = _$setProp(_el$7, "initialValue", _v$10, _p$.u));
+      _v$11 !== _p$.c && (_p$.c = _$setProp(_el$7, "textColor", _v$11, _p$.c));
+      _v$12 !== _p$.w && (_p$.w = _$setProp(_el$7, "placeholderColor", _v$12, _p$.w));
+      _v$13 !== _p$.m && (_p$.m = _$setProp(_el$7, "backgroundColor", _v$13, _p$.m));
+      _v$14 !== _p$.f && (_p$.f = _$setProp(_el$7, "focusedBackgroundColor", _v$14, _p$.f));
+      _v$15 !== _p$.y && (_p$.y = _$setProp(_el$7, "focusedTextColor", _v$15, _p$.y));
+      _v$16 !== _p$.g && (_p$.g = _$setProp(_el$7, "cursorColor", _v$16, _p$.g));
+      _v$17 !== _p$.p && (_p$.p = _$setProp(_el$8, "fg", _v$17, _p$.p));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined,
+      o: undefined,
+      i: undefined,
+      n: undefined,
+      s: undefined,
+      h: undefined,
+      r: undefined,
+      d: undefined,
+      l: undefined,
+      u: undefined,
+      c: undefined,
+      w: undefined,
+      m: undefined,
+      f: undefined,
+      y: undefined,
+      g: undefined,
+      p: undefined
+    });
+    return _el$;
+  })();
+}
+function openEnhanceDialog(api, options, state, setEnhanceDialog, signal) {
+  if (state.enhancing) {
+    api.ui.toast({
+      variant: "warning",
+      title: TOAST_TITLE,
+      message: "Enhancement in progress."
+    });
+    return;
+  }
+  if (signal.aborted) return;
+  const target = state.promptTarget ?? (api.route.current.name === "home" ? {
+    name: "home"
+  } : isSessionRoute(api.route.current) ? {
+    name: "session",
+    sessionID: api.route.current.params.sessionID
+  } : undefined);
+  if (!target) {
+    api.ui.toast({
+      variant: "warning",
+      title: TOAST_TITLE,
+      message: "Enhancement only works from a prompt."
+    });
+    return;
+  }
+  const handle = {
+    target,
+    directory: api.state.path.directory,
+    ref: state.promptRef
+  };
+  const originalPrompt = handle.ref ? clonePromptInfo(handle.ref.current) : undefined;
+  const initialValue = originalPrompt?.input ?? "";
+  const closeDialog = () => setEnhanceDialog(undefined);
+  const confirmInput = value => {
+    if (state.enhancing) return;
+    const input = value.trim();
+    if (!input) {
+      api.ui.toast({
+        variant: "warning",
+        title: TOAST_TITLE,
+        message: "Enter a prompt first."
+      });
+      closeDialog();
+      return;
+    }
+    const enhancementInput = parseEnhancementInput(value);
+    if (!enhancementInput.draft) {
+      api.ui.toast({
+        variant: "warning",
+        title: TOAST_TITLE,
+        message: "Enter instructions after the slash command."
+      });
+      closeDialog();
+      return;
+    }
+    if (!isPromptHandleActive(api, state, handle)) {
+      api.ui.toast({
+        variant: "warning",
+        title: TOAST_TITLE,
+        message: "Prompt changed while dialog was open."
+      });
+      closeDialog();
+      return;
+    }
+    state.enhancing = true;
+    closeDialog();
+    api.ui.toast({
+      variant: "info",
+      title: TOAST_TITLE,
+      message: "Enhancing prompt...",
+      duration: TOAST_DURATION_MS
+    });
+    const enhancementController = new AbortController();
+    const onLifecycleAbort = () => enhancementController.abort(signal.reason);
+    const activeEnhancement = {
+      controller: enhancementController,
+      handle,
+      originalPrompt,
+      input
+    };
+    state.activeEnhancement = activeEnhancement;
+    if (signal.aborted) {
+      enhancementController.abort(signal.reason);
+    } else {
+      signal.addEventListener("abort", onLifecycleAbort, {
+        once: true
+      });
+    }
+    void (async () => {
+      let stopAnimation = () => {};
+      try {
+        const cleared = await clearPrompt(api, state, handle, signal, originalPrompt);
+        if (!cleared) {
+          api.ui.toast({
+            variant: "warning",
+            title: TOAST_TITLE,
+            message: "Prompt changed before enhancement started."
+          });
+          return;
+        }
+        stopAnimation = startEnhancementAnimation(api, state, handle, originalPrompt);
+        if (state.activeEnhancement) {
+          state.activeEnhancement.stopAnimation = stopAnimation;
+        }
+        const enhancedDraft = await enhanceWithModel(api, options, enhancementInput.draft, enhancementController.signal);
+        const enhanced = formatEnhancedInput(enhancementInput, enhancedDraft);
+        if (signal.aborted) return;
+        if (enhancementController.signal.aborted) {
+          throw errorFromReason(enhancementController.signal.reason, ENHANCEMENT_CANCELED_MESSAGE);
+        }
+        stopAnimation();
+        const wrote = await writePrompt(api, state, handle, enhanced, signal, originalPrompt);
+        if (!wrote) {
+          api.ui.toast({
+            variant: "warning",
+            title: TOAST_TITLE,
+            message: "Enhanced prompt is ready, but that prompt is no longer active."
+          });
+          return;
+        }
+        if (enhancementController.signal.aborted) {
+          throw errorFromReason(enhancementController.signal.reason, ENHANCEMENT_CANCELED_MESSAGE);
+        }
+        state.lastEnhancement = originalPrompt ? {
+          original: clonePromptInfo(originalPrompt),
+          enhancedInput: enhanced,
+          target: {
+            ...handle.target
+          },
+          directory: handle.directory
+        } : undefined;
+        api.ui.toast({
+          variant: "success",
+          title: "Prompt enhanced",
+          message: "Enhanced prompt added to input.",
+          duration: TOAST_DURATION_MS
+        });
+      } catch (error) {
+        if (signal.aborted) return;
+        stopAnimation();
+        const canceled = enhancementController.signal.aborted && !signal.aborted;
+        if (canceled && state.activeEnhancement?.canceled) {
+          // cancelActiveEnhancement already stopped the animation and restored the prompt.
+          return;
+        }
+        let restored;
+        try {
+          restored = await restoreEnhancementPrompt(api, state, activeEnhancement, signal);
+        } catch {
+          // Best-effort restore; do not suppress the error toast.
+          restored = false;
+        }
+        let baseMessage;
+        if (canceled) {
+          baseMessage = ENHANCEMENT_CANCELED_MESSAGE;
+        } else if (error instanceof Error) {
+          baseMessage = error.message;
+        } else {
+          baseMessage = "Prompt enhancement failed.";
+        }
+        let message;
+        if (canceled && restored) {
+          message = "Enhancement canceled. Original prompt restored.";
+        } else if (restored) {
+          message = baseMessage;
+        } else {
+          message = `${baseMessage} Original prompt could not be restored because the prompt changed. Please re-enter your prompt manually.`;
+        }
+        api.ui.toast({
+          variant: canceled && restored ? "info" : "error",
+          title: TOAST_TITLE,
+          message
+        });
+      } finally {
+        stopAnimation();
+        signal.removeEventListener("abort", onLifecycleAbort);
+        if (state.activeEnhancement?.controller === enhancementController) {
+          state.activeEnhancement = undefined;
+        }
+        state.enhancing = false;
+      }
+    })();
+  };
+  setEnhanceDialog({
+    initialValue,
+    onCancel: closeDialog,
+    onConfirm: confirmInput
+  });
+}
+function revertEnhancement(api, state, signal) {
+  if (state.enhancing && state.activeEnhancement) {
+    void (async () => {
+      try {
+        const restored = await cancelActiveEnhancement(api, state, signal);
+        if (!restored) {
+          api.ui.toast({
+            variant: "warning",
+            title: TOAST_TITLE,
+            message: "Prompt changed while canceling."
+          });
+          return;
+        }
+        api.ui.toast({
+          variant: "info",
+          title: TOAST_TITLE,
+          message: "Enhancement canceled. Original prompt restored.",
+          duration: TOAST_DURATION_MS
+        });
+      } catch (error) {
+        if (signal.aborted) return;
+        const message = error instanceof Error ? error.message : "Cancel failed.";
+        api.ui.toast({
+          variant: "error",
+          title: TOAST_TITLE,
+          message
+        });
+      }
+    })();
+    return;
+  }
+  const lastEnhancement = state.lastEnhancement;
+  if (!lastEnhancement) {
+    api.ui.toast({
+      variant: "warning",
+      title: TOAST_TITLE,
+      message: "No enhancement to revert."
+    });
+    return;
+  }
+  const target = state.promptTarget;
+  if (!target) {
+    api.ui.toast({
+      variant: "warning",
+      title: TOAST_TITLE,
+      message: "Revert only works from a prompt."
+    });
+    return;
+  }
+  if (api.state.path.directory !== lastEnhancement.directory || !samePromptTarget(target, lastEnhancement.target)) {
+    api.ui.toast({
+      variant: "warning",
+      title: TOAST_TITLE,
+      message: "The enhanced prompt is no longer active."
+    });
+    return;
+  }
+  const handle = {
+    target,
+    directory: api.state.path.directory,
+    ref: state.promptRef
+  };
+  if (!isPromptHandleActive(api, state, handle)) {
+    api.ui.toast({
+      variant: "warning",
+      title: TOAST_TITLE,
+      message: "Prompt changed since enhancement."
+    });
+    return;
+  }
+  const currentPrompt = handle.ref?.current;
+  const expectedEnhancedPrompt = nextPromptInfo(lastEnhancement.original, lastEnhancement.enhancedInput);
+  if (!currentPrompt || !samePromptInfo(currentPrompt, expectedEnhancedPrompt)) {
+    api.ui.toast({
+      variant: "warning",
+      title: TOAST_TITLE,
+      message: "Prompt was manually changed after enhancement. Revert skipped."
+    });
+    return;
+  }
+  void (async () => {
+    try {
+      const wrote = await restorePrompt(api, state, handle, lastEnhancement.original, signal);
+      if (!wrote) {
+        api.ui.toast({
+          variant: "warning",
+          title: TOAST_TITLE,
+          message: "Prompt changed while reverting."
+        });
+        return;
+      }
+      state.lastEnhancement = undefined;
+      api.ui.toast({
+        variant: "success",
+        title: TOAST_TITLE,
+        message: "Reverted to original prompt.",
+        duration: TOAST_DURATION_MS
+      });
+    } catch (error) {
+      if (signal.aborted) return;
+      const message = error instanceof Error ? error.message : "Revert failed.";
+      api.ui.toast({
+        variant: "error",
+        title: TOAST_TITLE,
+        message
+      });
+    }
+  })();
+}
+const tui = async (api, options) => {
+  const state = {
+    enhancing: false
+  };
+  const [enhanceDialog, setEnhanceDialog] = createSignal();
+  const promptSlots = {
+    slots: {
+      app() {
+        return _$createComponent(Show, {
+          get when() {
+            return enhanceDialog();
+          },
+          children: dialog => renderEnhanceDialog(api, dialog())
+        });
+      },
+      home_prompt(_ctx, props) {
+        return _$createComponent(api.ui.Prompt, {
+          ref: ref => bindPromptRef(state, {
+            name: "home"
+          }, props.ref, ref),
+          get right() {
+            return _$createComponent(api.ui.Slot, {
+              name: "home_prompt_right"
+            });
+          }
+        });
+      },
+      session_prompt(_ctx, props) {
+        return _$createComponent(api.ui.Prompt, {
+          ref: ref => bindPromptRef(state, {
+            name: "session",
+            sessionID: props.session_id
+          }, props.ref, ref),
+          get sessionID() {
+            return props.session_id;
+          },
+          get visible() {
+            return props.visible;
+          },
+          get disabled() {
+            return props.disabled;
+          },
+          get onSubmit() {
+            return props.on_submit;
+          },
+          get right() {
+            return _$createComponent(api.ui.Slot, {
+              name: "session_prompt_right",
+              get session_id() {
+                return props.session_id;
+              }
+            });
+          }
+        });
+      }
+    }
+  };
+  api.slots.register(promptSlots);
+  const unregister = api.keymap.registerLayer({
+    commands: [{
+      name: "prompt-enhancer.enhance",
+      title: DIALOG_TITLE,
+      desc: "Enhance current prompt",
+      category: "Prompt",
+      suggested: true,
+      run: () => {
+        openEnhanceDialog(api, options, state, setEnhanceDialog, api.lifecycle.signal);
+      }
+    }, {
+      name: "prompt-enhancer.revert",
+      title: "Revert Enhanced Prompt",
+      desc: "Revert last prompt enhancement",
+      category: "Prompt",
+      run: () => {
+        revertEnhancement(api, state, api.lifecycle.signal);
+      }
+    }],
+    bindings: [{
+      key: "ctrl+e",
+      cmd: "prompt-enhancer.enhance"
+    }, {
+      key: "ctrl+shift+e",
+      cmd: "prompt-enhancer.revert"
+    }]
+  });
+  api.lifecycle.onDispose(() => {
+    unregister();
+    setEnhanceDialog(undefined);
+    const active = state.activeEnhancement;
+    if (active) {
+      active.controller.abort(api.lifecycle.signal.reason);
+    }
+    state.activeEnhancement = undefined;
+    state.enhancing = false;
+    state.promptRef = undefined;
+    state.promptTarget = undefined;
+    state.lastEnhancement = undefined;
+  });
+};
+const plugin = {
+  id: "prompt-enhancer",
+  tui
+};
+export default plugin;