@ridit/lens 0.3.7 → 0.3.9

package/src/utils/watch.ts

@@ -1,307 +1,165 @@
-import { spawn, type ChildProcess } from "child_process";
-import { readFileSync, existsSync } from "fs";
-import path from "path";
-
-export type WatchProcess = {
-  kill: () => void;
-  onLog: (cb: (line: string, isErr: boolean) => void) => void;
-  onError: (cb: (chunk: ErrorChunk) => void) => void;
-  onExit: (cb: (code: number | null) => void) => void;
-  onInputRequest: (cb: (prompt: string) => void) => void;
-  sendInput: (text: string) => void;
-};
-
-export type ErrorChunk = {
-  raw: string;
-  lines: string[];
-  contextBefore: string[];
-  filePath?: string;
-  lineNumber?: number;
-  timestamp: number;
-};
-
-export type Suggestion = {
-  id: string;
-  errorSummary: string;
-  simplified: string;
-  fix: string;
-  filePath?: string;
-  patch?: { path: string; content: string; isNew: boolean };
-  timestamp: number;
-};
-
-const ERROR_PATTERNS = [
-  /error:/i,
-  /TypeError/,
-  /ReferenceError/,
-  /SyntaxError/,
-  /RangeError/,
-  /NameError/,
-  /AttributeError/,
-  /KeyError/,
-  /IndexError/,
-  /ImportError/,
-  /ModuleNotFoundError/,
-  /ZeroDivisionError/,
-  /ValueError/,
-  /RuntimeError/,
-  /Traceback \(most recent call last\)/,
-  /Cannot find module/,
-  /Cannot read propert/,
-  /is not defined/,
-  /is not a function/,
-  /Unhandled/,
-  /ENOENT/,
-  /EADDRINUSE/,
-  /failed to compile/i,
-  /Build failed/i,
-  /Module not found/i,
-  /unexpected token/i,
-  /Expected/,
-];
-
-const NOISE_PATTERNS = [
-  /^\s*at\s+/,
-  /^\s*\^+\s*$/,
-  /^\s*$/,
-  /^\s*warn/i,
-  /deprecat/i,
-];
-
-const INPUT_REQUEST_PATTERNS = [
-  /:\s*$/,
-  /\?\s*$/,
-  />\s*$/,
-  /input/i,
-  /enter\s+\w/i,
-  /type\s+\w/i,
-  /press\s+\w/i,
-];
-
-function isErrorLine(line: string): boolean {
-  return ERROR_PATTERNS.some((p) => p.test(line));
-}
-
-function isNoise(line: string): boolean {
-  return NOISE_PATTERNS.some((p) => p.test(line));
-}
-
-function isInputRequest(line: string): boolean {
-  const stripped = line.replace(/\x1b\[[0-9;]*m/g, "").trim();
-  if (!stripped) return false;
-  return INPUT_REQUEST_PATTERNS.some((p) => p.test(stripped));
-}
-
-function extractFilePath(lines: string[]): {
-  filePath?: string;
-  lineNumber?: number;
-} {
-  for (const line of lines) {
-    const pyM = line.match(/File "([^"]+\.py)",\s*line\s*(\d+)/);
-    if (pyM) {
-      return { filePath: pyM[1], lineNumber: parseInt(pyM[2]!, 10) };
-    }
-
-    const m = line.match(
-      /([./][\w./\\-]+\.(tsx?|jsx?|mjs|cjs|ts|js|py)):(\d+)/,
-    );
-    if (m) {
-      return { filePath: m[1], lineNumber: parseInt(m[3]!, 10) };
-    }
-
-    const absM = line.match(/\(([^)]+\.(tsx?|jsx?|ts|js)):(\d+)/);
-    if (absM) {
-      return { filePath: absM[1], lineNumber: parseInt(absM[3]!, 10) };
-    }
-  }
-  return {};
-}
-
-export function spawnWatch(cmd: string, cwd: string): WatchProcess {
-  const [bin, ...args] = cmd.split(/\s+/) as [string, ...string[]];
-
-  const child: ChildProcess = spawn(bin, args, {
-    cwd,
-    shell: true,
-    env: { ...process.env, FORCE_COLOR: "1" },
-    stdio: ["pipe", "pipe", "pipe"],
-  });
-
-  const logCallbacks: ((line: string, isErr: boolean) => void)[] = [];
-  const errorCallbacks: ((chunk: ErrorChunk) => void)[] = [];
-  const exitCallbacks: ((code: number | null) => void)[] = [];
-  const inputRequestCallbacks: ((prompt: string) => void)[] = [];
-
-  const recentLines: string[] = [];
-  let errorBuffer: string[] = [];
-  let errorTimer: ReturnType<typeof setTimeout> | null = null;
-  const seenErrors = new Set<string>();
-
-  const flushError = () => {
-    if (errorBuffer.length === 0) return;
-
-    const raw = errorBuffer.join("\n");
-    const key = raw.slice(0, 120);
-
-    if (seenErrors.has(key)) {
-      errorBuffer = [];
-      return;
-    }
-    seenErrors.add(key);
-
-    const { filePath, lineNumber } = extractFilePath(errorBuffer);
-
-    const chunk: ErrorChunk = {
-      raw,
-      lines: errorBuffer.filter((l) => !isNoise(l)).slice(0, 20),
-      contextBefore: recentLines.slice(-15),
-      filePath,
-      lineNumber,
-      timestamp: Date.now(),
-    };
-
-    errorCallbacks.forEach((cb) => cb(chunk));
-    errorBuffer = [];
-  };
-
-  const processLine = (line: string, isErr: boolean) => {
-    recentLines.push(line);
-    if (recentLines.length > 30) recentLines.shift();
-
-    logCallbacks.forEach((cb) => cb(line, isErr));
-
-    if (isErrorLine(line)) {
-      errorBuffer.push(line);
-      if (errorTimer) clearTimeout(errorTimer);
-      errorTimer = setTimeout(flushError, 300);
-    } else if (errorBuffer.length > 0) {
-      errorBuffer.push(line);
-      if (errorTimer) clearTimeout(errorTimer);
-      errorTimer = setTimeout(flushError, 300);
-    } else if (!isErr && isInputRequest(line)) {
-      inputRequestCallbacks.forEach((cb) => cb(line.trim()));
-    }
-  };
-
-  child.stdout?.on("data", (data: Buffer) => {
-    data
-      .toString()
-      .split("\n")
-      .filter(Boolean)
-      .forEach((l) => processLine(l, false));
-  });
-
-  child.stderr?.on("data", (data: Buffer) => {
-    data
-      .toString()
-      .split("\n")
-      .filter(Boolean)
-      .forEach((l) => processLine(l, true));
-  });
-
-  child.on("close", (code) => {
-    if (errorTimer) clearTimeout(errorTimer);
-    flushError();
-    exitCallbacks.forEach((cb) => cb(code));
-  });
-
-  return {
-    kill: () => child.kill(),
-    onLog: (cb) => logCallbacks.push(cb),
-    onError: (cb) => errorCallbacks.push(cb),
-    onExit: (cb) => exitCallbacks.push(cb),
-    onInputRequest: (cb) => inputRequestCallbacks.push(cb),
-    sendInput: (text) => {
-      child.stdin?.write(text + "\n");
-    },
-  };
-}
-
-export function readFileContext(
-  filePath: string,
-  repoPath: string,
-  lineNumber?: number,
-): string {
-  const candidates = [
-    filePath,
-    path.join(repoPath, filePath),
-    path.resolve(repoPath, filePath),
-  ];
-
-  for (const p of candidates) {
-    if (!existsSync(p)) continue;
-    try {
-      const content = readFileSync(p, "utf-8");
-      if (!lineNumber) return content.slice(0, 3000);
-
-      const lines = content.split("\n");
-      const start = Math.max(0, lineNumber - 30);
-      const end = Math.min(lines.length, lineNumber + 30);
-      return lines
-        .slice(start, end)
-        .map((l, i) => `${start + i + 1}: ${l}`)
-        .join("\n");
-    } catch {
-      continue;
-    }
-  }
-  return "";
-}
-
-export function readPackageJson(repoPath: string): string {
-  const p = path.join(repoPath, "package.json");
-  if (!existsSync(p)) return "";
-  try {
-    const pkg = JSON.parse(readFileSync(p, "utf-8")) as Record<string, unknown>;
-    const deps = {
-      ...((pkg.dependencies as object) ?? {}),
-      ...((pkg.devDependencies as object) ?? {}),
-    };
-    return Object.keys(deps).slice(0, 30).join(", ");
-  } catch {
-    return "";
-  }
-}
-
-export function buildWatchPrompt(
-  chunk: ErrorChunk,
-  fileContext: string,
-  deps: string,
-  repoPath: string,
-): string {
-  return `You are a senior developer assistant watching a dev server. An error just occurred.
-
-Error output:
-\`\`\`
-${chunk.lines.join("\n").slice(0, 2000)}
-\`\`\`
-
-${chunk.contextBefore.length > 0 ? `Log context (lines before error):\n\`\`\`\n${chunk.contextBefore.join("\n")}\n\`\`\`` : ""}
-
-${fileContext ? `File content${chunk.lineNumber ? ` (around line ${chunk.lineNumber})` : ""}:\n\`\`\`\n${fileContext.slice(0, 2500)}\n\`\`\`` : ""}
-
-${deps ? `Project dependencies: ${deps}` : ""}
-Repo path: ${repoPath}
-${chunk.filePath ? `Error in file: ${chunk.filePath}` : ""}
-
-Respond ONLY with a JSON object (no markdown, no backticks) with this exact shape:
-{
-  "errorSummary": "one line — what went wrong",
-  "simplified": "2-3 sentences in plain language — what this error means and why it usually happens",
-  "fix": "specific actionable fix — reference actual file names and line numbers if known",
-  "patch": null
-}
-
-If you can provide a code fix, replace "patch" with:
-{
-  "path": "relative/file/path.ts",
-  "content": "complete corrected file content",
-  "isNew": false
-}
-
-Rules:
-- Be specific — mention actual files, variables, function names from the error
-- Don't be generic ("check if variable is defined") — say WHERE
-- patch should only be included when you are confident in the fix
-- Keep simplified under 60 words`;
-}
+import { spawn, type ChildProcess } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+
+export type WatchProcess = {
+  kill: () => void;
+  onLog: (cb: (line: string, isErr: boolean) => void) => void;
+  onError: (cb: (chunk: ErrorChunk) => void) => void;
+  onExit: (cb: (code: number | null) => void) => void;
+  onInputRequest: (cb: (prompt: string) => void) => void;
+  sendInput: (text: string) => void;
+};
+
+export type ErrorChunk = {
+  lines: string[];
+  contextBefore: string[];
+  filePath?: string;
+  lineNumber?: number;
+  timestamp: number;
+};
+
+const ERROR_PATTERNS = [
+  /error:/i,
+  /TypeError/,
+  /ReferenceError/,
+  /SyntaxError/,
+  /RangeError/,
+  /Cannot find module/,
+  /Cannot read propert/,
+  /is not defined/,
+  /is not a function/,
+  /Unhandled/,
+  /ENOENT/,
+  /EADDRINUSE/,
+  /failed to compile/i,
+  /Build failed/i,
+  /Module not found/i,
+  /unexpected token/i,
+  /Traceback \(most recent call last\)/,
+  /NameError/,
+  /AttributeError/,
+  /ImportError/,
+];
+
+const NOISE_PATTERNS = [/^\s*at\s+/, /^\s*\^+\s*$/, /^\s*$/, /^\s*warn/i];
+
+const INPUT_REQUEST_PATTERNS = [/:\s*$/, /\?\s*$/, /input/i, /press\s+\w/i];
+
+function isErrorLine(line: string): boolean {
+  return ERROR_PATTERNS.some((p) => p.test(line));
+}
+
+function isNoise(line: string): boolean {
+  return NOISE_PATTERNS.some((p) => p.test(line));
+}
+
+function isInputRequest(line: string): boolean {
+  const stripped = line.replace(/\x1b\[[0-9;]*m/g, "").trim();
+  if (!stripped) return false;
+  return INPUT_REQUEST_PATTERNS.some((p) => p.test(stripped));
+}
+
+function extractFilePath(lines: string[]): {
+  filePath?: string;
+  lineNumber?: number;
+} {
+  for (const line of lines) {
+    const m = line.match(
+      /([./][\w./\\-]+\.(tsx?|jsx?|mjs|cjs|ts|js|py)):(\d+)/,
+    );
+    if (m) return { filePath: m[1], lineNumber: parseInt(m[3]!, 10) };
+
+    const pyM = line.match(/File "([^"]+\.py)",\s*line\s*(\d+)/);
+    if (pyM) return { filePath: pyM[1], lineNumber: parseInt(pyM[2]!, 10) };
+  }
+  return {};
+}
+
+export function spawnWatch(cmd: string, cwd: string): WatchProcess {
+  const [bin, ...args] = cmd.split(/\s+/) as [string, ...string[]];
+
+  const child: ChildProcess = spawn(bin, args, {
+    cwd,
+    shell: true,
+    env: { ...process.env, FORCE_COLOR: "1" },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  const logCbs: ((line: string, isErr: boolean) => void)[] = [];
+  const errorCbs: ((chunk: ErrorChunk) => void)[] = [];
+  const exitCbs: ((code: number | null) => void)[] = [];
+  const inputCbs: ((prompt: string) => void)[] = [];
+
+  const recentLines: string[] = [];
+  let errorBuffer: string[] = [];
+  let errorTimer: ReturnType<typeof setTimeout> | null = null;
+  const seenErrors = new Set<string>();
+
+  const flushError = () => {
+    if (errorBuffer.length === 0) return;
+    const key = errorBuffer.slice(0, 3).join("\n").slice(0, 120);
+    if (seenErrors.has(key)) { errorBuffer = []; return; }
+    seenErrors.add(key);
+
+    const { filePath, lineNumber } = extractFilePath(errorBuffer);
+    const chunk: ErrorChunk = {
+      lines: errorBuffer.filter((l) => !isNoise(l)).slice(0, 20),
+      contextBefore: recentLines.slice(-15),
+      filePath,
+      lineNumber,
+      timestamp: Date.now(),
+    };
+    errorCbs.forEach((cb) => cb(chunk));
+    errorBuffer = [];
+  };
+
+  const processLine = (line: string, isErr: boolean) => {
+    recentLines.push(line);
+    if (recentLines.length > 30) recentLines.shift();
+    logCbs.forEach((cb) => cb(line, isErr));
+
+    if (isErrorLine(line)) {
+      errorBuffer.push(line);
+      if (errorTimer) clearTimeout(errorTimer);
+      errorTimer = setTimeout(flushError, 300);
+    } else if (errorBuffer.length > 0) {
+      errorBuffer.push(line);
+      if (errorTimer) clearTimeout(errorTimer);
+      errorTimer = setTimeout(flushError, 300);
+    } else if (!isErr && isInputRequest(line)) {
+      inputCbs.forEach((cb) => cb(line.trim()));
+    }
+  };
+
+  child.stdout?.on("data", (data: Buffer) =>
+    data.toString().split("\n").filter(Boolean).forEach((l) => processLine(l, false)),
+  );
+  child.stderr?.on("data", (data: Buffer) =>
+    data.toString().split("\n").filter(Boolean).forEach((l) => processLine(l, true)),
+  );
+  child.on("close", (code) => {
+    if (errorTimer) clearTimeout(errorTimer);
+    flushError();
+    exitCbs.forEach((cb) => cb(code));
+  });
+
+  return {
+    kill: () => child.kill(),
+    onLog: (cb) => logCbs.push(cb),
+    onError: (cb) => errorCbs.push(cb),
+    onExit: (cb) => exitCbs.push(cb),
+    onInputRequest: (cb) => inputCbs.push(cb),
+    sendInput: (text) => { child.stdin?.write(text + "\n"); },
+  };
+}
+
+export function readPackageJson(repoPath: string): string {
+  const p = path.join(repoPath, "package.json");
+  if (!existsSync(p)) return "";
+  try {
+    const pkg = JSON.parse(readFileSync(p, "utf-8")) as Record<string, unknown>;
+    const deps = { ...((pkg.dependencies as object) ?? {}), ...((pkg.devDependencies as object) ?? {}) };
+    return Object.keys(deps).slice(0, 30).join(", ");
+  } catch { return ""; }
+}

package/tests/message.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "bun:test";
+import { extractText } from "../src/components/Message";
+
+describe("extractText", () => {
+  it("returns a plain string as-is", () => {
+    expect(extractText("hello world")).toBe("hello world");
+  });
+
+  it("extracts text from a content array", () => {
+    const content = [
+      { type: "text", text: "hello " },
+      { type: "text", text: "world" },
+    ];
+    expect(extractText(content)).toBe("hello world");
+  });
+
+  it("skips non-text content blocks", () => {
+    const content = [
+      { type: "image", url: "http://example.com/img.png" },
+      { type: "text", text: "caption" },
+    ];
+    expect(extractText(content)).toBe("caption");
+  });
+
+  it("returns empty string for null / undefined", () => {
+    expect(extractText(null)).toBe("");
+    expect(extractText(undefined)).toBe("");
+  });
+
+  it("returns empty string for empty array", () => {
+    expect(extractText([])).toBe("");
+  });
+
+  it("handles missing text field gracefully", () => {
+    const content = [{ type: "text" }];
+    expect(extractText(content)).toBe("");
+  });
+});

package/tests/toolcall-utils.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "bun:test";
+import { extractFileDiff, getLabel, getArgDetail } from "../src/components/toolcall-utils";
+
+describe("getLabel", () => {
+  it("returns running label for known tools", () => {
+    expect(getLabel("read_file", true)).toBe("Reading");
+    expect(getLabel("write_file", true)).toBe("Writing");
+    expect(getLabel("bash", true)).toBe("Running");
+    expect(getLabel("ls", true)).toBe("Listing");
+    expect(getLabel("str_replace", true)).toBe("Editing");
+  });
+
+  it("returns done label for known tools", () => {
+    expect(getLabel("read_file", false)).toBe("Read");
+    expect(getLabel("write_file", false)).toBe("Wrote");
+    expect(getLabel("bash", false)).toBe("Ran");
+    expect(getLabel("ls", false)).toBe("Listed");
+    expect(getLabel("create_file", false)).toBe("Created");
+  });
+
+  it("falls back gracefully for unknown tools", () => {
+    expect(getLabel("some_tool", true)).toBe("Some tooling");
+    expect(getLabel("some_tool", false)).toBe("Some tooled");
+  });
+});
+
+describe("extractFileDiff", () => {
+  it("returns null for non-object args", () => {
+    expect(extractFileDiff("write_file", null)).toBeNull();
+    expect(extractFileDiff("write_file", "string")).toBeNull();
+  });
+
+  it("returns null when no path in args", () => {
+    expect(extractFileDiff("write_file", { content: "hello" })).toBeNull();
+  });
+
+  it("returns path with empty diff for read tools", () => {
+    const result = extractFileDiff("read_file", { path: "src/foo.ts" });
+    expect(result).toEqual({ path: "src/foo.ts", removals: [], additions: [] });
+  });
+
+  it("handles file_path and filename aliases", () => {
+    expect(extractFileDiff("read", { file_path: "a.ts" })?.path).toBe("a.ts");
+    expect(extractFileDiff("read", { filename: "b.ts" })?.path).toBe("b.ts");
+  });
+
+  it("parses str_replace style args (old_string / new_string)", () => {
+    const result = extractFileDiff("str_replace", {
+      path: "src/foo.ts",
+      old_string: "const x = 1;\nconst y = 2;",
+      new_string: "const x = 10;",
+    });
+    expect(result?.path).toBe("src/foo.ts");
+    expect(result?.removals).toEqual(["const x = 1;", "const y = 2;"]);
+    expect(result?.additions).toEqual(["const x = 10;"]);
+  });
+
+  it("parses old_str / new_str aliases", () => {
+    const result = extractFileDiff("edit", {
+      path: "foo.ts",
+      old_str: "old",
+      new_str: "new",
+    });
+    expect(result?.removals).toEqual(["old"]);
+    expect(result?.additions).toEqual(["new"]);
+  });
+
+  it("parses full content write with no previous content", () => {
+    const result = extractFileDiff("write_file", {
+      path: "new.ts",
+      content: "line1\nline2\nline3",
+    });
+    expect(result?.removals).toEqual([]);
+    expect(result?.additions).toEqual(["line1", "line2", "line3"]);
+  });
+
+  it("includes prev content as removals when _prevContent is present", () => {
+    const result = extractFileDiff("write_file", {
+      path: "existing.ts",
+      content: "new content",
+      _prevContent: "old content\nmore old",
+    });
+    expect(result?.removals).toEqual(["old content", "more old"]);
+    expect(result?.additions).toEqual(["new content"]);
+  });
+
+  it("returns empty diff for file tool with no content args", () => {
+    const result = extractFileDiff("write_file", { path: "foo.ts" });
+    expect(result).toEqual({ path: "foo.ts", removals: [], additions: [] });
+  });
+});
+
+describe("getArgDetail", () => {
+  it("returns path when present", () => {
+    expect(getArgDetail("read", { path: "src/index.ts" })).toBe("src/index.ts");
+  });
+
+  it("prefers path over other fields", () => {
+    expect(getArgDetail("bash", { path: "foo.ts", command: "ls" })).toBe("foo.ts");
+  });
+
+  it("falls back to query/command when no path", () => {
+    expect(getArgDetail("bash", { command: "npm install" })).toBe("npm install");
+    expect(getArgDetail("grep", { query: "TODO" })).toBe("TODO");
+  });
+
+  it("handles non-object args", () => {
+    expect(getArgDetail("tool", null)).toBe("");
+    expect(getArgDetail("tool", "plain")).toBe("plain");
+  });
+});

package/tsconfig.json

@@ -1,24 +1,8 @@
-{
-  "compilerOptions": {
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "jsx": "react-jsx",
-    "allowJs": true,
-    "outDir": "dist",
-    "esModuleInterop": true,
-    "verbatimModuleSyntax": true,
-
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  },
-  "include": ["src"]
-}
+{
+  "extends": "@ridit/typescript-config/base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}