@k3_2o/pi-move 0.1.0

package/.prettierrc.json

@@ -0,0 +1,8 @@
+{
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "all",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "arrowParens": "always"
+}

package/Makefile

@@ -0,0 +1,53 @@
+.PHONY: fmt fmt-check lint typecheck check security smoke install clean
+
+# --- Formatting ---
+
+fmt:
+	@echo "=== Formatting with Prettier ==="
+	npx prettier --write '*.ts'
+
+fmt-check:
+	@echo "=== Checking format with Prettier ==="
+	npx prettier --check '*.ts'
+
+# --- Linting ---
+
+lint:
+	@echo "=== Linting with ESLint ==="
+	npx eslint '*.ts'
+
+# --- Type Checking ---
+
+typecheck:
+	@echo "=== Type checking with tsc ==="
+	npx tsc --noEmit
+
+# --- Combined Check ---
+
+check: fmt-check lint typecheck
+	@echo "=== All checks passed ==="
+
+# --- Security Audit ---
+
+security:
+	@echo "=== Security audit ==="
+	npm audit --audit-level=high
+
+# --- Smoke Test ---
+
+smoke:
+	@echo "=== Smoke test ==="
+	bun -e "import('./src/index.ts').then(() => console.log('SMOKE OK')).catch(e => { console.error(e); process.exit(1); })"
+
+# --- Install ---
+
+install:
+	@echo "=== Installing dependencies ==="
+	npm install
+
+# --- Clean ---
+
+clean:
+	@echo "=== Cleaning ==="
+	rm -rf node_modules/ dist/
+	rm -f package-lock.json

package/README.md

@@ -0,0 +1,41 @@
+# pi-move
+
+A Pi extension that adds `/move` — switch to a fresh Pi session in any directory
+from inside Pi. No quitting.
+
+## Why
+
+Pi works in one directory at a time. To switch projects you normally have to
+quit, `cd`, and restart. `/move` does that in one step.
+
+## How
+
+Type `/move`, an overlay pops up with a path input. Start typing, tab to autocomplete directories 
+as you go. Press Enter and Pi creates a new empty session in that
+directory and switches to it.
+
+If the directory doesn't exist, Pi asks if you want to create it. 
+no need to exit to make a new directory for your project
+
+## Requirements
+
+- Pi 0.79+
+- `fd` (pi usually demands you have this on start-up, as a pi user you probably already have it)
+
+## Install
+
+```bash
+pi install @k3_2o/pi-move
+# or
+pi install git:github.com/k3-2o/pi-move
+```
+
+Or clone manually:
+
+```bash
+git clone https://github.com/k3-2o/pi-move ~/.pi/agent/extensions/pi-move
+```
+
+## License
+
+MIT

package/eslint.config.js

@@ -0,0 +1,30 @@
+// @ts-check
+import tseslint from "typescript-eslint";
+import eslint from "@eslint/js";
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommendedTypeChecked,
+  {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+  {
+    rules: {
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        { argsIgnorePattern: "^_" },
+      ],
+      "@typescript-eslint/no-non-null-assertion": "warn",
+      "@typescript-eslint/no-confusing-void-expression": "off",
+      "no-console": ["warn", { allow: ["warn", "error"] }],
+    },
+  },
+  {
+    ignores: ["dist/", "node_modules/", "tests/", "scripts/"],
+  },
+);

package/index.ts

@@ -0,0 +1,43 @@
+// --- 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";
+
+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"),
+    );
+    if (hasRealMessages) return; // Has real messages — keep it
+
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    if (!sessionFile) return;
+
+    try {
+      fs.unlinkSync(sessionFile);
+    } catch {
+      // File already gone — skip
+    }
+  });
+
+  // --- 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
+      return null;
+    },
+    handler: async (args, ctx) => {
+      await handleMoveCommand(args, ctx);
+    },
+  });
+}

package/move.ts

@@ -0,0 +1,144 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+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);
+    }
+    return;
+  }
+
+  if (!ctx.hasUI || ctx.mode !== "tui") {
+    ctx.ui.notify("/move requires interactive TUI mode", "error");
+    return;
+  }
+
+  const result = await ctx.ui.custom<MoveOverlayResult | undefined>(
+    (_tui, theme, _keybindings, done) => new MoveOverlay(theme, ctx.cwd, done),
+    { overlay: true },
+  );
+
+  if (result === undefined) return;
+
+  const target = await resolveOrCreateDirectory(result.directory, 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
+  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));
+  } else if (path.isAbsolute(input)) {
+    targetPath = path.normalize(input);
+  } else {
+    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",
+    );
+    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?`,
+  );
+
+  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");
+    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();
+
+    if (!sessionFile) {
+      ctx.ui.notify("Failed to create new session", "error");
+      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.
+    const sessionId = newSession.getSessionId();
+    const header = {
+      type: "session",
+      version: 3,
+      id: sessionId,
+      timestamp: new Date().toISOString(),
+      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");
+  }
+}

package/overlay.ts

@@ -0,0 +1,216 @@
+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 = "";
+  private cursor = 0;
+  private selectedIndex = 0;
+  private results: Array<{ value: string; label: string; description?: string }> = [];
+  private theme: Theme;
+  private done: (result: MoveOverlayResult | undefined) => void;
+  private cwd: string;
+
+  constructor(theme: Theme, cwd: string, done: (result: MoveOverlayResult | undefined) => void) {
+    this.theme = theme;
+    this.cwd = cwd;
+    this.done = done;
+    this.updateResults();
+  }
+
+  handleInput(data: string): void {
+    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);
+      }
+      return;
+    }
+
+    if (matchesKey(data, "down")) {
+      if (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;
+        this.cursor = this.input.length;
+        this.updateResults();
+      }
+      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);
+      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();
+    }
+  }
+
+  render(_width: number): string[] {
+    const w = this.width;
+    const th = this.theme;
+    const innerW = w - 2;
+    const lines: string[] = [];
+
+    const pad = (s: string, len: number) => {
+      const vis = visibleWidth(s);
+      return s + " ".repeat(Math.max(0, len - vis));
+    };
+
+    const row = (content: string) => {
+      const vis = visibleWidth(content);
+      return (
+        th.fg("border", "│") +
+        (vis > innerW ? content.slice(0, innerW) : pad(content, innerW)) +
+        th.fg("border", "│")
+      );
+    };
+
+    // ── 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) {
+      const before = inputDisplay.slice(0, this.cursor);
+      const cursorChar = this.cursor < inputDisplay.length ? inputDisplay[this.cursor] : " ";
+      const after = inputDisplay.slice(this.cursor + 1);
+      const marker = this.focused ? CURSOR_MARKER : "";
+      inputDisplay = `${before}${marker}\x1b[7m${cursorChar}\x1b[27m${after}`;
+    } else {
+      const placeholder = th.fg("dim", "Type a directory path...");
+      const marker = this.focused ? CURSOR_MARKER : "";
+      inputDisplay = `${placeholder}${marker}\x1b[7m \x1b[27m`;
+    }
+    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
+  }
+
+  dispose(): void {
+    // No resources to clean up
+  }
+
+  private updateResults(): void {
+    this.results = findDirectories(this.input, this.cwd, this.maxResults + 5);
+    if (this.selectedIndex >= this.results.length) {
+      this.selectedIndex = Math.max(0, this.results.length - 1);
+    }
+  }
+
+  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
+    this.done(undefined);
+  }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@k3_2o/pi-move",
+  "version": "0.1.0",
+  "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'",
+    "typecheck": "tsc --noEmit",
+    "check": "npm run fmt:check && npm run lint && npm run typecheck",
+    "security": "npm audit --audit-level=high"
+  },
+  "devDependencies": {
+    "eslint": "^9.0.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.7.0",
+    "typescript-eslint": "^8.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/k3-2o/pi-move.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": ["./index.ts"]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "exactOptionalPropertyTypes": false,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "declaration": false,
+    "outDir": "dist",
+    "baseUrl": ".",
+    "paths": {
+      "@earendil-works/pi-coding-agent": [
+        "/home/k2/node_modules/@earendil-works/pi-coding-agent/dist/index.d.ts"
+      ],
+      "@earendil-works/pi-coding-agent/*": [
+        "/home/k2/node_modules/@earendil-works/pi-coding-agent/dist/*.d.ts"
+      ],
+      "@earendil-works/pi-tui": [
+        "/home/k2/node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-tui/dist/index.d.ts"
+      ],
+      "@earendil-works/pi-tui/*": [
+        "/home/k2/node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-tui/dist/*.d.ts"
+      ]
+    }
+  },
+  "include": ["*.ts", "scripts/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/utils.ts

@@ -0,0 +1,264 @@
+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);
+}