clikit-plugin 0.3.20 → 0.3.22

package/dist/tui.js

@@ -1,804 +0,0 @@
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __require = import.meta.require;
-
-// src/tools/augment.ts
-var REVIEW_RULE = {
-  intent: "review",
-  patterns: [
-    /\breview\b/,
-    /\baudit\b/,
-    /\bsecurity issues?\b/,
-    /\bfindings?\b/,
-    /\bpr\b/
-  ]
-};
-var DEBUG_RULE = {
-  intent: "debug",
-  patterns: [
-    /\bdebug\b/,
-    /\bfix\b/,
-    /\bbug\b/,
-    /\bbroken\b/,
-    /\bfails?\b/,
-    /\bfailing\b/,
-    /\b404\b/,
-    /\berrors?\b/,
-    /\broot cause\b/
-  ]
-};
-var REFACTOR_RULE = {
-  intent: "refactor",
-  patterns: [
-    /\brefactor\b/,
-    /\bclean\s+up\b/,
-    /\bcleanup\b/,
-    /\bsimplif(?:y|ication)\b/,
-    /\bdedupe\b/,
-    /\bdeduplicate\b/,
-    /\brestructure\b/,
-    /\breorganize\b/,
-    /\bduplication\b/
-  ]
-};
-var TEST_FIX_RULE = {
-  intent: "test-fix",
-  patterns: [
-    /\btests?\b/,
-    /\bregression\b/,
-    /\bfix tests?\b/,
-    /\badd tests?\b/,
-    /\bupdate tests?\b/
-  ]
-};
-var DOCS_RULE = {
-  intent: "docs",
-  patterns: [
-    /\breadme\b/i,
-    /\bdocs?\b/,
-    /\bdocument(?:ation)?\b/,
-    /\busage guide\b/
-  ]
-};
-var RESEARCH_RULE = {
-  intent: "research",
-  patterns: [
-    /\bresearch\b/,
-    /\binvestigate\b/,
-    /\blook up\b/,
-    /\bcompare\b/,
-    /\bevaluate\b/,
-    /\bbest approach\b/
-  ]
-};
-var EXPLAIN_RULE = {
-  intent: "explain",
-  patterns: [
-    /^explain\b/,
-    /^how\b/,
-    /^why\b/,
-    /\bwalk me through\b/,
-    /\bhelp me understand\b/
-  ]
-};
-var IMPLEMENT_RULE = {
-  intent: "implement",
-  patterns: [
-    /\bimplement\b/,
-    /\bbuild\b/,
-    /\bcreate\b/,
-    /\badd\b/,
-    /\bintegrate\b/,
-    /\bwire up\b/,
-    /\bsupport\b/
-  ]
-};
-var STRONG_INTENT_RULES = [
-  REVIEW_RULE,
-  DEBUG_RULE,
-  REFACTOR_RULE,
-  TEST_FIX_RULE,
-  DOCS_RULE,
-  RESEARCH_RULE,
-  EXPLAIN_RULE,
-  IMPLEMENT_RULE
-];
-var EXECUTION_CONTRACT_INTENTS = new Set([
-  "implement",
-  "debug",
-  "refactor",
-  "review",
-  "research",
-  "docs",
-  "test-fix"
-]);
-var STANDARD_INTENTS = new Set([
-  "implement",
-  "debug",
-  "refactor",
-  "review",
-  "research",
-  "docs",
-  "test-fix"
-]);
-var DEEP_SIGNALS = [
-  /\bcareful\b/,
-  /\bdeep\b/,
-  /\bthorough\b/,
-  /\bhigh.?stakes?\b/,
-  /\bproduction\b/,
-  /\bcritical\b/,
-  /\barchitecture\b/,
-  /\bsecurity\b/
-];
-function detectTaskIntent(draft) {
-  const normalized = normalizeDraft(draft);
-  if (!normalized) {
-    return "general";
-  }
-  for (const rule of STRONG_INTENT_RULES) {
-    if (rule.patterns.some((pattern) => pattern.test(normalized))) {
-      return rule.intent;
-    }
-  }
-  return "general";
-}
-function resolveRewriteMode(configuredMode, intent) {
-  if (configuredMode === "plain" || configuredMode === "execution-contract") {
-    return configuredMode;
-  }
-  return EXECUTION_CONTRACT_INTENTS.has(intent) ? "execution-contract" : "plain";
-}
-function inferIntensity(draft, intent) {
-  const normalized = normalizeDraft(draft);
-  if (DEEP_SIGNALS.some((pattern) => pattern.test(normalized))) {
-    return "Deep";
-  }
-  return STANDARD_INTENTS.has(intent) ? "Standard" : "Light";
-}
-function buildPromptLeverageBlocks(draft, intent, intensity) {
-  return {
-    objective: buildObjective(draft),
-    context: buildContext(intent),
-    workStyle: buildWorkStyle(intent, intensity),
-    toolRules: buildToolRules(intent),
-    outputContract: buildOutputContract(intent),
-    verification: buildVerification(intent),
-    doneCriteria: buildDoneCriteria(intent)
-  };
-}
-function augmentPrompt(draft, options = {}) {
-  const normalized = collapseWhitespace(draft);
-  if (!normalized) {
-    throw new Error("Prompt is required.");
-  }
-  const intent = detectTaskIntent(normalized);
-  const mode = resolveRewriteMode(options.mode ?? "auto", intent);
-  const intensity = inferIntensity(normalized, intent);
-  const blocks = buildPromptLeverageBlocks(normalized, intent, intensity);
-  return {
-    original: normalized,
-    intent,
-    mode,
-    intensity,
-    blocks,
-    enhanced: mode === "execution-contract" ? formatExecutionContract(normalized, blocks) : formatPlainRewrite(normalized, intent, blocks.outputContract),
-    enhancementSource: "deterministic"
-  };
-}
-async function augmentPromptWithRefinement(draft, options = {}) {
-  const deterministic = augmentPrompt(draft, options);
-  if (!options.refine) {
-    return deterministic;
-  }
-  try {
-    const refined = await options.refine({
-      original: deterministic.original,
-      enhanced: deterministic.enhanced,
-      intent: deterministic.intent,
-      mode: deterministic.mode,
-      intensity: deterministic.intensity,
-      blocks: deterministic.blocks
-    });
-    const normalized = normalizeEnhancedPrompt(refined);
-    if (!normalized) {
-      return {
-        ...deterministic,
-        fallbackReason: "LLM refinement returned empty output."
-      };
-    }
-    return {
-      ...deterministic,
-      enhanced: normalized,
-      enhancementSource: "llm",
-      fallbackReason: undefined
-    };
-  } catch (error) {
-    return {
-      ...deterministic,
-      fallbackReason: error instanceof Error ? error.message : "LLM refinement failed."
-    };
-  }
-}
-function formatExecutionContract(draft, blocks) {
-  const task = stripObjectivePrefix(blocks.objective) || toSentence(draft);
-  return [
-    wrapTag("task", task),
-    wrapTag("context", bulletize(blocks.context)),
-    wrapTag("constraints", bulletize([blocks.workStyle, blocks.toolRules].filter(Boolean).join(`
-`))),
-    wrapTag("verification", bulletize(blocks.verification)),
-    wrapTag("deliverable", [blocks.outputContract, blocks.doneCriteria].filter(Boolean).join(`
-`))
-  ].join(`
-
-`);
-}
-function formatPlainRewrite(draft, intent, outputContract) {
-  const sentence = toSentence(draft);
-  if (intent === "explain") {
-    return [
-      sentence,
-      "Keep the explanation clear and well-structured without turning it into an execution plan."
-    ].join(" ");
-  }
-  if (intent === "general") {
-    return [
-      sentence,
-      "Return a clear, well-structured response matched to the task. Keep it concise unless extra detail is necessary."
-    ].join(" ");
-  }
-  return [sentence, outputContract].join(" ");
-}
-function buildObjective(draft) {
-  return `Complete this task: ${toSentence(draft)}`;
-}
-function buildContext(intent) {
-  switch (intent) {
-    case "implement":
-      return [
-        "Review the current code path and identify the narrowest safe integration point.",
-        "Preserve existing behavior outside the requested change."
-      ].join(`
-`);
-    case "debug":
-      return [
-        "Reproduce the issue first and confirm the failing path before editing.",
-        "Inspect the code and data flow around the suspected failure point."
-      ].join(`
-`);
-    case "refactor":
-      return [
-        "Map the current structure before extracting or consolidating logic.",
-        "Identify duplication and branching that can be simplified without changing behavior."
-      ].join(`
-`);
-    case "review":
-      return [
-        "Read enough surrounding context to understand intent before critiquing.",
-        "Focus on confirmed issues first, then call out plausible risks separately."
-      ].join(`
-`);
-    case "research":
-      return [
-        "Gather evidence from authoritative sources before concluding.",
-        "Preserve uncertainty explicitly when the evidence is incomplete or conflicting."
-      ].join(`
-`);
-    case "docs":
-      return [
-        "Read the current behavior and documentation surface before rewriting anything.",
-        "Keep commands, examples, and terminology aligned with the actual system."
-      ].join(`
-`);
-    case "test-fix":
-      return [
-        "Decide whether the test, the implementation, or both are wrong before changing anything.",
-        "Keep regression coverage close to the observed failure mode."
-      ].join(`
-`);
-    case "explain":
-      return [
-        "Preserve the original question and answer it directly.",
-        "Use structure only when it improves clarity."
-      ].join(`
-`);
-    case "general":
-    default:
-      return [
-        "Preserve the user\u2019s intent and constraints.",
-        "Add only enough structure to improve clarity and usefulness."
-      ].join(`
-`);
-  }
-}
-function buildWorkStyle(intent, intensity) {
-  const guidance = [];
-  switch (intent) {
-    case "implement":
-      guidance.push("Understand the problem broadly enough to avoid narrow mistakes, then go deep where the risk is highest.");
-      guidance.push("Use first-principles reasoning before proposing changes.");
-      break;
-    case "debug":
-      guidance.push("Inspect before editing and find the root cause, not just the symptom.");
-      break;
-    case "refactor":
-      guidance.push("Preserve behavior while reducing duplication, branching, or complexity.");
-      break;
-    case "review":
-      guidance.push("Distinguish confirmed issues from plausible risks and order them by impact.");
-      break;
-    case "research":
-      guidance.push("Synthesize evidence into a recommendation instead of a raw note dump.");
-      break;
-    case "docs":
-      guidance.push("Optimize for accuracy, clarity, and examples that match real behavior.");
-      break;
-    case "test-fix":
-      guidance.push("Keep changes focused on the failing behavior and preserve useful coverage.");
-      break;
-    case "explain":
-      guidance.push("Stay explanatory and avoid turning the answer into an execution plan.");
-      break;
-    case "general":
-      guidance.push("Be specific, structured, and proportionate to the request.");
-      break;
-  }
-  if (intensity === "Deep") {
-    guidance.push("Review the result once with fresh eyes before finalizing.");
-  }
-  if (intensity === "Standard") {
-    guidance.push("Cover the main edge cases before finalizing.");
-  }
-  return guidance.join(`
-`);
-}
-function buildToolRules(intent) {
-  switch (intent) {
-    case "implement":
-    case "refactor":
-    case "debug":
-    case "test-fix":
-      return "Inspect the relevant files and dependencies first. Validate the final change with the narrowest useful checks before broadening scope.";
-    case "research":
-      return "Retrieve evidence from reliable sources before concluding. Do not guess facts that can be checked.";
-    case "review":
-      return "Read enough surrounding context to understand intent before critiquing. Distinguish confirmed issues from plausible risks.";
-    case "docs":
-      return "Read the current documentation and runtime behavior before rewriting. Keep examples and commands accurate.";
-    case "explain":
-    case "general":
-    default:
-      return "Use extra tools or context only when they materially improve correctness or completeness.";
-  }
-}
-function buildOutputContract(intent) {
-  switch (intent) {
-    case "implement":
-    case "refactor":
-    case "test-fix":
-      return "Return a practical execution result: concise summary, concrete changes, validation notes, and any remaining risks.";
-    case "debug":
-      return "Return a diagnosis with root cause, the fix, validation steps, and regression notes.";
-    case "research":
-      return "Return a structured synthesis with key findings, supporting evidence, and a concise recommendation.";
-    case "docs":
-      return "Return polished documentation aligned with current runtime behavior and verified examples.";
-    case "review":
-      return "Return findings grouped by severity or importance, explain why each matters, and suggest the smallest credible next step.";
-    case "explain":
-      return "Return a clear, well-structured explanation matched to the question.";
-    case "general":
-    default:
-      return "Return a clear, well-structured response matched to the task.";
-  }
-}
-function buildVerification(intent) {
-  switch (intent) {
-    case "implement":
-    case "refactor":
-    case "test-fix":
-      return [
-        "Check correctness, completeness, and edge cases.",
-        "Run relevant checks such as tests, lint, or typecheck when appropriate."
-      ].join(`
-`);
-    case "debug":
-      return [
-        "Check correctness, completeness, and edge cases.",
-        "Confirm the root cause is addressed and add regression coverage when appropriate."
-      ].join(`
-`);
-    case "review":
-      return [
-        "Check correctness and completeness.",
-        "Avoid speculative redesign unless it is necessary to explain a risk."
-      ].join(`
-`);
-    case "docs":
-      return [
-        "Check correctness and completeness.",
-        "Verify commands, examples, and terminology against the current behavior."
-      ].join(`
-`);
-    case "research":
-      return [
-        "Check correctness, completeness, and edge cases.",
-        "Call out uncertainty explicitly when evidence is incomplete or conflicting."
-      ].join(`
-`);
-    case "explain":
-    case "general":
-    default:
-      return [
-        "Check correctness, completeness, and edge cases.",
-        "Improve obvious weaknesses if a better phrasing is available within scope."
-      ].join(`
-`);
-  }
-}
-function buildDoneCriteria(intent) {
-  switch (intent) {
-    case "implement":
-    case "refactor":
-    case "test-fix":
-      return "Stop only when the change is complete, the important checks pass, and there are no known regressions.";
-    case "debug":
-      return "Stop only when the root cause is confirmed fixed and regression coverage is in place when appropriate.";
-    case "review":
-      return "Stop only when the findings are clear, prioritized, and actionable.";
-    case "research":
-      return "Stop only when the synthesis is grounded in evidence and ends with a recommended path.";
-    case "docs":
-      return "Stop only when the documentation matches the current behavior and examples are accurate.";
-    case "explain":
-      return "Stop only when the explanation clearly answers the question.";
-    case "general":
-    default:
-      return "Stop only when the response satisfies the task and matches the requested format.";
-  }
-}
-function bulletize(text) {
-  return text.split(`
-`).map((line) => collapseWhitespace(line)).filter(Boolean).map((line) => `- ${line}`).join(`
-`);
-}
-function wrapTag(tagName, content) {
-  return `<${tagName}>
-${content}
-</${tagName}>`;
-}
-function stripObjectivePrefix(objective) {
-  return objective.replace(/^Complete this task:\s*/i, "").trim();
-}
-function normalizeDraft(draft) {
-  return collapseWhitespace(draft).toLowerCase();
-}
-function normalizeEnhancedPrompt(value) {
-  return (value ?? "").replace(/\r\n/g, `
-`).trim();
-}
-function collapseWhitespace(value) {
-  return value.replace(/\r\n/g, `
-`).replace(/\s+/g, " ").trim();
-}
-function toSentence(value) {
-  const normalized = collapseWhitespace(value);
-  if (!normalized) {
-    return "";
-  }
-  const capitalized = normalized.charAt(0).toUpperCase() + normalized.slice(1);
-  if (/[.!?]$/.test(capitalized)) {
-    return capitalized;
-  }
-  return `${capitalized}.`;
-}
-
-// src/tui.ts
-var PROMPT_LOADING_TEXT = "\u23F3 Enhancing prompt\u2026";
-function buildRefinementPrompt(input) {
-  return [
-    "You are refining an already-structured prompt for OpenCode.",
-    `Intent: ${input.intent}`,
-    `Rewrite mode: ${input.mode}`,
-    `Effort: ${input.intensity}`,
-    "Preserve the original user request exactly.",
-    "Keep the output as a single prompt only.",
-    "Do not add commentary, preambles, markdown fences, or explanations.",
-    "If the prompt is already strong, return a minimally polished version.",
-    "Return only the final rewritten prompt.",
-    "",
-    input.enhanced
-  ].join(`
-`);
-}
-function clonePromptInfo(prompt) {
-  return {
-    input: prompt.input,
-    mode: prompt.mode,
-    parts: [...prompt.parts]
-  };
-}
-function updatePromptRef(promptRef, prompt) {
-  promptRef.set(clonePromptInfo(prompt));
-}
-function getActivePromptRef(api, promptRefs) {
-  const currentRoute = api.route.current;
-  if (currentRoute.name === "session") {
-    const sessionID = currentRoute.params?.sessionID;
-    return typeof sessionID === "string" ? promptRefs.sessions.get(sessionID) : undefined;
-  }
-  return promptRefs.home;
-}
-function registerPromptSlots(api, promptRefs) {
-  const registerSlots = api.slots?.register;
-  if (typeof registerSlots !== "function") {
-    return;
-  }
-  registerSlots({
-    slots: {
-      home_prompt: (_ctx, props) => api.ui.Prompt({
-        workspaceID: props.workspace_id,
-        ref: (ref) => {
-          promptRefs.home = ref;
-          props.ref?.(ref);
-        }
-      }),
-      session_prompt: (_ctx, props) => api.ui.Prompt({
-        sessionID: props.session_id,
-        visible: props.visible,
-        disabled: props.disabled,
-        onSubmit: props.on_submit,
-        ref: (ref) => {
-          if (ref) {
-            promptRefs.sessions.set(props.session_id, ref);
-          } else {
-            promptRefs.sessions.delete(props.session_id);
-          }
-          props.ref?.(ref);
-        }
-      })
-    }
-  });
-}
-function showAugmentResultToast(api, deliveryMode, result) {
-  const source = result.enhancementSource ?? "deterministic";
-  const successPrefix = deliveryMode === "replaced" ? "Replaced" : deliveryMode === "injected" ? "Injected" : "Prepared";
-  if (result.fallbackReason) {
-    api.ui.toast({
-      variant: "warning",
-      title: "CliKit Augment",
-      message: `${successPrefix} deterministic fallback. ${result.fallbackReason}`,
-      duration: 3500
-    });
-    return;
-  }
-  api.ui.toast({
-    variant: "success",
-    title: "CliKit Augment",
-    message: deliveryMode === "replaced" ? `Enhanced prompt replaced in composer (${source}).` : deliveryMode === "injected" ? `Enhanced prompt inserted (${source}).` : `Enhanced prompt ready (${source}).`,
-    duration: 3500
-  });
-}
-function showAugmentErrorToast(api, error) {
-  const message = error instanceof Error ? error.message : "Prompt enhancement failed.";
-  api.ui.toast({
-    variant: "error",
-    title: "CliKit Augment",
-    message,
-    duration: 3500
-  });
-}
-async function enhancePromptDraft(api, draft) {
-  const directory = api.state.path.directory;
-  const workspace = api.workspace.current();
-  const client = api.scopedClient(workspace);
-  return augmentPromptWithRefinement(draft, {
-    mode: "auto",
-    refine: async ({ enhanced, mode, intent, intensity }) => {
-      const createResult = await client.session.create({
-        directory,
-        workspace,
-        title: `augment:${intent}`
-      });
-      if (createResult.error || !createResult.data?.id) {
-        throw new Error("Unable to create OpenCode session for prompt enhancement.");
-      }
-      const sessionID = createResult.data.id;
-      try {
-        const promptResult = await client.session.prompt({
-          sessionID,
-          directory,
-          workspace,
-          parts: [
-            {
-              type: "text",
-              text: buildRefinementPrompt({
-                enhanced,
-                intent,
-                mode,
-                intensity
-              })
-            }
-          ]
-        });
-        if (promptResult.error) {
-          throw new Error("OpenCode prompt enhancement request failed.");
-        }
-        const textPart = promptResult.data?.parts?.find((part) => part.type === "text");
-        if (!textPart || !("text" in textPart) || typeof textPart.text !== "string") {
-          throw new Error("OpenCode prompt enhancement returned no text output.");
-        }
-        return textPart.text;
-      } finally {
-        client.session.delete({
-          sessionID,
-          directory,
-          workspace
-        }).catch(() => {
-          return;
-        });
-      }
-    }
-  });
-}
-async function injectPrompt(api, prompt) {
-  const directory = api.state.path.directory;
-  const workspace = api.workspace.current();
-  const client = api.scopedClient(workspace);
-  try {
-    await client.tui.clearPrompt?.({ directory, workspace });
-    await client.tui.appendPrompt({ directory, workspace, text: prompt });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function deliverPrompt(api, prompt) {
-  if (await injectPrompt(api, prompt)) {
-    return "injected";
-  }
-  return "ready";
-}
-function openAugmentDialog(api, initialValue) {
-  api.ui.dialog.replace(() => api.ui.DialogPrompt({
-    title: "CliKit Augment",
-    placeholder: "Paste or type the prompt draft to enhance",
-    value: initialValue,
-    onConfirm: async (value) => {
-      await runDialogAugment(api, value);
-    },
-    onCancel: () => {
-      api.ui.dialog.clear();
-    }
-  }));
-}
-async function runDialogAugment(api, draft) {
-  const normalized = draft.trim();
-  if (!normalized) {
-    api.ui.toast({
-      variant: "error",
-      title: "CliKit Augment",
-      message: "Prompt is required.",
-      duration: 2500
-    });
-    return;
-  }
-  api.ui.toast({
-    variant: "info",
-    title: "CliKit Augment",
-    message: "Enhancing prompt.",
-    duration: 2000
-  });
-  const directory = api.state.path.directory;
-  const workspace = api.workspace.current();
-  const client = api.scopedClient(workspace);
-  try {
-    const result = await enhancePromptDraft(api, normalized);
-    const deliveryMode = await deliverPrompt(api, result.enhanced);
-    api.ui.dialog.clear();
-    showAugmentResultToast(api, deliveryMode, result);
-  } catch (error) {
-    showAugmentErrorToast(api, error);
-  }
-}
-async function runComposerAugment(api, promptRef) {
-  const originalPrompt = clonePromptInfo(promptRef.current);
-  const normalized = originalPrompt.input.trim();
-  if (!normalized) {
-    api.ui.toast({
-      variant: "error",
-      title: "CliKit Augment",
-      message: "Prompt is required.",
-      duration: 2500
-    });
-    return;
-  }
-  try {
-    promptRef.blur();
-    updatePromptRef(promptRef, {
-      ...originalPrompt,
-      input: PROMPT_LOADING_TEXT
-    });
-  } catch {
-    openAugmentDialog(api, originalPrompt.input);
-    return;
-  }
-  try {
-    const result = await enhancePromptDraft(api, normalized);
-    updatePromptRef(promptRef, {
-      ...originalPrompt,
-      input: result.enhanced
-    });
-    promptRef.focus();
-    showAugmentResultToast(api, "replaced", result);
-  } catch (error) {
-    try {
-      updatePromptRef(promptRef, originalPrompt);
-      promptRef.focus();
-    } catch {}
-    showAugmentErrorToast(api, error);
-  }
-}
-var CliKitTuiPlugin = {
-  id: "clikit-tui",
-  async tui(api) {
-    const promptRefs = {
-      sessions: new Map
-    };
-    registerPromptSlots(api, promptRefs);
-    const unregister = api.command.register(() => [
-      {
-        title: "CliKit Augment",
-        value: "clikit.augment",
-        description: "Rewrite the current composer prompt when available, with dialog fallback on unsupported runtimes.",
-        category: "CliKit",
-        slash: {
-          name: "augment"
-        },
-        onSelect: () => {
-          const promptRef = getActivePromptRef(api, promptRefs);
-          if (promptRef) {
-            runComposerAugment(api, promptRef);
-            return;
-          }
-          openAugmentDialog(api);
-        }
-      }
-    ]);
-    api.lifecycle.onDispose(() => {
-      promptRefs.home = undefined;
-      promptRefs.sessions.clear();
-    });
-    api.lifecycle.onDispose(unregister);
-  }
-};
-var tui_default = CliKitTuiPlugin;
-export {
-  tui_default as default
-};