@k3_2o/pi-move 0.1.0 → 0.1.1

package/Makefile

@@ -4,17 +4,17 @@
 
 fmt:
 	@echo "=== Formatting with Prettier ==="
-	npx prettier --write '*.ts'
+	npx prettier --write '{index.ts,src/*.ts}'
 
 fmt-check:
 	@echo "=== Checking format with Prettier ==="
-	npx prettier --check '*.ts'
+	npx prettier --check '{index.ts,src/*.ts}'
 
 # --- Linting ---
 
 lint:
 	@echo "=== Linting with ESLint ==="
-	npx eslint '*.ts'
+	npx eslint 'index.ts' 'src/*.ts'
 
 # --- Type Checking ---
 

package/README.md

@@ -25,7 +25,7 @@ no need to exit to make a new directory for your project
 ## Install
 
 ```bash
-pi install @k3_2o/pi-move
+pi install npm:@k3_2o/pi-move
 # or
 pi install git:github.com/k3-2o/pi-move
 ```

package/index.ts

@@ -1,39 +1,24 @@
-// --- pi-move: Directory Switcher for Pi ---
-
 import * as fs from "node:fs";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { handleMoveCommand } from "./move.js";
+import { handleMoveCommand } from "./src/move.js";
 
 export default function piMoveExtension(pi: ExtensionAPI): void {
-  // --- Lifecycle: session_shutdown ---
-  // When leaving an empty session (user moved here via /move but sent
-  // no messages), delete the file so it doesn't clutter /resume.
   pi.on("session_shutdown", (_event, ctx) => {
     const entries = ctx.sessionManager.getEntries();
-    // Check for actual user/assistant messages, not just metadata entries
-    // like model_change and thinking_level_change that pi auto-appends.
     const hasRealMessages = entries.some(
-      (e) => e.type === "message" && (e.message.role === "user" || e.message.role === "assistant"),
+      (e) => e.type === "message" &&
+        (e.message.role === "user" || e.message.role === "assistant"),
     );
-    if (hasRealMessages) return; // Has real messages — keep it
+    if (hasRealMessages) return;
 
     const sessionFile = ctx.sessionManager.getSessionFile();
     if (!sessionFile) return;
-
-    try {
-      fs.unlinkSync(sessionFile);
-    } catch {
-      // File already gone — skip
-    }
+    try { fs.unlinkSync(sessionFile); } catch { /* file gone, that's fine */ }
   });
 
-  // --- Command: /move ---
-
   pi.registerCommand("move", {
-    description:
-      "Move to a different directory — starts a fresh Pi session in the target directory",
-    getArgumentCompletions: (_argumentPrefix: string) => {
-      // We don't use inline arg completion — the overlay handles it
+    description: "Move to a different directory — starts a fresh Pi session in the target directory",
+    getArgumentCompletions: (_argumentPrefix: string): null => {
       return null;
     },
     handler: async (args, ctx) => {

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@k3_2o/pi-move",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Pi extension — /move command to switch directories from inside Pi",
   "keywords": ["pi-package", "extension", "directory", "navigation"],
   "author": "k3_2o",
   "license": "MIT",
   "type": "module",
   "scripts": {
-    "fmt": "prettier --write '*.ts'",
-    "fmt:check": "prettier --check '*.ts'",
-    "lint": "eslint '*.ts'",
+    "fmt": "prettier --write '{index.ts,src/*.ts}'",
+    "fmt:check": "prettier --check '{index.ts,src/*.ts}'",
+    "lint": "eslint 'index.ts' 'src/*.ts'",
     "typecheck": "tsc --noEmit",
     "check": "npm run fmt:check && npm run lint && npm run typecheck",
     "security": "npm audit --audit-level=high"

package/{move.ts → src/move.ts}

@@ -6,17 +6,12 @@ import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { MoveOverlay, type MoveOverlayResult } from "./overlay.js";
 import { resolveDirectory } from "./utils.js";
 
-/**
- * Handle the /move command.
- */
 export async function handleMoveCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
   const trimmedArg = args.trim();
 
   if (trimmedArg.length > 0) {
     const target = await resolveOrCreateDirectory(trimmedArg, ctx);
-    if (target !== null) {
-      await switchToNewSession(target, ctx);
-    }
+    if (target !== null) await switchToNewSession(target, ctx);
     return;
   }
 
@@ -33,25 +28,13 @@ export async function handleMoveCommand(args: string, ctx: ExtensionCommandConte
   if (result === undefined) return;
 
   const target = await resolveOrCreateDirectory(result.directory, ctx);
-  if (target !== null) {
-    await switchToNewSession(target, ctx);
-  }
+  if (target !== null) await switchToNewSession(target, ctx);
 }
 
-/**
- * Resolve a directory path. If it doesn't exist, prompt the user to create it.
- * Returns the resolved path, or null if the user cancels or the path is invalid.
- */
-async function resolveOrCreateDirectory(
-  input: string,
-  ctx: ExtensionCommandContext,
-): Promise<string | null> {
-  // Try normal resolution first
+async function resolveOrCreateDirectory(input: string, ctx: ExtensionCommandContext): Promise<string | null> {
   const resolved = resolveDirectory(input, ctx.cwd);
   if (resolved !== null) return resolved;
 
-  // Directory doesn't exist. Check if we can create it.
-  // Resolve the path to get the intended full path.
   let targetPath: string;
   if (input.startsWith("~/")) {
     targetPath = path.join(os.homedir(), input.slice(2));
@@ -61,51 +44,29 @@ async function resolveOrCreateDirectory(
     targetPath = path.resolve(ctx.cwd, input);
   }
 
-  // Check if parent directory exists
   const parentDir = path.dirname(targetPath);
   if (!fs.existsSync(parentDir)) {
-    ctx.ui.notify(
-      `Cannot create "${path.basename(targetPath)}": parent directory does not exist`,
-      "error",
-    );
+    ctx.ui.notify(`Cannot create "${path.basename(targetPath)}": parent directory does not exist`, "error");
     return null;
   }
 
-  // Prompt user to create it
   const basename = path.basename(targetPath);
-  const confirmed = await ctx.ui.confirm(
-    "Create directory?",
-    `"${basename}" does not exist. Create it?`,
-  );
-
+  const confirmed = await ctx.ui.confirm("Create directory?", `"${basename}" does not exist. Create it?`);
   if (!confirmed) return null;
 
   try {
     fs.mkdirSync(targetPath, { recursive: true });
     return targetPath;
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    ctx.ui.notify(`Failed to create directory: ${message}`, "error");
+    ctx.ui.notify(`Failed to create directory: ${err instanceof Error ? err.message : String(err)}`, "error");
     return null;
   }
 }
 
-/**
- * Switch to a fresh Pi session in the target directory.
- *
- * Strategy: Create a new session file in the CURRENT session directory
- * (so /resume still scans the same folder) but with the target directory
- * as the session's CWD. Then switch to that session.
- *
- * IMPORTANT: SessionManager.create() does NOT write the file to disk.
- * We must write the session header ourselves before switchSession reads it.
- */
 async function switchToNewSession(targetDir: string, ctx: ExtensionCommandContext): Promise<void> {
   ctx.ui.notify(`Moving to ${targetDir}...`, "info");
 
   try {
-    // Create the session manager — this generates a file path but does NOT
-    // write the file. We need the file on disk so switchSession can open it.
     const currentSessionDir = ctx.sessionManager.getSessionDir();
     const newSession = SessionManager.create(targetDir, currentSessionDir);
     const sessionFile = newSession.getSessionFile();
@@ -115,9 +76,8 @@ async function switchToNewSession(targetDir: string, ctx: ExtensionCommandContex
       return;
     }
 
-    // Write the session header to disk. Without this, SessionManager.open()
-    // in switchSession cannot read the CWD from the header and falls back
-    // to process.cwd() — which is the OLD directory.
+    // SessionManager.create() doesn't write the file. Must write it manually
+    // so switchSession can read the cwd from the header.
     const sessionId = newSession.getSessionId();
     const header = {
       type: "session",
@@ -127,18 +87,13 @@ async function switchToNewSession(targetDir: string, ctx: ExtensionCommandContex
       cwd: targetDir,
     };
 
-    // Ensure the session directory exists
     if (!fs.existsSync(currentSessionDir)) {
       fs.mkdirSync(currentSessionDir, { recursive: true });
     }
 
     fs.writeFileSync(sessionFile, JSON.stringify(header) + "\n", "utf-8");
-
-    // Switch to the new session. Pi opens the file, reads cwd: targetDir
-    // from the header, and creates a fresh runtime with the target CWD.
     await ctx.switchSession(sessionFile);
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    ctx.ui.notify(`Failed to move: ${message}`, "error");
+    ctx.ui.notify(`Failed to move: ${err instanceof Error ? err.message : String(err)}`, "error");
   }
 }

package/{overlay.ts → src/overlay.ts}

@@ -2,27 +2,14 @@ import type { Theme } from "@earendil-works/pi-coding-agent";
 import { CURSOR_MARKER, type Focusable, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
 import { findDirectories } from "./utils.js";
 
-/**
- * Result emitted by the move overlay when the user confirms a selection.
- */
 export interface MoveOverlayResult {
-  /** The selected directory path (resolved, absolute). */
   directory: string;
 }
 
-/**
- * Overlay component for the /move command.
- *
- * Renders a floating modal with:
- * - A text input field for typing a directory path
- * - A list of matching directories below (updated on each keystroke)
- * - Keyboard navigation: type to filter, ↑↓ to select, Enter to confirm, Esc to cancel
- */
 export class MoveOverlay implements Focusable {
   readonly width = 68;
   readonly maxResults = 15;
 
-  /** Focusable interface — set by TUI when focus changes */
   focused = false;
 
   private input = "";
@@ -32,6 +19,7 @@ export class MoveOverlay implements Focusable {
   private theme: Theme;
   private done: (result: MoveOverlayResult | undefined) => void;
   private cwd: string;
+  private _updateTimeout: ReturnType<typeof setTimeout> | undefined;
 
   constructor(theme: Theme, cwd: string, done: (result: MoveOverlayResult | undefined) => void) {
     this.theme = theme;
@@ -41,32 +29,20 @@ export class MoveOverlay implements Focusable {
   }
 
   handleInput(data: string): void {
-    if (matchesKey(data, "escape")) {
-      this.done(undefined);
-      return;
-    }
-
-    if (matchesKey(data, "return")) {
-      this.confirmSelection();
-      return;
-    }
+    if (matchesKey(data, "escape")) { this.done(undefined); return; }
+    if (matchesKey(data, "return")) { this.confirmSelection(); return; }
 
-    if (matchesKey(data, "up")) {
-      if (this.results.length > 0) {
-        this.selectedIndex = Math.max(0, this.selectedIndex - 1);
-      }
+    if (matchesKey(data, "up") && this.results.length > 0) {
+      this.selectedIndex = Math.max(0, this.selectedIndex - 1);
       return;
     }
 
-    if (matchesKey(data, "down")) {
-      if (this.results.length > 0) {
-        this.selectedIndex = Math.min(this.results.length - 1, this.selectedIndex + 1);
-      }
+    if (matchesKey(data, "down") && this.results.length > 0) {
+      this.selectedIndex = Math.min(this.results.length - 1, this.selectedIndex + 1);
       return;
     }
 
     if (matchesKey(data, "tab")) {
-      // Tab auto-completes the selected item into the input
       const selected = this.results[this.selectedIndex];
       if (selected) {
         this.input = selected.value;
@@ -76,32 +52,22 @@ export class MoveOverlay implements Focusable {
       return;
     }
 
-    if (matchesKey(data, "backspace")) {
-      if (this.cursor > 0) {
-        this.input = this.input.slice(0, this.cursor - 1) + this.input.slice(this.cursor);
-        this.cursor--;
-        this.selectedIndex = 0;
-        this.updateResults();
-      }
-      return;
-    }
-
-    if (matchesKey(data, "left")) {
-      this.cursor = Math.max(0, this.cursor - 1);
+    if (matchesKey(data, "backspace") && this.cursor > 0) {
+      this.input = this.input.slice(0, this.cursor - 1) + this.input.slice(this.cursor);
+      this.cursor--;
+      this.selectedIndex = 0;
+      this.scheduleUpdate();
       return;
     }
 
-    if (matchesKey(data, "right")) {
-      this.cursor = Math.min(this.input.length, this.cursor + 1);
-      return;
-    }
+    if (matchesKey(data, "left")) { this.cursor = Math.max(0, this.cursor - 1); return; }
+    if (matchesKey(data, "right")) { this.cursor = Math.min(this.input.length, this.cursor + 1); return; }
 
-    // Regular character input
     if (data.length === 1 && data.charCodeAt(0) >= 32) {
       this.input = this.input.slice(0, this.cursor) + data + this.input.slice(this.cursor);
       this.cursor++;
       this.selectedIndex = 0;
-      this.updateResults();
+      this.scheduleUpdate();
     }
   }
 
@@ -125,14 +91,10 @@ export class MoveOverlay implements Focusable {
       );
     };
 
-    // ── Top border ──
     lines.push(th.fg("border", `╭${"─".repeat(innerW)}╮`));
-
-    // ── Title ──
     lines.push(row(` ${th.fg("accent", "📂 Move to directory")}`));
     lines.push(row(""));
 
-    // ── Input field ──
     const inputPrompt = th.fg("text", "  Path: ");
     let inputDisplay = this.input;
     if (this.input.length > 0) {
@@ -149,43 +111,37 @@ export class MoveOverlay implements Focusable {
     lines.push(row(`${inputPrompt}${inputDisplay}`));
     lines.push(row(""));
 
-    // ── Results list ──
     if (this.results.length === 0 && this.input.length > 0) {
       lines.push(row(` ${th.fg("dim", "No matching directories")}`));
     } else {
       const visibleResults = this.results.slice(0, this.maxResults);
-
       for (let i = 0; i < visibleResults.length; i++) {
         const item = visibleResults[i];
         if (!item) continue;
         const isSelected = i === this.selectedIndex;
-
         const prefix = isSelected ? th.fg("accent", " ▶") : "  ";
         const label = isSelected ? th.fg("accent", item.label) : th.fg("text", item.label);
-
         const desc = item.description ? th.fg("dim", ` ${item.description}`) : "";
-
         lines.push(row(`${prefix} ${label}${desc}`));
       }
     }
 
     lines.push(row(""));
-
-    // ── Footer ──
     lines.push(row(` ${th.fg("dim", "Type to filter · ↑↓·Tab·Enter·Esc")}`));
-
-    // ── Bottom border ──
     lines.push(th.fg("border", `╰${"─".repeat(innerW)}╯`));
 
     return lines;
   }
 
-  invalidate(): void {
-    // No external state to invalidate
-  }
+  invalidate(): void {}
+  dispose(): void {}
 
-  dispose(): void {
-    // No resources to clean up
+  private scheduleUpdate(): void {
+    if (this._updateTimeout) clearTimeout(this._updateTimeout);
+    this._updateTimeout = setTimeout(() => {
+      this.updateResults();
+      this._updateTimeout = undefined;
+    }, 150);
   }
 
   private updateResults(): void {
@@ -196,21 +152,9 @@ export class MoveOverlay implements Focusable {
   }
 
   private confirmSelection(): void {
-    // If there's a selection, use it
     const selectedItem = this.results[this.selectedIndex];
-    if (selectedItem) {
-      this.done({ directory: selectedItem.value });
-      return;
-    }
-
-    // If input is non-empty, try resolving it directly
-    if (this.input.trim().length > 0) {
-      // Resolve will be done by the handler
-      this.done({ directory: this.input.trim() });
-      return;
-    }
-
-    // Nothing to select
+    if (selectedItem) { this.done({ directory: selectedItem.value }); return; }
+    if (this.input.trim().length > 0) { this.done({ directory: this.input.trim() }); return; }
     this.done(undefined);
   }
 }

package/src/utils.ts

@@ -0,0 +1,91 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+export function resolveDirectory(input: string, cwd: string): string | null {
+  let resolved = input;
+  if (input.startsWith("~/") || input === "~") {
+    resolved = path.join(os.homedir(), input.slice(1));
+  } else if (!path.isAbsolute(input)) {
+    resolved = path.resolve(cwd, input);
+  }
+  resolved = path.normalize(resolved);
+  try { return fs.statSync(resolved).isDirectory() ? resolved : null; } catch { return null; }
+}
+
+export function findDirectories(
+  prefix: string, cwd: string, maxResults = 30,
+): Array<{ value: string; label: string; description?: string }> {
+  const resolved = resolveDirectory(prefix, cwd);
+  if (resolved !== null && fs.statSync(resolved).isDirectory()) {
+    return listDirectoryContents(resolved, maxResults);
+  }
+  const searchDir = getSearchBase(prefix, cwd);
+  const query = getQuery(prefix);
+  return searchDirectories(searchDir, query, maxResults);
+}
+
+function listDirectoryContents(
+  dirPath: string, maxResults: number,
+): Array<{ value: string; label: string; description?: string }> {
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    const results: Array<{ value: string; label: string; description?: string }> = [];
+    for (const entry of entries) {
+      if (results.length >= maxResults) break;
+      if (entry.name.startsWith(".")) continue;
+      let isDir: boolean;
+      try {
+        isDir = entry.isDirectory();
+        if (!isDir && entry.isSymbolicLink()) isDir = fs.statSync(path.join(dirPath, entry.name)).isDirectory();
+      } catch { continue; }
+      if (isDir) {
+        const fullPath = path.join(dirPath, entry.name);
+        results.push({ value: fullPath, label: entry.name + "/", description: fullPath });
+      }
+    }
+    results.sort((a, b) => a.label.localeCompare(b.label));
+    return results;
+  } catch { return []; }
+}
+
+function searchDirectories(
+  baseDir: string, query: string, maxResults: number,
+): Array<{ value: string; label: string; description?: string }> {
+  const results: Array<{ value: string; label: string; description?: string }> = [];
+  try {
+    const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+    const lowerQuery = query.toLowerCase();
+    for (const entry of entries) {
+      if (results.length >= maxResults) break;
+      let isDir: boolean;
+      try {
+        isDir = entry.isDirectory();
+        if (!isDir && entry.isSymbolicLink()) isDir = fs.statSync(path.join(baseDir, entry.name)).isDirectory();
+      } catch { continue; }
+      if (!isDir) continue;
+      if (query === "" || entry.name.toLowerCase().includes(lowerQuery)) {
+        results.push({ value: path.join(baseDir, entry.name), label: entry.name + "/", description: path.join(baseDir, entry.name) });
+      }
+    }
+  } catch { /* directory not accessible */ }
+  return results;
+}
+
+function getSearchBase(prefix: string, cwd: string): string {
+  if (prefix === "" || prefix === "~") return cwd;
+  const normalized = prefix.replace(/\\/g, "/");
+  const lastSlash = normalized.lastIndexOf("/");
+  if (lastSlash === -1) return cwd;
+  const basePart = normalized.slice(0, lastSlash + 1);
+  if (basePart.startsWith("~")) return path.join(os.homedir(), basePart.slice(1));
+  if (path.isAbsolute(basePart)) return basePart;
+  return path.resolve(cwd, basePart);
+}
+
+function getQuery(prefix: string): string {
+  if (prefix === "" || prefix === "~") return "";
+  const normalized = prefix.replace(/\\/g, "/");
+  const lastSlash = normalized.lastIndexOf("/");
+  if (lastSlash === -1) return normalized;
+  return normalized.slice(lastSlash + 1);
+}

package/tsconfig.json

@@ -28,6 +28,6 @@
       ]
     }
   },
-  "include": ["*.ts", "scripts/**/*.ts"],
+  "include": ["index.ts", "src/*.ts"],
   "exclude": ["node_modules", "dist", "tests"]
 }

package/utils.ts

@@ -1,264 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { spawn } from "node:child_process";
-
-/**
- * Resolve a user-provided directory path against the given CWD.
- * Handles ~ expansion, relative paths, . and .. segments.
- *
- * Returns null if the resolved path doesn't exist or isn't a directory.
- */
-export function resolveDirectory(input: string, cwd: string): string | null {
-  let resolved: string;
-
-  if (input.startsWith("~/") || input === "~") {
-    resolved = path.join(os.homedir(), input.slice(1));
-  } else if (path.isAbsolute(input)) {
-    resolved = input;
-  } else {
-    resolved = path.resolve(cwd, input);
-  }
-
-  resolved = path.normalize(resolved);
-
-  try {
-    if (fs.statSync(resolved).isDirectory()) {
-      return resolved;
-    }
-  } catch {
-    // Does not exist or permission denied
-  }
-
-  return null;
-}
-
-/**
- * Get a sorted list of directories matching the given prefix.
- *
- * Uses `fd` for fast, recursive, .gitignore-respecting search when available.
- * Falls back to a basic readdirSync scan if fd isn't installed.
- */
-export function findDirectories(
-  prefix: string,
-  cwd: string,
-  maxResults = 30,
-): Array<{ value: string; label: string; description?: string }> {
-  const resolved = resolveDirectory(prefix, cwd);
-  if (resolved !== null && fs.statSync(resolved).isDirectory()) {
-    // If prefix is already a valid directory, list its contents
-    return listDirectoryContents(resolved, maxResults);
-  }
-
-  // Fuzzy search from cwd (or from the partial path)
-  const searchDir = getSearchBase(prefix, cwd);
-  const query = getQuery(prefix);
-
-  return searchDirectories(searchDir, query, maxResults);
-}
-
-/**
- * Search for directories using fd (fast) or readdirSync (fallback).
- */
-async function searchDirectoriesFd(
-  baseDir: string,
-  query: string,
-  maxResults: number,
-): Promise<Array<{ path: string; isDirectory: boolean }>> {
-  return new Promise((resolve) => {
-    const args = [
-      "--base-directory",
-      baseDir,
-      "--max-results",
-      String(maxResults),
-      "--type",
-      "d",
-      "--follow",
-      "--hidden",
-      "--exclude",
-      ".git",
-      "--exclude",
-      "node_modules",
-    ];
-
-    if (query) {
-      args.push(query);
-    }
-
-    const child = spawn("fd", args, {
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-
-    child.stdout.setEncoding("utf-8");
-    child.stdout.on("data", (chunk: string) => {
-      stdout += chunk;
-    });
-
-    child.on("error", () => {
-      resolve([]);
-    });
-
-    child.on("close", (code) => {
-      if (code !== 0 || !stdout) {
-        resolve([]);
-        return;
-      }
-
-      const lines = stdout.trim().split("\n").filter(Boolean);
-      const results = lines.map((line) => {
-        const normalized = line.replace(/\\/g, "/");
-        const isDir = normalized.endsWith("/");
-        return {
-          path: isDir ? normalized.slice(0, -1) : normalized,
-          isDirectory: true,
-        };
-      });
-
-      resolve(results);
-    });
-  });
-}
-
-/**
- * List directory contents (all subdirectories).
- */
-function listDirectoryContents(
-  dirPath: string,
-  maxResults: number,
-): Array<{ value: string; label: string; description?: string }> {
-  try {
-    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-    const results: Array<{ value: string; label: string; description?: string }> = [];
-
-    for (const entry of entries) {
-      if (results.length >= maxResults) break;
-      if (entry.name.startsWith(".")) continue; // skip hidden
-
-      let isDir: boolean;
-      try {
-        isDir = entry.isDirectory();
-        if (!isDir && entry.isSymbolicLink()) {
-          isDir = fs.statSync(path.join(dirPath, entry.name)).isDirectory();
-        }
-      } catch {
-        continue;
-      }
-
-      if (isDir) {
-        const fullPath = path.join(dirPath, entry.name);
-        results.push({
-          value: fullPath,
-          label: entry.name + "/",
-          description: fullPath,
-        });
-      }
-    }
-
-    // Alphabetical sort
-    results.sort((a, b) => a.label.localeCompare(b.label));
-    return results;
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Search directories using readdirSync recursively (fallback when fd is unavailable).
- */
-function searchDirectories(
-  baseDir: string,
-  query: string,
-  maxResults: number,
-): Array<{ value: string; label: string; description?: string }> {
-  // First, try fd for speed
-  searchDirectoriesFd(baseDir, query, maxResults)
-    .then((fdResults) => {
-      if (fdResults.length > 0) {
-        return fdResults.map((r) => ({
-          value: path.resolve(baseDir, r.path),
-          label: r.path + "/",
-          description: path.resolve(baseDir, r.path),
-        }));
-      }
-      return null;
-    })
-    .catch(() => null);
-
-  // Synchronous fallback: iterate parent directories
-  // This is simpler and immediate
-  const results: Array<{ value: string; label: string; description?: string }> = [];
-
-  try {
-    const entries = fs.readdirSync(baseDir, { withFileTypes: true });
-    const lowerQuery = query.toLowerCase();
-
-    for (const entry of entries) {
-      if (results.length >= maxResults) break;
-
-      let isDir: boolean;
-      try {
-        isDir = entry.isDirectory();
-        if (!isDir && entry.isSymbolicLink()) {
-          isDir = fs.statSync(path.join(baseDir, entry.name)).isDirectory();
-        }
-      } catch {
-        continue;
-      }
-
-      if (!isDir) continue;
-
-      if (query === "" || entry.name.toLowerCase().includes(lowerQuery)) {
-        const fullPath = path.join(baseDir, entry.name);
-        results.push({
-          value: fullPath,
-          label: entry.name + "/",
-          description: fullPath,
-        });
-      }
-    }
-  } catch {
-    // Permission denied or non-existent
-  }
-
-  return results;
-}
-
-/**
- * Extract the search base directory and the query part from a path prefix.
- * E.g., "~/projects/my" → base: "~/projects", query: "my"
- *         "foo/bar" → base: "cwd/foo", query: "bar"
- */
-function getSearchBase(prefix: string, cwd: string): string {
-  if (prefix === "" || prefix === "~") {
-    return cwd;
-  }
-
-  const normalized = prefix.replace(/\\/g, "/");
-  const lastSlash = normalized.lastIndexOf("/");
-
-  if (lastSlash === -1) {
-    return cwd;
-  }
-
-  const basePart = normalized.slice(0, lastSlash + 1);
-
-  if (basePart.startsWith("~")) {
-    return path.join(os.homedir(), basePart.slice(1));
-  }
-
-  if (path.isAbsolute(basePart)) {
-    return basePart;
-  }
-
-  return path.resolve(cwd, basePart);
-}
-
-function getQuery(prefix: string): string {
-  if (prefix === "" || prefix === "~") return "";
-  const normalized = prefix.replace(/\\/g, "/");
-  const lastSlash = normalized.lastIndexOf("/");
-  if (lastSlash === -1) return normalized;
-  return normalized.slice(lastSlash + 1);
-}