wdyt 0.1.0

package/src/commands/select.ts

@@ -0,0 +1,180 @@
+/**
+ * Select commands - get, add
+ *
+ * Commands:
+ * - select get: returns selected file paths (newline-separated)
+ * - select add <paths>: adds files to selection
+ *
+ * Compatible with flowctl.py:
+ * - cmd_rp_select_get (line 3946): select get
+ * - cmd_rp_select_add (line 3955): select add <paths>
+ */
+
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { getTab, updateTab, getWindow } from "../state";
+
+/**
+ * Select get response
+ */
+export interface SelectGetResponse {
+  files: string[];
+}
+
+/**
+ * Get selected files for a tab
+ *
+ * @param windowId - Window ID
+ * @param tabId - Tab ID
+ * @returns Newline-separated file paths
+ */
+export async function selectGetCommand(
+  windowId: number,
+  tabId: string
+): Promise<{
+  success: boolean;
+  data?: SelectGetResponse;
+  output?: string;
+  error?: string;
+}> {
+  try {
+    const tab = await getTab(windowId, tabId);
+
+    // Return newline-separated paths for non-JSON output
+    const output = tab.selectedFiles.join("\n");
+
+    return {
+      success: true,
+      data: { files: tab.selectedFiles },
+      output,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to get selection: ${message}`,
+    };
+  }
+}
+
+/**
+ * Parse shell-quoted paths from the arguments string
+ *
+ * Handles paths that may be quoted with single quotes (from shlex.quote)
+ * Example: "'path/to/file.ts' 'another file.ts'"
+ */
+function parsePaths(argsString: string): string[] {
+  const paths: string[] = [];
+  let remaining = argsString.trim();
+
+  while (remaining.length > 0) {
+    remaining = remaining.trimStart();
+
+    if (remaining.startsWith("'")) {
+      // Single-quoted path
+      const endQuote = remaining.indexOf("'", 1);
+      if (endQuote === -1) {
+        // Unterminated quote, take rest
+        paths.push(remaining.slice(1));
+        break;
+      }
+      paths.push(remaining.slice(1, endQuote));
+      remaining = remaining.slice(endQuote + 1);
+    } else if (remaining.startsWith('"')) {
+      // Double-quoted path
+      const endQuote = remaining.indexOf('"', 1);
+      if (endQuote === -1) {
+        paths.push(remaining.slice(1));
+        break;
+      }
+      paths.push(remaining.slice(1, endQuote));
+      remaining = remaining.slice(endQuote + 1);
+    } else {
+      // Unquoted path - ends at whitespace
+      const spaceIndex = remaining.search(/\s/);
+      if (spaceIndex === -1) {
+        paths.push(remaining);
+        break;
+      }
+      paths.push(remaining.slice(0, spaceIndex));
+      remaining = remaining.slice(spaceIndex);
+    }
+  }
+
+  return paths.filter((p) => p.length > 0);
+}
+
+/**
+ * Add files to selection for a tab
+ *
+ * @param windowId - Window ID
+ * @param tabId - Tab ID
+ * @param argsString - Space-separated file paths (may be shell-quoted)
+ * @returns Success status with count of added files
+ */
+export async function selectAddCommand(
+  windowId: number,
+  tabId: string,
+  argsString: string
+): Promise<{
+  success: boolean;
+  data?: { added: number; total: number };
+  output?: string;
+  error?: string;
+}> {
+  try {
+    // Parse the paths from the args string
+    const pathsToAdd = parsePaths(argsString);
+
+    if (pathsToAdd.length === 0) {
+      return {
+        success: false,
+        error: "select add requires at least one path",
+      };
+    }
+
+    // Get window to determine root paths for resolving relative paths
+    const window = await getWindow(windowId);
+    const rootPath = window.rootFolderPaths[0] || process.cwd();
+
+    // Get current selection
+    const tab = await getTab(windowId, tabId);
+    const existingFiles = new Set(tab.selectedFiles);
+
+    // Process each path
+    let addedCount = 0;
+    for (const path of pathsToAdd) {
+      // Resolve to absolute path if relative
+      const absolutePath = resolve(rootPath, path);
+
+      // Skip if already selected (deduplicate)
+      if (existingFiles.has(absolutePath)) {
+        continue;
+      }
+
+      // Check if file exists - silently skip non-existent files
+      if (!existsSync(absolutePath)) {
+        continue;
+      }
+
+      existingFiles.add(absolutePath);
+      addedCount++;
+    }
+
+    // Update the tab with new selection
+    const newSelection = Array.from(existingFiles);
+    await updateTab(windowId, tabId, { selectedFiles: newSelection });
+
+    return {
+      success: true,
+      data: { added: addedCount, total: newSelection.length },
+      output: `Added ${addedCount} file(s), total: ${newSelection.length}`,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to add to selection: ${message}`,
+    };
+  }
+}

package/src/commands/windows.ts

@@ -0,0 +1,54 @@
+/**
+ * Windows command - list all windows
+ *
+ * Returns JSON: {windows: [{windowID, rootFolderPaths}]}
+ * Compatible with flowctl.py parsing at line 215-231
+ */
+
+import { getWindows } from "../state";
+
+/**
+ * Window data formatted for flowctl.py compatibility
+ * Uses windowID (not id) to match expected format
+ */
+export interface WindowOutput {
+  windowID: number;
+  rootFolderPaths: string[];
+}
+
+/**
+ * Windows command response
+ */
+export interface WindowsResponse {
+  windows: WindowOutput[];
+}
+
+/**
+ * Execute the windows command
+ * Returns all windows with their IDs and root folder paths
+ */
+export async function windowsCommand(): Promise<{
+  success: boolean;
+  data?: WindowsResponse;
+  error?: string;
+}> {
+  try {
+    const windows = await getWindows();
+
+    return {
+      success: true,
+      data: {
+        windows: windows.map((w) => ({
+          windowID: w.id,
+          rootFolderPaths: w.rootFolderPaths,
+        })),
+      },
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to get windows: ${message}`,
+    };
+  }
+}

package/src/state.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Tests for state management layer
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { join } from "path";
+import { rm } from "fs/promises";
+import {
+  loadState,
+  saveState,
+  getWindow,
+  getWindows,
+  createTab,
+  getTab,
+  updateTab,
+  deleteTab,
+  createWindow,
+  ensureState,
+} from "./state";
+
+// Use a test-specific directory
+const TEST_DIR = join(import.meta.dir, "..", ".test-state");
+
+beforeEach(async () => {
+  // Set XDG_DATA_HOME to test directory
+  process.env.XDG_DATA_HOME = TEST_DIR;
+
+  // Clean up any existing test state
+  try {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  } catch {
+    // Directory might not exist
+  }
+});
+
+afterEach(async () => {
+  // Clean up test directory
+  try {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  } catch {
+    // Directory might not exist
+  }
+  delete process.env.XDG_DATA_HOME;
+});
+
+describe("State management", () => {
+  test("loadState creates default state if none exists", async () => {
+    const state = await loadState();
+
+    expect(state).toBeDefined();
+    expect(state.version).toBe(1);
+    expect(state.windows).toHaveLength(1);
+    expect(state.windows[0].id).toBe(1);
+    expect(state.windows[0].tabs).toHaveLength(0);
+    expect(state.windows[0].rootFolderPaths).toEqual([]);
+  });
+
+  test("state survives process restarts (save and reload)", async () => {
+    // Initial load creates default
+    await ensureState();
+
+    // Create a tab
+    const tab = await createTab(1);
+    expect(tab.id).toBeDefined();
+    expect(tab.prompt).toBe("");
+    expect(tab.selectedFiles).toEqual([]);
+
+    // Update the tab
+    await updateTab(1, tab.id, {
+      prompt: "test prompt",
+      selectedFiles: ["file1.ts", "file2.ts"],
+    });
+
+    // Reload state (simulating process restart)
+    const reloadedState = await loadState();
+    const reloadedWindow = reloadedState.windows.find((w) => w.id === 1);
+    expect(reloadedWindow).toBeDefined();
+    expect(reloadedWindow!.tabs).toHaveLength(1);
+
+    const reloadedTab = reloadedWindow!.tabs[0];
+    expect(reloadedTab.id).toBe(tab.id);
+    expect(reloadedTab.prompt).toBe("test prompt");
+    expect(reloadedTab.selectedFiles).toEqual(["file1.ts", "file2.ts"]);
+  });
+
+  test("getWindow returns window or throws", async () => {
+    await ensureState();
+
+    // Window 1 should exist by default
+    const window = await getWindow(1);
+    expect(window.id).toBe(1);
+
+    // Window 999 should not exist
+    await expect(getWindow(999)).rejects.toThrow("Window 999 not found");
+  });
+
+  test("createTab returns new tab with UUID", async () => {
+    await ensureState();
+
+    const tab = await createTab(1);
+
+    expect(tab.id).toBeDefined();
+    expect(tab.id.length).toBe(36); // UUID length
+    expect(tab.prompt).toBe("");
+    expect(tab.selectedFiles).toEqual([]);
+    expect(tab.createdAt).toBeDefined();
+
+    // Verify it was persisted
+    const window = await getWindow(1);
+    expect(window.tabs).toHaveLength(1);
+    expect(window.tabs[0].id).toBe(tab.id);
+  });
+
+  test("updateTab persists changes", async () => {
+    await ensureState();
+
+    const tab = await createTab(1);
+
+    // Update prompt only
+    const updated1 = await updateTab(1, tab.id, { prompt: "new prompt" });
+    expect(updated1.prompt).toBe("new prompt");
+    expect(updated1.selectedFiles).toEqual([]);
+
+    // Update selectedFiles only
+    const updated2 = await updateTab(1, tab.id, {
+      selectedFiles: ["a.ts", "b.ts"],
+    });
+    expect(updated2.prompt).toBe("new prompt");
+    expect(updated2.selectedFiles).toEqual(["a.ts", "b.ts"]);
+
+    // Verify persistence
+    const reloadedTab = await getTab(1, tab.id);
+    expect(reloadedTab.prompt).toBe("new prompt");
+    expect(reloadedTab.selectedFiles).toEqual(["a.ts", "b.ts"]);
+  });
+
+  test("createTab throws for non-existent window", async () => {
+    await ensureState();
+
+    await expect(createTab(999)).rejects.toThrow("Window 999 not found");
+  });
+
+  test("updateTab throws for non-existent tab", async () => {
+    await ensureState();
+
+    await expect(updateTab(1, "fake-id", { prompt: "test" })).rejects.toThrow(
+      "Tab fake-id not found"
+    );
+  });
+
+  test("deleteTab removes tab from window", async () => {
+    await ensureState();
+
+    const tab = await createTab(1);
+    const window1 = await getWindow(1);
+    expect(window1.tabs).toHaveLength(1);
+
+    await deleteTab(1, tab.id);
+
+    const window2 = await getWindow(1);
+    expect(window2.tabs).toHaveLength(0);
+  });
+
+  test("createWindow adds new window with incremented ID", async () => {
+    await ensureState();
+
+    const newWindow = await createWindow(["/path/to/project"]);
+
+    expect(newWindow.id).toBe(2);
+    expect(newWindow.rootFolderPaths).toEqual(["/path/to/project"]);
+    expect(newWindow.tabs).toHaveLength(0);
+
+    const windows = await getWindows();
+    expect(windows).toHaveLength(2);
+  });
+
+  test("getWindows returns all windows", async () => {
+    await ensureState();
+
+    const windows = await getWindows();
+    expect(windows).toHaveLength(1);
+    expect(windows[0].id).toBe(1);
+  });
+});

package/src/state.ts

@@ -0,0 +1,282 @@
+/**
+ * State management layer for wdyt
+ *
+ * Persists windows, tabs, and selections to disk.
+ * State is stored in ~/.wdyt/state.json (or XDG_DATA_HOME/wdyt/state.json)
+ */
+
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync, existsSync, renameSync } from "fs";
+import type { StateFile, Window, Tab, TabUpdate } from "./types";
+
+const STATE_VERSION = 1;
+
+/**
+ * Get the data directory path
+ * Uses XDG_DATA_HOME if set, otherwise falls back to ~/.wdyt
+ */
+function getDataDir(): string {
+  const xdgDataHome = process.env.XDG_DATA_HOME;
+  if (xdgDataHome) {
+    return join(xdgDataHome, "wdyt");
+  }
+  return join(homedir(), ".wdyt");
+}
+
+/**
+ * Get the state file path
+ */
+function getStatePath(): string {
+  return join(getDataDir(), "state.json");
+}
+
+/**
+ * Create default state with a single window
+ */
+function createDefaultState(): StateFile {
+  return {
+    version: STATE_VERSION,
+    windows: [
+      {
+        id: 1,
+        rootFolderPaths: [],
+        tabs: [],
+      },
+    ],
+  };
+}
+
+/**
+ * Generate a UUID v4 for tab IDs
+ */
+function generateUUID(): string {
+  return crypto.randomUUID();
+}
+
+/**
+ * Load state from disk, creating default if not exists
+ */
+export async function loadState(): Promise<StateFile> {
+  const statePath = getStatePath();
+
+  // Check if file exists first
+  if (!existsSync(statePath)) {
+    return createDefaultState();
+  }
+
+  try {
+    const file = Bun.file(statePath);
+    const content = await file.text();
+    const state = JSON.parse(content) as StateFile;
+
+    // Validate basic structure
+    if (!state || typeof state !== "object" || !Array.isArray(state.windows)) {
+      throw new Error("Invalid state structure");
+    }
+
+    // Validate and migrate if needed
+    if (!state.version || state.version < STATE_VERSION) {
+      // Future: handle migrations
+      state.version = STATE_VERSION;
+    }
+
+    return state;
+  } catch (error) {
+    // State file exists but is corrupted - backup and start fresh
+    const backupPath = `${statePath}.backup.${Date.now()}`;
+    try {
+      renameSync(statePath, backupPath);
+      console.error(`Warning: State file corrupted, backed up to ${backupPath}`);
+    } catch {
+      console.error(`Warning: Could not backup corrupted state file: ${error}`);
+    }
+    return createDefaultState();
+  }
+}
+
+/**
+ * Save state to disk
+ */
+export async function saveState(state: StateFile): Promise<void> {
+  const statePath = getStatePath();
+  const dataDir = getDataDir();
+
+  // Ensure directory exists using proper mkdir
+  mkdirSync(dataDir, { recursive: true });
+
+  // Write state file atomically
+  const content = JSON.stringify(state, null, 2);
+  await Bun.write(statePath, content);
+}
+
+/**
+ * Get a window by ID
+ * @throws Error if window not found
+ */
+export async function getWindow(id: number): Promise<Window> {
+  const state = await loadState();
+  const window = state.windows.find((w) => w.id === id);
+
+  if (!window) {
+    throw new Error(`Window ${id} not found`);
+  }
+
+  return window;
+}
+
+/**
+ * Get all windows
+ */
+export async function getWindows(): Promise<Window[]> {
+  const state = await loadState();
+  return state.windows;
+}
+
+/**
+ * Create a new tab in a window
+ * @returns The newly created tab
+ */
+export async function createTab(windowId: number): Promise<Tab> {
+  const state = await loadState();
+  const window = state.windows.find((w) => w.id === windowId);
+
+  if (!window) {
+    throw new Error(`Window ${windowId} not found`);
+  }
+
+  const tab: Tab = {
+    id: generateUUID(),
+    prompt: "",
+    selectedFiles: [],
+    createdAt: new Date().toISOString(),
+  };
+
+  window.tabs.push(tab);
+  await saveState(state);
+
+  return tab;
+}
+
+/**
+ * Get a tab by ID from a window
+ * @throws Error if window or tab not found
+ */
+export async function getTab(windowId: number, tabId: string): Promise<Tab> {
+  const window = await getWindow(windowId);
+  const tab = window.tabs.find((t) => t.id === tabId);
+
+  if (!tab) {
+    throw new Error(`Tab ${tabId} not found in window ${windowId}`);
+  }
+
+  return tab;
+}
+
+/**
+ * Update a tab in a window
+ * @returns The updated tab
+ */
+export async function updateTab(
+  windowId: number,
+  tabId: string,
+  update: TabUpdate
+): Promise<Tab> {
+  const state = await loadState();
+  const window = state.windows.find((w) => w.id === windowId);
+
+  if (!window) {
+    throw new Error(`Window ${windowId} not found`);
+  }
+
+  const tabIndex = window.tabs.findIndex((t) => t.id === tabId);
+  if (tabIndex === -1) {
+    throw new Error(`Tab ${tabId} not found in window ${windowId}`);
+  }
+
+  // Merge update into existing tab
+  const tab = window.tabs[tabIndex];
+  if (update.prompt !== undefined) {
+    tab.prompt = update.prompt;
+  }
+  if (update.selectedFiles !== undefined) {
+    tab.selectedFiles = update.selectedFiles;
+  }
+
+  await saveState(state);
+
+  return tab;
+}
+
+/**
+ * Delete a tab from a window
+ */
+export async function deleteTab(windowId: number, tabId: string): Promise<void> {
+  const state = await loadState();
+  const window = state.windows.find((w) => w.id === windowId);
+
+  if (!window) {
+    throw new Error(`Window ${windowId} not found`);
+  }
+
+  const tabIndex = window.tabs.findIndex((t) => t.id === tabId);
+  if (tabIndex === -1) {
+    throw new Error(`Tab ${tabId} not found in window ${windowId}`);
+  }
+
+  window.tabs.splice(tabIndex, 1);
+  await saveState(state);
+}
+
+/**
+ * Create a new window
+ * @returns The newly created window
+ */
+export async function createWindow(
+  rootFolderPaths: string[] = []
+): Promise<Window> {
+  const state = await loadState();
+
+  // Find the next available ID
+  const maxId = state.windows.reduce((max, w) => Math.max(max, w.id), 0);
+
+  const window: Window = {
+    id: maxId + 1,
+    rootFolderPaths,
+    tabs: [],
+  };
+
+  state.windows.push(window);
+  await saveState(state);
+
+  return window;
+}
+
+/**
+ * Update window root folder paths
+ */
+export async function updateWindowPaths(
+  windowId: number,
+  rootFolderPaths: string[]
+): Promise<Window> {
+  const state = await loadState();
+  const window = state.windows.find((w) => w.id === windowId);
+
+  if (!window) {
+    throw new Error(`Window ${windowId} not found`);
+  }
+
+  window.rootFolderPaths = rootFolderPaths;
+  await saveState(state);
+
+  return window;
+}
+
+/**
+ * Ensure state file exists, creating if necessary
+ * Called on startup to initialize state
+ */
+export async function ensureState(): Promise<void> {
+  const state = await loadState();
+  await saveState(state);
+}