@pi-unipi/command-enchantment 0.1.1

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@pi-unipi/command-enchantment",
+  "version": "0.1.1",
+  "description": "Enhanced TUI autocomplete for /unipi:* commands — colored, sorted, and grouped by package",
+  "type": "module",
+  "license": "MIT",
+  "author": "Neuron Mr White",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Neuron-Mr-White/unipi.git",
+    "directory": "packages/autocomplete"
+  },
+  "homepage": "https://github.com/Neuron-Mr-White/unipi#readme",
+  "bugs": {
+    "url": "https://github.com/Neuron-Mr-White/unipi/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-coding-agent",
+    "unipi",
+    "autocomplete"
+  ],
+  "pi": {
+    "extensions": [
+      "src/index.ts"
+    ]
+  },
+  "files": [
+    "src/**/*.ts",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,214 @@
+/**
+ * @pi-unipi/command-enchantment — Constants
+ *
+ * Static mappings for the command registry, package ordering, and package colors.
+ * These drive the enhanced autocomplete display for /unipi:* commands.
+ */
+
+// ─── ANSI Color Helpers ──────────────────────────────────────────────
+const ESC = "\x1b";
+const RESET = `${ESC}[0m`;
+
+/** Wrap text in an ANSI color code */
+export function colorize(ansiCode: string, text: string): string {
+  return `${ansiCode}${text}${RESET}`;
+}
+
+// ─── Package Order ───────────────────────────────────────────────────
+/** Packages sorted by display priority (top-to-bottom in autocomplete) */
+export const PACKAGE_ORDER: string[] = [
+  "workflow",
+  "ralph",
+  "memory",
+  "mcp",
+  "utility",
+  "ask-user",
+  "info",
+  "web-api",
+  "compact",
+  "notify",
+];
+
+// ─── Package Colors ──────────────────────────────────────────────────
+/** ANSI bright-color codes per package */
+export const PACKAGE_COLORS: Record<string, string> = {
+  workflow:  `${ESC}[91m`, // Bright Red
+  ralph:     `${ESC}[33m`, // Yellow/Orange
+  memory:    `${ESC}[93m`, // Bright Yellow
+  mcp:       `${ESC}[32m`, // Green
+  utility:   `${ESC}[36m`, // Cyan
+  "ask-user": `${ESC}[94m`, // Bright Blue
+  info:      `${ESC}[35m`, // Magenta
+  "web-api": `${ESC}[95m`, // Bright Magenta
+  compact:   `${ESC}[37m`, // White
+  notify:    `${ESC}[96m`, // Bright Cyan
+};
+
+// ─── Command Registry ────────────────────────────────────────────────
+/** Mapping of full command name → package name (58 verified commands) */
+export const COMMAND_REGISTRY: Record<string, string> = {
+  // workflow (20 commands)
+  "unipi:brainstorm":     "workflow",
+  "unipi:plan":           "workflow",
+  "unipi:work":           "workflow",
+  "unipi:review-work":    "workflow",
+  "unipi:consolidate":    "workflow",
+  "unipi:worktree-create": "workflow",
+  "unipi:worktree-list":  "workflow",
+  "unipi:worktree-merge": "workflow",
+  "unipi:consultant":     "workflow",
+  "unipi:quick-work":     "workflow",
+  "unipi:gather-context": "workflow",
+  "unipi:document":       "workflow",
+  "unipi:scan-issues":    "workflow",
+  "unipi:auto":           "workflow",
+  "unipi:debug":          "workflow",
+  "unipi:fix":            "workflow",
+  "unipi:quick-fix":      "workflow",
+  "unipi:research":       "workflow",
+  "unipi:chore-create":   "workflow",
+  "unipi:chore-execute":  "workflow",
+
+  // ralph (2 commands)
+  "unipi:ralph":          "ralph",
+  "unipi:ralph-stop":     "ralph",
+
+  // memory (7 commands)
+  "unipi:memory-process":     "memory",
+  "unipi:memory-search":      "memory",
+  "unipi:memory-consolidate": "memory",
+  "unipi:memory-forget":      "memory",
+  "unipi:global-memory-search": "memory",
+  "unipi:global-memory-list":   "memory",
+  "unipi:memory-settings":   "memory",
+
+  // mcp (5 commands)
+  "unipi:mcp-status":   "mcp",
+  "unipi:mcp-sync":     "mcp",
+  "unipi:mcp-add":      "mcp",
+  "unipi:mcp-settings": "mcp",
+  "unipi:mcp-reload":   "mcp",
+
+  // utility (6 commands)
+  "unipi:continue": "utility",
+  "unipi:reload":   "utility",
+  "unipi:status":   "utility",
+  "unipi:cleanup":  "utility",
+  "unipi:env":      "utility",
+  "unipi:doctor":   "utility",
+
+  // ask-user (1 command)
+  "unipi:ask-user-settings": "ask-user",
+
+  // info (2 commands)
+  "unipi:info":          "info",
+  "unipi:info-settings": "info",
+
+  // web-api (2 commands)
+  "unipi:web-settings":    "web-api",
+  "unipi:web-cache-clear": "web-api",
+
+  // compact (9 commands)
+  "unipi:compact":         "compact",
+  "unipi:compact-recall":  "compact",
+  "unipi:compact-stats":   "compact",
+  "unipi:compact-doctor":  "compact",
+  "unipi:compact-settings": "compact",
+  "unipi:compact-preset":  "compact",
+  "unipi:compact-index":   "compact",
+  "unipi:compact-search":  "compact",
+  "unipi:compact-purge":   "compact",
+
+  // notify (4 commands)
+  "unipi:notify-settings":  "notify",
+  "unipi:notify-set-gotify": "notify",
+  "unipi:notify-set-tg":    "notify",
+  "unipi:notify-test":      "notify",
+};
+
+// ─── Description Map ─────────────────────────────────────────────────
+/** Short descriptions for each command (used when base suggestions lack them) */
+export const COMMAND_DESCRIPTIONS: Record<string, string> = {
+  "unipi:brainstorm":     "Collaborative discovery — explore problem space",
+  "unipi:plan":           "Strategic planning — tasks, dependencies",
+  "unipi:work":           "Execute plan — implement tasks, test, commit",
+  "unipi:review-work":    "Review work — check task completion, run lint",
+  "unipi:consolidate":    "Save learnings to memory, craft skills",
+  "unipi:worktree-create": "Create git worktree for parallel work",
+  "unipi:worktree-list":  "List all unipi worktrees",
+  "unipi:worktree-merge": "Merge worktree branches back to main",
+  "unipi:consultant":     "Expert consultation — advisory analysis",
+  "unipi:quick-work":     "Fast single-task execution — one shot",
+  "unipi:gather-context": "Research codebase — surface patterns",
+  "unipi:document":       "Generate documentation — README, API docs",
+  "unipi:scan-issues":    "Deep investigation — find bugs, issues",
+  "unipi:auto":           "Full pipeline — brainstorm → plan → work → review",
+  "unipi:debug":          "Active bug investigation — reproduce, diagnose",
+  "unipi:fix":            "Fix bugs using debug reports",
+  "unipi:quick-fix":      "Fast bug fix without debug report",
+  "unipi:research":       "Read-only research with bash access",
+  "unipi:chore-create":   "Create reusable chore definition",
+  "unipi:chore-execute":  "Execute a saved chore",
+
+  "unipi:ralph":          "Ralph loop — start/resume coding session",
+  "unipi:ralph-stop":     "Stop the active ralph loop",
+
+  "unipi:memory-process":     "Process and store conversation learnings",
+  "unipi:memory-search":      "Search project memory for past context",
+  "unipi:memory-consolidate": "Consolidate memory entries",
+  "unipi:memory-forget":      "Remove memory entries",
+  "unipi:global-memory-search": "Search across all project memories",
+  "unipi:global-memory-list":   "List all project memories",
+  "unipi:memory-settings":   "Configure memory settings",
+
+  "unipi:mcp-status":   "Show MCP server status",
+  "unipi:mcp-sync":     "Sync MCP server connections",
+  "unipi:mcp-add":      "Add a new MCP server",
+  "unipi:mcp-settings": "Configure MCP settings",
+  "unipi:mcp-reload":   "Reload MCP connections",
+
+  "unipi:continue": "Continue the last conversation",
+  "unipi:reload":   "Reload extensions and settings",
+  "unipi:status":   "Show system status",
+  "unipi:cleanup":  "Clean up old sessions and cache",
+  "unipi:env":      "Show environment info",
+  "unipi:doctor":   "Run diagnostics",
+
+  "unipi:ask-user-settings": "Configure ask-user settings",
+
+  "unipi:info":          "Show system information",
+  "unipi:info-settings": "Configure info display",
+
+  "unipi:web-settings":    "Configure web search settings",
+  "unipi:web-cache-clear": "Clear web search cache",
+
+  "unipi:compact":          "Compact context window",
+  "unipi:compact-recall":   "Recall a compacted session",
+  "unipi:compact-stats":    "Show compaction statistics",
+  "unipi:compact-doctor":   "Diagnose compaction issues",
+  "unipi:compact-settings": "Configure compaction settings",
+  "unipi:compact-preset":   "Manage compaction presets",
+  "unipi:compact-index":    "Show compaction index",
+  "unipi:compact-search":   "Search compacted sessions",
+  "unipi:compact-purge":    "Purge old compacted sessions",
+
+  "unipi:notify-settings":  "Configure notification platforms and events",
+  "unipi:notify-set-gotify": "Set up Gotify push notifications",
+  "unipi:notify-set-tg":    "Set up Telegram bot notifications",
+  "unipi:notify-test":      "Test all enabled notification platforms",
+};
+
+// ─── Package Display Names ───────────────────────────────────────────
+/** Pretty names for package tags in autocomplete items */
+export const PACKAGE_LABELS: Record<string, string> = {
+  workflow:  "workflow",
+  ralph:     "ralph",
+  memory:    "memory",
+  mcp:       "mcp",
+  utility:   "utility",
+  "ask-user": "ask-user",
+  info:      "info",
+  "web-api": "web-api",
+  compact:   "compact",
+  notify:    "notify",
+};

package/src/index.ts

@@ -0,0 +1,31 @@
+/**
+ * @pi-unipi/command-enchantment — Extension Entry Point
+ *
+ * Registers an enhanced autocomplete provider for /unipi:* commands.
+ * Intercepts slash command suggestions and returns colored, sorted,
+ * package-grouped items with descriptions.
+ *
+ * Toggle via: ~/.unipi/config/command-enchantment/config.json
+ * Setting: autocompleteEnhanced (default: true)
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { createEnchantedProvider } from "./provider.js";
+import { isAutocompleteEnhanced } from "./settings.js";
+
+export default function commandEnchantment(pi: ExtensionAPI): void {
+  pi.on("session_start", async (_event, ctx) => {
+    // Check if enhancement is enabled
+    const enabled = isAutocompleteEnhanced();
+
+    if (!enabled) {
+      // When disabled, don't register the provider at all — pure passthrough
+      return;
+    }
+
+    // Register the autocomplete provider that wraps the base provider
+    ctx.ui.addAutocompleteProvider((current) =>
+      createEnchantedProvider(current, enabled),
+    );
+  });
+}

package/src/provider.ts

@@ -0,0 +1,307 @@
+/**
+ * @pi-unipi/command-enchantment — Autocomplete Provider
+ *
+ * Intercepts /unipi:* autocomplete and returns enhanced items with
+ * package-colored tags, sorted grouping, and descriptions.
+ * Non-unipi commands pass through unchanged.
+ */
+
+import type {
+  AutocompleteItem,
+  AutocompleteProvider,
+  AutocompleteSuggestions,
+} from "@mariozechner/pi-tui";
+import { fuzzyFilter } from "@mariozechner/pi-tui";
+
+import {
+  COMMAND_REGISTRY,
+  COMMAND_DESCRIPTIONS,
+  PACKAGE_COLORS,
+  PACKAGE_LABELS,
+  PACKAGE_ORDER,
+  colorize,
+} from "./constants.js";
+
+// ─── Fuzzy matching ──────────────────────────────────────────────────
+
+/** Simple character-subsequence fuzzy match (case-insensitive) */
+function fuzzyMatch(text: string, query: string): boolean {
+  if (!query) return true;
+  const lower = text.toLowerCase();
+  const q = query.toLowerCase();
+  let qi = 0;
+  for (let i = 0; i < lower.length && qi < q.length; i++) {
+    if (lower[i] === q[qi]) qi++;
+  }
+  return qi === q.length;
+}
+
+// ─── Namespace detection ─────────────────────────────────────────────
+
+/**
+ * If the query looks like a package namespace (e.g. "workflow", "memory",
+ * "utility"), return that package name so its commands sort to the top.
+ * Returns null when the query isn't a pure namespace search.
+ */
+function detectNamespaceBoost(query: string): string | null {
+  if (!query) return null;
+  const q = query.toLowerCase();
+  // Direct match against known package names (and common aliases)
+  const NAMESPACE_ALIASES: Record<string, string> = {
+    // Full package names
+    workflow: "workflow",
+    ralph: "ralph",
+    memory: "memory",
+    mcp: "mcp",
+    utility: "utility",
+    "ask-user": "ask-user",
+    info: "info",
+    "web-api": "web-api",
+    compact: "compact",
+    notify: "notify",
+    // Unambiguous short aliases
+    mem: "memory",
+    util: "utility",
+    web: "web-api",
+    notification: "notify",
+  };
+  return NAMESPACE_ALIASES[q] ?? null;
+}
+
+// ─── Enhanced item generation ────────────────────────────────────────
+
+/**
+ * Generate enhanced autocomplete items for unipi commands,
+ * sorted by package order then alphabetically within each package.
+ * When the query matches a package namespace, that package floats to top.
+ */
+function getEnhancedUnipiItems(
+  prefix: string,
+  descriptionOverrides: Map<string, string> = new Map(),
+): AutocompleteItem[] {
+  // The base provider sets prefix = full textBeforeCursor e.g. "/uni", "/unipi:brain".
+  // Two cases:
+  //   Case A  "/unipi:something" — user typed past the colon; match the short name.
+  //   Case B  "/something"       — user is still forming the command word; the base
+  //                                 fuzzyFilter matched against the full "unipi:work"
+  //                                 string, so we must do the same.
+  const stripped = prefix.replace(/^\//, "").toLowerCase();
+  const isPastUnipiColon = stripped.startsWith("unipi:");
+  const query = isPastUnipiColon
+    ? stripped.slice("unipi:".length) // e.g. "brain" from "/unipi:brain"
+    : stripped;                        // e.g. "uni" from "/uni"
+
+  const entries = Object.entries(COMMAND_REGISTRY);
+
+  // Detect namespace query: when the query is exactly a package name/alias
+  // (e.g. "workflow", "mem", "utility") short-circuit and return ALL commands
+  // from that package, sorted by name, with other packages following.
+  const boostedPackage = detectNamespaceBoost(query);
+
+  let matched: [string, string][];
+
+  if (boostedPackage) {
+    // Namespace mode: show boosted package first (all its commands), then
+    // remaining packages in normal order.
+    // Works for both "/workflow" and "/unipi:workflow".
+    matched = entries;
+  } else {
+    // Case A: match short name ("brain" against "brainstorm")
+    // Case B: match full value ("uni" against "unipi:work") so all unipi
+    //         commands surface when the user hasn't typed the full prefix.
+    matched = entries.filter(([cmd]) => {
+      if (isPastUnipiColon) {
+        return fuzzyMatch(cmd.replace("unipi:", "").toLowerCase(), query);
+      }
+      return fuzzyMatch(cmd.toLowerCase(), query);
+    });
+  }
+
+  // Sort: boosted package first, then by PACKAGE_ORDER, then alphabetically.
+  matched.sort((a, b) => {
+    const pkgA = a[1];
+    const pkgB = b[1];
+
+    if (boostedPackage) {
+      const aIsBoosted = pkgA === boostedPackage;
+      const bIsBoosted = pkgB === boostedPackage;
+      if (aIsBoosted && !bIsBoosted) return -1;
+      if (!aIsBoosted && bIsBoosted) return 1;
+    }
+
+    const orderA = PACKAGE_ORDER.indexOf(pkgA);
+    const orderB = PACKAGE_ORDER.indexOf(pkgB);
+    if (orderA !== orderB) return orderA - orderB;
+    return a[0].localeCompare(b[0]);
+  });
+
+  // Map to AutocompleteItem format
+  return matched.map(([cmd, pkg]) => {
+    const color = PACKAGE_COLORS[pkg] ?? "";
+    const label = PACKAGE_LABELS[pkg] ?? pkg;
+
+    // Use description from base suggestions if available, else from our map
+    const desc =
+      descriptionOverrides.get(cmd) ??
+      COMMAND_DESCRIPTIONS[cmd] ??
+      "";
+
+    const tag = colorize(color, `[${label}]`);
+
+    return {
+      value: cmd,
+      label: cmd.replace("unipi:", ""),
+      description: desc ? `${tag} ${desc}` : tag,
+    };
+  });
+}
+
+// ─── Argument re-trigger helpers ─────────────────────────────────────
+
+/**
+ * Return true when textBeforeCursor is inside the arguments of a /unipi:* command.
+ * e.g. "/unipi:work " or "/unipi:work plan:foo" → true
+ *      "/unipi:work" (no space) → false
+ */
+function isInUnipiArgPosition(textBeforeCursor: string): boolean {
+  const spaceIdx = textBeforeCursor.indexOf(" ");
+  if (spaceIdx === -1) return false;
+  const cmdName = textBeforeCursor.slice(1, spaceIdx); // strip leading "/"
+  return cmdName.startsWith("unipi:");
+}
+
+// ─── Provider factory ────────────────────────────────────────────────
+
+/**
+ * Create an enhanced autocomplete provider that wraps the base provider.
+ *
+ * @param current - The base (CombinedAutocompleteProvider) to delegate to
+ * @param enabled - Whether enhancement is active (if false, pure delegation)
+ */
+export function createEnchantedProvider(
+  current: AutocompleteProvider,
+  enabled: boolean,
+): AutocompleteProvider {
+  return {
+    async getSuggestions(
+      lines: string[],
+      cursorLine: number,
+      cursorCol: number,
+      options: { signal: AbortSignal; force?: boolean },
+    ): Promise<AutocompleteSuggestions | null> {
+      // When disabled, pure passthrough
+      if (!enabled) {
+        return current.getSuggestions(lines, cursorLine, cursorCol, options);
+      }
+
+      const currentLine = lines[cursorLine] ?? "";
+      const textBeforeCursor = currentLine.slice(0, cursorCol);
+
+      // Only intercept slash commands
+      if (!textBeforeCursor.startsWith("/")) {
+        return current.getSuggestions(lines, cursorLine, cursorCol, options);
+      }
+
+      // ── Argument position ──────────────────────────────────────────
+      // When there's a space, the user is typing arguments for a command.
+      // The base provider handles argument completions only when force=false
+      // (it skips the slash-command path entirely when force=true, falling
+      // back to file suggestions instead).  We fix that by always calling
+      // base with force=false so the getArgumentCompletions path is taken.
+      if (textBeforeCursor.includes(" ")) {
+        if (isInUnipiArgPosition(textBeforeCursor)) {
+          // Force the non-force path so argument completions are returned
+          // even when the editor called us with force=true (Tab key after space).
+          return current.getSuggestions(lines, cursorLine, cursorCol, {
+            ...options,
+            force: false,
+          });
+        }
+        return current.getSuggestions(lines, cursorLine, cursorCol, options);
+      }
+
+      // ── Command-name position ──────────────────────────────────────
+      // Get base suggestions (includes all commands)
+      const baseSuggestions = await current.getSuggestions(
+        lines,
+        cursorLine,
+        cursorCol,
+        options,
+      );
+
+      // Separate: keep non-unipi items, collect unipi descriptions
+      const nonUnipiItems: AutocompleteItem[] = [];
+      const descriptionOverrides = new Map<string, string>();
+
+      if (baseSuggestions) {
+        for (const item of baseSuggestions.items) {
+          if (item.value.startsWith("unipi:")) {
+            if (item.description) {
+              descriptionOverrides.set(item.value, item.description);
+            }
+          } else {
+            nonUnipiItems.push(item);
+          }
+        }
+      }
+
+      // The prefix we pass to getEnhancedUnipiItems: prefer base's prefix
+      // (which is the full textBeforeCursor), fall back to textBeforeCursor.
+      const effectivePrefix = baseSuggestions?.prefix ?? textBeforeCursor;
+
+      // Generate enhanced unipi items (handles namespace queries too)
+      const enhancedUnipiItems = getEnhancedUnipiItems(
+        effectivePrefix,
+        descriptionOverrides,
+      );
+
+      // If no unipi items match, just return non-unipi (or null if empty)
+      if (enhancedUnipiItems.length === 0) {
+        return nonUnipiItems.length > 0
+          ? { items: nonUnipiItems, prefix: effectivePrefix }
+          : null;
+      }
+
+      // Merge: non-unipi first, then enhanced unipi (sorted by package)
+      return {
+        items: [...nonUnipiItems, ...enhancedUnipiItems],
+        prefix: effectivePrefix,
+      };
+    },
+
+    applyCompletion(
+      lines: string[],
+      cursorLine: number,
+      cursorCol: number,
+      item: AutocompleteItem,
+      prefix: string,
+    ) {
+      return current.applyCompletion(
+        lines,
+        cursorLine,
+        cursorCol,
+        item,
+        prefix,
+      );
+    },
+
+    shouldTriggerFileCompletion(
+      lines: string[],
+      cursorLine: number,
+      cursorCol: number,
+    ): boolean {
+      const currentLine = lines[cursorLine] ?? "";
+      const textBeforeCursor = currentLine.slice(0, cursorCol);
+
+      // When Tab is pressed inside a /unipi:* argument context we still
+      // want getSuggestions to be called (returning true here allows that),
+      // and getSuggestions will override force=false so the base provider
+      // takes the argument-completion path instead of the file path.
+      if (isInUnipiArgPosition(textBeforeCursor)) {
+        return true;
+      }
+
+      return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
+    },
+  };
+}

package/src/settings.ts

@@ -0,0 +1,84 @@
+/**
+ * @pi-unipi/command-enchantment — Settings
+ *
+ * Manages the autocompleteEnhanced toggle.
+ * Persists to ~/.unipi/config/command-enchantment/config.json
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+/** Config structure */
+export interface CommandEnchantmentConfig {
+  autocompleteEnhanced: boolean;
+}
+
+/** Default configuration */
+const DEFAULT_CONFIG: CommandEnchantmentConfig = {
+  autocompleteEnhanced: true,
+};
+
+/** Config directory path */
+function getConfigDir(): string {
+  return path.join(os.homedir(), ".unipi", "config", "command-enchantment");
+}
+
+/** Config file path */
+function getConfigPath(): string {
+  return path.join(getConfigDir(), "config.json");
+}
+
+/** Ensure config directory exists */
+function ensureConfigDir(): void {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * Load configuration from disk.
+ * Returns defaults if file doesn't exist or is malformed.
+ */
+export function loadConfig(): CommandEnchantmentConfig {
+  try {
+    const configPath = getConfigPath();
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content) as Partial<CommandEnchantmentConfig>;
+      return {
+        ...DEFAULT_CONFIG,
+        ...config,
+      };
+    }
+  } catch (error) {
+    console.error("[command-enchantment] Failed to load config:", error);
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Save configuration to disk.
+ */
+export function saveConfig(config: CommandEnchantmentConfig): void {
+  ensureConfigDir();
+  const configPath = getConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+/**
+ * Check if autocomplete enhancement is enabled.
+ */
+export function isAutocompleteEnhanced(): boolean {
+  return loadConfig().autocompleteEnhanced;
+}
+
+/**
+ * Enable or disable autocomplete enhancement.
+ */
+export function setAutocompleteEnhanced(enabled: boolean): void {
+  const config = loadConfig();
+  config.autocompleteEnhanced = enabled;
+  saveConfig(config);
+}