@ridit/lens 0.3.2 → 0.3.4

package/src/index.tsx

@@ -1,110 +1,144 @@
-import React from "react";
-import "./utils/tools/registry";
-import { render } from "ink";
-import { Command } from "commander";
-import { RepoCommand } from "./commands/repo";
-import { InitCommand } from "./commands/provider";
-import { ReviewCommand } from "./commands/review";
-import { TaskCommand } from "./commands/task";
-import { ChatCommand } from "./commands/chat";
-import { TimelineCommand } from "./commands/timeline";
-import { CommitCommand } from "./commands/commit";
-import { registerBuiltins } from "./utils/tools/builtins";
-import { loadAddons } from "./utils/addons/loadAddons";
-
-registerBuiltins();
-await loadAddons();
-
-const program = new Command();
-
-program
-  .command("stalk <url>")
-  .alias("repo")
-  .description("Analyze a remote repository")
-  .action((url) => {
-    render(<RepoCommand url={url} />);
-  });
-
-program
-  .command("provider")
-  .description("Configure AI providers")
-  .action(() => {
-    render(<InitCommand />);
-  });
-
-program
-  .command("judge [path]")
-  .alias("review")
-  .description("Review a local codebase")
-  .action((inputPath) => {
-    render(<ReviewCommand path={inputPath ?? "."} />);
-  });
-
-program
-  .command("cook <text>")
-  .alias("task")
-  .description("Apply a natural language change to the codebase")
-  .option("-p, --path <path>", "Path to the repo", ".")
-  .action((text: string, opts: { path: string }) => {
-    render(<TaskCommand prompt={text} path={opts.path} />);
-  });
-
-program
-  .command("vibe")
-  .alias("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} />);
-  });
-
-program
-  .command("history")
-  .alias("timeline")
-  .description(
-    "Explore your code history — see commits, changes, and evolution",
-  )
-  .option("-p, --path <path>", "Path to the repo", ".")
-  .action((opts: { path: string }) => {
-    render(<TimelineCommand path={opts.path} />);
-  });
-
-program
-  .command("crimes [files...]")
-  .alias("commit")
-  .description(
-    "Generate a smart conventional commit message from staged changes or specific files",
-  )
-  .option("-p, --path <path>", "Path to the repo", ".")
-  .option(
-    "--auto",
-    "Stage all changes (or the given files) and commit without confirmation",
-  )
-  .option("--confirm", "Show preview before committing even when using --auto")
-  .option("--preview", "Show the generated message without committing")
-  .option("--push", "Push to remote after committing")
-  .action(
-    (
-      files: string[],
-      opts: {
-        path: string;
-        auto: boolean;
-        confirm: boolean;
-        preview: boolean;
-        push: boolean;
-      },
-    ) => {
-      render(
-        <CommitCommand
-          path={opts.path}
-          files={files ?? []}
-          auto={opts.auto ?? false}
-          confirm={opts.confirm ?? false}
-          preview={opts.preview ?? false}
-          push={opts.push ?? false}
-        />,
-      );
-    },
-  );
-
-program.parse(process.argv);
+import React from "react";
+import "./utils/tools/registry";
+import { render } from "ink";
+import { Command } from "commander";
+import { RepoCommand } from "./commands/repo";
+import { InitCommand } from "./commands/provider";
+import { ReviewCommand } from "./commands/review";
+import { TaskCommand } from "./commands/task";
+import { ChatCommand } from "./commands/chat";
+import { WatchCommand } from "./commands/watch";
+import { TimelineCommand } from "./commands/timeline";
+import { CommitCommand } from "./commands/commit";
+import { registerBuiltins } from "./utils/tools/builtins";
+import { loadAddons } from "./utils/addons/loadAddons";
+
+registerBuiltins();
+await loadAddons();
+
+const program = new Command();
+
+program
+  .command("stalk <url>")
+  .alias("repo")
+  .description("Analyze a remote repository")
+  .action((url) => {
+    render(<RepoCommand url={url} />);
+  });
+
+program
+  .command("provider")
+  .description("Configure AI providers")
+  .action(() => {
+    render(<InitCommand />);
+  });
+
+program
+  .command("judge [path]")
+  .alias("review")
+  .description("Review a local codebase")
+  .action((inputPath) => {
+    render(<ReviewCommand path={inputPath ?? "."} />);
+  });
+
+program
+  .command("cook <text>")
+  .alias("task")
+  .description("Apply a natural language change to the codebase")
+  .option("-p, --path <path>", "Path to the repo", ".")
+  .action((text: string, opts: { path: string }) => {
+    render(<TaskCommand prompt={text} path={opts.path} />);
+  });
+
+program
+  .command("vibe")
+  .alias("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} />);
+  });
+
+program
+  .command("history")
+  .alias("timeline")
+  .description(
+    "Explore your code history — see commits, changes, and evolution",
+  )
+  .option("-p, --path <path>", "Path to the repo", ".")
+  .action((opts: { path: string }) => {
+    render(<TimelineCommand path={opts.path} />);
+  });
+
+program
+  .command("crimes [files...]")
+  .alias("commit")
+  .description(
+    "Generate a smart conventional commit message from staged changes or specific files",
+  )
+  .option("-p, --path <path>", "Path to the repo", ".")
+  .option(
+    "--auto",
+    "Stage all changes (or the given files) and commit without confirmation",
+  )
+  .option("--confirm", "Show preview before committing even when using --auto")
+  .option("--preview", "Show the generated message without committing")
+  .option("--push", "Push to remote after committing")
+  .action(
+    (
+      files: string[],
+      opts: {
+        path: string;
+        auto: boolean;
+        confirm: boolean;
+        preview: boolean;
+        push: boolean;
+      },
+    ) => {
+      render(
+        <CommitCommand
+          path={opts.path}
+          files={files ?? []}
+          auto={opts.auto ?? false}
+          confirm={opts.confirm ?? false}
+          preview={opts.preview ?? false}
+          push={opts.push ?? false}
+        />,
+      );
+    },
+  );
+
+program
+  .command("watch <cmd>")
+  .alias("spy")
+  .description("Watch a dev command and get AI suggestions for errors")
+  .option("-p, --path <path>", "Path to the repo", ".")
+  .option("--clean", "Only show AI suggestions, hide raw logs")
+  .option("--fix-all", "Auto-apply fixes as errors are detected")
+  .option("--auto-restart", "Automatically re-run the command after a crash")
+  .option("--prompt <text>", "Extra context for the AI about your project")
+  .action(
+    (
+      cmd: string,
+      opts: {
+        path: string;
+        clean: boolean;
+        fixAll: boolean;
+        autoRestart: boolean;
+        prompt?: string;
+      },
+    ) => {
+      render(
+        <WatchCommand
+          cmd={cmd}
+          path={opts.path}
+          clean={opts.clean ?? false}
+          fixAll={opts.fixAll ?? false}
+          autoRestart={opts.autoRestart ?? false}
+          prompt={opts.prompt}
+        />,
+      );
+    },
+  );
+
+program.parse(process.argv);

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[],

package/src/utils/lensfile.ts

@@ -7,10 +7,13 @@ export const LENS_FILENAME = "LENS.md";
 export type LensFile = {
   overview: string;
   importantFolders: string[];
-  missingConfigs: string[];
-  securityIssues: string[];
+  tooling: Record<string, string>;
+  keyFiles: string[];
+  patterns: string[];
+  architecture: string;
   suggestions: string[];
   generatedAt: string;
+  lastUpdated: string;
 };
 
 export function lensFilePath(repoPath: string): string {
@@ -21,36 +24,96 @@ export function lensFileExists(repoPath: string): boolean {
   return existsSync(lensFilePath(repoPath));
 }
 
-export function writeLensFile(repoPath: string, result: AnalysisResult): void {
-  const data: LensFile = {
-    ...result,
-    generatedAt: new Date().toISOString(),
-  };
+function renderLensFile(data: LensFile): string {
+  const toolingLines = Object.entries(data.tooling)
+    .map(([k, v]) => `- **${k}**: ${v}`)
+    .join("\n");
 
-  const content = `# Lens Analysis
-> Generated: ${data.generatedAt}
+  return `# Lens
+> Generated: ${data.generatedAt}${data.lastUpdated !== data.generatedAt ? `  |  Updated: ${data.lastUpdated}` : ""}
 
 ## Overview
 ${data.overview}
 
+## Architecture
+${data.architecture}
+
+## Tooling & Conventions
+${toolingLines || "- Not yet determined"}
+
 ## Important Folders
-${data.importantFolders.map((f) => `- ${f}`).join("\n")}
+${data.importantFolders.map((f) => `- ${f}`).join("\n") || "- None"}
 
-## Missing Configs
-${data.missingConfigs.length > 0 ? data.missingConfigs.map((f) => `- ${f}`).join("\n") : "- None detected"}
+## Key Files
+${data.keyFiles.map((f) => `- ${f}`).join("\n") || "- None"}
 
-## Security Issues
-${data.securityIssues.length > 0 ? data.securityIssues.map((s) => `- ${s}`).join("\n") : "- None detected"}
+## Patterns & Idioms
+${data.patterns.map((p) => `- ${p}`).join("\n") || "- None"}
 
 ## Suggestions
-${data.suggestions.map((s) => `- ${s}`).join("\n")}
+${data.suggestions.map((s) => `- ${s}`).join("\n") || "- None"}
 
 <!--lens-json
 ${JSON.stringify(data)}
 lens-json-->
 `;
+}
+
+export function writeLensFile(repoPath: string, result: AnalysisResult): void {
+  const now = new Date().toISOString();
+  const data: LensFile = {
+    overview: result.overview,
+    importantFolders: result.importantFolders,
+    tooling: result.tooling ?? {},
+    keyFiles: result.keyFiles ?? [],
+    patterns: result.patterns ?? [],
+    architecture: result.architecture ?? "",
+    suggestions: result.suggestions,
+    generatedAt: now,
+    lastUpdated: now,
+  };
+  writeFileSync(lensFilePath(repoPath), renderLensFile(data), "utf-8");
+}
+
+export function patchLensFile(
+  repoPath: string,
+  patch: Partial<AnalysisResult>,
+): void {
+  const existing = readLensFile(repoPath);
+  const now = new Date().toISOString();
+
+  const base: LensFile = existing ?? {
+    overview: "",
+    importantFolders: [],
+    tooling: {},
+    keyFiles: [],
+    patterns: [],
+    architecture: "",
+    suggestions: [],
+    generatedAt: now,
+    lastUpdated: now,
+  };
+
+  const merged: LensFile = {
+    ...base,
+    lastUpdated: now,
+    overview: patch.overview ?? base.overview,
+    architecture: patch.architecture ?? base.architecture,
+    tooling: { ...base.tooling, ...(patch.tooling ?? {}) },
+    importantFolders: dedup([
+      ...base.importantFolders,
+      ...(patch.importantFolders ?? []),
+    ]),
+    keyFiles: dedup([...base.keyFiles, ...(patch.keyFiles ?? [])]),
+    patterns: dedup([...base.patterns, ...(patch.patterns ?? [])]),
+    suggestions: dedup([...base.suggestions, ...(patch.suggestions ?? [])]),
+  };
+
+  writeFileSync(lensFilePath(repoPath), renderLensFile(merged), "utf-8");
+}
 
-  writeFileSync(lensFilePath(repoPath), content, "utf-8");
+function dedup(arr: string[]): string[] {
+  return [...new Map(arr.map((s) => [s.trim().toLowerCase(), s])).values()];
 }
 
 export function readLensFile(repoPath: string): LensFile | null {
@@ -70,8 +133,10 @@ export function lensFileToAnalysisResult(lf: LensFile): AnalysisResult {
   return {
     overview: lf.overview,
     importantFolders: lf.importantFolders,
-    missingConfigs: lf.missingConfigs,
-    securityIssues: lf.securityIssues,
+    tooling: lf.tooling,
+    keyFiles: lf.keyFiles,
+    patterns: lf.patterns,
+    architecture: lf.architecture,
     suggestions: lf.suggestions,
   };
 }