wdyt 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdyt",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "type": "module",
   "description": "Code review context builder for LLMs - what do you think?",
   "license": "MIT",

package/src/commands/chat.ts

@@ -23,6 +23,7 @@ import { join, dirname, basename } from "path";
 import { homedir } from "os";
 import { $ } from "bun";
 import { getTab, getWindow } from "../state";
+import { processReReview, recordReview } from "../context/rereview";
 
 /**
  * Chat send payload structure (from flowctl.py build_chat_payload)
@@ -32,9 +33,17 @@ export interface ChatSendPayload {
   mode: string;
   new_chat?: boolean;
   chat_name?: string;
+  chat_id?: string; // Continue specific chat by ID (for re-reviews)
   selected_paths?: string[];
+  base_branch?: string; // Base branch for changed files detection
+  review_type?: string; // Type of review for preamble (e.g., "implementation", "plan")
 }
 
+/**
+ * Verdict type for code reviews
+ */
+export type Verdict = "SHIP" | "NEEDS_WORK" | "MAJOR_RETHINK";
+
 /**
  * Chat send response
  */
@@ -42,6 +51,9 @@ export interface ChatSendResponse {
   id: string;
   path: string;
   review?: string;
+  verdict?: Verdict;
+  isReReview?: boolean;
+  changedFiles?: string[];
 }
 
 /**
@@ -207,6 +219,22 @@ async function loadSkillPrompt(skillName: string): Promise<string> {
   throw new Error(`Skill not found: ${skillName}`);
 }
 
+/**
+ * Parse verdict from Claude's response
+ * Looks for <verdict>SHIP|NEEDS_WORK|MAJOR_RETHINK</verdict> tag
+ *
+ * @param response - The raw response from Claude
+ * @returns The parsed verdict or undefined if not found
+ */
+function parseVerdict(response: string): Verdict | undefined {
+  const verdictMatch = response.match(/<verdict>(SHIP|NEEDS_WORK|MAJOR_RETHINK)<\/verdict>/i);
+  if (verdictMatch) {
+    // Normalize to uppercase since the regex is case-insensitive
+    return verdictMatch[1].toUpperCase() as Verdict;
+  }
+  return undefined;
+}
+
 /**
  * Run a chat using Claude CLI
  * Sends the prompt + context to Claude and returns the response
@@ -378,8 +406,24 @@ export async function chatSendCommand(
     const tab = await getTab(windowId, tabId);
     const window = await getWindow(windowId);
 
+    // Check for re-review scenario
+    // Re-review is detected when:
+    // - chat_id is provided (continuing a previous chat)
+    // - new_chat is explicitly false (not starting fresh)
+    const isReReviewExplicit = payload.chat_id !== undefined || payload.new_chat === false;
+    const reReviewResult = await processReReview({
+      chatId: payload.chat_id,
+      isReReview: isReReviewExplicit,
+      baseBranch: payload.base_branch,
+      reviewType: payload.review_type,
+    });
+
     // Use message from payload as the prompt, or fall back to tab's prompt
-    const prompt = payload.message || tab.prompt;
+    // Prepend re-review preamble if this is a re-review
+    let prompt = payload.message || tab.prompt;
+    if (reReviewResult.isReReview && reReviewResult.preamble) {
+      prompt = reReviewResult.preamble + prompt;
+    }
 
     // Determine which files to include
     // Use selected_paths from payload if provided, otherwise use tab's selectedFiles
@@ -426,13 +470,26 @@ export async function chatSendCommand(
     const chatPath = join(chatsDir, `${chatId}.xml`);
     await Bun.write(chatPath, xmlContent);
 
+    // Record this review for future re-review detection
+    recordReview(chatId, files.map((f) => f.path));
+
     // Always run Claude CLI to process the chat - that's what a drop-in rp-cli replacement does
     if (await claudeCliAvailable()) {
       const response = await runClaudeChat(chatPath, prompt);
 
+      // Parse verdict from response
+      const verdict = parseVerdict(response);
+
       return {
         success: true,
-        data: { id: chatId, path: chatPath, review: response },
+        data: {
+          id: chatId,
+          path: chatPath,
+          review: response,
+          verdict,
+          isReReview: reReviewResult.isReReview,
+          changedFiles: reReviewResult.changedFiles,
+        },
         output: `Chat: \`${chatId}\`\n\n${response}`,
       };
     }
@@ -440,7 +497,12 @@ export async function chatSendCommand(
     // Fallback: just return the chat ID if Claude CLI isn't available
     return {
       success: true,
-      data: { id: chatId, path: chatPath },
+      data: {
+        id: chatId,
+        path: chatPath,
+        isReReview: reReviewResult.isReReview,
+        changedFiles: reReviewResult.changedFiles,
+      },
       output: `Chat: \`${chatId}\`\n\nContext exported to: ${chatPath}\n(Install Claude CLI for automatic LLM processing)`,
     };
   } catch (error) {

package/src/context/hints.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Tests for context hints generation module
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+  generateContextHints,
+  formatHints,
+  type ContextHint,
+} from "./hints";
+
+describe("formatHints", () => {
+  it("returns empty string for empty hints array", () => {
+    const result = formatHints([]);
+    expect(result).toBe("");
+  });
+
+  it("formats single hint correctly", () => {
+    const hints: ContextHint[] = [
+      { file: "src/auth.ts", line: 15, symbol: "validateToken", refCount: 3 },
+    ];
+    const result = formatHints(hints);
+    expect(result).toBe(
+      "Consider these related files:\n- src/auth.ts:15 - references validateToken"
+    );
+  });
+
+  it("formats multiple hints correctly", () => {
+    const hints: ContextHint[] = [
+      { file: "src/auth.ts", line: 15, symbol: "validateToken", refCount: 5 },
+      { file: "src/types.ts", line: 42, symbol: "User", refCount: 3 },
+      { file: "src/api.ts", line: 100, symbol: "fetchUser", refCount: 2 },
+    ];
+    const result = formatHints(hints);
+    const expected = [
+      "Consider these related files:",
+      "- src/auth.ts:15 - references validateToken",
+      "- src/types.ts:42 - references User",
+      "- src/api.ts:100 - references fetchUser",
+    ].join("\n");
+    expect(result).toBe(expected);
+  });
+});
+
+describe("generateContextHints", () => {
+  it("returns empty array when no changed files provided", async () => {
+    const result = await generateContextHints({
+      changedFiles: [],
+      fileContents: new Map(),
+    });
+    expect(result).toEqual([]);
+  });
+
+  it("returns empty array for unsupported file types", async () => {
+    const result = await generateContextHints({
+      changedFiles: ["README.md", "config.json"],
+      fileContents: new Map([
+        ["README.md", "# Readme"],
+        ["config.json", '{"key": "value"}'],
+      ]),
+    });
+    expect(result).toEqual([]);
+  });
+
+  it("extracts symbols from TypeScript files", async () => {
+    const fileContents = new Map([
+      [
+        "src/test.ts",
+        `
+export function uniqueTestFunction123() {}
+export interface UniqueTestInterface456 {}
+export type UniqueTestType789 = string;
+`,
+      ],
+    ]);
+
+    // This test verifies symbol extraction works
+    // References won't be found in a clean test environment,
+    // but we can verify the pipeline runs without errors
+    const result = await generateContextHints({
+      changedFiles: ["src/test.ts"],
+      fileContents,
+      cwd: process.cwd(),
+    });
+
+    // Should return empty since no references exist for made-up names
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  it("respects maxHints limit", async () => {
+    // Create a mock scenario where we'd have many hints
+    // In practice, the limit is applied after collecting all refs
+    const result = await generateContextHints({
+      changedFiles: ["src/test.ts"],
+      fileContents: new Map([["src/test.ts", "function test() {}"]]),
+      cwd: process.cwd(),
+      maxHints: 5,
+    });
+
+    expect(result.length).toBeLessThanOrEqual(5);
+  });
+});
+
+describe("integration", () => {
+  it("combines extraction and reference finding", async () => {
+    // Test with real project files if available
+    const fileContents = new Map([
+      [
+        "src/context/symbols.ts",
+        `
+export function extractSymbols() {}
+export interface Symbol {}
+`,
+      ],
+    ]);
+
+    // This runs the full pipeline
+    const result = await generateContextHints({
+      changedFiles: ["src/context/symbols.ts"],
+      fileContents,
+      cwd: process.cwd(),
+    });
+
+    // Should complete without errors
+    expect(Array.isArray(result)).toBe(true);
+
+    // Each hint should have the required fields
+    for (const hint of result) {
+      expect(hint).toHaveProperty("file");
+      expect(hint).toHaveProperty("line");
+      expect(hint).toHaveProperty("symbol");
+      expect(hint).toHaveProperty("refCount");
+    }
+  });
+});

package/src/context/hints.ts

@@ -0,0 +1,264 @@
+/**
+ * Context hints generation module for wdyt
+ *
+ * Combines symbol extraction + reference finding to generate
+ * context hints for code reviews, matching flowctl's gather_context_hints().
+ */
+
+import { extractSymbols, isSupported, type Symbol } from "./symbols";
+import { findReferences, type Reference } from "./references";
+
+/** Maximum number of context hints to return */
+const MAX_HINTS = 15;
+
+/** Maximum references to fetch per symbol (before curation) */
+const REFS_PER_SYMBOL = 5;
+
+/** Context hint for a related file */
+export interface ContextHint {
+  file: string;
+  line: number;
+  symbol: string;
+  refCount: number;
+}
+
+/** Options for generating context hints */
+export interface GenerateHintsOptions {
+  /** Changed files to analyze */
+  changedFiles: string[];
+  /** File contents (path -> content) */
+  fileContents: Map<string, string>;
+  /** Working directory (defaults to cwd) */
+  cwd?: string;
+  /** Maximum hints to return (default: 15) */
+  maxHints?: number;
+}
+
+/**
+ * Extract symbols from changed files
+ *
+ * @param changedFiles - Array of changed file paths
+ * @param fileContents - Map of file path to content
+ * @returns Map of file path to extracted symbols
+ */
+function extractSymbolsFromFiles(
+  changedFiles: string[],
+  fileContents: Map<string, string>
+): Map<string, Symbol[]> {
+  const result = new Map<string, Symbol[]>();
+
+  for (const filePath of changedFiles) {
+    // Skip unsupported files
+    if (!isSupported(filePath)) {
+      continue;
+    }
+
+    const content = fileContents.get(filePath);
+    if (!content) {
+      continue;
+    }
+
+    const symbols = extractSymbols(content, filePath);
+    if (symbols.length > 0) {
+      result.set(filePath, symbols);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Find references for all symbols across files
+ *
+ * @param symbolsByFile - Map of file path to symbols
+ * @param cwd - Working directory
+ * @returns Map of symbol name to references (with reference count)
+ */
+async function findAllReferences(
+  symbolsByFile: Map<string, Symbol[]>,
+  cwd: string
+): Promise<Map<string, { refs: Reference[]; count: number }>> {
+  const results = new Map<string, { refs: Reference[]; count: number }>();
+  const promises: Promise<void>[] = [];
+
+  for (const [filePath, symbols] of Array.from(symbolsByFile.entries())) {
+    for (const symbol of symbols) {
+      const promise = findReferences({
+        symbol: symbol.name,
+        definitionFile: filePath,
+        cwd,
+        limit: REFS_PER_SYMBOL,
+      }).then((refs) => {
+        const existing = results.get(symbol.name);
+        if (existing) {
+          // Merge refs and update count
+          existing.refs.push(...refs);
+          existing.count += refs.length;
+        } else {
+          results.set(symbol.name, { refs, count: refs.length });
+        }
+      });
+      promises.push(promise);
+    }
+  }
+
+  await Promise.all(promises);
+  return results;
+}
+
+/**
+ * Curate hints to max limit, prioritizing by reference frequency
+ *
+ * @param referenceMap - Map of symbol to references
+ * @param maxHints - Maximum hints to return
+ * @returns Array of curated context hints
+ */
+function curateHints(
+  referenceMap: Map<string, { refs: Reference[]; count: number }>,
+  maxHints: number
+): ContextHint[] {
+  // Flatten all references with their symbol info
+  const allHints: ContextHint[] = [];
+  const seenFileLines = new Set<string>();
+
+  for (const [symbol, { refs, count }] of Array.from(referenceMap.entries())) {
+    for (const ref of refs) {
+      // Deduplicate by file:line
+      const key = `${ref.file}:${ref.line}`;
+      if (seenFileLines.has(key)) {
+        continue;
+      }
+      seenFileLines.add(key);
+
+      allHints.push({
+        file: ref.file,
+        line: ref.line,
+        symbol,
+        refCount: count,
+      });
+    }
+  }
+
+  // Sort by reference count (descending) - most referenced symbols first
+  allHints.sort((a, b) => b.refCount - a.refCount);
+
+  // Take top maxHints
+  return allHints.slice(0, maxHints);
+}
+
+/**
+ * Format hints as flowctl-compatible output
+ *
+ * Output format:
+ * ```
+ * Consider these related files:
+ * - src/auth.ts:15 - references validateToken
+ * - src/types.ts:42 - references User
+ * ```
+ *
+ * @param hints - Array of context hints
+ * @returns Formatted string matching flowctl gather_context_hints() output
+ */
+export function formatHints(hints: ContextHint[]): string {
+  if (hints.length === 0) {
+    return "";
+  }
+
+  const lines = ["Consider these related files:"];
+
+  for (const hint of hints) {
+    lines.push(`- ${hint.file}:${hint.line} - references ${hint.symbol}`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Generate context hints from changed files
+ *
+ * Combines symbol extraction + reference finding to identify
+ * related files that may be affected by changes.
+ *
+ * @param options - Generation options
+ * @returns Array of context hints (max 15 by default)
+ */
+export async function generateContextHints(
+  options: GenerateHintsOptions
+): Promise<ContextHint[]> {
+  const {
+    changedFiles,
+    fileContents,
+    cwd = process.cwd(),
+    maxHints = MAX_HINTS,
+  } = options;
+
+  // Step 1: Extract symbols from changed files
+  const symbolsByFile = extractSymbolsFromFiles(changedFiles, fileContents);
+
+  if (symbolsByFile.size === 0) {
+    return [];
+  }
+
+  // Step 2: Find references to extracted symbols
+  const referenceMap = await findAllReferences(symbolsByFile, cwd);
+
+  // Step 3: Curate to max hints, prioritized by relevance
+  return curateHints(referenceMap, maxHints);
+}
+
+/**
+ * Generate formatted context hints string
+ *
+ * This is the main entry point for getting context hints in flowctl format.
+ *
+ * @param options - Generation options
+ * @returns Formatted hints string (empty if no hints found)
+ */
+export async function getFormattedContextHints(
+  options: GenerateHintsOptions
+): Promise<string> {
+  const hints = await generateContextHints(options);
+  return formatHints(hints);
+}
+
+/**
+ * Generate context hints from git diff
+ *
+ * Convenience function that reads file contents and generates hints.
+ *
+ * @param changedFiles - List of changed file paths (relative to cwd)
+ * @param cwd - Working directory (defaults to process.cwd())
+ * @param maxHints - Maximum hints to return (default: 15)
+ * @returns Formatted hints string
+ */
+export async function generateHintsFromDiff(
+  changedFiles: string[],
+  cwd: string = process.cwd(),
+  maxHints: number = MAX_HINTS
+): Promise<string> {
+  const { join } = await import("path");
+
+  // Read file contents
+  const fileContents = new Map<string, string>();
+
+  for (const filePath of changedFiles) {
+    const fullPath = filePath.startsWith("/") ? filePath : join(cwd, filePath);
+    const file = Bun.file(fullPath);
+
+    if (await file.exists()) {
+      try {
+        const content = await file.text();
+        fileContents.set(filePath, content);
+      } catch {
+        // Skip files we can't read
+      }
+    }
+  }
+
+  return getFormattedContextHints({
+    changedFiles,
+    fileContents,
+    cwd,
+    maxHints,
+  });
+}

package/src/context/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Context module exports
+ *
+ * Provides symbol extraction, reference finding, and context hints
+ * generation for code reviews.
+ */
+
+// Symbol extraction
+export {
+  extractSymbols,
+  extractSymbolsFromFile,
+  isSupported,
+  getSupportedExtensions,
+  type Symbol,
+  type SymbolType,
+} from "./symbols";
+
+// Reference finding
+export {
+  findReferences,
+  findReferencesForSymbols,
+  formatReferences,
+  isGitRepository,
+  type Reference,
+  type FindReferencesOptions,
+} from "./references";
+
+// Context hints generation
+export {
+  generateContextHints,
+  getFormattedContextHints,
+  generateHintsFromDiff,
+  formatHints,
+  type ContextHint,
+  type GenerateHintsOptions,
+} from "./hints";
+
+// Re-review cache-busting
+export {
+  buildReReviewPreamble,
+  getChangedFiles,
+  detectReReview,
+  recordReview,
+  getPreviousReviewState,
+  clearReviewState,
+  processReReview,
+  type ReReviewOptions,
+} from "./rereview";