wdyt 0.1.13 → 0.1.15

package/src/context/references.test.ts

@@ -0,0 +1,341 @@
+/**
+ * Tests for reference finding module
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import {
+  findReferences,
+  findReferencesForSymbols,
+  formatReferences,
+  isGitRepository,
+  type Reference,
+} from "./references";
+import { join } from "path";
+import { mkdir, writeFile, rm } from "fs/promises";
+import { spawn } from "child_process";
+
+// Test fixtures directory - using a git-initialized temp directory
+const FIXTURES_DIR = join(import.meta.dir, "..", "..", ".test-fixtures-refs");
+
+/**
+ * Helper to run git commands
+ */
+async function git(args: string[], cwd: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const process = spawn("git", args, { cwd, stdio: "ignore" });
+    process.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`git ${args.join(" ")} failed with code ${code}`));
+    });
+    process.on("error", reject);
+  });
+}
+
+describe("Reference finding", () => {
+  // Set up a temp git repo with test files
+  beforeAll(async () => {
+    await mkdir(FIXTURES_DIR, { recursive: true });
+
+    // Initialize git repo
+    await git(["init"], FIXTURES_DIR);
+    await git(["config", "user.email", "test@test.com"], FIXTURES_DIR);
+    await git(["config", "user.name", "Test User"], FIXTURES_DIR);
+
+    // Create test files
+    await writeFile(
+      join(FIXTURES_DIR, "utils.ts"),
+      `
+export function helper() {
+  return "helper";
+}
+
+export function otherFunc() {
+  return helper();
+}
+`
+    );
+
+    await writeFile(
+      join(FIXTURES_DIR, "main.ts"),
+      `
+import { helper } from './utils';
+
+function main() {
+  const result = helper();
+  console.log(result);
+}
+
+export { main };
+`
+    );
+
+    await writeFile(
+      join(FIXTURES_DIR, "test.ts"),
+      `
+import { helper } from './utils';
+
+test('helper works', () => {
+  expect(helper()).toBe('helper');
+});
+`
+    );
+
+    await writeFile(
+      join(FIXTURES_DIR, "noRefs.ts"),
+      `
+export function uniqueFunction() {
+  return "unique";
+}
+`
+    );
+
+    // Stage and commit files
+    await git(["add", "."], FIXTURES_DIR);
+    await git(["commit", "-m", "Initial commit"], FIXTURES_DIR);
+  });
+
+  afterAll(async () => {
+    await rm(FIXTURES_DIR, { recursive: true, force: true });
+  });
+
+  describe("findReferences", () => {
+    test("finds references to a symbol", async () => {
+      const refs = await findReferences({
+        symbol: "helper",
+        cwd: FIXTURES_DIR,
+      });
+
+      expect(refs.length).toBeGreaterThan(0);
+
+      // Should find references in main.ts and test.ts
+      const files = refs.map((r) => r.file);
+      expect(files).toContain("main.ts");
+      expect(files).toContain("test.ts");
+    });
+
+    test("excludes definition file from results", async () => {
+      const refs = await findReferences({
+        symbol: "helper",
+        definitionFile: "utils.ts",
+        cwd: FIXTURES_DIR,
+      });
+
+      // Should not include utils.ts
+      const files = refs.map((r) => r.file);
+      expect(files).not.toContain("utils.ts");
+    });
+
+    test("returns line numbers", async () => {
+      const refs = await findReferences({
+        symbol: "helper",
+        cwd: FIXTURES_DIR,
+      });
+
+      for (const ref of refs) {
+        expect(typeof ref.line).toBe("number");
+        expect(ref.line).toBeGreaterThan(0);
+      }
+    });
+
+    test("returns context for each reference", async () => {
+      const refs = await findReferences({
+        symbol: "helper",
+        cwd: FIXTURES_DIR,
+      });
+
+      for (const ref of refs) {
+        expect(typeof ref.context).toBe("string");
+        expect(ref.context.length).toBeGreaterThan(0);
+      }
+    });
+
+    test("respects limit option", async () => {
+      const refs = await findReferences({
+        symbol: "helper",
+        cwd: FIXTURES_DIR,
+        limit: 2,
+      });
+
+      expect(refs.length).toBeLessThanOrEqual(2);
+    });
+
+    test("handles symbols with no references gracefully", async () => {
+      const refs = await findReferences({
+        symbol: "nonExistentSymbol12345",
+        cwd: FIXTURES_DIR,
+      });
+
+      expect(refs).toEqual([]);
+    });
+
+    test("handles file patterns option", async () => {
+      const refs = await findReferences({
+        symbol: "helper",
+        cwd: FIXTURES_DIR,
+        filePatterns: ["*.ts"],
+      });
+
+      expect(refs.length).toBeGreaterThan(0);
+
+      // All results should be .ts files
+      for (const ref of refs) {
+        expect(ref.file.endsWith(".ts")).toBe(true);
+      }
+    });
+
+    test("uses word boundary matching", async () => {
+      // Create a file with similar but different symbol names
+      await writeFile(
+        join(FIXTURES_DIR, "partial.ts"),
+        `
+const helperFunc = 1;
+const myhelper = 2;
+const helper = 3;
+`
+      );
+      await git(["add", "partial.ts"], FIXTURES_DIR);
+      await git(["commit", "-m", "Add partial matches file"], FIXTURES_DIR);
+
+      const refs = await findReferences({
+        symbol: "helper",
+        cwd: FIXTURES_DIR,
+      });
+
+      // Should only find exact "helper" matches, not "helperFunc" or "myhelper"
+      for (const ref of refs) {
+        if (ref.file === "partial.ts") {
+          // The context should contain "helper" as a whole word
+          expect(ref.context).toMatch(/\bhelper\b/);
+          // Should not be the helperFunc or myhelper lines
+          expect(ref.context).not.toMatch(/helperFunc/);
+          expect(ref.context).not.toMatch(/myhelper/);
+        }
+      }
+    });
+  });
+
+  describe("findReferencesForSymbols", () => {
+    test("finds references for multiple symbols", async () => {
+      const results = await findReferencesForSymbols(
+        ["helper", "main"],
+        undefined,
+        FIXTURES_DIR
+      );
+
+      expect(results.size).toBe(2);
+      expect(results.has("helper")).toBe(true);
+      expect(results.has("main")).toBe(true);
+    });
+
+    test("excludes definition file for all symbols", async () => {
+      const results = await findReferencesForSymbols(
+        ["helper", "otherFunc"],
+        "utils.ts",
+        FIXTURES_DIR
+      );
+
+      // Neither should have utils.ts in results
+      for (const [, refs] of results) {
+        const files = refs.map((r) => r.file);
+        expect(files).not.toContain("utils.ts");
+      }
+    });
+
+    test("respects per-symbol limit", async () => {
+      const results = await findReferencesForSymbols(
+        ["helper"],
+        undefined,
+        FIXTURES_DIR,
+        1
+      );
+
+      const helperRefs = results.get("helper") ?? [];
+      expect(helperRefs.length).toBeLessThanOrEqual(1);
+    });
+
+    test("handles symbols with no references", async () => {
+      const results = await findReferencesForSymbols(
+        ["helper", "nonExistent12345"],
+        undefined,
+        FIXTURES_DIR
+      );
+
+      expect(results.get("nonExistent12345")).toEqual([]);
+    });
+  });
+
+  describe("formatReferences", () => {
+    test("formats references as file:line:context", () => {
+      const refs: Reference[] = [
+        { file: "main.ts", line: 4, context: "const result = helper();" },
+        { file: "test.ts", line: 5, context: "expect(helper()).toBe('helper');" },
+      ];
+
+      const formatted = formatReferences(refs);
+
+      expect(formatted).toEqual([
+        "main.ts:4:const result = helper();",
+        "test.ts:5:expect(helper()).toBe('helper');",
+      ]);
+    });
+
+    test("handles empty array", () => {
+      expect(formatReferences([])).toEqual([]);
+    });
+  });
+
+  describe("isGitRepository", () => {
+    test("returns true for git repository", async () => {
+      const result = await isGitRepository(FIXTURES_DIR);
+      expect(result).toBe(true);
+    });
+
+    test("returns false for non-git directory", async () => {
+      const tempDir = join(FIXTURES_DIR, "non-git");
+      await mkdir(tempDir, { recursive: true });
+
+      // This dir is inside the git repo, but let's test with a clearly non-git path
+      // Actually, since it's inside the repo, it would still return true
+      // Let's use /tmp instead
+      const result = await isGitRepository("/tmp");
+      // /tmp might or might not be a git repo, but we can at least verify the function runs
+      expect(typeof result).toBe("boolean");
+    });
+  });
+
+  describe("Edge cases", () => {
+    test("handles special regex characters in symbol names", async () => {
+      // Git grep -w handles word boundaries, but let's make sure special chars work
+      // Most special chars wouldn't be valid symbol names anyway
+      const refs = await findReferences({
+        symbol: "test",
+        cwd: FIXTURES_DIR,
+      });
+
+      // Should not throw
+      expect(Array.isArray(refs)).toBe(true);
+    });
+
+    test("handles definition file with path prefix", async () => {
+      // Test that definition file exclusion works with various path formats
+      const refs = await findReferences({
+        symbol: "helper",
+        definitionFile: "./utils.ts",
+        cwd: FIXTURES_DIR,
+      });
+
+      const files = refs.map((r) => r.file);
+      expect(files).not.toContain("utils.ts");
+    });
+
+    test("handles empty symbol", async () => {
+      const refs = await findReferences({
+        symbol: "",
+        cwd: FIXTURES_DIR,
+      });
+
+      // Git grep with empty pattern returns error, we should handle gracefully
+      expect(Array.isArray(refs)).toBe(true);
+    });
+  });
+});

package/src/context/references.ts

@@ -0,0 +1,232 @@
+/**
+ * Reference finding module for wdyt
+ *
+ * Finds where symbols are used across the codebase using git grep.
+ */
+
+import { spawn } from "child_process";
+
+/** Reference information for a symbol */
+export interface Reference {
+  file: string;
+  line: number;
+  context: string;
+}
+
+/** Options for finding references */
+export interface FindReferencesOptions {
+  /** The symbol name to search for */
+  symbol: string;
+  /** File path where the symbol is defined (will be excluded from results) */
+  definitionFile?: string;
+  /** Working directory (defaults to cwd) */
+  cwd?: string;
+  /** Maximum number of results to return (default: 20) */
+  limit?: number;
+  /** File patterns to search (e.g., "*.ts", "*.js") */
+  filePatterns?: string[];
+}
+
+/** Default maximum results per symbol */
+const DEFAULT_LIMIT = 20;
+
+/**
+ * Execute git grep and return raw output
+ */
+async function execGitGrep(
+  args: string[],
+  cwd: string
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  return new Promise((resolve) => {
+    const process = spawn("git", ["grep", ...args], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    process.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    process.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    process.on("close", (exitCode) => {
+      resolve({ stdout, stderr, exitCode: exitCode ?? 0 });
+    });
+
+    process.on("error", () => {
+      resolve({ stdout: "", stderr: "Failed to spawn git grep", exitCode: 1 });
+    });
+  });
+}
+
+/**
+ * Parse git grep output line into Reference object
+ *
+ * git grep -n output format: file:line:context
+ */
+function parseGrepLine(line: string): Reference | null {
+  // Handle format: file:line:context
+  // Need to handle Windows paths (C:\...) and colons in context
+  const match = line.match(/^([^:]+):(\d+):(.*)$/);
+  if (!match) return null;
+
+  const [, file, lineStr, context] = match;
+  const lineNum = parseInt(lineStr, 10);
+
+  if (isNaN(lineNum)) return null;
+
+  return {
+    file,
+    line: lineNum,
+    context: context.trim(),
+  };
+}
+
+/**
+ * Normalize file path for comparison
+ */
+function normalizePath(filePath: string): string {
+  return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+/**
+ * Find references to a symbol across the codebase using git grep
+ *
+ * @param options - Search options
+ * @returns Array of references found
+ */
+export async function findReferences(
+  options: FindReferencesOptions
+): Promise<Reference[]> {
+  const {
+    symbol,
+    definitionFile,
+    cwd = process.cwd(),
+    limit = DEFAULT_LIMIT,
+    filePatterns,
+  } = options;
+
+  // Build git grep arguments
+  // -w: word boundary matching (whole word only)
+  // -n: show line numbers
+  const args: string[] = ["-w", "-n", symbol];
+
+  // Add file patterns if specified
+  if (filePatterns && filePatterns.length > 0) {
+    args.push("--");
+    args.push(...filePatterns);
+  }
+
+  const { stdout, exitCode } = await execGitGrep(args, cwd);
+
+  // Exit code 1 means no matches found (not an error)
+  if (exitCode !== 0 && exitCode !== 1) {
+    return [];
+  }
+
+  // Parse output lines
+  const lines = stdout.split("\n").filter((line) => line.trim() !== "");
+  const references: Reference[] = [];
+
+  const normalizedDefinitionFile = definitionFile
+    ? normalizePath(definitionFile)
+    : null;
+
+  for (const line of lines) {
+    const ref = parseGrepLine(line);
+    if (!ref) continue;
+
+    // Exclude the definition file
+    if (normalizedDefinitionFile) {
+      const normalizedRefFile = normalizePath(ref.file);
+      if (
+        normalizedRefFile === normalizedDefinitionFile ||
+        normalizedRefFile.endsWith(`/${normalizedDefinitionFile}`) ||
+        normalizedDefinitionFile.endsWith(`/${normalizedRefFile}`)
+      ) {
+        continue;
+      }
+    }
+
+    references.push(ref);
+
+    // Stop if we've reached the limit
+    if (references.length >= limit) {
+      break;
+    }
+  }
+
+  return references;
+}
+
+/**
+ * Find references for multiple symbols
+ *
+ * @param symbols - Array of symbol names
+ * @param definitionFile - File where symbols are defined (excluded from results)
+ * @param cwd - Working directory
+ * @param limitPerSymbol - Maximum references per symbol (default: 10)
+ * @returns Map of symbol name to references
+ */
+export async function findReferencesForSymbols(
+  symbols: string[],
+  definitionFile?: string,
+  cwd?: string,
+  limitPerSymbol: number = 10
+): Promise<Map<string, Reference[]>> {
+  const results = new Map<string, Reference[]>();
+
+  // Process symbols in parallel for better performance
+  const promises = symbols.map(async (symbol) => {
+    const refs = await findReferences({
+      symbol,
+      definitionFile,
+      cwd,
+      limit: limitPerSymbol,
+    });
+    return { symbol, refs };
+  });
+
+  const resolvedResults = await Promise.all(promises);
+
+  for (const { symbol, refs } of resolvedResults) {
+    results.set(symbol, refs);
+  }
+
+  return results;
+}
+
+/**
+ * Format references as file:line:context strings
+ *
+ * @param references - References to format
+ * @returns Array of formatted strings
+ */
+export function formatReferences(references: Reference[]): string[] {
+  return references.map((ref) => `${ref.file}:${ref.line}:${ref.context}`);
+}
+
+/**
+ * Check if git is available and cwd is a git repository
+ */
+export async function isGitRepository(cwd?: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const process = spawn("git", ["rev-parse", "--git-dir"], {
+      cwd: cwd ?? process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    process.on("close", (exitCode) => {
+      resolve(exitCode === 0);
+    });
+
+    process.on("error", () => {
+      resolve(false);
+    });
+  });
+}

package/src/context/rereview.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Tests for re-review cache-busting module
+ */
+
+import { describe, test, expect, beforeEach } from "bun:test";
+import {
+  buildReReviewPreamble,
+  detectReReview,
+  recordReview,
+  getPreviousReviewState,
+  clearReviewState,
+  processReReview,
+} from "./rereview";
+
+describe("buildReReviewPreamble", () => {
+  test("builds preamble with changed files", () => {
+    const files = ["src/auth.ts", "src/types.ts"];
+    const preamble = buildReReviewPreamble(files, "implementation");
+
+    expect(preamble).toContain("## IMPORTANT: Re-review After Fixes");
+    expect(preamble).toContain("This is a RE-REVIEW");
+    expect(preamble).toContain("- src/auth.ts");
+    expect(preamble).toContain("- src/types.ts");
+    expect(preamble).toContain("implementation review");
+  });
+
+  test("truncates files list at 30 files", () => {
+    const files = Array.from({ length: 40 }, (_, i) => `src/file${i}.ts`);
+    const preamble = buildReReviewPreamble(files, "plan");
+
+    expect(preamble).toContain("- src/file0.ts");
+    expect(preamble).toContain("- src/file29.ts");
+    expect(preamble).not.toContain("- src/file30.ts");
+    expect(preamble).toContain("... and 10 more files");
+  });
+
+  test("uses correct review type in message", () => {
+    const files = ["src/spec.md"];
+    const preamble = buildReReviewPreamble(files, "plan");
+
+    expect(preamble).toContain("plan review");
+  });
+});
+
+describe("detectReReview", () => {
+  beforeEach(() => {
+    clearReviewState();
+  });
+
+  test("returns false when no chatId and no explicit flag", () => {
+    const result = detectReReview({});
+    expect(result).toBe(false);
+  });
+
+  test("returns true when isReReview is explicitly true", () => {
+    const result = detectReReview({ isReReview: true });
+    expect(result).toBe(true);
+  });
+
+  test("returns false when chatId has no previous review", () => {
+    const result = detectReReview({ chatId: "new-chat-id" });
+    expect(result).toBe(false);
+  });
+
+  test("returns true when chatId has previous review", () => {
+    recordReview("existing-chat-id", ["file1.ts"]);
+    const result = detectReReview({ chatId: "existing-chat-id" });
+    expect(result).toBe(true);
+  });
+});
+
+describe("recordReview and getPreviousReviewState", () => {
+  beforeEach(() => {
+    clearReviewState();
+  });
+
+  test("records and retrieves review state", () => {
+    const files = ["src/auth.ts", "src/types.ts"];
+    recordReview("test-chat-id", files);
+
+    const state = getPreviousReviewState("test-chat-id");
+    expect(state).toBeDefined();
+    expect(state?.files).toEqual(files);
+    expect(state?.timestamp).toBeGreaterThan(0);
+  });
+
+  test("returns undefined for unknown chat id", () => {
+    const state = getPreviousReviewState("unknown-chat-id");
+    expect(state).toBeUndefined();
+  });
+
+  test("clearReviewState removes all state", () => {
+    recordReview("chat-1", ["file1.ts"]);
+    recordReview("chat-2", ["file2.ts"]);
+
+    clearReviewState();
+
+    expect(getPreviousReviewState("chat-1")).toBeUndefined();
+    expect(getPreviousReviewState("chat-2")).toBeUndefined();
+  });
+});
+
+describe("processReReview", () => {
+  beforeEach(() => {
+    clearReviewState();
+  });
+
+  test("returns isReReview false when not a re-review", async () => {
+    const result = await processReReview({});
+    expect(result.isReReview).toBe(false);
+    expect(result.preamble).toBeUndefined();
+  });
+
+  test("returns preamble when is re-review", async () => {
+    recordReview("prev-chat", ["file.ts"]);
+    const result = await processReReview({
+      chatId: "prev-chat",
+      reviewType: "implementation",
+    });
+
+    expect(result.isReReview).toBe(true);
+    expect(result.preamble).toBeDefined();
+    expect(result.preamble).toContain("RE-REVIEW");
+  });
+
+  test("uses explicit isReReview flag", async () => {
+    const result = await processReReview({
+      isReReview: true,
+      reviewType: "plan",
+    });
+
+    expect(result.isReReview).toBe(true);
+    expect(result.preamble).toBeDefined();
+  });
+});