wdyt 0.1.10 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdyt",
-  "version": "0.1.10",
+  "version": "0.1.13",
   "type": "module",
   "description": "Code review context builder for LLMs - what do you think?",
   "license": "MIT",
@@ -45,7 +45,8 @@
     "prepublishOnly": "bun test"
   },
   "dependencies": {
-    "citty": "^0.1.6"
+    "citty": "^0.1.6",
+    "shell-quote": "^1.8.3"
   },
   "devDependencies": {
     "@types/bun": "^1.1.0"

package/src/cli.ts

@@ -26,34 +26,33 @@ import {
 import { selectGetCommand, selectAddCommand } from "./commands/select";
 import { chatSendCommand } from "./commands/chat";
 import { initCommand, parseInitArgs } from "./commands/init";
+import { parseExpression } from "./parseExpression";
 
 /**
- * Parse and execute an expression
+ * Execute a parsed expression
  */
 async function executeExpression(
   expression: string,
   flags: CLIFlags
 ): Promise<{ success: boolean; data?: unknown; output?: string; error?: string }> {
-  const expr = expression.trim();
+  const parsed = parseExpression(expression);
 
-  // Parse command and arguments
-  // Expressions can be: "windows", "builder {json}", "prompt get", etc.
-  const match = expr.match(/^(\w+)(?:\s+(.*))?$/);
-  if (!match) {
+  if (!parsed.command) {
     return { success: false, error: `Invalid expression: ${expression}` };
   }
 
-  const [, command, args] = match;
-
-  switch (command) {
+  switch (parsed.command) {
     case "windows":
       return await windowsCommand();
 
-    case "builder":
+    case "builder": {
       if (!flags.window) {
         return { success: false, error: "builder requires -w <window>" };
       }
-      return await builderCommand(flags.window, args);
+      // Pass the first positional (summary) and flags
+      const summary = parsed.positional[0];
+      return await builderCommand(flags.window, summary, parsed.flags);
+    }
 
     case "prompt": {
       if (!flags.window || !flags.tab) {
@@ -63,19 +62,21 @@ async function executeExpression(
         };
       }
 
-      // Parse subcommand: "get", "export <file>"
-      const promptArgs = args?.trim();
-      if (!promptArgs || promptArgs === "get") {
+      const subcommand = parsed.subcommand || "get";
+
+      if (subcommand === "get") {
         return await promptGetCommand(flags.window, flags.tab);
       }
 
-      if (promptArgs.startsWith("export ")) {
-        // Extract file path - may be quoted with shlex.quote
-        const filePath = promptArgs.slice(7).trim().replace(/^'|'$/g, "");
+      if (subcommand === "export") {
+        const filePath = parsed.positional[0];
+        if (!filePath) {
+          return { success: false, error: "prompt export requires a file path" };
+        }
         return await promptExportCommand(flags.window, flags.tab, filePath);
       }
 
-      return { success: false, error: `Unknown prompt subcommand: ${promptArgs}` };
+      return { success: false, error: `Unknown prompt subcommand: ${subcommand}` };
     }
 
     case "select": {
@@ -86,49 +87,55 @@ async function executeExpression(
         };
       }
 
-      // Parse subcommand: "get", "add <paths>"
-      const selectArgs = args?.trim();
-      if (!selectArgs || selectArgs === "get") {
+      const subcommand = parsed.subcommand || "get";
+
+      if (subcommand === "get") {
         return await selectGetCommand(flags.window, flags.tab);
       }
 
-      if (selectArgs.startsWith("add ")) {
-        const pathsArg = selectArgs.slice(4).trim();
-        return await selectAddCommand(flags.window, flags.tab, pathsArg);
+      if (subcommand === "add") {
+        // All remaining positionals are paths
+        const paths = parsed.positional.join(" ");
+        if (!paths) {
+          return { success: false, error: "select add requires file paths" };
+        }
+        return await selectAddCommand(flags.window, flags.tab, paths);
       }
 
-      return { success: false, error: `Unknown select subcommand: ${selectArgs}` };
+      return { success: false, error: `Unknown select subcommand: ${subcommand}` };
     }
 
     case "call": {
       // Handle "call prompt {json}" and "call chat_send {json}"
-      if (args?.startsWith("prompt ")) {
+      const callTarget = parsed.subcommand || parsed.positional[0];
+
+      if (callTarget === "prompt") {
         if (!flags.window || !flags.tab) {
           return {
             success: false,
             error: "prompt requires -w <window> -t <tab>",
           };
         }
-        const payload = args.slice(7).trim();
+        const payload = parsed.positional.slice(1).join(" ") || "{}";
         return await promptSetCommand(flags.window, flags.tab, payload);
       }
 
-      if (args?.startsWith("chat_send")) {
+      if (callTarget === "chat_send") {
         if (!flags.window || !flags.tab) {
           return {
             success: false,
             error: "chat_send requires -w <window> -t <tab>",
           };
         }
-        // Extract payload - "chat_send {json}" or "chat_send"
-        const payload = args.slice(9).trim() || "{}";
+        const payload = parsed.positional.slice(1).join(" ") || "{}";
         return await chatSendCommand(flags.window, flags.tab, payload);
       }
-      return { success: false, error: `Unknown call: ${args}` };
+
+      return { success: false, error: `Unknown call: ${callTarget}` };
     }
 
     default:
-      return { success: false, error: `Unknown command: ${command}` };
+      return { success: false, error: `Unknown command: ${parsed.command}` };
   }
 }
 

package/src/commands/builder.ts

@@ -1,14 +1,12 @@
 /**
  * Builder command - create a new tab
  *
- * Parses JSON arg: {summary: string}
  * Returns: Tab: <uuid>
  * Compatible with flowctl.py parsing at line 255-259:
  *   match = re.search(r"Tab:\s*([A-Za-z0-9-]+)", output)
  */
 
 import { createTab, getWindow } from "../state";
-import type { BuilderConfig } from "../types";
 
 /**
  * Builder command response
@@ -18,43 +16,11 @@ export interface BuilderResponse {
 }
 
 /**
- * Parse builder JSON argument
- * Handles formats:
- * - {} or {"summary": "..."}  (JSON object)
- * - "summary text"            (JSON string - flowctl format)
- * - "summary" --response-type review  (flowctl with flags - flags ignored)
- *
- * @param args - JSON string or object
- * @returns Parsed BuilderConfig or null if invalid
+ * Builder flags from expression parser
  */
-function parseBuilderArgs(args?: string): BuilderConfig | null {
-  if (!args) {
-    // Empty config is valid - just creates a blank tab
-    return {};
-  }
-
-  let jsonPart = args.trim();
-
-  // Strip --response-type flag if present (not supported, but don't fail)
-  // flowctl passes: "summary" --response-type review
-  const responseTypeMatch = jsonPart.match(/^(.+?)\s+--response-type\s+\w+$/);
-  if (responseTypeMatch) {
-    jsonPart = responseTypeMatch[1].trim();
-  }
-
-  try {
-    const parsed = JSON.parse(jsonPart);
-
-    // If parsed is a string, convert to BuilderConfig with summary
-    if (typeof parsed === "string") {
-      return { summary: parsed };
-    }
-
-    // Otherwise expect an object
-    return parsed as BuilderConfig;
-  } catch {
-    return null;
-  }
+export interface BuilderFlags {
+  "response-type"?: string;
+  [key: string]: string | boolean | undefined;
 }
 
 /**
@@ -62,12 +28,14 @@ function parseBuilderArgs(args?: string): BuilderConfig | null {
  * Creates a new tab in the specified window
  *
  * @param windowId - The window ID to create the tab in
- * @param args - JSON string with optional summary, path, name
+ * @param summary - Optional summary/description for the tab
+ * @param flags - Optional flags (e.g., --response-type)
  * @returns Tab: <uuid> on success
  */
 export async function builderCommand(
   windowId: number,
-  args?: string
+  summary?: string,
+  flags?: BuilderFlags
 ): Promise<{
   success: boolean;
   data?: BuilderResponse;
@@ -78,18 +46,13 @@ export async function builderCommand(
     // Verify window exists
     await getWindow(windowId);
 
-    // Parse builder config (optional)
-    const config = parseBuilderArgs(args);
-    if (config === null) {
-      return {
-        success: false,
-        error: `Invalid builder config JSON: ${args}`,
-      };
-    }
-
     // Create the tab
     const tab = await createTab(windowId);
 
+    // Note: summary and flags like --response-type are accepted but
+    // not used in this minimal implementation. The real RepoPrompt
+    // uses them for its GUI features.
+
     // Return in the format flowctl.py expects: Tab: <uuid>
     return {
       success: true,

package/src/parseExpression.ts

@@ -0,0 +1,95 @@
+/**
+ * Expression parser for wdyt CLI
+ *
+ * Properly parses shell-like expressions into command + args + flags
+ * Example: 'builder "summary text" --response-type review'
+ * -> { command: "builder", positional: ["summary text"], flags: { responseType: "review" } }
+ */
+
+import { parseArgs } from "node:util";
+import { parse as shellParse } from "shell-quote";
+
+/**
+ * Tokenize a shell-like string
+ *
+ * Uses shell-quote for most parsing, but preserves JSON objects literally
+ * since shell-quote would strip internal quotes from JSON.
+ */
+export function tokenize(input: string): string[] {
+  // Check if input contains a JSON object (starts with {)
+  const jsonStart = input.indexOf("{");
+
+  if (jsonStart !== -1) {
+    // Split into pre-JSON and JSON parts
+    const preJson = input.slice(0, jsonStart).trim();
+    const jsonPart = input.slice(jsonStart);
+
+    // Parse the pre-JSON part with shell-quote
+    const preTokens = preJson
+      ? shellParse(preJson).filter((t): t is string => typeof t === "string")
+      : [];
+
+    // Keep the JSON part as-is
+    return [...preTokens, jsonPart];
+  }
+
+  // No JSON, use shell-quote for everything
+  const parsed = shellParse(input);
+  return parsed.filter((t): t is string => typeof t === "string");
+}
+
+/**
+ * Parsed expression result
+ */
+export interface ParsedExpression {
+  command: string;
+  subcommand?: string;
+  positional: string[];
+  flags: Record<string, string | boolean>;
+}
+
+/**
+ * Parse an expression string into structured parts
+ */
+export function parseExpression(expression: string): ParsedExpression {
+  const tokens = tokenize(expression.trim());
+
+  if (tokens.length === 0) {
+    return { command: "", positional: [], flags: {} };
+  }
+
+  const command = tokens[0];
+  const rest = tokens.slice(1);
+
+  // Use parseArgs for the remaining tokens
+  const { values, positionals } = parseArgs({
+    args: rest,
+    options: {
+      "response-type": { type: "string" },
+      "new-chat": { type: "boolean" },
+      "chat-name": { type: "string" },
+      "chat-id": { type: "string" },
+    },
+    allowPositionals: true,
+    strict: false, // Don't error on unknown flags
+  });
+
+  // Determine subcommand for commands that have them
+  let subcommand: string | undefined;
+  let finalPositional = positionals;
+
+  if (command === "prompt" || command === "select") {
+    // First positional is the subcommand (get, set, add, export)
+    if (positionals.length > 0) {
+      subcommand = positionals[0];
+      finalPositional = positionals.slice(1);
+    }
+  }
+
+  return {
+    command,
+    subcommand,
+    positional: finalPositional,
+    flags: values as Record<string, string | boolean>,
+  };
+}