@ridit/lens 0.3.3 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ridit/lens",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Know Your Codebase.",
   "author": "Ridit Jangra <riditjangra09@gmail.com> (https://ridit.space)",
   "license": "MIT",
@@ -20,7 +20,6 @@
   },
   "dependencies": {
     "@ridit/lens-sdk": "0.1.6",
-    "add": "^2.0.6",
     "asciichart": "^1.5.25",
     "bun": "^1.3.11",
     "commander": "^14.0.3",

package/src/components/repo/LensFileMenu.tsx

@@ -31,18 +31,11 @@ const buildOptions = (lf: LensFile): MenuOption[] => {
       description: "Run a fresh AI analysis",
     },
   ];
-  if (lf.suggestions.length > 0 || lf.missingConfigs.length > 0) {
+  if (lf.suggestions.length > 0) {
     opts.push({
       id: "fix-issues",
       label: "Fix issues",
-      description: `${lf.suggestions.length + lf.missingConfigs.length} issues found`,
-    });
-  }
-  if (lf.securityIssues.length > 0) {
-    opts.push({
-      id: "security",
-      label: "Review security issues",
-      description: `${lf.securityIssues.length} issue(s) found`,
+      description: `${lf.suggestions.length} issues found`,
     });
   }
   opts.push({

package/src/components/repo/RepoAnalysis.tsx

@@ -1,18 +1,26 @@
 import React from "react";
-import { Box, Text, useInput } from "ink";
+import { Box, Text, Static, useInput } from "ink";
 import Spinner from "ink-spinner";
 import figures from "figures";
-import { useState } from "react";
+import { useState, useRef } from "react";
 import { writeFileSync } from "fs";
 import path from "path";
 import { ACCENT } from "../../colors";
-import { requestFileList, analyzeRepo } from "../../utils/ai";
+import {
+  requestFileList,
+  analyzeRepo,
+  extractToolingPatch,
+} from "../../utils/ai";
 import { ProviderPicker } from "../provider/ProviderPicker";
 import { PreviewRunner } from "./PreviewRunner";
 import { IssueFixer } from "./IssueFixer";
-import { writeLensFile } from "../../utils/lensfile";
+import { writeLensFile, patchLensFile } from "../../utils/lensfile";
+import { callChat } from "../../utils/chat";
+import { StaticMessage } from "../chat/ChatMessage";
+import { InputBox, TypewriterText, ShortcutBar } from "../chat/ChatOverlays";
 import type { Provider } from "../../types/config";
 import type { AnalysisResult, ImportantFile } from "../../types/repo";
+import type { Message } from "../../types/chat";
 import { useThinkingPhrase } from "../../utils/thinking";
 
 type AnalysisStage =
@@ -24,12 +32,17 @@ type AnalysisStage =
   | { type: "written"; filePath: string }
   | { type: "previewing" }
   | { type: "fixing"; result: AnalysisResult }
+  | { type: "asking"; result: AnalysisResult }
   | { type: "error"; message: string };
 
 const OUTPUT_FILES = ["CLAUDE.md", "copilot-instructions.md"] as const;
 type OutputFile = (typeof OUTPUT_FILES)[number];
 
 function buildMarkdown(repoUrl: string, result: AnalysisResult): string {
+  const toolingLines = Object.entries(result.tooling ?? {})
+    .map(([k, v]) => `- **${k}**: ${v}`)
+    .join("\n");
+
   return `# Repository Analysis
 
 > ${repoUrl}
@@ -37,28 +50,56 @@ function buildMarkdown(repoUrl: string, result: AnalysisResult): string {
 ## Overview
 ${result.overview}
 
+## Architecture
+${result.architecture ?? ""}
+
+## Tooling
+${toolingLines || "- Not determined"}
+
 ## Important Folders
 ${result.importantFolders.map((f) => `- ${f}`).join("\n")}
 
-## Missing Configs
-${
-  result.missingConfigs.length > 0
-    ? result.missingConfigs.map((f) => `- ${f}`).join("\n")
-    : "- None detected"
-}
+## Key Files
+${(result.keyFiles ?? []).map((f) => `- ${f}`).join("\n")}
 
-## Security Issues
-${
-  result.securityIssues.length > 0
-    ? result.securityIssues.map((s) => `- ⚠️ ${s}`).join("\n")
-    : "- None detected"
-}
+## Patterns & Idioms
+${(result.patterns ?? []).map((p) => `- ${p}`).join("\n")}
 
 ## Suggestions
 ${result.suggestions.map((s) => `- ${s}`).join("\n")}
 `;
 }
 
+function buildQASystemPrompt(repoUrl: string, result: AnalysisResult): string {
+  const toolingLines = Object.entries(result.tooling ?? {})
+    .map(([k, v]) => `- ${k}: ${v}`)
+    .join("\n");
+
+  return `You are a codebase assistant for the repository at ${repoUrl}.
+
+Here is what you know about this codebase:
+
+Overview:
+${result.overview}
+
+Architecture:
+${result.architecture ?? "Not determined"}
+
+Tooling:
+${toolingLines || "Not determined"}
+
+Important Folders:
+${result.importantFolders.map((f) => `- ${f}`).join("\n")}
+
+Key Files:
+${(result.keyFiles ?? []).map((f) => `- ${f}`).join("\n")}
+
+Patterns & Idioms:
+${(result.patterns ?? []).map((p) => `- ${p}`).join("\n")}
+
+Answer questions about this codebase concisely and accurately. If you're unsure about something not covered in the analysis, say so clearly rather than guessing.`;
+}
+
 function AskingFilesStep() {
   const phrase = useThinkingPhrase(true, "model");
   return (
@@ -83,6 +124,121 @@ function AnalyzingStep() {
   );
 }
 
+// ─── CodebaseQA ──────────────────────────────────────────────────────────────
+
+type QAStage = "idle" | "thinking";
+
+function CodebaseQA({
+  repoUrl,
+  result,
+  provider,
+  onExit,
+}: {
+  repoUrl: string;
+  result: AnalysisResult;
+  provider: Provider;
+  onExit: () => void;
+}) {
+  const [committed, setCommitted] = useState<Message[]>([]);
+  const [allMessages, setAllMessages] = useState<Message[]>([]);
+  const [inputValue, setInputValue] = useState("");
+  const [inputKey, setInputKey] = useState(0);
+  const [qaStage, setQaStage] = useState<QAStage>("idle");
+  const abortRef = useRef<AbortController | null>(null);
+  const systemPrompt = buildQASystemPrompt(repoUrl, result);
+  const thinkingPhrase = useThinkingPhrase(qaStage === "thinking");
+
+  useInput((_, key) => {
+    if (key.escape) {
+      if (qaStage === "thinking") {
+        abortRef.current?.abort();
+        abortRef.current = null;
+        setQaStage("idle");
+        return;
+      }
+      onExit();
+    }
+  });
+
+  const sendQuestion = (text: string) => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+
+    const userMsg: Message = { role: "user", type: "text", content: trimmed };
+    const nextAll = [...allMessages, userMsg];
+    setCommitted((prev) => [...prev, userMsg]);
+    setAllMessages(nextAll);
+    setQaStage("thinking");
+
+    const abort = new AbortController();
+    abortRef.current = abort;
+
+    callChat(provider, systemPrompt, nextAll, abort.signal)
+      .then((answer) => {
+        const assistantMsg: Message = {
+          role: "assistant",
+          type: "text",
+          content: answer,
+        };
+        setCommitted((prev) => [...prev, assistantMsg]);
+        setAllMessages([...nextAll, assistantMsg]);
+        setQaStage("idle");
+      })
+      .catch((err: unknown) => {
+        if (err instanceof Error && err.name === "AbortError") {
+          setQaStage("idle");
+          return;
+        }
+        const errMsg: Message = {
+          role: "assistant",
+          type: "text",
+          content: `Error: ${err instanceof Error ? err.message : "Request failed"}`,
+        };
+        setCommitted((prev) => [...prev, errMsg]);
+        setAllMessages([...nextAll, errMsg]);
+        setQaStage("idle");
+      });
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Static items={committed}>
+        {(msg, i) => <StaticMessage key={i} msg={msg} />}
+      </Static>
+
+      {qaStage === "thinking" && (
+        <Box gap={1}>
+          <Text color={ACCENT}>●</Text>
+          <TypewriterText text={thinkingPhrase} />
+          <Text color="gray" dimColor>
+            · esc cancel
+          </Text>
+        </Box>
+      )}
+
+      {qaStage === "idle" && (
+        <Box flexDirection="column">
+          <InputBox
+            value={inputValue}
+            onChange={setInputValue}
+            onSubmit={(val) => {
+              if (val.trim()) sendQuestion(val.trim());
+              setInputValue("");
+              setInputKey((k) => k + 1);
+            }}
+            inputKey={inputKey}
+          />
+          <Text color="gray" dimColor>
+            enter send · esc back
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+// ─── RepoAnalysis ─────────────────────────────────────────────────────────────
+
 export const RepoAnalysis = ({
   repoUrl,
   repoPath,
@@ -103,18 +259,31 @@ export const RepoAnalysis = ({
       ? { type: "done", result: preloadedResult }
       : { type: "picking-provider" },
   );
-  const [selectedOutput, setSelectedOutput] = useState<0 | 1 | 2 | 3>(0);
+  const [selectedOutput, setSelectedOutput] = useState<0 | 1 | 2 | 3 | 4>(0);
   const [requestedFiles, setRequestedFiles] = useState<ImportantFile[]>([]);
   const [provider, setProvider] = useState<Provider | null>(null);
 
-  const OPTIONS = [...OUTPUT_FILES, "Preview repo", "Fix issues"] as const;
+  const OPTIONS = [
+    ...OUTPUT_FILES,
+    "Preview repo",
+    "Fix issues",
+    "Ask questions",
+  ] as const;
 
   const handleProviderDone = (p: Provider) => {
     setProvider(p);
     setStage({ type: "requesting-files" });
+
     requestFileList(repoUrl, repoPath, fileTree, p)
       .then((files) => {
         setRequestedFiles(files);
+
+        extractToolingPatch(repoUrl, files.length > 0 ? files : initialFiles, p)
+          .then((patch) => {
+            if (patch) patchLensFile(repoPath, patch);
+          })
+          .catch(() => {});
+
         setStage({ type: "analyzing" });
         return analyzeRepo(repoUrl, files.length > 0 ? files : initialFiles, p);
       })
@@ -133,10 +302,10 @@ export const RepoAnalysis = ({
   useInput((_, key) => {
     if (stage.type !== "done") return;
     if (key.leftArrow)
-      setSelectedOutput((i) => Math.max(0, i - 1) as 0 | 1 | 2 | 3);
+      setSelectedOutput((i) => Math.max(0, i - 1) as 0 | 1 | 2 | 3 | 4);
     if (key.rightArrow)
       setSelectedOutput(
-        (i) => Math.min(OPTIONS.length - 1, i + 1) as 0 | 1 | 2 | 3,
+        (i) => Math.min(OPTIONS.length - 1, i + 1) as 0 | 1 | 2 | 3 | 4,
       );
     if (key.return) {
       if (selectedOutput === 2) {
@@ -147,6 +316,10 @@ export const RepoAnalysis = ({
         setStage({ type: "fixing", result: stage.result });
         return;
       }
+      if (selectedOutput === 4) {
+        setStage({ type: "asking", result: stage.result });
+        return;
+      }
       const fileName = OUTPUT_FILES[selectedOutput] as OutputFile;
       setStage({ type: "writing" });
       try {
@@ -205,9 +378,7 @@ export const RepoAnalysis = ({
   if (stage.type === "written") {
     setTimeout(() => {
       if (onExit) onExit();
-      else {
-        process.exit(0);
-      }
+      else process.exit(0);
     }, 100);
     return (
       <Text color="green">
@@ -228,9 +399,7 @@ export const RepoAnalysis = ({
           onExit={() => {
             setTimeout(() => {
               if (onExit) onExit();
-              else {
-                process.exit(0);
-              }
+              else process.exit(0);
             }, 100);
           }}
         />
@@ -250,6 +419,17 @@ export const RepoAnalysis = ({
     );
   }
 
+  if (stage.type === "asking") {
+    return (
+      <CodebaseQA
+        repoUrl={repoUrl}
+        result={stage.result}
+        provider={provider!}
+        onExit={() => setStage({ type: "done", result: stage.result })}
+      />
+    );
+  }
+
   if (stage.type === "error") {
     return (
       <Text color="red">
@@ -269,6 +449,25 @@ export const RepoAnalysis = ({
         <Text color="white">{result.overview}</Text>
       </Box>
 
+      <Box flexDirection="column">
+        <Text bold color="cyan">
+          {figures.pointerSmall} Architecture
+        </Text>
+        <Text color="white">{result.architecture}</Text>
+      </Box>
+
+      <Box flexDirection="column">
+        <Text bold color="cyan">
+          {figures.pointerSmall} Tooling
+        </Text>
+        {Object.entries(result.tooling ?? {}).map(([k, v]) => (
+          <Text key={k} color="white">
+            {" "}
+            {figures.bullet} <Text bold>{k}</Text>: {v}
+          </Text>
+        ))}
+      </Box>
+
       <Box flexDirection="column">
         <Text bold color="cyan">
           {figures.pointerSmall} Important Folders
@@ -282,35 +481,27 @@ export const RepoAnalysis = ({
       </Box>
 
       <Box flexDirection="column">
-        <Text bold color="yellow">
-          {figures.warning} Missing Configs
+        <Text bold color="cyan">
+          {figures.pointerSmall} Key Files
         </Text>
-        {result.missingConfigs.length > 0 ? (
-          result.missingConfigs.map((f) => (
-            <Text key={f} color="yellow">
-              {" "}
-              {figures.bullet} {f}
-            </Text>
-          ))
-        ) : (
-          <Text color="gray"> None detected</Text>
-        )}
+        {(result.keyFiles ?? []).map((f) => (
+          <Text key={f} color="white">
+            {" "}
+            {figures.bullet} {f}
+          </Text>
+        ))}
       </Box>
 
       <Box flexDirection="column">
-        <Text bold color="red">
-          {figures.cross} Security Issues
+        <Text bold color="cyan">
+          {figures.pointerSmall} Patterns & Idioms
         </Text>
-        {result.securityIssues.length > 0 ? (
-          result.securityIssues.map((s) => (
-            <Text key={s} color="red">
-              {" "}
-              {figures.bullet} {s}
-            </Text>
-          ))
-        ) : (
-          <Text color="gray"> None detected</Text>
-        )}
+        {(result.patterns ?? []).map((p) => (
+          <Text key={p} color="white">
+            {" "}
+            {figures.bullet} {p}
+          </Text>
+        ))}
       </Box>
 
       <Box flexDirection="column">

package/src/types/repo.ts

@@ -27,12 +27,24 @@ export type AIProvider =
 export type AnalysisResult = {
   overview: string;
   importantFolders: string[];
-  missingConfigs: string[];
-  securityIssues: string[];
+
+  tooling: Record<string, string>;
+
+  keyFiles: string[];
+
+  patterns: string[];
+
+  architecture: string;
   suggestions: string[];
 };
 
-export type PackageManager = "npm" | "yarn" | "pnpm" | "pip" | "unknown";
+export type PackageManager =
+  | "npm"
+  | "yarn"
+  | "pnpm"
+  | "bun"
+  | "pip"
+  | "unknown";
 
 export type PreviewInfo = {
   packageManager: PackageManager;

package/src/utils/ai.ts

@@ -19,8 +19,8 @@ Your job is to select the files you need to read to fully understand what this p
 Rules:
 - ALWAYS include package.json, tsconfig.json, README.md if they exist
 - ALWAYS include ALL files inside src/ — especially index files, main entry points, and any files that reveal the project's purpose (components, hooks, utilities, exports)
-- Include config files: vite.config, eslint.config, tailwind.config, etc.
-- If there is a src/index.ts or src/main.ts or src/lib/index.ts, ALWAYS include it — these reveal what the project exports
+- Include config files: vite.config, eslint.config, tailwind.config, bun.lockb, .nvmrc, etc.
+- If there is a src/index.ts or src/main.ts or src/lib/index.ts, ALWAYS include it
 - Do NOT skip source files just because there are many — pick up to 30 files
 - Prefer breadth: pick at least one file from every folder under src/
 
@@ -36,36 +36,96 @@ export function buildAnalysisPrompt(
     .map((f) => `### ${f.path}\n\`\`\`\n${f.content.slice(0, 3000)}\n\`\`\``)
     .join("\n\n");
 
-  return `You are a senior software engineer analyzing a repository.
+  return `You are a senior software engineer building a persistent knowledge base about a codebase. Your output will be stored and incrementally updated over time — it must be durable, structural knowledge, not ephemeral warnings.
+
 Repository URL: ${repoUrl}
 
 Here are the file contents:
 
 ${fileList}
 
-Analyze this repository thoroughly using the actual file contents above.
+Analyze this repository and extract permanent, structural understanding. Focus on WHAT the codebase IS and HOW it works — not linting issues or missing configs.
 
-Important instructions:
-- Read the actual source code carefully to determine what the project really is
-- Look at every component, hook, utility and describe what it actually does
-- importantFolders must describe EVERY folder with specifics: what files are in it, what they do, and why they matter
-- suggestions must be specific to the actual code you read — reference real file names, real function names, real patterns you saw
-- missingConfigs should only list things genuinely missing for THIS type of project
-- securityIssues must reference actual file names and line patterns found
-- overview must be specific: name the actual components/features/exports you saw, not just the tech stack
+Rules:
+- Read source code carefully. Reference real file names, real function names, real patterns.
+- tooling: detect from package.json, lockfiles, config files. Keys: packageManager (npm/yarn/pnpm/bun), language, runtime, bundler, framework, testRunner, linter, formatter — only include what you actually found evidence of.
+- keyFiles: list the most important files with a one-line description of what they do. Format: "src/utils/ai.ts: callModel abstraction supporting anthropic/gemini/ollama/openai"
+- patterns: list recurring idioms, design patterns, or conventions actually used in the code. E.g. "Discriminated union state machines for multi-stage UI flows", "React + Ink for terminal rendering"
+- architecture: 2-3 sentences describing the high-level structure and how data flows through the system.
+- importantFolders: describe EVERY folder with specifics — what files are in it and what they do.
+- suggestions: specific, actionable improvements referencing real file names and real patterns you saw. No generic advice.
+- overview: 3-5 sentences naming actual components, features, exports. Be specific.
 
-Respond ONLY with a JSON object (no markdown, no explanation) with this exact shape:
+Respond ONLY with a JSON object (no markdown, no explanation):
 {
-  "overview": "3-5 sentences. Name the actual components, features, or exports you found. Describe what the project does, who would use it, and what makes it distinctive. Be specific — mention actual file names or component names.",
+  "overview": "...",
+  "architecture": "...",
+  "tooling": {
+    "packageManager": "bun",
+    "language": "TypeScript",
+    "runtime": "Node.js",
+    "bundler": "tsup",
+    "framework": "Ink"
+  },
   "importantFolders": [
-    "src/components: contains X, Y, Z components. ButtonComponent uses CVA for variants. Each component is exported from index.ts."
+    "src/commands: contains chat.tsx, commit.tsx, review.tsx — each exports an Ink component that is the top-level renderer for that CLI command"
+  ],
+  "keyFiles": [
+    "src/utils/ai.ts: callModel abstraction supporting anthropic/gemini/ollama/openai providers via a unified Provider type"
+  ],
+  "patterns": [
+    "Discriminated union state machines (type + stage fields) for multi-step UI flows in every command component"
   ],
-  "missingConfigs": ["only configs genuinely missing and relevant — explain WHY each is missing for this specific project"],
-  "securityIssues": ["reference actual file names and patterns found"],
-  "suggestions": ["each suggestion must reference actual code — e.g. 'In src/components/Button.tsx, consider adding ...' not generic advice"]
+  "suggestions": [
+    "In src/utils/ai.ts, callModel has no retry logic — adding exponential backoff would improve reliability for ollama which can be slow to start"
+  ]
 }`;
 }
 
+export function buildToolingPatchPrompt(
+  repoUrl: string,
+  files: ImportantFile[],
+): string {
+  const relevant = files.filter((f) =>
+    [
+      "package.json",
+      "bun.lockb",
+      "yarn.lock",
+      "pnpm-lock.yaml",
+      "package-lock.json",
+      "tsconfig.json",
+      ".nvmrc",
+      ".node-version",
+    ].includes(path.basename(f.path)),
+  );
+
+  if (relevant.length === 0) return "";
+
+  const fileList = relevant
+    .map((f) => `### ${f.path}\n\`\`\`\n${f.content.slice(0, 2000)}\n\`\`\``)
+    .join("\n\n");
+
+  return `You are analyzing a repository's tooling configuration.
+Repository: ${repoUrl}
+
+${fileList}
+
+Extract only tooling information. Respond ONLY with a JSON object:
+{
+  "tooling": {
+    "packageManager": "bun | npm | yarn | pnpm",
+    "language": "TypeScript | JavaScript | ...",
+    "runtime": "Node.js | Bun | Deno | ...",
+    "bundler": "tsup | esbuild | vite | webpack | ...",
+    "framework": "React | Ink | Next.js | ...",
+    "testRunner": "vitest | jest | ...",
+    "linter": "eslint | biome | ...",
+    "formatter": "prettier | biome | ..."
+  }
+}
+Only include keys where you found actual evidence. No markdown, no explanation.`;
+}
+
 function parseStringArray(text: string): string[] {
   const cleaned = text.replace(/```json|```/g, "").trim();
   const match = cleaned.match(/\[[\s\S]*\]/);
@@ -87,12 +147,25 @@ function parseResult(text: string): AnalysisResult {
   return {
     overview: parsed.overview ?? "No overview provided",
     importantFolders: parsed.importantFolders ?? [],
-    missingConfigs: parsed.missingConfigs ?? [],
-    securityIssues: parsed.securityIssues ?? [],
+    tooling: parsed.tooling ?? {},
+    keyFiles: parsed.keyFiles ?? [],
+    patterns: parsed.patterns ?? [],
+    architecture: parsed.architecture ?? "",
     suggestions: parsed.suggestions ?? [],
   };
 }
 
+function parseToolingPatch(text: string): Partial<AnalysisResult> | null {
+  try {
+    const cleaned = text.replace(/```json|```/g, "").trim();
+    const match = cleaned.match(/\{[\s\S]*\}/);
+    if (!match) return null;
+    return JSON.parse(match[0]) as Partial<AnalysisResult>;
+  } catch {
+    return null;
+  }
+}
+
 export function checkOllamaInstalled(): Promise<boolean> {
   return new Promise((resolve) => {
     exec("ollama --version", (err) => resolve(!err));
@@ -220,6 +293,21 @@ export async function requestFileList(
   return files;
 }
 
+export async function extractToolingPatch(
+  repoUrl: string,
+  files: ImportantFile[],
+  provider: Provider,
+): Promise<Partial<AnalysisResult> | null> {
+  const prompt = buildToolingPatchPrompt(repoUrl, files);
+  if (!prompt) return null;
+  try {
+    const text = await callModel(provider, prompt);
+    return parseToolingPatch(text);
+  } catch {
+    return null;
+  }
+}
+
 export async function analyzeRepo(
   repoUrl: string,
   files: ImportantFile[],