@ridit/lens 0.3.6 → 0.3.8

package/src/utils/thinking.tsx

@@ -1,5 +1,23 @@
 import { useEffect, useRef, useState } from "react";
 
+const TIPS = [
+  "use /auto to toggle auto-approve for safe tools",
+  "ctrl+f to toggle force-all mode",
+  "shift+enter for a new line in the input",
+  "↑ / ↓ arrows navigate message history",
+  "ctrl+w deletes the previous word",
+  "ctrl+delete deletes the next word",
+  "/timeline to browse commit history",
+  "/review to analyze the current codebase",
+  "/memory list to view stored memories",
+  "/chat list to see saved conversations",
+  "esc cancels a running response",
+  "/clear history resets session memory",
+  "tab autocompletes slash commands",
+  "lens commit --auto for fast AI commits",
+  "lens run \"bun dev\" to watch and auto-fix errors",
+];
+
 const PHRASES: Record<string, string[]> = {
   general: [
     "marinating on that... 🍖",
@@ -321,6 +339,52 @@ const PHRASES: Record<string, string[]> = {
 
 export type ThinkingKind = keyof typeof PHRASES;
 
+export function useThinkingTip(active: boolean, intervalMs = 8000): string {
+  const [index, setIndex] = useState(() => Math.floor(Math.random() * TIPS.length));
+  const usedRef = useRef<Set<number>>(new Set());
+
+  useEffect(() => {
+    if (!active) return;
+    const pickUnused = () => {
+      if (usedRef.current.size >= TIPS.length) usedRef.current.clear();
+      let next: number;
+      do {
+        next = Math.floor(Math.random() * TIPS.length);
+      } while (usedRef.current.has(next));
+      usedRef.current.add(next);
+      return next;
+    };
+    setIndex(pickUnused());
+    const id = setInterval(() => setIndex(pickUnused()), intervalMs);
+    return () => clearInterval(id);
+  }, [active, intervalMs]);
+
+  return TIPS[index]!;
+}
+
+export function useThinkingTimer(active: boolean): string {
+  const [seconds, setSeconds] = useState(0);
+  const startRef = useRef<number | null>(null);
+
+  useEffect(() => {
+    if (active) {
+      startRef.current = Date.now();
+      setSeconds(0);
+      const id = setInterval(() => {
+        setSeconds(Math.floor((Date.now() - (startRef.current ?? Date.now())) / 1000));
+      }, 1000);
+      return () => clearInterval(id);
+    } else {
+      startRef.current = null;
+      setSeconds(0);
+    }
+  }, [active]);
+
+  if (!active || seconds === 0) return "";
+  if (seconds < 60) return `${seconds}s`;
+  return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+
 export function useThinkingPhrase(
   active: boolean,
   kind: ThinkingKind = "general",

package/src/utils/tools/builtins.ts

@@ -136,15 +136,56 @@ export const writeFileTool: Tool<WriteFileInput> = {
   systemPromptEntry: (i) =>
     `### ${i}. write-file — create or overwrite a file\n<write-file>\n{"path": "data/output.csv", "content": "col1,col2\\nval1,val2"}\n</write-file>`,
   parseInput: (body) => {
+    const tryParse = (s: string): WriteFileInput | null => {
+      try {
+        const parsed = JSON.parse(s) as { path?: unknown; content?: unknown };
+        if (
+          typeof parsed.path !== "string" ||
+          typeof parsed.content !== "string"
+        )
+          return null;
+        return {
+          path: parsed.path.replace(/\\/g, "/"),
+          content: parsed.content,
+        };
+      } catch {
+        return null;
+      }
+    };
+
+    // attempt 1: parse as-is
+    const first = tryParse(body.trim());
+    if (first) return first;
+
+    // attempt 2: escape unescaped control characters
     try {
-      const parsed = JSON.parse(body) as { path: string; content: string };
-      if (!parsed.path) return null;
-      return { ...parsed, path: parsed.path.replace(/\\/g, "/") };
-    } catch {
-      return null;
+      const sanitized = body
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "")
+        .replace(/(?<!\\)\n/g, "\\n")
+        .replace(/(?<!\\)\r/g, "\\r")
+        .replace(/(?<!\\)\t/g, "\\t");
+      const second = tryParse(sanitized);
+      if (second) return second;
+    } catch {}
+
+    // attempt 3: regex extraction as last resort
+    const pathMatch = body.match(/"path"\s*:\s*"([^"]+)"/);
+    const contentMatch = body.match(/"content"\s*:\s*"([\s\S]*?)"\s*}?\s*$/);
+    if (pathMatch?.[1] && contentMatch?.[1] !== undefined) {
+      return {
+        path: pathMatch[1].replace(/\\/g, "/"),
+        content: contentMatch[1]
+          .replace(/\\n/g, "\n")
+          .replace(/\\r/g, "\r")
+          .replace(/\\t/g, "\t"),
+      };
     }
+
+    return null;
   },
-  summariseInput: ({ path, content }) => `${path} (${content.length} bytes)`,
+  // null-safe — parseInput can return null if AI sends malformed JSON
+  summariseInput: (input) =>
+    input ? `${input.path} (${input.content.length} bytes)` : "unknown file",
   execute: ({ path: filePath, content }, ctx) => ({
     kind: "text",
     value: writeFile(filePath, content, ctx.repoPath),