wdyt 0.1.0 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdyt",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "type": "module",
   "description": "Code review context builder for LLMs - what do you think?",
   "license": "MIT",
@@ -16,12 +16,12 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Bewinxed/reepoproompt.git"
+    "url": "git+https://github.com/Bewinxed/wdyt.git"
   },
   "bugs": {
-    "url": "https://github.com/Bewinxed/reepoproompt/issues"
+    "url": "https://github.com/Bewinxed/wdyt/issues"
   },
-  "homepage": "https://github.com/Bewinxed/reepoproompt#readme",
+  "homepage": "https://github.com/Bewinxed/wdyt#readme",
   "keywords": [
     "code-review",
     "llm",

package/src/cli.ts

@@ -15,6 +15,7 @@
 
 import { defineCommand, runMain } from "citty";
 import type { CLIFlags } from "./types";
+import pkg from "../package.json";
 import { windowsCommand } from "./commands/windows";
 import { builderCommand } from "./commands/builder";
 import {
@@ -179,7 +180,7 @@ if (args[0] === "init") {
   const main = defineCommand({
     meta: {
       name: "wdyt",
-      version: "0.1.0",
+      version: pkg.version,
       description: "Code review context builder for LLMs",
     },
     args: {

package/src/commands/chat.ts

@@ -18,9 +18,10 @@
  * }
  */
 
-import { existsSync, readFileSync, mkdirSync } from "fs";
+import { mkdirSync } from "fs";
 import { join, dirname, basename } from "path";
 import { homedir } from "os";
+import { $ } from "bun";
 import { getTab, getWindow } from "../state";
 
 /**
@@ -74,14 +75,79 @@ function generateUUID(): string {
 }
 
 /**
- * Read file content safely
+ * Check if claude CLI is available
  */
-function readFileSafe(path: string): { success: boolean; content?: string; error?: string } {
+async function claudeCliAvailable(): Promise<boolean> {
   try {
-    if (!existsSync(path)) {
+    await $`which claude`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Run a review using Claude CLI
+ * Returns the review output including verdict
+ */
+async function runClaudeReview(contextPath: string, prompt: string): Promise<string> {
+  // Read the context file content first
+  const contextFile = Bun.file(contextPath);
+  const contextContent = await contextFile.text();
+
+  const reviewPrompt = `You are reviewing code changes. Analyze the following context and provide a thorough review.
+
+Review instructions:
+${prompt}
+
+<context>
+${contextContent}
+</context>
+
+Analyze the code for:
+- Correctness - Logic errors, bugs, spec compliance
+- Security - Injection risks, auth gaps, data exposure
+- Simplicity - Over-engineering, unnecessary complexity
+- Edge cases - Failure modes, boundary conditions
+
+Provide findings organized by severity (Critical > Major > Minor).
+
+REQUIRED: End your review with exactly one verdict tag:
+<verdict>SHIP</verdict> - Code is production-ready
+<verdict>NEEDS_WORK</verdict> - Issues must be fixed first
+<verdict>MAJOR_RETHINK</verdict> - Fundamental problems require redesign`;
+
+  // Write prompt to temp file to avoid shell escaping issues
+  const tempPromptPath = join(getChatsDir(), `review-prompt-${Date.now()}.txt`);
+  await Bun.write(tempPromptPath, reviewPrompt);
+
+  try {
+    // Run claude CLI in print mode, reading from temp file
+    const result = await $`cat ${tempPromptPath} | claude -p`.text();
+
+    // Clean up temp file
+    await $`rm ${tempPromptPath}`.quiet();
+
+    return result.trim();
+  } catch (error) {
+    // Clean up temp file on error too
+    await $`rm ${tempPromptPath}`.quiet();
+
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Claude CLI review failed: ${message}`);
+  }
+}
+
+/**
+ * Read file content safely using Bun's file API
+ */
+async function readFileSafe(path: string): Promise<{ success: boolean; content?: string; error?: string }> {
+  try {
+    const file = Bun.file(path);
+    if (!(await file.exists())) {
       return { success: false, error: `File not found: ${path}` };
     }
-    const content = readFileSync(path, "utf-8");
+    const content = await file.text();
     return { success: true, content };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -218,7 +284,7 @@ export async function chatSendCommand(
     const errors: string[] = [];
 
     for (const filePath of filePaths) {
-      const result = readFileSafe(filePath);
+      const result = await readFileSafe(filePath);
       if (result.success && result.content !== undefined) {
         files.push({ path: filePath, content: result.content });
       } else {
@@ -252,41 +318,26 @@ export async function chatSendCommand(
     const chatPath = join(chatsDir, `${chatId}.xml`);
     await Bun.write(chatPath, xmlContent);
 
-    // Check if this is a review request - if so, output subagent spawn instruction
+    // Check if this is a review request - if so, run Claude CLI to do the review
     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
-""")
+      // Check if claude CLI is available
+      if (!(await claudeCliAvailable())) {
+        return {
+          success: false,
+          error: "Review mode requires Claude CLI (claude) to be installed and in PATH",
+        };
+      }
 
-The subagent will return the review findings and verdict.
-[/CLAUDE_CODE_REVIEW_REQUEST]`;
+      // Run the review using Claude CLI
+      console.error("Running review with Claude CLI...");
+      const reviewOutput = await runClaudeReview(chatPath, prompt);
 
       return {
         success: true,
-        data: { id: chatId, path: chatPath },
-        output: reviewOutput,
+        data: { id: chatId, path: chatPath, review: reviewOutput },
+        output: `Chat: \`${chatId}\`\n\n${reviewOutput}`,
       };
     }
 

package/src/commands/init.ts

@@ -8,11 +8,14 @@
  *   bunx wdyt init --global     # Install globally
  */
 
-import { mkdirSync, existsSync, symlinkSync, unlinkSync } from "fs";
+import { mkdirSync, symlinkSync, unlinkSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { $ } from "bun";
 import * as readline from "readline";
+import pkg from "../../package.json";
+
+const CURRENT_VERSION = pkg.version;
 
 interface InitOptions {
   rpAlias?: boolean;
@@ -20,6 +23,30 @@ interface InitOptions {
   global?: boolean;
 }
 
+/**
+ * Get the installed version of wdyt binary
+ */
+async function getInstalledVersion(binPath: string): Promise<string | null> {
+  try {
+    const result = await $`${binPath} --version 2>/dev/null`.text();
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compare semver versions, returns true if v1 > v2
+ */
+function isNewerVersion(v1: string, v2: string): boolean {
+  const parse = (v: string) => v.split(".").map(Number);
+  const [a1, b1, c1] = parse(v1);
+  const [a2, b2, c2] = parse(v2);
+  if (a1 !== a2) return a1 > a2;
+  if (b1 !== b2) return b1 > b2;
+  return c1 > c2;
+}
+
 /**
  * Prompt user for yes/no input
  */
@@ -102,25 +129,40 @@ export async function initCommand(options: InitOptions): Promise<{
     };
   }
 
-  // 2. Check if already installed globally
+  // 2. Check if already installed globally and compare versions
   const alreadyInstalled = await commandExists("wdyt");
+  const wdytPath = join(binDir, "wdyt");
+  let needsUpdate = false;
 
-  if (alreadyInstalled && !options.global) {
-    lines.push("");
-    lines.push("✓ wdyt is already available in PATH");
+  if (alreadyInstalled) {
+    const installedVersion = await getInstalledVersion(wdytPath);
+    if (installedVersion) {
+      if (isNewerVersion(CURRENT_VERSION, installedVersion)) {
+        lines.push("");
+        lines.push(`⚠️  Installed version: ${installedVersion}, available: ${CURRENT_VERSION}`);
+        lines.push("  Updating to latest version...");
+        needsUpdate = true;
+      } else if (!options.global) {
+        lines.push("");
+        lines.push(`✓ wdyt ${installedVersion} is already installed and up to date`);
+      }
+    } else if (!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...");
+  // 3. Global install if requested OR if update needed
+  if (options.global || needsUpdate) {
+    if (!needsUpdate) {
+      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
@@ -128,7 +170,7 @@ export async function initCommand(options: InitOptions): Promise<{
       const srcDir = join(import.meta.dir, "..");
       await $`bun build ${join(srcDir, "cli.ts")} --compile --outfile ${targetPath}`.quiet();
 
-      lines.push(`  ✓ Installed to ${targetPath}`);
+      lines.push(`  ✓ ${needsUpdate ? "Updated" : "Installed"} to ${targetPath} (v${CURRENT_VERSION})`);
 
       // Check if ~/.local/bin is in PATH
       const path = process.env.PATH || "";
@@ -169,12 +211,12 @@ export async function initCommand(options: InitOptions): Promise<{
       mkdirSync(binDir, { recursive: true });
 
       // Remove existing symlink if present
-      if (existsSync(rpCliPath)) {
+      if (await Bun.file(rpCliPath).exists()) {
         unlinkSync(rpCliPath);
       }
 
       // Check if wdyt binary exists
-      if (existsSync(secondOpinionPath)) {
+      if (await Bun.file(secondOpinionPath).exists()) {
         symlinkSync(secondOpinionPath, rpCliPath);
         lines.push(`  ✓ Created symlink: rp-cli -> wdyt`);
       } else {

package/src/state.ts

@@ -7,7 +7,7 @@
 
 import { join } from "path";
 import { homedir } from "os";
-import { mkdirSync, existsSync, renameSync } from "fs";
+import { mkdirSync, renameSync } from "fs";
 import type { StateFile, Window, Tab, TabUpdate } from "./types";
 
 const STATE_VERSION = 1;
@@ -60,14 +60,14 @@ function generateUUID(): string {
 export async function loadState(): Promise<StateFile> {
   const statePath = getStatePath();
 
-  // Check if file exists first
-  if (!existsSync(statePath)) {
+  // Check if file exists first using Bun's file API
+  const stateFile = Bun.file(statePath);
+  if (!(await stateFile.exists())) {
     return createDefaultState();
   }
 
   try {
-    const file = Bun.file(statePath);
-    const content = await file.text();
+    const content = await stateFile.text();
     const state = JSON.parse(content) as StateFile;
 
     // Validate basic structure