@ridit/lens 0.3.6 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ridit/lens",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "Know Your Codebase.",
   "author": "Ridit Jangra <riditjangra09@gmail.com> (https://ridit.space)",
   "license": "MIT",

package/src/components/chat/ChatOverlays.tsx

@@ -1,7 +1,7 @@
 import React from "react";
-import { Box, Static, Text } from "ink";
+import { Box, Static, Text, useStdout } from "ink";
 import Spinner from "ink-spinner";
-import TextInput from "ink-text-input";
+import { TextArea } from "./TextArea";
 import { ACCENT, GREEN, RED } from "../../colors";
 import { DiffViewer } from "../repo/DiffViewer";
 import { StaticMessage } from "./ChatMessage";
@@ -134,25 +134,24 @@ export function InputBox({
   onSubmit: (v: string) => void;
   inputKey?: number;
 }) {
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  const rule = "─".repeat(Math.max(1, cols));
+
   return (
-    <Box
-      marginTop={1}
-      borderBottom
-      borderTop
-      borderRight={false}
-      borderLeft={false}
-      borderColor={"gray"}
-      borderStyle="single"
-    >
+    <Box flexDirection="column" marginTop={1}>
+      <Text color="gray" dimColor>{rule}</Text>
       <Box gap={1}>
         <Text color={ACCENT}>{">"}</Text>
-        <TextInput
+        <TextArea
           key={inputKey}
           value={value}
           onChange={onChange}
           onSubmit={onSubmit}
+          placeholder="ask anything..."
         />
       </Box>
+      <Text color="gray" dimColor>{rule}</Text>
     </Box>
   );
 }
@@ -196,7 +195,7 @@ export function ShortcutBar({
   return (
     <Box gap={3} marginTop={0}>
       <Text color="gray" dimColor>
-        enter send · ^v paste · ^c exit
+        enter send · alt+enter newline · ^w del word · ^c exit
       </Text>
       {forceApprove ? (
         <Text color={RED}>⚡⚡ force-all</Text>

package/src/components/chat/ChatRunner.tsx

@@ -4,7 +4,7 @@ import Spinner from "ink-spinner";
 import { useState } from "react";
 import path from "path";
 import os from "os";
-import TextInput from "ink-text-input";
+import { TextArea } from "./TextArea";
 import { ACCENT } from "../../colors";
 import { ProviderPicker } from "../provider/ProviderPicker";
 import { startCloneRepo } from "../../utils/repo";
@@ -136,7 +136,7 @@ function ForceAllWarning({
           esc
         </Text>
         <Text color="gray"> to cancel: </Text>
-        <TextInput
+        <TextArea
           value={input}
           onChange={setInput}
           onSubmit={(v) => onConfirm(v.trim().toLowerCase() === "yes")}

package/src/components/chat/TextArea.tsx

@@ -0,0 +1,176 @@
+import React, { useState, useEffect } from "react";
+import { Text, useInput } from "ink";
+import chalk from "chalk";
+
+function isWordChar(ch: string): boolean {
+  return /[\w]/.test(ch);
+}
+
+function wordBoundaryLeft(text: string, pos: number): number {
+  if (pos <= 0) return 0;
+  let i = pos - 1;
+
+  while (i > 0 && !isWordChar(text[i]!)) i--;
+
+  while (i > 0 && isWordChar(text[i - 1]!)) i--;
+  return i;
+}
+
+function wordBoundaryRight(text: string, pos: number): number {
+  const len = text.length;
+  if (pos >= len) return len;
+  let i = pos;
+
+  while (i < len && isWordChar(text[i]!)) i++;
+
+  while (i < len && !isWordChar(text[i]!)) i++;
+  return i;
+}
+
+export interface TextAreaProps {
+  value: string;
+  onChange: (value: string) => void;
+  onSubmit: (value: string) => void;
+  focus?: boolean;
+  placeholder?: string;
+}
+
+export function TextArea({
+  value,
+  onChange,
+  onSubmit,
+  focus = true,
+  placeholder = "",
+}: TextAreaProps) {
+  const [cursor, setCursor] = useState(value.length);
+  const [prevValue, setPrevValue] = useState(value);
+
+  if (value !== prevValue) {
+    setPrevValue(value);
+    const lenDiff = Math.abs(value.length - prevValue.length);
+    if (cursor > value.length || lenDiff > 1) {
+      setCursor(value.length);
+    }
+  }
+
+  useInput(
+    (input, key) => {
+      if (key.upArrow || key.downArrow) return;
+      if (key.tab || (key.shift && key.tab)) return;
+      if (key.ctrl && input === "c") return;
+
+      if (key.return && !key.meta) {
+        onSubmit(value);
+        return;
+      }
+
+      if ((key.return && key.meta) || (key.ctrl && input === "j")) {
+        const next = value.slice(0, cursor) + "\n" + value.slice(cursor);
+        onChange(next);
+        setCursor((c) => c + 1);
+        return;
+      }
+
+      if (key.leftArrow && key.ctrl) {
+        setCursor(wordBoundaryLeft(value, cursor));
+        return;
+      }
+
+      if (key.rightArrow && key.ctrl) {
+        setCursor(wordBoundaryRight(value, cursor));
+        return;
+      }
+
+      if (key.leftArrow) {
+        setCursor((c) => Math.max(0, c - 1));
+        return;
+      }
+
+      if (key.rightArrow) {
+        setCursor((c) => Math.min(value.length, c + 1));
+        return;
+      }
+
+      if (key.ctrl && input === "a") {
+        const lineStart = value.lastIndexOf("\n", cursor - 1) + 1;
+        setCursor(lineStart);
+        return;
+      }
+
+      if (key.ctrl && input === "e") {
+        const lineEnd = value.indexOf("\n", cursor);
+        setCursor(lineEnd === -1 ? value.length : lineEnd);
+        return;
+      }
+
+      if (key.ctrl && input === "u") {
+        const lineStart = value.lastIndexOf("\n", cursor - 1) + 1;
+        onChange(value.slice(0, lineStart) + value.slice(cursor));
+        setCursor(lineStart);
+        return;
+      }
+
+      if (key.ctrl && input === "k") {
+        const lineEnd = value.indexOf("\n", cursor);
+        onChange(
+          value.slice(0, cursor) + (lineEnd === -1 ? "" : value.slice(lineEnd)),
+        );
+        return;
+      }
+
+      if (key.ctrl && input === "w") {
+        const to = wordBoundaryLeft(value, cursor);
+        onChange(value.slice(0, to) + value.slice(cursor));
+        setCursor(to);
+        return;
+      }
+
+      if (key.ctrl && key.delete) {
+        const to = wordBoundaryRight(value, cursor);
+        onChange(value.slice(0, cursor) + value.slice(to));
+        return;
+      }
+
+      if (key.backspace || key.delete) {
+        if (cursor > 0) {
+          onChange(value.slice(0, cursor - 1) + value.slice(cursor));
+          setCursor((c) => c - 1);
+        }
+        return;
+      }
+
+      if (key.escape) return;
+
+      if (input) {
+        const next = value.slice(0, cursor) + input + value.slice(cursor);
+        onChange(next);
+        setCursor((c) => c + input.length);
+      }
+    },
+    { isActive: focus },
+  );
+
+  if (value.length === 0 && placeholder) {
+    return (
+      <Text>
+        {chalk.inverse(placeholder[0] ?? " ")}
+        {placeholder.length > 1 ? chalk.gray(placeholder.slice(1)) : ""}
+      </Text>
+    );
+  }
+
+  let rendered = "";
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i]!;
+    if (i === cursor) {
+      rendered += ch === "\n" ? chalk.inverse(" ") + "\n" : chalk.inverse(ch);
+    } else {
+      rendered += ch;
+    }
+  }
+  if (cursor === value.length) {
+    rendered += chalk.inverse(" ");
+  }
+
+  return <Text>{rendered}</Text>;
+}

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

@@ -13,6 +13,8 @@ import {
   buildMemorySummary,
   addMemory,
   deleteMemory,
+  getSessionToolSummary,
+  logToolCall,
 } from "../../../utils/memory";
 import { fetchFileTree, readImportantFiles } from "../../../utils/files";
 import { readLensFile } from "../../../utils/lensfile";
@@ -26,6 +28,7 @@ import {
   buildSystemPrompt,
   parseResponse,
   callChat,
+  type ChatResult,
 } from "../../../utils/chat";
 
 export function useChat(repoPath: string) {
@@ -90,32 +93,26 @@ export function useChat(repoPath: string) {
     setStage({ type: "idle" });
   };
 
-  const TOOL_TAG_NAMES = [
-    "shell",
-    "fetch",
-    "read-file",
-    "read-folder",
-    "grep",
-    "write-file",
-    "delete-file",
-    "delete-folder",
-    "open-url",
-    "generate-pdf",
-    "search",
-    "clone",
-    "changes",
-  ];
+  const MAX_AUTO_CONTINUES = 3;
 
   function isLikelyTruncated(text: string): boolean {
-    return TOOL_TAG_NAMES.some(
-      (tag) => text.includes(`<${tag}>`) && !text.includes(`</${tag}>`),
-    );
+    // Check unclosed XML tool tags (dynamic — includes addon tools)
+    for (const tag of registry.names()) {
+      if (text.includes(`<${tag}>`) && !text.includes(`</${tag}>`))
+        return true;
+    }
+    // Check unclosed fenced code blocks (```tool\n... without closing ```)
+    const fences = text.match(/```/g);
+    if (fences && fences.length % 2 !== 0) return true;
+    return false;
   }
 
   const processResponse = (
     raw: string,
     currentAll: Message[],
     signal: AbortSignal,
+    truncated = false,
+    continueCount = 0,
   ) => {
     if (signal.aborted) {
       batchApprovedRef.current = false;
@@ -123,16 +120,73 @@ export function useChat(repoPath: string) {
       return;
     }
 
-    if (isLikelyTruncated(raw)) {
-      const truncMsg: Message = {
+    if (truncated || isLikelyTruncated(raw)) {
+      if (continueCount >= MAX_AUTO_CONTINUES) {
+        // Give up after max attempts — show whatever we have
+        batchApprovedRef.current = false;
+        const msg: Message = {
+          role: "assistant",
+          content:
+            raw.trim() ||
+            "(response was empty after multiple continuation attempts)",
+          type: "text",
+        };
+        setAllMessages([...currentAll, msg]);
+        setCommitted((prev) => [...prev, msg]);
+        setStage({ type: "idle" });
+        return;
+      }
+
+      // Include the partial response so the model knows where it left off
+      const partialMsg: Message = {
         role: "assistant",
+        content: raw,
+        type: "text",
+      };
+      const nudgeMsg: Message = {
+        role: "user",
         content:
-          "(response cut off — the model hit its output limit mid-tool-call. Try asking it to continue, or simplify the request.)",
+          "Your response was cut off. Please continue exactly from where you left off.",
+        type: "text",
+      };
+      const withContext = [...currentAll, partialMsg, nudgeMsg];
+
+      const truncMsg: Message = {
+        role: "assistant",
+        content: `(response cut off — auto-continuing ${continueCount + 1}/${MAX_AUTO_CONTINUES}…)`,
         type: "text",
       };
       setAllMessages([...currentAll, truncMsg]);
       setCommitted((prev) => [...prev, truncMsg]);
-      setStage({ type: "idle" });
+
+      const currentProvider = providerRef.current;
+      const currentSystemPrompt = systemPromptRef.current;
+
+      if (!currentProvider) {
+        setStage({ type: "idle" });
+        return;
+      }
+
+      const nextAbort = new AbortController();
+      abortControllerRef.current = nextAbort;
+      setStage({ type: "thinking" });
+      callChat(
+        currentProvider,
+        currentSystemPrompt,
+        withContext,
+        nextAbort.signal,
+      )
+        .then((result: ChatResult) => {
+          if (nextAbort.signal.aborted) return;
+          processResponse(
+            result.text ?? "",
+            withContext,
+            nextAbort.signal,
+            result.truncated,
+            continueCount + 1,
+          );
+        })
+        .catch(handleError(withContext));
       return;
     }
 
@@ -313,13 +367,14 @@ export function useChat(repoPath: string) {
       }
 
       if (approved && !result.startsWith("Error:")) {
-        appendMemory({
-          kind: "shell-run",
-          detail: tool.summariseInput
+        logToolCall(
+          parsed.toolName,
+          tool.summariseInput
             ? String(tool.summariseInput(parsed.input))
             : parsed.rawInput,
-          summary: result.split("\n")[0]?.slice(0, 120) ?? "",
-        });
+          result,
+          repoPath,
+        );
       }
 
       const displayContent = tool.summariseInput
@@ -340,7 +395,7 @@ export function useChat(repoPath: string) {
       setCommitted((prev) => [...prev, toolMsg]);
 
       if (approved && remainder && remainder.length > 0) {
-        processResponse(remainder, withTool, signal);
+        processResponse(remainder, withTool, signal, truncated, continueCount);
         return;
       }
 
@@ -350,31 +405,55 @@ export function useChat(repoPath: string) {
       abortControllerRef.current = nextAbort;
       setStage({ type: "thinking" });
 
-      callChat(currentProvider, currentSystemPrompt, withTool, nextAbort.signal)
-        .then((r: string) => {
-          if (nextAbort.signal.aborted) return;
-          if (!r.trim()) {
-            const nudged: Message[] = [
-              ...withTool,
-              { role: "user", content: "Please continue.", type: "text" },
-            ];
-            return callChat(
-              currentProvider,
-              currentSystemPrompt,
-              nudged,
-              nextAbort.signal,
-            );
-          }
-          return r;
-        })
-        .then((r: string | undefined) => {
+      const callWithAutoContinue = async (
+        messages: Message[],
+        maxRetries = 3,
+      ): Promise<ChatResult> => {
+        let currentMessages = messages;
+        for (let i = 0; i < maxRetries; i++) {
+          if (nextAbort.signal.aborted)
+            return { text: "", truncated: false };
+          const result = await callChat(
+            currentProvider,
+            currentSystemPrompt,
+            currentMessages,
+            nextAbort.signal,
+          );
+          if (result.text.trim()) return result;
+          const nudgeMsg: Message = {
+            role: "assistant",
+            content: `(model stalled — auto-continuing, attempt ${i + 1}/${maxRetries})`,
+            type: "text",
+          };
+          setCommitted((prev) => [...prev, nudgeMsg]);
+          setAllMessages((prev) => [...prev, nudgeMsg]);
+          currentMessages = [
+            ...currentMessages,
+            {
+              role: "user",
+              content:
+                "Please continue. Provide your response to the previous tool output.",
+              type: "text",
+            },
+          ];
+        }
+        return { text: "", truncated: false };
+      };
+
+      callWithAutoContinue(withTool)
+        .then((result: ChatResult) => {
           if (nextAbort.signal.aborted) return;
-          processResponse(r ?? "", withTool, nextAbort.signal);
+          processResponse(
+            result.text ?? "",
+            withTool,
+            nextAbort.signal,
+            result.truncated,
+          );
         })
         .catch(handleError(withTool));
     };
 
-    if (forceApprove || (autoApprove && isSafe) || batchApprovedRef.current) {
+    if (forceApprove || isSafe || batchApprovedRef.current) {
       executeAndContinue(true);
       return;
     }
@@ -424,15 +503,25 @@ export function useChat(repoPath: string) {
 
     const intent = classifyIntent(text);
     const scopedToolsSection = registry.buildSystemPromptSection(intent);
+    const sessionSummary = getSessionToolSummary(repoPath);
 
-    const scopedSystemPrompt = currentSystemPrompt.replace(
+    let scopedSystemPrompt = currentSystemPrompt.replace(
       /## TOOLS[\s\S]*?(?=\n## (?!TOOLS))/,
       scopedToolsSection + "\n\n",
     );
 
+    if (sessionSummary) {
+      scopedSystemPrompt = scopedSystemPrompt.replace(
+        /## CODEBASE/,
+        sessionSummary + "\n\n## CODEBASE",
+      );
+    }
+
     setStage({ type: "thinking" });
     callChat(currentProvider, scopedSystemPrompt, nextAll, abort.signal)
-      .then((raw: string) => processResponse(raw, nextAll, abort.signal))
+      .then((result: ChatResult) =>
+        processResponse(result.text, nextAll, abort.signal, result.truncated),
+      )
       .catch(handleError(nextAll));
   };
 
@@ -477,22 +566,24 @@ export function useChat(repoPath: string) {
   const applyPatchesAndContinue = (patches: any[]) => {
     try {
       applyPatches(repoPath, patches);
-      appendMemory({
-        kind: "code-applied",
-        detail: patches.map((p) => p.path).join(", "),
-        summary: `Applied changes to ${patches.length} file(s)`,
-      });
+      logToolCall(
+        "changes",
+        patches.map((p) => p.path).join(", "),
+        `Applied changes to ${patches.length} file(s)`,
+        repoPath,
+      );
     } catch {
       /* non-fatal */
     }
   };
 
   const skipPatches = (patches: any[]) => {
-    appendMemory({
-      kind: "code-skipped",
-      detail: patches.map((p: { path: string }) => p.path).join(", "),
-      summary: `Skipped changes to ${patches.length} file(s)`,
-    });
+    logToolCall(
+      "changes-skipped",
+      patches.map((p: { path: string }) => p.path).join(", "),
+      `Skipped changes to ${patches.length} file(s)`,
+      repoPath,
+    );
   };
 
   return {

package/src/components/repo/RepoAnalysis.tsx

@@ -174,11 +174,11 @@ function CodebaseQA({
     abortRef.current = abort;
 
     callChat(provider, systemPrompt, nextAll, abort.signal)
-      .then((answer) => {
+      .then((result) => {
         const assistantMsg: Message = {
           role: "assistant",
           type: "text",
-          content: answer,
+          content: result.text,
         };
         setCommitted((prev) => [...prev, assistantMsg]);
         setAllMessages([...nextAll, assistantMsg]);

package/src/components/timeline/TimelineRunner.tsx

@@ -777,9 +777,9 @@ ${summarizeTimeline(commits)}`;
 
   const runChat = async (history: Message[], signal: AbortSignal) => {
     try {
-      const raw = await callChat(provider, systemPrompt, history, signal);
+      const result = await callChat(provider, systemPrompt, history, signal);
       if (signal.aborted) return;
-      processResponse(raw, history, signal);
+      processResponse(result.text, history, signal);
     } catch (e: any) {
       if (e?.name === "AbortError") return;
       setMessages((prev) => [

package/src/components/watch/RunRunner.tsx

@@ -602,12 +602,13 @@ ${lensFile.suggestions.length > 0 ? `\nProject suggestions:\n${lensFile.suggesti
 
       let raw: string;
       try {
-        raw = await callChat(
+        const result = await callChat(
           provider,
           systemPromptRef.current,
           messages,
           combinedSignal,
         );
+        raw = result.text;
       } finally {
         clearTimeout(timeoutId);
       }

package/src/prompts/fewshot.ts

@@ -231,4 +231,22 @@ export const FEW_SHOT_MESSAGES: { role: string; content: string }[] = [
     content:
       "Done — addons/hello-world.js created using defineTool from @ridit/lens-sdk.",
   },
+  {
+    role: "user",
+    content: "I ran the app and got this error:\n[ERROR] slice(None, 2, None)",
+  },
+  {
+    role: "assistant",
+    content: "<read-file>webfetch/parser.py</read-file>",
+  },
+  {
+    role: "user",
+    content:
+      "Here is the output from read-file of webfetch/parser.py:\n\n# file content here\n\nPlease continue your response based on this output.",
+  },
+  {
+    role: "assistant",
+    content:
+      '<write-file>\n{"path": "webfetch/parser.py", "content": "...complete fixed content..."}\n</write-file>',
+  },
 ];

package/src/prompts/system.ts

@@ -21,13 +21,25 @@ ${tools}
 You can save and delete memories at any time by emitting these tags alongside your normal response.
 They are stripped before display — the user will not see the raw tags.
  
-### memory-add — save something important to long-term memory for this repo
+### memory-add — save something important to long-term memory
 <memory-add>User prefers TypeScript strict mode in all new files</memory-add>
  
+Use [global] prefix for things that apply across ALL repos (user preferences, name, coding style):
+<memory-add>[global] User prefers bun over npm for all projects</memory-add>
+ 
+Omit [global] for repo-specific memories (architecture decisions, patterns, agreed conventions):
+<memory-add>This repo uses path aliases defined in tsconfig.json</memory-add>
+ 
 ### memory-delete — delete a memory by its ID (shown in brackets like [abc123])
 <memory-delete>abc123</memory-delete>
  
-Use memory-add when the user asks you to remember something, or when you learn something project-specific that would be useful in future sessions.
+Use memory-add ONLY for information that cannot be inferred by reading the codebase:
+- User preferences and coding conventions
+- Decisions made during the session (e.g. "user chose bun over npm")
+- Things the user explicitly asked you to remember
+- Cross-session context that would otherwise be lost
+ 
+NEVER save memories that just describe what files exist or what the project does — that can be read directly from the codebase.
 Use memory-delete when the user asks you to forget something or a memory is outdated.
  
 ## RULES
@@ -49,6 +61,8 @@ Use memory-delete when the user asks you to forget something or a memory is outd
 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.
  
 ## ADDON FORMAT