@ridit/lens 0.3.7 → 0.3.8

package/src/components/chat/hooks/useCommandHandlers.ts

@@ -66,10 +66,6 @@ function makeMsg(content: string): Message {
   return { role: "assistant", content, type: "text" };
 }
 
-/**
- * Returns true if the command was handled, false if it should fall through
- * to the normal message flow.
- */
 export function handleCommand(text: string, ctx: CommandContext): boolean {
   const t = text.trim().toLowerCase();
 

package/src/components/repo/RepoAnalysis.tsx

@@ -105,7 +105,7 @@ function AskingFilesStep() {
   return (
     <Box gap={1}>
       <Text color={ACCENT}>
-        <Spinner />
+        <Spinner type="moon" />
       </Text>
       <Text color={ACCENT}>{phrase}</Text>
     </Box>
@@ -117,7 +117,7 @@ function AnalyzingStep() {
   return (
     <Box gap={1}>
       <Text color={ACCENT}>
-        <Spinner />
+        <Spinner type="earth" />
       </Text>
       <Text color={ACCENT}>{phrase}</Text>
     </Box>
@@ -366,7 +366,7 @@ export const RepoAnalysis = ({
     return (
       <Box marginTop={1}>
         <Text color={ACCENT}>
-          <Spinner />
+          <Spinner type="arc" />
         </Text>
         <Box marginLeft={1}>
           <Text>Writing file...</Text>

package/src/components/task/TaskRunner.tsx

@@ -88,7 +88,7 @@ function ThinkingAboutStep({ prompt }: { prompt: string }) {
   return (
     <Box gap={1}>
       <Text color={ACCENT}>
-        <Spinner />
+        <Spinner type="triangle" />
       </Text>
       <Text color={ACCENT}>{phrase}</Text>
       <Text color="gray">"{prompt}"</Text>
@@ -270,7 +270,7 @@ export const PromptRunner = ({
     return (
       <Box marginTop={1} gap={1}>
         <Text color={ACCENT}>
-          <Spinner />
+          <Spinner type="dots2" />
         </Text>
         <Text>Reading codebase...</Text>
       </Box>
@@ -322,7 +322,7 @@ export const PromptRunner = ({
     return (
       <Box marginTop={1} gap={1}>
         <Text color={ACCENT}>
-          <Spinner />
+          <Spinner type="bouncingBar" />
         </Text>
         <Text>Applying changes...</Text>
       </Box>

package/src/index.tsx

@@ -16,6 +16,11 @@ import { loadAddons } from "./utils/addons/loadAddons";
 registerBuiltins();
 await loadAddons();
 
+if (process.stdout.isTTY) {
+  process.stdout.write("\x1b[>4;1m");
+  process.on("exit", () => process.stdout.write("\x1b[>4;0m"));
+}
+
 const program = new Command();
 
 program
@@ -51,8 +56,14 @@ program
   .command("chat")
   .description("Chat with your codebase — ask questions or make changes")
   .option("-p, --path <path>", "Path to the repo", ".")
-  .action((opts: { path: string }) => {
-    render(<ChatCommand path={opts.path} />);
+  .option(
+    "--auto-force",
+    "Start with force-all mode enabled (auto-approves all tools)",
+  )
+  .action((opts: { path: string; autoForce: boolean }) => {
+    render(
+      <ChatCommand path={opts.path} autoForce={opts.autoForce ?? false} />,
+    );
   });
 
 program

package/src/prompts/system.ts

@@ -46,23 +46,22 @@ Use memory-delete when the user asks you to forget something or a memory is outd
  
 1. ONE tool per response — emit the XML tag, then stop. Never chain tools in one response except when scaffolding (see below).
 2. NEVER call a tool more than once for the same path in a session. If write-file or shell returned a result, it succeeded. Move on immediately.
-3. NEVER write the same file twice in one session. One write per file, period. If you already wrote it, it is done.
-4. shell is ONLY for running code, installing packages, building, and testing. NEVER use shell to inspect the filesystem or read files — use read-file, read-folder, or grep instead.
-5. write-file content must be the COMPLETE file content, never a placeholder or partial.
-6. NEVER read a file you just wrote. The write output confirms success.
-7. NEVER apologize and redo a tool call — one attempt is enough, trust the output.
-8. NEVER use shell to run git clone — use the clone tag instead.
-9. When the user asks you to CREATE a new file, write it immediately — do NOT read first.
-10. When the user asks you to MODIFY or FIX an existing file, read it first, then write the complete updated version ONCE.
-11. When fixing multiple files, use read-files to read ALL of them first, then write each one ONCE sequentially — never rewrite a file already written this session.
-12. If a read-folder or read-file returns not found, accept it and move on — do NOT retry the same path.
-13. Every shell command runs from the repo root — cd has no persistent effect. Use full paths or combine with && e.g. cd myapp && bun run index.ts
-14. write-file paths are relative to the repo root — use full relative paths e.g. myapp/src/index.tsx not src/index.tsx
-15. When explaining how to use a tool in text, use [tag] bracket notation — NEVER emit a real XML tool tag as part of an explanation.
-16. NEVER use markdown formatting in plain text responses — no bold, no headings, no bullet points. Only use fenced code blocks when showing actual code.
-17. When scaffolding multiple files, emit ONE write-file tag per response and wait for the result before writing the next file.
-18. When you identify a bug or error, ALWAYS write the fix immediately using write-file or changes. Never describe the fix without writing it.
-19. NEVER use shell for filesystem inspection or searching — always use grep, read-file, or read-folder instead.
+3. shell is ONLY for running code, installing packages, building, and testing. NEVER use shell to inspect the filesystem or read files — use read-file, read-folder, or grep instead.
+4. NEVER use shell to run git clone — use the clone tag instead.
+5. NEVER read a file you just wrote. The write output confirms success.
+6. NEVER apologize and redo a tool call — one attempt is enough, trust the output.
+7. When the user asks you to CREATE a brand new file, use write-file immediately — do NOT read first. write-file content must be the COMPLETE file content.
+8. When the user asks you to MODIFY or FIX an existing file, read it first, then propose the edit using changes — NEVER use write-file on an existing file.
+9. When fixing multiple files, use read-files to read ALL of them first, then emit one changes tag with all patches together.
+10. If a read-folder or read-file returns not found, accept it and move on — do NOT retry the same path.
+11. Every shell command runs from the repo root — cd has no persistent effect. Use full paths or combine with && e.g. cd myapp && bun run index.ts
+12. write-file paths are relative to the repo root — use full relative paths e.g. myapp/src/index.tsx not src/index.tsx
+13. When explaining how to use a tool in text, use [tag] bracket notation — NEVER emit a real XML tool tag as part of an explanation.
+14. NEVER use markdown formatting in plain text responses — no bold, no headings, no bullet points. Only use fenced code blocks when showing actual code.
+15. When scaffolding multiple NEW files, emit ONE write-file per response and wait for the result before writing the next file.
+16. When you identify a bug or error, ALWAYS propose the fix immediately using changes. Never describe the fix without proposing it.
+17. NEVER use shell for filesystem inspection or searching — always use grep, read-file, or read-folder instead.
+18. changes patches must include the COMPLETE new file content for each path — never partial content.
  
 ## ADDON FORMAT
  

package/src/types/chat.ts

@@ -33,7 +33,8 @@ export type Message =
         | "delete-folder"
         | "open-url"
         | "generate-pdf"
-        | "search";
+        | "search"
+        | "changes";
       content: string;
       result: string;
       approved: boolean;
@@ -43,6 +44,7 @@ export type Message =
       type: "plan";
       content: string;
       patches: FilePatch[];
+      diffLines?: DiffLine[][];
       applied: boolean;
     };
 

package/src/utils/chat.ts

@@ -195,12 +195,22 @@ export function toCloneUrl(url: string): string {
   return clean.endsWith(".git") ? clean : `${clean}.git`;
 }
 
+// Replace buildApiMessages in src/utils/chat.ts
+
 function buildApiMessages(
   messages: Message[],
 ): { role: string; content: string }[] {
   const recent = messages.slice(-MAX_HISTORY);
 
-  return recent.map((m) => {
+  const writtenFiles: string[] = [];
+  for (const m of recent) {
+    if (m.type === "tool" && m.toolName === "write-file" && m.approved) {
+      const pathMatch = m.content.match(/^(.+?)\s*\(/);
+      if (pathMatch?.[1]) writtenFiles.push(pathMatch[1]);
+    }
+  }
+
+  return recent.map((m, idx) => {
     if (m.type === "tool") {
       if (!m.approved) {
         return {
@@ -209,11 +219,39 @@ function buildApiMessages(
             "The tool call was denied by the user. Please respond without using that tool.",
         };
       }
+
+      if (m.toolName === "write-file") {
+        const remaining = writtenFiles.slice(
+          writtenFiles.indexOf(m.content.split(" (")[0]!) + 1,
+        );
+        const doneList = writtenFiles
+          .slice(0, writtenFiles.indexOf(m.content.split(" (")[0]!) + 1)
+          .map((f) => `- ${f}`)
+          .join("\n");
+
+        return {
+          role: "user",
+          content: [
+            `Tool result for write-file (${m.content}):`,
+            "",
+            m.result,
+            "",
+            `Files written so far:`,
+            doneList || `- ${m.content.split(" (")[0]}`,
+            "",
+            remaining.length > 0
+              ? `Continue with the NEXT file. Do NOT rewrite any file already written above.`
+              : `All files written. Summarize what was created.`,
+          ].join("\n"),
+        };
+      }
+
       return {
         role: "user",
-        content: `Here is the output from the ${m.toolName} of ${m.content}:\n\n${m.result}\n\nPlease continue your response based on this output.`,
+        content: `Tool result for ${m.toolName} (${m.content}):\n\n${m.result}\n\nPlease continue your response based on this output.`,
       };
     }
+
     return { role: m.role, content: m.content };
   });
 }
@@ -262,7 +300,7 @@ export async function callChat(
   }
 
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 60_000);
+  const timer = setTimeout(() => controller.abort(), 180_000);
   abortSignal?.addEventListener("abort", () => controller.abort());
 
   try {
@@ -310,7 +348,22 @@ export async function callChat(
     }
   } catch (err) {
     clearTimeout(timer);
-    if (err instanceof Error && err.name === "AbortError") throw err;
+    if (err instanceof Error && err.name === "AbortError") {
+      if (abortSignal?.aborted) throw err;
+      if (retries > 0) {
+        await new Promise((r) => setTimeout(r, 1500));
+        return callChat(
+          provider,
+          systemPrompt,
+          messages,
+          abortSignal,
+          retries - 1,
+        );
+      }
+      throw new Error(
+        "Request timed out. The model took too long to respond (>3 min).",
+      );
+    }
     if (retries > 0) {
       await new Promise((r) => setTimeout(r, 1500));
       return callChat(

package/src/utils/intentClassifier.ts

@@ -1,48 +1,33 @@
-/**
- * Classifies user message intent to scope which tools the LLM is allowed to use.
- *
- * readonly  → only read/search/fetch tools exposed (no write, delete, shell)
- * mutating  → all tools exposed
- * any       → all tools exposed (ambiguous / can't tell)
- */
 export type Intent = "readonly" | "mutating" | "any";
 
 const READONLY_PATTERNS: RegExp[] = [
-  // listing / exploring
   /\b(list|ls|dir|show|display|print|dump)\b/i,
   /\bwhat(('?s| is| are| does)\b| files| folder)/i,
   /\b(folder|directory|file) (structure|tree|layout|contents?)\b/i,
   /\bexplore\b/i,
 
-  // reading / explaining
   /\b(read|open|view|look at|check out|inspect|peek)\b/i,
   /\b(explain|describe|summarize|summarise|tell me about|walk me through)\b/i,
   /\bhow does\b/i,
   /\bwhat('?s| is) (in|inside|this|that|the)\b/i,
 
-  // searching
   /\b(find|search|grep|locate|where is|where are)\b/i,
   /\b(look for|scan|trace)\b/i,
 
-  // understanding
   /\bunderstand\b/i,
   /\bshow me (how|what|where|why)\b/i,
 ];
 
 const MUTATING_PATTERNS: RegExp[] = [
-  // writing
   /\b(write|create|make|generate|add|build|scaffold|init|initialize|setup|set up)\b/i,
   /\b(new file|new folder|new component|new page|new route)\b/i,
 
-  // editing
   /\b(edit|modify|update|change|refactor|rename|move|migrate)\b/i,
   /\b(fix|patch|resolve|correct|debug|repair)\b/i,
   /\b(implement|add .+ to|insert|inject|append|prepend)\b/i,
 
-  // deleting
   /\b(delete|remove|drop|clean ?up|purge|wipe)\b/i,
 
-  // running
   /\b(run|execute|install|deploy|build|test|start|launch|compile|lint|format)\b/i,
 ];
 

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,41 +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) => {
+    const tryParse = (s: string): WriteFileInput | null => {
       try {
-        const parsed = JSON.parse(s) as { path: string; content: string };
-        if (!parsed.path || parsed.content === undefined) return null;
-        return { ...parsed, path: parsed.path.replace(/\\/g, "/") };
+        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 sanitized = body
         .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "")
-        .replace(/\n/g, "\\n")
-        .replace(/\r/g, "\\r")
-        .replace(/\t/g, "\\t");
+        .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 && contentMatch && contentMatch[1] !== undefined) {
+    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(/\\t/g, "\t"),
+        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),