wdyt 0.1.0

package/src/commands/chat.ts

@@ -0,0 +1,306 @@
+/**
+ * Chat commands - chat_send
+ *
+ * Commands:
+ * - call chat_send {json}: Export context (prompt + files) to XML
+ *
+ * Compatible with flowctl.py:
+ * - Line 3975: call chat_send {payload}
+ * - Line 272-289: build_chat_payload structure
+ *
+ * Payload structure:
+ * {
+ *   "message": string,      // The prompt/message
+ *   "mode": string,         // Mode (e.g., "review")
+ *   "new_chat"?: boolean,   // Start new chat
+ *   "chat_name"?: string,   // Optional name
+ *   "selected_paths"?: string[] // Files to include
+ * }
+ */
+
+import { existsSync, readFileSync, mkdirSync } from "fs";
+import { join, dirname, basename } from "path";
+import { homedir } from "os";
+import { getTab, getWindow } from "../state";
+
+/**
+ * Chat send payload structure (from flowctl.py build_chat_payload)
+ */
+export interface ChatSendPayload {
+  message: string;
+  mode: string;
+  new_chat?: boolean;
+  chat_name?: string;
+  selected_paths?: string[];
+}
+
+/**
+ * Chat send response
+ */
+export interface ChatSendResponse {
+  id: string;
+  path: string;
+  review?: string;
+}
+
+/**
+ * Get the chats directory path
+ */
+function getChatsDir(): string {
+  const xdgDataHome = process.env.XDG_DATA_HOME;
+  if (xdgDataHome) {
+    return join(xdgDataHome, "wdyt", "chats");
+  }
+  return join(homedir(), ".wdyt", "chats");
+}
+
+/**
+ * Escape XML special characters
+ */
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+/**
+ * Generate a UUID v4
+ */
+function generateUUID(): string {
+  return crypto.randomUUID();
+}
+
+/**
+ * Read file content safely
+ */
+function readFileSafe(path: string): { success: boolean; content?: string; error?: string } {
+  try {
+    if (!existsSync(path)) {
+      return { success: false, error: `File not found: ${path}` };
+    }
+    const content = readFileSync(path, "utf-8");
+    return { success: true, content };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: message };
+  }
+}
+
+/**
+ * Build XML content with prompt and files
+ *
+ * Format:
+ * <context>
+ *   <prompt>...</prompt>
+ *   <files>
+ *     <file path="...">content</file>
+ *     ...
+ *   </files>
+ *   <directory_structure>...</directory_structure>
+ * </context>
+ */
+function buildContextXml(
+  prompt: string,
+  files: Array<{ path: string; content: string }>,
+  directoryStructure: string
+): string {
+  const lines: string[] = [];
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push("<context>");
+
+  // Add prompt
+  lines.push("  <prompt>");
+  lines.push(`    ${escapeXml(prompt)}`);
+  lines.push("  </prompt>");
+
+  // Add files
+  if (files.length > 0) {
+    lines.push("  <files>");
+    for (const file of files) {
+      lines.push(`    <file path="${escapeXml(file.path)}">`);
+      lines.push(escapeXml(file.content));
+      lines.push("    </file>");
+    }
+    lines.push("  </files>");
+  }
+
+  // Add directory structure
+  if (directoryStructure) {
+    lines.push("  <directory_structure>");
+    lines.push(`    ${escapeXml(directoryStructure)}`);
+    lines.push("  </directory_structure>");
+  }
+
+  lines.push("</context>");
+  return lines.join("\n");
+}
+
+/**
+ * Build directory structure string from file paths
+ */
+function buildDirectoryStructure(paths: string[]): string {
+  if (paths.length === 0) return "";
+
+  // Group files by directory
+  const dirs = new Map<string, string[]>();
+
+  for (const path of paths) {
+    const dir = dirname(path);
+    const file = basename(path);
+    if (!dirs.has(dir)) {
+      dirs.set(dir, []);
+    }
+    dirs.get(dir)!.push(file);
+  }
+
+  // Build tree-like structure
+  const lines: string[] = [];
+  const sortedDirs = Array.from(dirs.keys()).sort();
+
+  for (const dir of sortedDirs) {
+    lines.push(`${dir}/`);
+    const files = dirs.get(dir)!.sort();
+    for (const file of files) {
+      lines.push(`  ${file}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Chat send command
+ *
+ * Exports context (prompt + selected files) to an XML file
+ *
+ * @param windowId - Window ID
+ * @param tabId - Tab ID
+ * @param payloadJson - JSON string with chat_send payload
+ * @returns Chat ID in format "Chat: `<uuid>`"
+ */
+export async function chatSendCommand(
+  windowId: number,
+  tabId: string,
+  payloadJson: string
+): Promise<{
+  success: boolean;
+  data?: ChatSendResponse;
+  output?: string;
+  error?: string;
+}> {
+  try {
+    // Parse the JSON payload
+    const payload = JSON.parse(payloadJson) as ChatSendPayload;
+
+    // Get tab state for prompt and selected files
+    const tab = await getTab(windowId, tabId);
+    const window = await getWindow(windowId);
+
+    // Use message from payload as the prompt, or fall back to tab's prompt
+    const prompt = payload.message || tab.prompt;
+
+    // Determine which files to include
+    // Use selected_paths from payload if provided, otherwise use tab's selectedFiles
+    let filePaths = payload.selected_paths || tab.selectedFiles;
+
+    // Resolve relative paths against window root
+    const rootPath = window.rootFolderPaths[0] || process.cwd();
+    filePaths = filePaths.map((p) => {
+      if (p.startsWith("/")) return p;
+      return join(rootPath, p);
+    });
+
+    // Read file contents
+    const files: Array<{ path: string; content: string }> = [];
+    const errors: string[] = [];
+
+    for (const filePath of filePaths) {
+      const result = readFileSafe(filePath);
+      if (result.success && result.content !== undefined) {
+        files.push({ path: filePath, content: result.content });
+      } else {
+        // Handle missing files gracefully - just skip them and log
+        errors.push(`Skipped: ${filePath} (${result.error})`);
+      }
+    }
+
+    // Log any skipped files to stderr so users are aware
+    if (errors.length > 0) {
+      console.error(`Warning: ${errors.length} file(s) skipped:`);
+      for (const err of errors) {
+        console.error(`  ${err}`);
+      }
+    }
+
+    // Build directory structure from the files we successfully read
+    const directoryStructure = buildDirectoryStructure(files.map((f) => f.path));
+
+    // Build the XML content
+    const xmlContent = buildContextXml(prompt, files, directoryStructure);
+
+    // Generate chat ID
+    const chatId = generateUUID();
+
+    // Ensure chats directory exists
+    const chatsDir = getChatsDir();
+    mkdirSync(chatsDir, { recursive: true });
+
+    // Write the XML file
+    const chatPath = join(chatsDir, `${chatId}.xml`);
+    await Bun.write(chatPath, xmlContent);
+
+    // Check if this is a review request - if so, output subagent spawn instruction
+    const isReviewMode = payload.mode === "review";
+
+    if (isReviewMode) {
+      // Build the review output that instructs Claude Code to spawn quality-auditor
+      const reviewOutput = `Chat: \`${chatId}\`
+
+[CLAUDE_CODE_REVIEW_REQUEST]
+The context has been exported to: ${chatPath}
+
+To complete this review, spawn a quality-auditor subagent with the Task tool:
+
+Task(subagent_type="flow-next:quality-auditor", prompt="""
+Review the code changes in this context file: ${chatPath}
+
+Read the file, analyze the code for:
+- Correctness - Logic errors, bugs
+- Security - Injection, auth gaps
+- Simplicity - Over-engineering
+- Edge cases - Failure modes
+
+Provide findings by severity (Critical > Major > Minor).
+
+REQUIRED: End with exactly one verdict tag:
+<verdict>SHIP</verdict> - Code is production-ready
+<verdict>NEEDS_WORK</verdict> - Issues must be fixed first
+""")
+
+The subagent will return the review findings and verdict.
+[/CLAUDE_CODE_REVIEW_REQUEST]`;
+
+      return {
+        success: true,
+        data: { id: chatId, path: chatPath },
+        output: reviewOutput,
+      };
+    }
+
+    // Return in the expected format: Chat: `<uuid>`
+    return {
+      success: true,
+      data: { id: chatId, path: chatPath },
+      output: `Chat: \`${chatId}\``,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to send chat: ${message}`,
+    };
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,222 @@
+/**
+ * Init command - set up wdyt
+ *
+ * Usage:
+ *   bunx wdyt init              # Interactive setup
+ *   bunx wdyt init --rp-alias   # Also create rp-cli alias (skip prompt)
+ *   bunx wdyt init --no-alias   # Skip rp-cli alias (no prompt)
+ *   bunx wdyt init --global     # Install globally
+ */
+
+import { mkdirSync, existsSync, symlinkSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { $ } from "bun";
+import * as readline from "readline";
+
+interface InitOptions {
+  rpAlias?: boolean;
+  noAlias?: boolean;
+  global?: boolean;
+}
+
+/**
+ * Prompt user for yes/no input
+ */
+async function promptYesNo(question: string, defaultYes = false): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const hint = defaultYes ? "[Y/n]" : "[y/N]";
+
+  return new Promise((resolve) => {
+    rl.question(`${question} ${hint} `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "") {
+        resolve(defaultYes);
+      } else {
+        resolve(trimmed === "y" || trimmed === "yes");
+      }
+    });
+  });
+}
+
+/**
+ * Get the data directory path
+ */
+function getDataDir(): string {
+  const xdgDataHome = process.env.XDG_DATA_HOME;
+  if (xdgDataHome) {
+    return join(xdgDataHome, "wdyt");
+  }
+  return join(homedir(), ".wdyt");
+}
+
+/**
+ * Get the bin directory for user installs
+ */
+function getUserBinDir(): string {
+  return join(homedir(), ".local", "bin");
+}
+
+/**
+ * Check if a command exists in PATH
+ */
+async function commandExists(cmd: string): Promise<boolean> {
+  try {
+    await $`which ${cmd}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Run the init command
+ */
+export async function initCommand(options: InitOptions): Promise<{
+  success: boolean;
+  output?: string;
+  error?: string;
+}> {
+  const lines: string[] = [];
+  const dataDir = getDataDir();
+  const binDir = getUserBinDir();
+
+  lines.push("🔍 wdyt - Code review context builder for LLMs");
+  lines.push("");
+
+  // 1. Create data directory
+  lines.push("Setting up data directory...");
+  try {
+    mkdirSync(dataDir, { recursive: true });
+    mkdirSync(join(dataDir, "chats"), { recursive: true });
+    lines.push(`  ✓ Created ${dataDir}`);
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to create data directory: ${error}`,
+    };
+  }
+
+  // 2. Check if already installed globally
+  const alreadyInstalled = await commandExists("wdyt");
+
+  if (alreadyInstalled && !options.global) {
+    lines.push("");
+    lines.push("✓ wdyt is already available in PATH");
+  }
+
+  // 3. Global install if requested
+  if (options.global) {
+    lines.push("");
+    lines.push("Installing globally...");
+
+    try {
+      // Ensure bin directory exists
+      mkdirSync(binDir, { recursive: true });
+
+      // Get the path to the current executable or script
+      const currentExe = process.argv[1];
+      const targetPath = join(binDir, "wdyt");
+
+      // Build the binary
+      lines.push("  Building binary...");
+      const srcDir = join(import.meta.dir, "..");
+      await $`bun build ${join(srcDir, "cli.ts")} --compile --outfile ${targetPath}`.quiet();
+
+      lines.push(`  ✓ Installed to ${targetPath}`);
+
+      // Check if ~/.local/bin is in PATH
+      const path = process.env.PATH || "";
+      if (!path.includes(binDir)) {
+        lines.push("");
+        lines.push(`⚠️  Add ${binDir} to your PATH:`);
+        lines.push(`   echo 'export PATH="${binDir}:$PATH"' >> ~/.bashrc`);
+      }
+    } catch (error) {
+      lines.push(`  ✗ Failed to install: ${error}`);
+    }
+  }
+
+  // 4. Determine if we should create rp-cli alias
+  let shouldCreateAlias = options.rpAlias;
+
+  // If neither --rp-alias nor --no-alias was specified, prompt the user
+  if (!options.rpAlias && !options.noAlias) {
+    lines.push("");
+    console.log(lines.join("\n"));
+    lines.length = 0; // Clear lines since we just printed them
+
+    console.log("");
+    console.log("The rp-cli alias enables compatibility with flowctl/flow-next.");
+    shouldCreateAlias = await promptYesNo("Create rp-cli alias?", true);
+  }
+
+  // Create rp-cli alias if requested or confirmed
+  if (shouldCreateAlias) {
+    lines.push("");
+    lines.push("Creating rp-cli alias (for flowctl compatibility)...");
+
+    const rpCliPath = join(binDir, "rp-cli");
+    const secondOpinionPath = join(binDir, "wdyt");
+
+    try {
+      // Ensure bin directory exists
+      mkdirSync(binDir, { recursive: true });
+
+      // Remove existing symlink if present
+      if (existsSync(rpCliPath)) {
+        unlinkSync(rpCliPath);
+      }
+
+      // Check if wdyt binary exists
+      if (existsSync(secondOpinionPath)) {
+        symlinkSync(secondOpinionPath, rpCliPath);
+        lines.push(`  ✓ Created symlink: rp-cli -> wdyt`);
+      } else {
+        // If not installed globally, create the binary first
+        lines.push("  Building rp-cli binary...");
+        const srcDir = join(import.meta.dir, "..");
+        await $`bun build ${join(srcDir, "cli.ts")} --compile --outfile ${rpCliPath}`.quiet();
+        lines.push(`  ✓ Installed rp-cli to ${rpCliPath}`);
+      }
+    } catch (error) {
+      lines.push(`  ✗ Failed to create alias: ${error}`);
+    }
+  }
+
+  // 5. Summary
+  lines.push("");
+  lines.push("Setup complete! 🎉");
+  lines.push("");
+  lines.push("Usage:");
+  lines.push("  wdyt -e 'windows'              # List windows");
+  lines.push("  wdyt -w 1 -e 'builder {}'      # Create tab");
+  lines.push("  wdyt -w 1 -t <id> -e 'select add file.ts'");
+  lines.push("");
+
+  if (!shouldCreateAlias && !options.noAlias) {
+    lines.push("Tip: For flowctl/flow-next compatibility, run:");
+    lines.push("  bunx wdyt init --rp-alias");
+  }
+
+  return {
+    success: true,
+    output: lines.join("\n"),
+  };
+}
+
+/**
+ * Parse init command arguments
+ */
+export function parseInitArgs(args: string[]): InitOptions {
+  return {
+    rpAlias: args.includes("--rp-alias") || args.includes("--rp"),
+    noAlias: args.includes("--no-alias") || args.includes("--no-rp"),
+    global: args.includes("--global") || args.includes("-g"),
+  };
+}

package/src/commands/prompt.ts

@@ -0,0 +1,188 @@
+/**
+ * Prompt commands - get, set (via call), export
+ *
+ * Commands:
+ * - prompt get: returns current prompt text
+ * - call prompt {"op":"set","text":"..."}: sets prompt text
+ * - prompt export <file>: writes prompt to file
+ *
+ * Compatible with flowctl.py:
+ * - cmd_rp_prompt_get (line 3924): prompt get
+ * - cmd_rp_prompt_set (line 3930): call prompt {"op":"set","text":"..."}
+ * - cmd_rp_prompt_export (line 3986): prompt export <file>
+ */
+
+import { resolve } from "path";
+import { homedir } from "os";
+import { getTab, updateTab } from "../state";
+
+/**
+ * Validate that a file path is safe for writing
+ * Prevents path traversal attacks by ensuring path is within allowed directories
+ */
+function isPathSafe(filePath: string): boolean {
+  const resolved = resolve(filePath);
+  const home = homedir();
+  const cwd = process.cwd();
+  const tmp = "/tmp";
+
+  // Allow paths within home directory, current working directory, or /tmp
+  return (
+    resolved.startsWith(home) ||
+    resolved.startsWith(cwd) ||
+    resolved.startsWith(tmp)
+  );
+}
+
+/**
+ * Prompt get response
+ */
+export interface PromptGetResponse {
+  prompt: string;
+}
+
+/**
+ * Prompt set payload
+ */
+export interface PromptSetPayload {
+  op: "set";
+  text: string;
+}
+
+/**
+ * Get prompt text for a tab
+ *
+ * @param windowId - Window ID
+ * @param tabId - Tab ID
+ * @returns Current prompt text (empty string if none)
+ */
+export async function promptGetCommand(
+  windowId: number,
+  tabId: string
+): Promise<{
+  success: boolean;
+  data?: PromptGetResponse;
+  output?: string;
+  error?: string;
+}> {
+  try {
+    const tab = await getTab(windowId, tabId);
+
+    // Return just the prompt text, no JSON wrapping when not --raw-json
+    return {
+      success: true,
+      data: { prompt: tab.prompt },
+      output: tab.prompt,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to get prompt: ${message}`,
+    };
+  }
+}
+
+/**
+ * Set prompt text for a tab
+ *
+ * Called as: call prompt {"op":"set","text":"..."}
+ *
+ * @param windowId - Window ID
+ * @param tabId - Tab ID
+ * @param payload - JSON payload with op and text
+ * @returns Success status
+ */
+export async function promptSetCommand(
+  windowId: number,
+  tabId: string,
+  payload: string
+): Promise<{
+  success: boolean;
+  data?: { success: boolean };
+  output?: string;
+  error?: string;
+}> {
+  try {
+    // Parse the JSON payload
+    const data = JSON.parse(payload) as PromptSetPayload;
+
+    if (data.op !== "set") {
+      return {
+        success: false,
+        error: `Unknown prompt operation: ${data.op}`,
+      };
+    }
+
+    if (typeof data.text !== "string") {
+      return {
+        success: false,
+        error: "Prompt text must be a string",
+      };
+    }
+
+    // Update the tab's prompt
+    await updateTab(windowId, tabId, { prompt: data.text });
+
+    return {
+      success: true,
+      data: { success: true },
+      output: "OK",
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to set prompt: ${message}`,
+    };
+  }
+}
+
+/**
+ * Export prompt to a file
+ *
+ * Called as: prompt export <file>
+ *
+ * @param windowId - Window ID
+ * @param tabId - Tab ID
+ * @param filePath - Path to write prompt to
+ * @returns Success status
+ */
+export async function promptExportCommand(
+  windowId: number,
+  tabId: string,
+  filePath: string
+): Promise<{
+  success: boolean;
+  data?: { path: string };
+  output?: string;
+  error?: string;
+}> {
+  try {
+    // Validate path to prevent path traversal attacks
+    if (!isPathSafe(filePath)) {
+      return {
+        success: false,
+        error: `Path not allowed: ${filePath}. Must be within home directory, current directory, or /tmp`,
+      };
+    }
+
+    const tab = await getTab(windowId, tabId);
+    const resolvedPath = resolve(filePath);
+
+    // Write prompt to file
+    await Bun.write(resolvedPath, tab.prompt);
+
+    return {
+      success: true,
+      data: { path: resolvedPath },
+      output: `Exported to ${resolvedPath}`,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to export prompt: ${message}`,
+    };
+  }
+}