opencode-snippets 2.2.4 → 3.0.0

package/dist/tui.js

@@ -0,0 +1,1639 @@
+// tui.tsx
+import { memo as _$memo } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { use as _$use } from "@opentui/solid";
+import { spread as _$spread } from "@opentui/solid";
+import { mergeProps as _$mergeProps } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { spawn } from "node:child_process";
+import { access as access2, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { RGBA } from "@opentui/core";
+import { useKeyboard } from "@opentui/solid";
+import { createEffect, createMemo, createResource, createSignal, Index, onCleanup, onMount, Show } from "solid-js";
+
+// src/constants.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var PATHS = {
+  CONFIG_DIR: join(homedir(), ".config", "opencode"),
+  SNIPPETS_DIR: join(homedir(), ".config", "opencode", "snippet"),
+  SNIPPETS_DIR_ALT: join(homedir(), ".config", "opencode", "snippets"),
+  CONFIG_FILE_GLOBAL: join(homedir(), ".config", "opencode", "snippet", "config.jsonc")
+};
+function getProjectPaths(projectDir) {
+  const snippetDir = join(projectDir, ".opencode", "snippet");
+  return {
+    SNIPPETS_DIR: snippetDir,
+    SNIPPETS_DIR_ALT: join(projectDir, ".opencode", "snippets"),
+    CONFIG_FILE: join(snippetDir, "config.jsonc")
+  };
+}
+var CONFIG = {
+  SNIPPET_EXTENSION: ".md"
+};
+
+// src/loader.ts
+import { access, mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { basename, join as join3 } from "node:path";
+
+// src/cjs-interop.ts
+async function importCjs(pkg) {
+  let val = await import(pkg);
+  for (let i = 0;i < 4; i++) {
+    if (val == null || typeof val === "function")
+      break;
+    if (!("default" in val) || val.default === undefined)
+      break;
+    val = val.default;
+  }
+  return val;
+}
+
+// src/logger.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+class Logger {
+  logDir;
+  debugEnabled;
+  silent;
+  constructor(logDirOverride, debugEnabled = false, silent = false) {
+    this.logDir = logDirOverride ?? join2(PATHS.CONFIG_DIR, "logs", "snippets");
+    this.debugEnabled = debugEnabled;
+    this.silent = silent;
+  }
+  ensureLogDir() {
+    if (!existsSync(this.logDir)) {
+      mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+  formatData(data) {
+    if (!data)
+      return "";
+    const parts = [];
+    for (const [key, value] of Object.entries(data)) {
+      if (value === undefined || value === null)
+        continue;
+      if (Array.isArray(value)) {
+        if (value.length === 0)
+          continue;
+        parts.push(`${key}=[${value.slice(0, 3).join(",")}${value.length > 3 ? `...+${value.length - 3}` : ""}]`);
+      } else if (typeof value === "object") {
+        const str = JSON.stringify(value);
+        if (str.length < 50) {
+          parts.push(`${key}=${str}`);
+        }
+      } else {
+        parts.push(`${key}=${value}`);
+      }
+    }
+    return parts.join(" ");
+  }
+  getCallerFile() {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+      const err = new Error;
+      Error.prepareStackTrace = (_, stack2) => stack2;
+      const stack = err.stack;
+      Error.prepareStackTrace = originalPrepareStackTrace;
+      for (let i = 3;i < stack.length; i++) {
+        const filename = stack[i]?.getFileName();
+        if (filename && !filename.includes("logger.")) {
+          const match = filename.match(/([^/\\]+)\.[tj]s$/);
+          return match ? match[1] : "unknown";
+        }
+      }
+      return "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  write(level, component, message, data) {
+    if (this.silent)
+      return;
+    if (level === "DEBUG" && !this.debugEnabled)
+      return;
+    try {
+      this.ensureLogDir();
+      const timestamp = new Date().toISOString();
+      const dataStr = this.formatData(data);
+      const dailyLogDir = join2(this.logDir, "daily");
+      if (!existsSync(dailyLogDir)) {
+        mkdirSync(dailyLogDir, { recursive: true });
+      }
+      const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? ` | ${dataStr}` : ""}
+`;
+      const logFile = join2(dailyLogDir, `${new Date().toISOString().split("T")[0]}.log`);
+      writeFileSync(logFile, logLine, { flag: "a" });
+    } catch {}
+  }
+  info(message, data) {
+    const component = this.getCallerFile();
+    this.write("INFO", component, message, data);
+  }
+  debug(message, data) {
+    const component = this.getCallerFile();
+    this.write("DEBUG", component, message, data);
+  }
+  warn(message, data) {
+    const component = this.getCallerFile();
+    this.write("WARN", component, message, data);
+  }
+  error(message, data) {
+    const component = this.getCallerFile();
+    this.write("ERROR", component, message, data);
+  }
+}
+var logger = new Logger(undefined, false, false);
+
+// src/loader.ts
+var matter = await importCjs("gray-matter");
+function getGlobalSnippetDirs(globalDir) {
+  if (globalDir)
+    return [globalDir];
+  return [PATHS.SNIPPETS_DIR_ALT, PATHS.SNIPPETS_DIR];
+}
+function getProjectSnippetDirs(projectDir) {
+  const paths = getProjectPaths(projectDir);
+  return [paths.SNIPPETS_DIR_ALT, paths.SNIPPETS_DIR];
+}
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveWritableSnippetDir(projectDir) {
+  const paths = projectDir ? getProjectPaths(projectDir) : { SNIPPETS_DIR: PATHS.SNIPPETS_DIR, SNIPPETS_DIR_ALT: PATHS.SNIPPETS_DIR_ALT };
+  for (const dir of [paths.SNIPPETS_DIR, paths.SNIPPETS_DIR_ALT]) {
+    if (await pathExists(dir))
+      return dir;
+  }
+  return paths.SNIPPETS_DIR;
+}
+async function loadSnippets(projectDir, globalDir) {
+  const snippets = new Map;
+  for (const dir of getGlobalSnippetDirs(globalDir)) {
+    await loadFromDirectory(dir, snippets, "global");
+  }
+  if (projectDir) {
+    for (const dir of getProjectSnippetDirs(projectDir)) {
+      await loadFromDirectory(dir, snippets, "project");
+    }
+  }
+  return snippets;
+}
+async function loadFromDirectory(dir, registry, source) {
+  try {
+    const files = await readdir(dir);
+    for (const file of files) {
+      if (!file.endsWith(CONFIG.SNIPPET_EXTENSION))
+        continue;
+      const snippet = await loadSnippetFile(dir, file, source);
+      if (snippet) {
+        registerSnippet(registry, snippet);
+      }
+    }
+    logger.debug(`Loaded snippets from ${source} directory`, {
+      path: dir,
+      fileCount: files.length
+    });
+  } catch (error) {
+    logger.debug(`${source} snippets directory not found or unreadable`, {
+      path: dir,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function loadSnippetFile(dir, filename, source) {
+  try {
+    const name = basename(filename, CONFIG.SNIPPET_EXTENSION);
+    const filePath = join3(dir, filename);
+    const fileContent = await readFile(filePath, "utf8");
+    const parsed = matter(fileContent);
+    const content = parsed.content.trim();
+    const frontmatter = parsed.data;
+    let aliases = [];
+    const aliasSource = frontmatter.aliases ?? frontmatter.alias;
+    if (aliasSource) {
+      if (Array.isArray(aliasSource)) {
+        aliases = aliasSource;
+      } else {
+        aliases = [aliasSource];
+      }
+    }
+    return {
+      name,
+      content,
+      aliases,
+      description: frontmatter.description,
+      filePath,
+      source
+    };
+  } catch (error) {
+    logger.warn("Failed to load snippet file", {
+      filename,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function registerSnippet(registry, snippet) {
+  const key = snippet.name.toLowerCase();
+  const existing = registry.get(key);
+  if (existing) {
+    for (const alias of existing.aliases) {
+      registry.delete(alias.toLowerCase());
+    }
+  }
+  registry.set(key, snippet);
+  for (const alias of snippet.aliases) {
+    registry.set(alias.toLowerCase(), snippet);
+  }
+}
+function listSnippets(registry) {
+  const seen = new Set;
+  const snippets = [];
+  for (const snippet of registry.values()) {
+    if (!seen.has(snippet.name)) {
+      seen.add(snippet.name);
+      snippets.push(snippet);
+    }
+  }
+  return snippets;
+}
+async function ensureSnippetsDir(projectDir) {
+  const dir = await resolveWritableSnippetDir(projectDir);
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+
+// src/pending-drafts.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function statePath() {
+  return join4(PATHS.CONFIG_DIR, "state", "pending-drafts.json");
+}
+function scopeKey(workspaceDir) {
+  return workspaceDir || "__global__";
+}
+function normalizeNames(names) {
+  return [...new Set(names.map((name) => name.trim().toLowerCase()).filter(Boolean))];
+}
+function normalizeState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return {};
+  return Object.fromEntries(Object.entries(value).filter(([, names]) => Array.isArray(names)).map(([key, names]) => [
+    key,
+    normalizeNames(names.filter((name) => typeof name === "string"))
+  ]).filter(([, names]) => names.length > 0));
+}
+async function readState() {
+  try {
+    return normalizeState(JSON.parse(await readFile2(statePath(), "utf8")));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return {};
+    logger.warn("Failed to read pending draft state", {
+      error: error instanceof Error ? error.message : String(error),
+      path: statePath()
+    });
+    return {};
+  }
+}
+async function writeState(state) {
+  await mkdir2(join4(PATHS.CONFIG_DIR, "state"), { recursive: true });
+  await writeFile2(statePath(), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+async function addPendingDraft(workspaceDir, name) {
+  const key = scopeKey(workspaceDir);
+  const state = await readState();
+  const next = normalizeNames([...state[key] || [], name]);
+  if (next.length === 0)
+    return;
+  state[key] = next;
+  await writeState(state);
+}
+
+// src/reload-signal.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+function statePath2() {
+  return join5(PATHS.CONFIG_DIR, "state", "snippet-reload.json");
+}
+function scopeKey2(workspaceDir) {
+  return workspaceDir || "__global__";
+}
+function normalizeState2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return {};
+  return Object.fromEntries(Object.entries(value).filter(([, stamp]) => typeof stamp === "number" && Number.isFinite(stamp)).map(([key, stamp]) => [key, stamp]));
+}
+async function readState2() {
+  try {
+    return normalizeState2(JSON.parse(await readFile3(statePath2(), "utf8")));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return {};
+    logger.warn("Failed to read snippet reload signal", {
+      error: error instanceof Error ? error.message : String(error),
+      path: statePath2()
+    });
+    return {};
+  }
+}
+async function writeState2(state) {
+  await mkdir3(join5(PATHS.CONFIG_DIR, "state"), { recursive: true });
+  await writeFile3(statePath2(), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+async function markSnippetReloadRequested(workspaceDir) {
+  const key = scopeKey2(workspaceDir);
+  const state = await readState2();
+  state[key] = Date.now();
+  await writeState2(state);
+}
+
+// src/skill-loader.ts
+import { readdir as readdir2, readFile as readFile4, stat } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join6, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var matter2 = await importCjs("gray-matter");
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function getGlobalSkillDirs(homeDir = homedir2()) {
+  return [
+    join6(homeDir, ".config", "opencode", "skill"),
+    join6(homeDir, ".config", "opencode", "skills"),
+    join6(homeDir, ".claude", "skills"),
+    join6(homeDir, ".agents", "skills")
+  ];
+}
+function getProjectSkillDirs(projectDir) {
+  return [
+    join6(projectDir, ".opencode", "skill"),
+    join6(projectDir, ".opencode", "skills"),
+    join6(projectDir, ".claude", "skills"),
+    join6(projectDir, ".agents", "skills")
+  ];
+}
+function getBundledSkillDirs() {
+  return [join6(__dirname2, "..", "..", "skill")];
+}
+function uniqueDirs(dirs) {
+  const seen = new Set;
+  const result = [];
+  for (const dir of dirs) {
+    const key = resolve(dir);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    result.push(dir);
+  }
+  return result;
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getProjectSearchRoots(projectDir) {
+  const roots = [];
+  let dir = resolve(projectDir);
+  while (true) {
+    roots.push(dir);
+    if (await exists(join6(dir, ".git"))) {
+      break;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return roots.reverse();
+}
+async function loadSkills(projectDir, options = {}) {
+  const skills = new Map;
+  const bundledDirs = options.bundledSkillDirs || getBundledSkillDirs();
+  for (const dir of uniqueDirs([...bundledDirs, ...options.opencodeSkillDirs || []])) {
+    await loadFromDirectory2(dir, skills, "global");
+  }
+  if (options.opencodeSkillDirs && options.opencodeSkillDirs.length > 0) {
+    logger.debug("Loaded OpenCode-exposed skill directories", { paths: options.opencodeSkillDirs });
+  }
+  for (const dir of getGlobalSkillDirs(options.homeDir)) {
+    await loadFromDirectory2(dir, skills, "global");
+  }
+  if (projectDir) {
+    for (const root of await getProjectSearchRoots(projectDir)) {
+      for (const dir of getProjectSkillDirs(root)) {
+        await loadFromDirectory2(dir, skills, "project");
+      }
+    }
+  }
+  logger.debug("Skills loaded", { count: skills.size });
+  return skills;
+}
+async function loadFromDirectory2(dir, registry, source) {
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const skill = await loadSkill(dir, entry.name, source);
+      if (skill) {
+        registry.set(skill.name.toLowerCase(), skill);
+      }
+    }
+    logger.debug(`Loaded skills from ${source} directory`, { path: dir });
+  } catch {
+    logger.debug(`${source} skill directory not found`, { path: dir });
+  }
+}
+async function loadSkill(baseDir, skillName, source) {
+  const filePath = join6(baseDir, skillName, "SKILL.md");
+  try {
+    const fileContent = await readFile4(filePath, "utf8");
+    const parsed = matter2(fileContent);
+    const content = parsed.content.trim();
+    const frontmatter = parsed.data;
+    const name = frontmatter.name || skillName;
+    return {
+      name,
+      content,
+      description: frontmatter.description,
+      source,
+      filePath
+    };
+  } catch (error) {
+    logger.warn("Failed to load skill", {
+      skillName,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+
+// src/tui-search.ts
+function normalizeSearchText(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isSubsequence(input, query) {
+  if (!query)
+    return true;
+  let i = 0;
+  for (const c of input) {
+    if (c !== query[i])
+      continue;
+    i += 1;
+    if (i === query.length)
+      return true;
+  }
+  return false;
+}
+function scoreText(input, query) {
+  const raw = input.toLowerCase();
+  const needle = query.toLowerCase();
+  const compact = normalizeSearchText(input);
+  const compactNeedle = normalizeSearchText(query);
+  if (raw === needle)
+    return 0;
+  if (compactNeedle && compact === compactNeedle)
+    return 1;
+  if (raw.startsWith(needle))
+    return 2;
+  if (compactNeedle && compact.startsWith(compactNeedle))
+    return 3;
+  if (raw.includes(needle))
+    return 4;
+  if (compactNeedle && compact.includes(compactNeedle))
+    return 5;
+  if (compactNeedle && isSubsequence(compact, compactNeedle))
+    return 6;
+  return Number.POSITIVE_INFINITY;
+}
+function scoreSnippet(snippet, query) {
+  if (!query)
+    return 0;
+  const description = (snippet.description || "").toLowerCase();
+  const score = Math.min(scoreText(snippet.name, query), ...snippet.aliases.map((alias) => scoreText(alias, query)));
+  if (Number.isFinite(score))
+    return score;
+  const needle = query.toLowerCase();
+  if (description.startsWith(needle))
+    return 7;
+  if (description.includes(needle))
+    return 8;
+  return Number.POSITIVE_INFINITY;
+}
+function sourceRank(item) {
+  return item.source === "project" ? 0 : 1;
+}
+function skillTag(skill) {
+  return `skill(${skill.name})`;
+}
+function scoreSkill(skill, query) {
+  if (!query)
+    return 0;
+  const description = (skill.description || "").toLowerCase();
+  const score = Math.min(scoreText(skill.name, query), scoreText(skillTag(skill), query));
+  if (Number.isFinite(score))
+    return score;
+  const needle = query.toLowerCase();
+  if (description.startsWith(needle))
+    return 7;
+  if (description.includes(needle))
+    return 8;
+  return Number.POSITIVE_INFINITY;
+}
+function filterSnippets(snippets, query) {
+  return [...snippets].map((snippet) => ({
+    snippet,
+    score: scoreSnippet(snippet, query.trim())
+  })).filter((item) => Number.isFinite(item.score)).sort((a, b) => {
+    if (a.score !== b.score)
+      return a.score - b.score;
+    const sourceDiff = sourceRank(a.snippet) - sourceRank(b.snippet);
+    if (sourceDiff !== 0)
+      return sourceDiff;
+    return a.snippet.name.localeCompare(b.snippet.name);
+  }).map((item) => item.snippet);
+}
+function filterSkills(skills, query) {
+  return [...skills].map((skill) => ({
+    skill,
+    score: scoreSkill(skill, query.trim())
+  })).filter((item) => Number.isFinite(item.score)).sort((a, b) => {
+    if (a.score !== b.score)
+      return a.score - b.score;
+    const sourceDiff = sourceRank(a.skill) - sourceRank(b.skill);
+    if (sourceDiff !== 0)
+      return sourceDiff;
+    return a.skill.name.localeCompare(b.skill.name);
+  }).map((item) => item.skill);
+}
+function matchedAliases(snippet, query) {
+  const needle = query.trim();
+  if (!needle)
+    return [];
+  const exact = snippet.aliases.filter((alias) => alias === needle);
+  if (exact.length > 0)
+    return exact;
+  return snippet.aliases.filter((alias) => Number.isFinite(scoreText(alias, needle)));
+}
+function snippetDescription(snippet) {
+  return (snippet.description || snippet.content).replace(/\s+/g, " ").trim();
+}
+function highlightMatches(input, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle)
+    return [{ text: input, match: false }];
+  const haystack = input.toLowerCase();
+  const parts = [];
+  let start = 0;
+  while (start < input.length) {
+    const index = haystack.indexOf(needle, start);
+    if (index === -1) {
+      parts.push({ text: input.slice(start), match: false });
+      break;
+    }
+    if (index > start) {
+      parts.push({ text: input.slice(start, index), match: false });
+    }
+    const end = index + needle.length;
+    parts.push({ text: input.slice(index, end), match: true });
+    start = end;
+  }
+  if (parts.length === 0)
+    return [{ text: input, match: false }];
+  return parts;
+}
+
+// src/tui-trigger.ts
+var HASHTAG_TRIGGER = /(^|\s)#([^\s#]*)$/;
+function compactTagText(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function findTrailingHashtagTrigger(input) {
+  const hit = input.match(HASHTAG_TRIGGER);
+  if (!hit)
+    return;
+  const query = hit[2] || "";
+  const token = `#${query}`;
+  return {
+    start: input.length - token.length,
+    end: input.length,
+    query,
+    token
+  };
+}
+function replaceTrailingHashtag(input, name) {
+  const match = findTrailingHashtagTrigger(input);
+  if (!match)
+    return;
+  return `${input.slice(0, match.start)}#${name} `;
+}
+function insertSnippetTag(input, name) {
+  const replaced = replaceTrailingHashtag(input, name);
+  if (replaced)
+    return replaced;
+  if (!input)
+    return `#${name} `;
+  if (/\s$/.test(input))
+    return `${input}#${name} `;
+  return `${input} #${name} `;
+}
+function insertSkillLoad(input, name) {
+  const match = findTrailingHashtagTrigger(input);
+  const load = `#skill(${name}) `;
+  if (match) {
+    return `${input.slice(0, match.start)}${load}`;
+  }
+  if (!input)
+    return load;
+  if (/\s$/.test(input))
+    return `${input}${load}`;
+  return `${input} ${load}`;
+}
+function preferredSnippetTag(input, item) {
+  const query = findTrailingHashtagTrigger(input)?.query.trim();
+  if (!query)
+    return item.name;
+  const exact = item.aliases.find((alias) => alias === query);
+  if (exact)
+    return exact;
+  const compact = compactTagText(query);
+  if (!compact)
+    return item.name;
+  return item.aliases.find((alias) => compactTagText(alias) === compact) ?? item.name;
+}
+function insertSnippetTrigger(input) {
+  if (findTrailingHashtagTrigger(input))
+    return input;
+  if (!input)
+    return "#";
+  if (/\s$/.test(input))
+    return `${input}#`;
+  return `${input} #`;
+}
+function isReloadCommand(input) {
+  return input.trim() === "/snippets:reload";
+}
+function isDialogInputBlocked(dialogOpen, dialogHandoffUntil, now = Date.now()) {
+  return dialogOpen || dialogHandoffUntil > now;
+}
+function isAutocompleteNavUpKey(evt) {
+  const name = evt.name?.toLowerCase();
+  return name === "up" || name === "arrowup" || evt.raw === "\x1B[A" || evt.sequence === "\x1B[A";
+}
+function isAutocompleteNavDownKey(evt) {
+  const name = evt.name?.toLowerCase();
+  return name === "down" || name === "arrowdown" || evt.raw === "\x1B[B" || evt.sequence === "\x1B[B";
+}
+function stepSelection(current, total, delta) {
+  if (total <= 0)
+    return 0;
+  const next = current + delta;
+  if (next < 0)
+    return 0;
+  if (next >= total)
+    return total - 1;
+  return next;
+}
+
+// tui.tsx
+var id = "opencode-snippets:autocomplete";
+var PROMPT_SYNC_MS = 50;
+var MENU_MAX_HEIGHT = 10;
+var MOUSE_HOVER_SUPPRESS_MS = 150;
+var HOME_PLACEHOLDERS = {
+  normal: ["Fix a TODO in the codebase", "What is the tech stack of this project?", "Fix broken tests"],
+  shell: ["ls -la", "git status", "pwd"]
+};
+var EMPTY_SNIPPET = `---
+description: ""
+---
+
+`;
+var INLINE_BORDER = {
+  border: ["left", "right"],
+  customBorderChars: {
+    topLeft: "",
+    bottomLeft: "",
+    vertical: "┃",
+    topRight: "",
+    bottomRight: "",
+    horizontal: " ",
+    bottomT: "",
+    topT: "",
+    cross: "",
+    leftT: "",
+    rightT: ""
+  }
+};
+function sortSnippets(snippets) {
+  return [...snippets].sort((a, b) => {
+    if (a.source !== b.source) {
+      if (a.source === "project")
+        return -1;
+      return 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+}
+function sortSkills(skills) {
+  return [...skills].sort((a, b) => {
+    if (a.source !== b.source) {
+      if (a.source === "project")
+        return -1;
+      return 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+}
+function selectedText(theme) {
+  if (theme.background.a !== 0)
+    return theme.background;
+  const {
+    r,
+    g,
+    b
+  } = theme.primary;
+  const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+  return luminance > 0.5 ? RGBA.fromInts(0, 0, 0) : RGBA.fromInts(255, 255, 255);
+}
+function renderHighlighted(text, query, fg) {
+  return highlightMatches(text, query).map((part) => {
+    if (!part.match)
+      return part.text;
+    return (() => {
+      var _el$ = _$createElement("span");
+      _$setProp(_el$, "style", {
+        fg,
+        underline: true
+      });
+      _$insert(_el$, () => part.text);
+      return _el$;
+    })();
+  });
+}
+function normalizeSnippetName(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolveExternalEditor() {
+  const visual = process.env.VISUAL?.trim();
+  if (visual) {
+    return {
+      command: visual,
+      env: "VISUAL"
+    };
+  }
+  const editor = process.env.EDITOR?.trim();
+  if (editor) {
+    return {
+      command: editor,
+      env: "EDITOR"
+    };
+  }
+}
+function editorBinary(editor) {
+  return editor.command.trim().split(/\s+/)[0] || "";
+}
+function usesTerminalUi(editor) {
+  const bin = editorBinary(editor).split(/[\\/]/).pop()?.toLowerCase();
+  if (!bin)
+    return true;
+  return !["code", "code-insiders", "cursor", "windsurf", "subl", "zed", "mate", "idea", "webstorm", "pycharm", "goland", "clion", "rubymine", "fleet", "notepad", "notepad++", "open"].includes(bin);
+}
+async function ensureSnippetDraft(name, projectDir) {
+  const dir = await ensureSnippetsDir(projectDir);
+  const filePath = join7(dir, `${name}${CONFIG.SNIPPET_EXTENSION}`);
+  try {
+    await access2(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    await writeFile4(filePath, EMPTY_SNIPPET, "utf8");
+  }
+  return filePath;
+}
+async function openExternalEditor(api, filePath, editor) {
+  if (!editor)
+    return false;
+  const interactive = usesTerminalUi(editor);
+  if (interactive) {
+    api.renderer.suspend();
+    api.renderer.currentRenderBuffer.clear();
+  }
+  try {
+    const cmd = process.platform === "win32" ? ["cmd", "/c", `${editor.command} "${filePath.replace(/"/g, "\\\"")}"`] : [...editor.command.split(" "), filePath];
+    const proc = spawn(cmd[0] ?? "", cmd.slice(1), {
+      stdio: interactive ? "inherit" : "ignore",
+      windowsHide: !interactive
+    });
+    await new Promise((resolve2, reject) => {
+      proc.once("error", reject);
+      proc.once("close", () => resolve2());
+    });
+    return true;
+  } finally {
+    if (interactive) {
+      api.renderer.currentRenderBuffer.clear();
+      api.renderer.resume();
+    }
+    api.renderer.requestRender();
+  }
+}
+function toPromptInfo(prompt, input) {
+  const current = prompt.current;
+  return {
+    input,
+    mode: current.mode,
+    parts: [...current.parts]
+  };
+}
+function setPromptInput(prompt, input) {
+  prompt.set(toPromptInfo(prompt, input));
+}
+function isSubmitKey(evt) {
+  return evt.name === "return" || evt.name === "linefeed" || evt.name === "enter" || evt.raw === "\r" || evt.raw === `
+` || evt.sequence === "\r" || evt.sequence === `
+` || evt.raw === "\x1BOM" || evt.sequence === "\x1BOM";
+}
+async function getSnippets(api) {
+  const registry = await loadSnippets(api.state.path.directory);
+  return sortSnippets(listSnippets(registry));
+}
+async function reloadSnippetsInTui(api) {
+  const registry = await loadSnippets(api.state.path.directory);
+  await markSnippetReloadRequested(api.state.path.directory);
+  return listSnippets(registry).length;
+}
+function executeReloadInPrompt(api, ref, clear, refresh) {
+  (async () => {
+    const count = await reloadSnippetsInTui(api);
+    await refresh();
+    clear();
+    ref.focus();
+    api.renderer.requestRender();
+    setTimeout(() => {
+      api.ui.toast({
+        variant: "success",
+        title: "Snippets reloaded",
+        message: `Reloaded ${count} snippet${count === 1 ? "" : "s"}.`,
+        duration: 3000
+      });
+      api.renderer.requestRender();
+    }, 0);
+  })();
+}
+async function getSkills(api) {
+  const native = api.client;
+  if (native.app?.skills) {
+    const response2 = await native.app.skills({
+      directory: api.state.path.directory
+    });
+    if (response2.data)
+      return sortSkills(response2.data.map(nativeSkillInfo));
+  }
+  if (native.global?.skills) {
+    const response2 = await native.global.skills({
+      directory: api.state.path.directory
+    });
+    if (response2.data)
+      return sortSkills(response2.data.map(nativeSkillInfo));
+  }
+  if (native.client?.get) {
+    const response2 = await native.client.get({
+      url: "/api/skill",
+      query: {
+        directory: api.state.path.directory
+      }
+    });
+    const skills = response2.data?.data;
+    if (skills) {
+      return sortSkills(skills.map(nativeSkillInfo));
+    }
+  }
+  const response = await api.client.config.get({
+    directory: api.state.path.directory
+  });
+  const cfg = response.data || api.state.config;
+  const registry = await loadSkills(api.state.path.directory, {
+    opencodeSkillDirs: cfg.skills?.paths
+  });
+  return sortSkills([...registry.values()]);
+}
+function nativeSkillInfo(skill) {
+  return {
+    name: skill.name,
+    content: skill.content.trim(),
+    description: skill.description,
+    source: "global",
+    filePath: skill.location
+  };
+}
+function skillDescription(skill) {
+  return (skill.description || skill.content).replace(/\s+/g, " ").trim();
+}
+function PromptWithSnippetAutocomplete(props) {
+  const [prompt, setPrompt] = createSignal();
+  const [dismissed, setDismissed] = createSignal();
+  const [selected, setSelected] = createSignal(0);
+  const [inputMode, setInputMode] = createSignal("keyboard");
+  const [ignoreMouseUntil, setIgnoreMouseUntil] = createSignal(0);
+  const [lastMousePos, setLastMousePos] = createSignal();
+  const [input, setInput] = createSignal("");
+  const [syncingPrompt, setSyncingPrompt] = createSignal(false);
+  const [menuEpoch, setMenuEpoch] = createSignal(0);
+  const [creating, setCreating] = createSignal(false);
+  const [dialogOpen, setDialogOpen] = createSignal(false);
+  const [dialogHandoffUntil, setDialogHandoffUntil] = createSignal(0);
+  const [snippets, {
+    refetch: refetchSnippets
+  }] = createResource(() => props.api.state.path.directory, () => getSnippets(props.api), {
+    initialValue: []
+  });
+  const [skills] = createResource(() => props.api.state.path.directory, () => getSkills(props.api), {
+    initialValue: []
+  });
+  const bind = (ref) => {
+    setPrompt(ref);
+    props.bindPrompt(ref);
+    props.hostRef?.(ref);
+  };
+  const refreshSnippetOptions = async () => {
+    await refetchSnippets();
+  };
+  let pendingPromptSync;
+  let pendingPromptFocus;
+  let pendingDialogHandoff;
+  onCleanup(() => {
+    if (pendingPromptSync)
+      clearTimeout(pendingPromptSync);
+    if (pendingPromptFocus)
+      clearTimeout(pendingPromptFocus);
+    if (pendingDialogHandoff)
+      clearTimeout(pendingDialogHandoff);
+  });
+  const lockKeyboardSelection = () => {
+    setInputMode("keyboard");
+    setIgnoreMouseUntil(Date.now() + MOUSE_HOVER_SUPPRESS_MS);
+  };
+  const allowMouseHover = () => Date.now() >= ignoreMouseUntil();
+  const dialogBlockingInput = () => isDialogInputBlocked(dialogOpen(), dialogHandoffUntil());
+  const beginDialogHandoff = () => {
+    if (pendingDialogHandoff)
+      clearTimeout(pendingDialogHandoff);
+    setDialogHandoffUntil(Date.now() + 150);
+    pendingDialogHandoff = setTimeout(() => {
+      pendingDialogHandoff = undefined;
+      setDialogHandoffUntil(0);
+      props.api.renderer.requestRender();
+    }, 175);
+  };
+  const recordMouseMove = (x, y) => {
+    const last = lastMousePos();
+    if (last?.x === x && last.y === y) {
+      return false;
+    }
+    setLastMousePos({
+      x,
+      y
+    });
+    return true;
+  };
+  const restorePromptFocus = (ref) => {
+    if (pendingPromptFocus)
+      clearTimeout(pendingPromptFocus);
+    pendingPromptFocus = setTimeout(() => {
+      pendingPromptFocus = undefined;
+      ref.focus();
+    }, 175);
+  };
+  const syncPromptInput = (ref, nextInput) => {
+    setPromptInput(ref, nextInput);
+    setInput(nextInput);
+    setSyncingPrompt(false);
+  };
+  const optionsForQuery = (value) => {
+    const snippetOptions = filterSnippets(snippets(), value).map((snippet) => ({
+      kind: "snippet",
+      id: `snippet:${snippet.name}`,
+      label: `#${snippet.name}`,
+      description: snippetDescription(snippet),
+      aliases: matchedAliases(snippet, value),
+      snippet
+    }));
+    const skillOptions = filterSkills(skills(), value).map((skill) => ({
+      kind: "skill",
+      id: `skill:${skill.name}`,
+      label: `#skill(${skill.name})`,
+      description: skillDescription(skill),
+      aliases: [],
+      skill
+    }));
+    return [...snippetOptions, ...skillOptions];
+  };
+  const schedulePromptSync = () => {
+    const ref = prompt();
+    if (!ref)
+      return;
+    if (dialogBlockingInput())
+      return;
+    setSyncingPrompt(true);
+    setMenuEpoch((n) => n + 1);
+    if (pendingPromptSync)
+      clearTimeout(pendingPromptSync);
+    pendingPromptSync = setTimeout(() => {
+      pendingPromptSync = undefined;
+      const next = ref.current.input;
+      setInput((prev) => prev === next ? prev : next);
+      setSyncingPrompt(false);
+      props.api.renderer.requestRender();
+    }, 0);
+  };
+  createEffect(() => {
+    const ref = prompt();
+    if (!ref) {
+      setInput("");
+      setSyncingPrompt(false);
+      return;
+    }
+    const sync = () => {
+      const next = ref.current.input;
+      setInput((prev) => {
+        if (prev === next)
+          return prev;
+        setSyncingPrompt(false);
+        return next;
+      });
+    };
+    sync();
+    const timer = setInterval(sync, PROMPT_SYNC_MS);
+    onCleanup(() => clearInterval(timer));
+  });
+  const match = createMemo(() => {
+    if (props.disabled || props.visible === false)
+      return;
+    return findTrailingHashtagTrigger(input());
+  });
+  const query = createMemo(() => match()?.query.trim() || "");
+  const options = createMemo(() => {
+    const next = match();
+    if (!next)
+      return [];
+    return optionsForQuery(next.query.trim());
+  });
+  const draftName = createMemo(() => normalizeSnippetName(query()));
+  const visible = createMemo(() => {
+    const next = match();
+    if (!next)
+      return false;
+    if (syncingPrompt())
+      return false;
+    return dismissed() !== next.token;
+  });
+  const canCreate = createMemo(() => {
+    if (snippets.loading || skills.loading)
+      return false;
+    if (options().length > 0)
+      return false;
+    return !!query() && !!draftName();
+  });
+  const optionKey = createMemo(() => options().map((item) => item.id).join(`
+`));
+  const menuHeight = createMemo(() => Math.min(MENU_MAX_HEIGHT, Math.max(1, options().length || 1)));
+  const activeRowId = createMemo(() => {
+    if (options().length > 0)
+      return options()[selected()]?.id;
+    if (canCreate())
+      return "create-snippet";
+    return;
+  });
+  let scroll;
+  createEffect(() => {
+    menuEpoch();
+    if (visible()) {
+      scroll = undefined;
+    }
+  });
+  createEffect((prev) => {
+    const next = match();
+    if (!next) {
+      if (dismissed())
+        setDismissed(undefined);
+      return "";
+    }
+    const key = `${next.token}
+${optionKey()}`;
+    if (key !== prev) {
+      setSelected(0);
+      lockKeyboardSelection();
+      setTimeout(() => {
+        scroll?.scrollTo(0);
+        const first = options()[0]?.id;
+        if (first) {
+          scroll?.scrollChildIntoView(first);
+        }
+      }, 0);
+    }
+    return key;
+  });
+  createEffect(() => {
+    const row = activeRowId();
+    if (!visible() || !row)
+      return;
+    setTimeout(() => {
+      scroll?.scrollChildIntoView(row);
+    }, 0);
+  });
+  const choose = (index = selected()) => {
+    const item = options()[index];
+    if (!item)
+      return;
+    chooseItem(item);
+  };
+  const chooseItem = (item) => {
+    const ref = prompt();
+    if (!ref)
+      return;
+    const nextInput = item.kind === "skill" ? insertSkillLoad(ref.current.input, item.skill.name) : insertSnippetTag(ref.current.input, preferredSnippetTag(ref.current.input, item.snippet));
+    syncPromptInput(ref, nextInput);
+    ref.focus();
+    setDismissed(undefined);
+  };
+  const handleNavigationKey = (evt) => {
+    if (dialogBlockingInput() || !visible())
+      return false;
+    const total = options().length;
+    if (total <= 0)
+      return false;
+    if (isAutocompleteNavUpKey(evt)) {
+      lockKeyboardSelection();
+      setSelected(stepSelection(selected(), total, -1));
+      evt.preventDefault();
+      evt.stopPropagation();
+      return true;
+    }
+    if (isAutocompleteNavDownKey(evt)) {
+      lockKeyboardSelection();
+      setSelected(stepSelection(selected(), total, 1));
+      evt.preventDefault();
+      evt.stopPropagation();
+      return true;
+    }
+    return false;
+  };
+  createEffect(() => {
+    const ref = prompt();
+    if (!ref)
+      return;
+    let dispose;
+    const timer = setTimeout(() => {
+      dispose = props.api.command.register(() => [{
+        title: "Reload snippets",
+        value: "snippets.reload",
+        description: "Reload snippet files from disk",
+        category: "Prompt",
+        slash: {
+          name: "snippets:reload"
+        },
+        onSelect() {
+          executeReloadInPrompt(props.api, ref, () => {
+            syncPromptInput(ref, "");
+            setDismissed(undefined);
+          }, refreshSnippetOptions);
+        }
+      }]);
+    }, 0);
+    onCleanup(() => {
+      clearTimeout(timer);
+      dispose?.();
+    });
+  });
+  createEffect(() => {
+    if (dialogBlockingInput() || !visible() || options().length === 0)
+      return;
+    props.api.renderer.keyInput.prependListener("keypress", handleNavigationKey);
+    onCleanup(() => {
+      props.api.renderer.keyInput.removeListener("keypress", handleNavigationKey);
+    });
+  });
+  const createSnippetDraft = async (rawQuery) => {
+    const ref = prompt();
+    const name = normalizeSnippetName(rawQuery ?? query());
+    if (!ref || !name || creating())
+      return;
+    const current = findTrailingHashtagTrigger(ref.current.input);
+    const nextInput = current ? `${ref.current.input.slice(0, current.start)}#${name}` : `#${name}`;
+    const dismissedToken = `#${name}`;
+    const editor = resolveExternalEditor();
+    if (!editor) {
+      props.api.ui.toast({
+        variant: "warning",
+        message: "Set VISUAL or EDITOR to create snippets from the TUI."
+      });
+      return;
+    }
+    props.api.ui.dialog.setSize("medium");
+    setDialogOpen(true);
+    props.api.ui.dialog.replace(() => _$createComponent(props.api.ui.DialogConfirm, {
+      title: `Create snippet #${name}?`,
+      get message() {
+        return `This will create the snippet draft and open it in $${editor.env} (${editor.command}).`;
+      },
+      onCancel: () => {
+        setDialogOpen(false);
+        beginDialogHandoff();
+        props.api.ui.dialog.clear();
+        restorePromptFocus(ref);
+      },
+      onConfirm: () => {
+        setDialogOpen(false);
+        beginDialogHandoff();
+        props.api.ui.dialog.clear();
+        (async () => {
+          setCreating(true);
+          try {
+            syncPromptInput(ref, nextInput);
+            const filePath = await ensureSnippetDraft(name);
+            await addPendingDraft(props.api.state.path.directory, name);
+            setDismissed(dismissedToken);
+            setCreating(false);
+            const opened = await openExternalEditor(props.api, filePath, editor);
+            if (!opened)
+              return;
+          } catch (error) {
+            props.api.ui.toast({
+              variant: "error",
+              message: `Failed to create snippet: ${error instanceof Error ? error.message : String(error)}`
+            });
+            syncPromptInput(ref, nextInput);
+            setDismissed(undefined);
+          } finally {
+            setCreating(false);
+            restorePromptFocus(ref);
+          }
+        })();
+      }
+    }));
+  };
+  const acceptVisibleAutocomplete = () => {
+    const total = options().length;
+    const actionable = total > 0 || canCreate();
+    if (!visible() || !actionable)
+      return false;
+    if (total > 0) {
+      choose(selected());
+    } else if (canCreate()) {
+      createSnippetDraft();
+    }
+    return true;
+  };
+  onMount(() => {
+    const submitAutocomplete = (evt) => {
+      if (!isSubmitKey(evt))
+        return;
+      if (dialogBlockingInput())
+        return;
+      if (!acceptVisibleAutocomplete())
+        return;
+      evt.preventDefault();
+      evt.stopPropagation();
+    };
+    props.api.renderer.keyInput.prependListener("keypress", submitAutocomplete);
+    onCleanup(() => {
+      props.api.renderer.keyInput.removeListener("keypress", submitAutocomplete);
+    });
+  });
+  useKeyboard((evt) => {
+    const ref = prompt();
+    const name = evt.name?.toLowerCase();
+    if (ref && isReloadCommand(ref.current.input) && (name === "return" || name === "enter")) {
+      executeReloadInPrompt(props.api, ref, () => {
+        syncPromptInput(ref, "");
+        setDismissed(undefined);
+      }, refreshSnippetOptions);
+      evt.preventDefault();
+      evt.stopPropagation();
+      return;
+    }
+    if (dialogBlockingInput())
+      return;
+    if (!visible())
+      return;
+    if (handleNavigationKey(evt)) {
+      return;
+    }
+    if (name === "escape") {
+      setDismissed(match()?.token);
+      evt.preventDefault();
+      evt.stopPropagation();
+      return;
+    }
+    if (name === "tab" || name === "return" || name === "linefeed" || name === "enter") {
+      if (!acceptVisibleAutocomplete())
+        return;
+      evt.preventDefault();
+      evt.stopPropagation();
+      return;
+    }
+    schedulePromptSync();
+  });
+  const emptyLabel = createMemo(() => {
+    if ((snippets.loading || skills.loading) && options().length === 0) {
+      return "Loading snippets and skills...";
+    }
+    if (snippets().length === 0 && skills().length === 0)
+      return "No snippets or skills found";
+    return "No matching snippets or skills";
+  });
+  const addSnippetLabel = createMemo(() => {
+    if (creating())
+      return "Creating snippet...";
+    return `Add new Snippet: #${draftName()}`;
+  });
+  const selectedFg = createMemo(() => selectedText(props.api.theme.current));
+  return (() => {
+    var _el$2 = _$createElement("box");
+    _$insert(_el$2, _$createComponent(Show, {
+      get when() {
+        return visible();
+      },
+      get children() {
+        var _el$3 = _$createElement("box"), _el$4 = _$createElement("scrollbox");
+        _$insertNode(_el$3, _el$4);
+        _$setProp(_el$3, "position", "absolute");
+        _$setProp(_el$3, "left", 0);
+        _$setProp(_el$3, "right", 0);
+        _$setProp(_el$3, "zIndex", 100);
+        _$spread(_el$3, _$mergeProps({
+          get top() {
+            return -menuHeight();
+          },
+          get borderColor() {
+            return props.api.theme.current.border;
+          }
+        }, INLINE_BORDER), true);
+        _$use((r) => {
+          scroll = r;
+        }, _el$4);
+        _$setProp(_el$4, "scrollbarOptions", {
+          visible: false
+        });
+        _$insert(_el$4, _$createComponent(Index, {
+          get each() {
+            return options();
+          },
+          get fallback() {
+            return _$createComponent(Show, {
+              get when() {
+                return canCreate();
+              },
+              get fallback() {
+                return (() => {
+                  var _el$7 = _$createElement("box"), _el$8 = _$createElement("text");
+                  _$insertNode(_el$7, _el$8);
+                  _$setProp(_el$7, "paddingLeft", 1);
+                  _$setProp(_el$7, "paddingRight", 1);
+                  _$insert(_el$8, emptyLabel);
+                  _$effect((_$p) => _$setProp(_el$8, "fg", props.api.theme.current.textMuted, _$p));
+                  return _el$7;
+                })();
+              },
+              get children() {
+                var _el$5 = _$createElement("box"), _el$6 = _$createElement("text");
+                _$insertNode(_el$5, _el$6);
+                _$setProp(_el$5, "id", "create-snippet");
+                _$setProp(_el$5, "paddingLeft", 1);
+                _$setProp(_el$5, "paddingRight", 1);
+                _$setProp(_el$5, "onMouseMove", (event) => {
+                  if (!allowMouseHover())
+                    return;
+                  if (!recordMouseMove(event.x, event.y))
+                    return;
+                  setInputMode("mouse");
+                });
+                _$setProp(_el$5, "onMouseDown", () => {
+                  setInputMode("mouse");
+                  setLastMousePos(undefined);
+                });
+                _$setProp(_el$5, "onMouseUp", () => {
+                  createSnippetDraft();
+                });
+                _$insert(_el$6, addSnippetLabel);
+                _$effect((_p$) => {
+                  var _v$3 = props.api.theme.current.primary, _v$4 = selectedFg();
+                  _v$3 !== _p$.e && (_p$.e = _$setProp(_el$5, "backgroundColor", _v$3, _p$.e));
+                  _v$4 !== _p$.t && (_p$.t = _$setProp(_el$6, "fg", _v$4, _p$.t));
+                  return _p$;
+                }, {
+                  e: undefined,
+                  t: undefined
+                });
+                return _el$5;
+              }
+            });
+          },
+          children: (option, index) => (() => {
+            var _el$9 = _$createElement("box"), _el$0 = _$createElement("text");
+            _$insertNode(_el$9, _el$0);
+            _$setProp(_el$9, "paddingLeft", 1);
+            _$setProp(_el$9, "paddingRight", 1);
+            _$setProp(_el$9, "flexDirection", "row");
+            _$setProp(_el$9, "onMouseMove", (event) => {
+              if (!allowMouseHover())
+                return;
+              if (!recordMouseMove(event.x, event.y))
+                return;
+              setInputMode("mouse");
+            });
+            _$setProp(_el$9, "onMouseOver", () => {
+              if (!allowMouseHover())
+                return;
+              if (inputMode() !== "mouse")
+                return;
+              setSelected(index);
+            });
+            _$setProp(_el$9, "onMouseDown", () => {
+              setInputMode("mouse");
+              setLastMousePos(undefined);
+              setSelected(index);
+            });
+            _$setProp(_el$9, "onMouseUp", () => choose(index));
+            _$setProp(_el$0, "flexShrink", 0);
+            _$setProp(_el$0, "wrapMode", "none");
+            _$insert(_el$0, () => renderHighlighted(option().label, query(), index === selected() ? selectedFg() : props.api.theme.current.text));
+            _$insert(_el$9, _$createComponent(Show, {
+              get when() {
+                return option().aliases.length > 0;
+              },
+              get children() {
+                var _el$1 = _$createElement("text");
+                _$setProp(_el$1, "wrapMode", "none");
+                _$setProp(_el$1, "flexShrink", 0);
+                _$insert(_el$1, () => renderHighlighted(`  ${option().aliases.length === 1 ? "alias" : "aliases"}: ${option().aliases.join(", ")}`, query(), index === selected() ? selectedFg() : props.api.theme.current.textMuted));
+                _$effect((_$p) => _$setProp(_el$1, "fg", index === selected() ? selectedFg() : props.api.theme.current.textMuted, _$p));
+                return _el$1;
+              }
+            }), null);
+            _$insert(_el$9, _$createComponent(Show, {
+              get when() {
+                return option().description;
+              },
+              get children() {
+                var _el$10 = _$createElement("text");
+                _$setProp(_el$10, "wrapMode", "none");
+                _$insert(_el$10, () => renderHighlighted(`  ${option().description}`, query(), index === selected() ? selectedFg() : props.api.theme.current.textMuted));
+                _$effect((_$p) => _$setProp(_el$10, "fg", index === selected() ? selectedFg() : props.api.theme.current.textMuted, _$p));
+                return _el$10;
+              }
+            }), null);
+            _$effect((_p$) => {
+              var _v$5 = option().id, _v$6 = index === selected() ? props.api.theme.current.primary : undefined, _v$7 = index === selected() ? selectedFg() : props.api.theme.current.text;
+              _v$5 !== _p$.e && (_p$.e = _$setProp(_el$9, "id", _v$5, _p$.e));
+              _v$6 !== _p$.t && (_p$.t = _$setProp(_el$9, "backgroundColor", _v$6, _p$.t));
+              _v$7 !== _p$.a && (_p$.a = _$setProp(_el$0, "fg", _v$7, _p$.a));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined,
+              a: undefined
+            });
+            return _el$9;
+          })()
+        }));
+        _$effect((_p$) => {
+          var _v$ = props.api.theme.current.backgroundMenu, _v$2 = menuHeight();
+          _v$ !== _p$.e && (_p$.e = _$setProp(_el$4, "backgroundColor", _v$, _p$.e));
+          _v$2 !== _p$.t && (_p$.t = _$setProp(_el$4, "height", _v$2, _p$.t));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined
+        });
+        return _el$3;
+      }
+    }), null);
+    _$insert(_el$2, _$createComponent(props.api.ui.Prompt, {
+      get sessionID() {
+        return props.sessionID;
+      },
+      get workspaceID() {
+        return props.workspaceID;
+      },
+      get visible() {
+        return props.visible;
+      },
+      get disabled() {
+        return props.disabled || dialogBlockingInput();
+      },
+      get onSubmit() {
+        return props.onSubmit;
+      },
+      get placeholders() {
+        return props.placeholders;
+      },
+      ref: bind,
+      get right() {
+        return props.right;
+      }
+    }), null);
+    return _el$2;
+  })();
+}
+var tui = async (api) => {
+  let currentPrompt;
+  const bindPrompt = (ref) => {
+    currentPrompt = ref;
+  };
+  api.command.register(() => [{
+    title: "Insert snippet",
+    value: "snippets.insert",
+    description: "Insert a # trigger into the current prompt",
+    category: "Prompt",
+    hidden: !currentPrompt,
+    onSelect() {
+      if (!currentPrompt)
+        return;
+      setPromptInput(currentPrompt, insertSnippetTrigger(currentPrompt.current.input));
+      currentPrompt.focus();
+    }
+  }]);
+  api.slots.register({
+    order: 100,
+    slots: {
+      home_prompt(_ctx, value) {
+        return _$createComponent(PromptWithSnippetAutocomplete, {
+          api,
+          bindPrompt,
+          get hostRef() {
+            return value.ref;
+          },
+          get workspaceID() {
+            return value.workspace_id;
+          },
+          placeholders: HOME_PLACEHOLDERS,
+          get right() {
+            return _$createComponent(api.ui.Slot, {
+              name: "home_prompt_right",
+              get workspace_id() {
+                return value.workspace_id;
+              }
+            });
+          }
+        });
+      },
+      session_prompt(_ctx, value) {
+        return _$createComponent(PromptWithSnippetAutocomplete, {
+          api,
+          bindPrompt,
+          get hostRef() {
+            return value.ref;
+          },
+          get sessionID() {
+            return value.session_id;
+          },
+          get visible() {
+            return value.visible;
+          },
+          get disabled() {
+            return value.disabled;
+          },
+          get onSubmit() {
+            return value.on_submit;
+          },
+          get right() {
+            return _$createComponent(api.ui.Slot, {
+              name: "session_prompt_right",
+              get session_id() {
+                return value.session_id;
+              }
+            });
+          }
+        });
+      }
+    }
+  });
+};
+var plugin = {
+  id,
+  tui
+};
+var tui_default = plugin;
+export {
+  tui_default as default
+};