wdyt 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 user
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# wdyt
+
+Code review context builder for LLMs - get a second opinion on your code.
+
+A CLI tool that exports code context for AI review, compatible with flowctl/flow-next.
+
+## Installation
+
+```bash
+# Run directly with bunx (recommended)
+bunx wdyt init
+
+# Or install globally
+bun add -g wdyt
+```
+
+## Quick Start
+
+```bash
+# Interactive setup - creates data directory and optionally adds rp-cli alias
+bunx wdyt init
+
+# List windows
+wdyt -e 'windows'
+
+# Create a new tab in window 1
+wdyt -w 1 -e 'builder {}'
+
+# Add files to selection
+wdyt -w 1 -t <tab-id> -e 'select add src/cli.ts'
+
+# Export context for review
+wdyt -w 1 -t <tab-id> -e 'call chat_send {"mode":"review"}'
+```
+
+## Commands
+
+### Setup
+
+```bash
+wdyt init              # Interactive setup
+wdyt init --global     # Install binary globally
+wdyt init --rp-alias   # Create rp-cli alias (for flowctl)
+wdyt init --no-alias   # Skip rp-cli alias prompt
+```
+
+### Expressions
+
+| Expression | Description |
+|------------|-------------|
+| `windows` | List all windows |
+| `builder {"summary":"..."}` | Create a new tab |
+| `prompt get` | Get current prompt |
+| `prompt export <file>` | Export prompt to file |
+| `select get` | Get selected files |
+| `select add "path"` | Add file to selection |
+| `call chat_send {...}` | Export context for review |
+
+### Flags
+
+| Flag | Description |
+|------|-------------|
+| `--raw-json` | Output raw JSON |
+| `-w <id>` | Window ID |
+| `-t <id>` | Tab ID |
+| `-e <expr>` | Expression to execute |
+
+## flowctl Compatibility
+
+This tool is compatible with [flow-next](https://github.com/gmickel/claude-marketplace) and provides the `rp-cli` interface expected by flowctl.
+
+```bash
+# Create the rp-cli alias during init
+bunx wdyt init --rp-alias
+```
+
+## Requirements
+
+- [Bun](https://bun.sh) runtime
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "wdyt",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Code review context builder for LLMs - what do you think?",
+  "license": "MIT",
+  "author": "bewinxed",
+  "main": "src/cli.ts",
+  "bin": {
+    "wdyt": "./src/cli.ts"
+  },
+  "files": [
+    "src/**/*.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bewinxed/reepoproompt.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Bewinxed/reepoproompt/issues"
+  },
+  "homepage": "https://github.com/Bewinxed/reepoproompt#readme",
+  "keywords": [
+    "code-review",
+    "llm",
+    "context",
+    "ai",
+    "claude",
+    "cli",
+    "bun"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "bun run src/cli.ts",
+    "build": "bun build ./src/cli.ts --compile --outfile wdyt",
+    "test": "bun test",
+    "prepublishOnly": "bun test"
+  },
+  "dependencies": {
+    "citty": "^0.1.6"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,267 @@
+#!/usr/bin/env bun
+/**
+ * wdyt - Code review context builder for LLMs
+ *
+ * Get a second opinion on your code by building context for AI review.
+ * Compatible with flowctl.py (rp-cli interface).
+ *
+ * Commands:
+ * - windows: list windows
+ * - builder: create tabs
+ * - prompt get/set/export: manage prompts
+ * - select get/add: track file selection
+ * - chat_send: export context for review
+ */
+
+import { defineCommand, runMain } from "citty";
+import type { CLIFlags } from "./types";
+import { windowsCommand } from "./commands/windows";
+import { builderCommand } from "./commands/builder";
+import {
+  promptGetCommand,
+  promptSetCommand,
+  promptExportCommand,
+} from "./commands/prompt";
+import { selectGetCommand, selectAddCommand } from "./commands/select";
+import { chatSendCommand } from "./commands/chat";
+import { initCommand, parseInitArgs } from "./commands/init";
+
+/**
+ * Parse and execute an expression
+ */
+async function executeExpression(
+  expression: string,
+  flags: CLIFlags
+): Promise<{ success: boolean; data?: unknown; output?: string; error?: string }> {
+  const expr = expression.trim();
+
+  // Parse command and arguments
+  // Expressions can be: "windows", "builder {json}", "prompt get", etc.
+  const match = expr.match(/^(\w+)(?:\s+(.*))?$/);
+  if (!match) {
+    return { success: false, error: `Invalid expression: ${expression}` };
+  }
+
+  const [, command, args] = match;
+
+  switch (command) {
+    case "windows":
+      return await windowsCommand();
+
+    case "builder":
+      if (!flags.window) {
+        return { success: false, error: "builder requires -w <window>" };
+      }
+      return await builderCommand(flags.window, args);
+
+    case "prompt": {
+      if (!flags.window || !flags.tab) {
+        return {
+          success: false,
+          error: "prompt commands require -w <window> -t <tab>",
+        };
+      }
+
+      // Parse subcommand: "get", "export <file>"
+      const promptArgs = args?.trim();
+      if (!promptArgs || promptArgs === "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, "");
+        return await promptExportCommand(flags.window, flags.tab, filePath);
+      }
+
+      return { success: false, error: `Unknown prompt subcommand: ${promptArgs}` };
+    }
+
+    case "select": {
+      if (!flags.window || !flags.tab) {
+        return {
+          success: false,
+          error: "select commands require -w <window> -t <tab>",
+        };
+      }
+
+      // Parse subcommand: "get", "add <paths>"
+      const selectArgs = args?.trim();
+      if (!selectArgs || selectArgs === "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);
+      }
+
+      return { success: false, error: `Unknown select subcommand: ${selectArgs}` };
+    }
+
+    case "call": {
+      // Handle "call prompt {json}" and "call chat_send {json}"
+      if (args?.startsWith("prompt ")) {
+        if (!flags.window || !flags.tab) {
+          return {
+            success: false,
+            error: "prompt requires -w <window> -t <tab>",
+          };
+        }
+        const payload = args.slice(7).trim();
+        return await promptSetCommand(flags.window, flags.tab, payload);
+      }
+
+      if (args?.startsWith("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() || "{}";
+        return await chatSendCommand(flags.window, flags.tab, payload);
+      }
+      return { success: false, error: `Unknown call: ${args}` };
+    }
+
+    default:
+      return { success: false, error: `Unknown command: ${command}` };
+  }
+}
+
+/**
+ * Format output based on --raw-json flag
+ */
+function formatOutput(
+  result: { success: boolean; data?: unknown; output?: string; error?: string },
+  rawJson: boolean
+): string {
+  if (rawJson) {
+    if (result.success) {
+      return JSON.stringify(result.data);
+    }
+    return JSON.stringify({ error: result.error });
+  }
+
+  // For non-raw-json mode, prefer the output field if present
+  // This allows commands like builder to return "Tab: <uuid>" format
+  if (result.success) {
+    // Check if output is defined (not undefined), allowing empty strings
+    if (result.output !== undefined) {
+      return result.output;
+    }
+    if (typeof result.data === "object") {
+      return JSON.stringify(result.data, null, 2);
+    }
+    return String(result.data);
+  }
+
+  return `Error: ${result.error}`;
+}
+
+// Check if init command and handle it before citty
+const args = process.argv.slice(2);
+if (args[0] === "init") {
+  const options = parseInitArgs(args.slice(1));
+  initCommand(options).then((result) => {
+    if (result.success) {
+      console.log(result.output);
+      process.exit(0);
+    } else {
+      console.error(result.error);
+      process.exit(1);
+    }
+  });
+} else {
+  // Only run citty for non-init commands
+  const main = defineCommand({
+    meta: {
+      name: "wdyt",
+      version: "0.1.0",
+      description: "Code review context builder for LLMs",
+    },
+    args: {
+      "raw-json": {
+        type: "boolean",
+        description: "Output raw JSON (no formatting)",
+        default: false,
+      },
+      w: {
+        type: "string",
+        description: "Window ID",
+      },
+      t: {
+        type: "string",
+        description: "Tab ID",
+      },
+      e: {
+        type: "string",
+        description: "Expression to execute",
+      },
+    },
+    async run({ args }) {
+      // Parse and validate window ID
+      let windowId: number | undefined;
+      if (args.w) {
+        windowId = parseInt(args.w, 10);
+        if (isNaN(windowId) || windowId < 1) {
+          console.error(`Error: Invalid window ID "${args.w}". Must be a positive integer.`);
+          process.exit(1);
+        }
+      }
+
+      const flags: CLIFlags = {
+        rawJson: args["raw-json"],
+        window: windowId,
+        tab: args.t,
+        expression: args.e,
+      };
+
+      // If no expression, show help message
+      if (!flags.expression) {
+        console.log("wdyt - Code review context builder for LLMs");
+        console.log("");
+        console.log("Setup:");
+        console.log("  wdyt init              # Interactive setup (prompts for options)");
+        console.log("  wdyt init --global     # Install binary globally");
+        console.log("  wdyt init --rp-alias   # Create rp-cli alias (for flowctl)");
+        console.log("  wdyt init --no-alias   # Skip rp-cli alias prompt");
+        console.log("");
+        console.log("Usage:");
+        console.log("  wdyt --raw-json -e <expression>");
+        console.log("  wdyt -w <window> -e <expression>");
+        console.log("  wdyt -w <window> -t <tab> -e <expression>");
+        console.log("");
+        console.log("Expressions:");
+        console.log("  windows                    List all windows");
+        console.log('  builder {"summary":"..."}  Create a new tab');
+        console.log("  prompt get                 Get current prompt");
+        console.log("  prompt export <file>       Export prompt to file");
+        console.log("  select get                 Get selected files");
+        console.log('  select add "path"          Add file to selection');
+        console.log("  call chat_send {...}       Export context for review");
+        console.log("");
+        console.log("Flags:");
+        console.log("  --raw-json    Output raw JSON");
+        console.log("  -w <id>       Window ID");
+        console.log("  -t <id>       Tab ID");
+        console.log("  -e <expr>     Expression to execute");
+        process.exit(0);
+      }
+
+      // Execute expression
+      const result = await executeExpression(flags.expression, flags);
+      const output = formatOutput(result, flags.rawJson);
+      console.log(output);
+
+      // Exit with code 1 on error
+      if (!result.success) {
+        process.exit(1);
+      }
+    },
+  });
+
+  runMain(main);
+}

package/src/commands/builder.ts

@@ -0,0 +1,85 @@
+/**
+ * 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
+ */
+export interface BuilderResponse {
+  tabId: string;
+}
+
+/**
+ * Parse builder JSON argument
+ * @param args - JSON string like {"summary": "test"}
+ * @returns Parsed BuilderConfig or null if invalid
+ */
+function parseBuilderArgs(args?: string): BuilderConfig | null {
+  if (!args) {
+    // Empty config is valid - just creates a blank tab
+    return {};
+  }
+
+  try {
+    const config = JSON.parse(args.trim()) as BuilderConfig;
+    return config;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Execute the builder command
+ * 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
+ * @returns Tab: <uuid> on success
+ */
+export async function builderCommand(
+  windowId: number,
+  args?: string
+): Promise<{
+  success: boolean;
+  data?: BuilderResponse;
+  output?: string;
+  error?: string;
+}> {
+  try {
+    // 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);
+
+    // Return in the format flowctl.py expects: Tab: <uuid>
+    return {
+      success: true,
+      data: { tabId: tab.id },
+      output: `Tab: ${tab.id}`,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to create tab: ${message}`,
+    };
+  }
+}