@ridit/lens 0.2.4 → 0.2.5

package/src/index.tsx

@@ -8,6 +8,7 @@ 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";
 
@@ -63,4 +64,41 @@ program
     render(<TimelineCommand path={opts.path} />);
   });
 
+program
+  .command("commit [files...]")
+  .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);

package/src/prompts/fewshot.ts

@@ -1,4 +1,73 @@
 export const FEW_SHOT_MESSAGES: { role: string; content: string }[] = [
+  // ── create new file directly (no read first) ──────────────────────────────
+  {
+    role: "user",
+    content: "this codebase doesn't have a readme",
+  },
+  {
+    role: "assistant",
+    content:
+      '<write-file>\n{"path": "README.md", "content": "# Project\\n\\nA brief description of what this project does.\\n\\n## Getting Started\\n\\n```bash\\nbun install\\nbun run dev\\n```"}\n</write-file>',
+  },
+  {
+    role: "user",
+    content:
+      "Here is the output from write-file to README.md:\n\nWritten: /repo/README.md (10 lines, 128 bytes)\n\nPlease continue your response based on this output.",
+  },
+  {
+    role: "assistant",
+    content: "Done — README.md has been created.",
+  },
+
+  // ── expand existing file (read first, then write) ─────────────────────────
+  {
+    role: "user",
+    content: "add more information to the README",
+  },
+  {
+    role: "assistant",
+    content: "<read-file>README.md</read-file>",
+  },
+  {
+    role: "user",
+    content:
+      "Here is the output from read-file of README.md:\n\nFile: README.md (10 lines)\n\n# Project\n\nA brief description.\n\n## Getting Started\n\n```bash\nbun install\n```\n\nPlease continue your response based on this output.",
+  },
+  {
+    role: "assistant",
+    content:
+      '<write-file>\n{"path": "README.md", "content": "# Project\\n\\nA brief description.\\n\\n## Getting Started\\n\\n```bash\\nbun install\\nbun run dev\\n```\\n\\n## Features\\n\\n- Feature one\\n- Feature two\\n\\n## Contributing\\n\\nPull requests welcome."}\n</write-file>',
+  },
+  {
+    role: "user",
+    content:
+      "Here is the output from write-file to README.md:\n\nWritten: /repo/README.md (20 lines, 280 bytes)\n\nPlease continue your response based on this output.",
+  },
+  {
+    role: "assistant",
+    content: "Done — README.md updated with more detail.",
+  },
+
+  // ── write a new doc file directly ─────────────────────────────────────────
+  {
+    role: "user",
+    content: "write a contributing guide",
+  },
+  {
+    role: "assistant",
+    content:
+      '<write-file>\n{"path": "CONTRIBUTING.md", "content": "# Contributing\\n\\nPull requests welcome. Please open an issue first to discuss major changes."}\n</write-file>',
+  },
+  {
+    role: "user",
+    content:
+      "Here is the output from write-file to CONTRIBUTING.md:\n\nWritten: /repo/CONTRIBUTING.md (4 lines, 96 bytes)\n\nPlease continue your response based on this output.",
+  },
+  {
+    role: "assistant",
+    content: "Done — CONTRIBUTING.md has been written.",
+  },
+
   // ── delete / open / pdf ───────────────────────────────────────────────────
   {
     role: "user",
@@ -186,7 +255,7 @@ export const FEW_SHOT_MESSAGES: { role: string; content: string }[] = [
       "The project root has 3 files (`package.json`, `tsconfig.json`, `README.md`) and the `src/` folder for source code.",
   },
 
-  // ── fetch → write → done ─────────────────────────────────────────────────
+  // ── fetch → write → done ──────────────────────────────────────────────────
   {
     role: "user",
     content: "fetch https://api.github.com/repos/microsoft/typescript",
@@ -244,7 +313,7 @@ export const FEW_SHOT_MESSAGES: { role: string; content: string }[] = [
     content: "Done — `hello.py` has been written.",
   },
 
-  // ── read before write ─────────────────────────────────────────────────────
+  // ── read before write (modifying existing file only) ─────────────────────
   {
     role: "user",
     content: "add a logout button to src/components/Header.tsx",
@@ -355,7 +424,7 @@ export const FEW_SHOT_MESSAGES: { role: string; content: string }[] = [
       "Done — scaffolded `myapp/package.json` and `myapp/src/index.ts`. Run `cd myapp && npm install` to get started.",
   },
 
-  // ── memory-add example ────────────────────────────────────────────────────
+  // ── memory ────────────────────────────────────────────────────────────────
   {
     role: "user",
     content: "remember that we always use bun in this project",
@@ -374,4 +443,32 @@ export const FEW_SHOT_MESSAGES: { role: string; content: string }[] = [
     content:
       "<memory-delete>MEMORY_ID</memory-delete>\n\nDone — removed that memory.",
   },
+  // ── make existing file more descriptive ───────────────────────────────────
+  {
+    role: "user",
+    content: "make the README.md more descriptive",
+  },
+  {
+    role: "assistant",
+    content: "<read-file>README.md</read-file>",
+  },
+  {
+    role: "user",
+    content:
+      "Here is the output from read-file of README.md:\n\nFile: README.md (50 lines)\n\n# Lens\n\nA CLI tool for codebase analysis.\n\n## Getting Started\n\n```bash\nbun install\nbun run dev\n```\n\nPlease continue your response based on this output.",
+  },
+  {
+    role: "assistant",
+    content:
+      '<write-file>\n{"path": "README.md", "content": "# Lens\\n\\nLens is a CLI tool that brings AI-powered codebase analysis directly to your terminal. It lets you explore, understand, and modify any repository through natural language.\\n\\n## Features\\n\\n- Chat with your codebase using any LLM provider\\n- Read, write, and edit files with AI assistance\\n- Browse commit history with /timeline\\n- Auto-approve safe tool calls with /auto\\n- Persistent memory across sessions\\n\\n## Getting Started\\n\\n```bash\\nbun install\\nbun run dev\\n```\\n\\n## Commands\\n\\n- /timeline — browse commit history\\n- /auto — toggle auto-approve for safe tools\\n- /review — review the current codebase\\n- /memory list — list stored memories\\n- /chat list — list saved chat sessions"}\n</write-file>',
+  },
+  {
+    role: "user",
+    content:
+      "Here is the output from write-file to README.md:\n\nWritten: /repo/README.md (30 lines, 800 bytes)\n\nPlease continue your response based on this output.",
+  },
+  {
+    role: "assistant",
+    content: "Done — README.md updated with a full description of Lens.",
+  },
 ];

package/src/prompts/system.ts

@@ -9,8 +9,6 @@ export function buildSystemPrompt(
     .map((f) => `### ${f.path}\n\`\`\`\n${f.content.slice(0, 2000)}\n\`\`\``)
     .join("\n\n");
 
-  // If a toolsSection is supplied (e.g. from the plugin registry), use it.
-  // Otherwise fall back to the static built-in section.
   const tools = toolsSection ?? BUILTIN_TOOLS_SECTION;
 
   return `You are an expert software engineer assistant with access to the user's codebase and tools.
@@ -54,6 +52,7 @@ You may emit multiple memory operations in a single response alongside normal co
 11. write-file content field must be the COMPLETE file content, never empty or placeholder
 12. After a write-file succeeds, do NOT repeat it — trust the result and move on
 13. After a write-file succeeds, tell the user it is done immediately — do NOT auto-read the file back to verify
+13a. NEVER read a file you just wrote — the write output confirms success. Reading back is a wasted tool call and will confuse you.
 14. NEVER apologize and redo a tool call you already made — if write-file or shell ran and returned a result, it worked, do not run it again
 15. NEVER say "I made a mistake" and repeat the same tool — one attempt is enough, trust the output
 16. NEVER second-guess yourself mid-response — commit to your answer
@@ -67,6 +66,7 @@ You may emit multiple memory operations in a single response alongside normal co
 24. When explaining how to use a tool in text, use [tag] bracket notation or a fenced code block — NEVER emit a real XML tool tag as part of an explanation or example
 25. NEVER read files, list folders, or run tools that were not asked for in the current user message
 26. NEVER use markdown formatting in plain text responses — no **bold**, no *italics*, no # headings, no bullet points with -, *, or +, no numbered lists, no backtick inline code. Write in plain prose. Only use fenced \`\`\` code blocks when showing actual code.
+27. When the user asks you to CREATE a new file (e.g. "write a README", "create a config", "add a license", "this codebase doesn't have X"), write it IMMEDIATELY — do NOT read first, even if a stub exists.
 
 ## SCAFFOLDING — CHAINING WRITE-FILE CALLS
 
@@ -86,25 +86,23 @@ in a single response by chaining the tags back-to-back with no text between them
 The system processes each tag sequentially and automatically continues to the next one.
 Do NOT wait for a user message between files — emit all tags at once.
 
-## CRITICAL: READ BEFORE YOU WRITE
+## WHEN TO READ BEFORE WRITING
 
-These rules are mandatory whenever you plan to edit or create a file:
+Only read a file before writing if ALL of these are true:
+- The file already exists AND has content you need to preserve
+- The user explicitly asked you to modify, edit, or update it (not create it)
+- You do not already have the file content in this conversation
 
-### Before modifying ANY existing file:
-1. ALWAYS use read-file on the exact file you plan to change FIRST
-2. Study the full current content — understand every import, every export, every type, every existing feature
-3. Your changes patch MUST preserve ALL existing functionality — do not remove or rewrite things that were not part of the request
-4. If you are unsure what other files import from the file you are editing, use read-folder on the parent directory first to see what exists nearby, then read-file the relevant ones
+Never read before writing when:
+- The user asked you to create, write, or add a new file
+- The file is empty, missing, or a stub
+- You already read it earlier in this conversation
 
-### Before adding a feature that touches multiple files:
-1. Use read-folder on the relevant directory to see what files exist
-2. Use read-file on each file you plan to touch
-3. Only then emit a changes tag — with patches that are surgical additions, not wholesale rewrites
-
-### The golden rule for write-file and changes:
-- The output file must contain EVERYTHING the original had, PLUS your new additions
-- NEVER produce a file that is shorter than the original unless you are explicitly asked to delete things
-- If you catch yourself rewriting a file from scratch, STOP — go back and read the original first
+When modifying an existing file:
+1. Use read-file on the exact file first
+2. Preserve ALL existing content — do not remove anything that was not part of the request
+3. Your write-file must contain EVERYTHING the original had, PLUS your additions
+4. NEVER produce a file shorter than the original unless explicitly asked to delete things
 
 ## CODEBASE
 
@@ -113,8 +111,6 @@ ${fileList.length > 0 ? fileList : "(no files indexed)"}
 ${memorySummary}`;
 }
 
-// ── Static fallback tools section (used when registry is not available) ───────
-
 const BUILTIN_TOOLS_SECTION = `## TOOLS
 
 You have exactly thirteen tools. To use a tool you MUST wrap it in the exact XML tags shown below — no other format will work.

package/src/tools/chart.ts

@@ -0,0 +1,210 @@
+//
+
+//
+
+//
+
+import type { Tool } from "@ridit/lens-sdk";
+
+type ChartType = "bar" | "line" | "sparkline";
+
+interface ChartInput {
+  type: ChartType;
+  title?: string;
+  labels?: string[];
+  values: number[];
+  /** For line charts: height in rows. Default 10. */
+  height?: number;
+  /** Bar fill character. Default "█" */
+  fill?: string;
+}
+
+function parseChartInput(body: string): ChartInput | null {
+  const trimmed = body.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed) as Partial<ChartInput> & {
+      data?: number[];
+      series?: number[];
+    };
+    const values = parsed.values ?? parsed.data ?? parsed.series ?? [];
+    if (!Array.isArray(values) || values.length === 0) return null;
+    return {
+      type: parsed.type ?? "bar",
+      title: parsed.title,
+      labels: parsed.labels,
+      values: values.map(Number),
+      height: parsed.height ?? 10,
+      fill: parsed.fill ?? "█",
+    };
+  } catch {
+    return null;
+  }
+}
+
+const C = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  bold: "\x1b[1m",
+  orange: "\x1b[38;2;218;119;88m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+  gray: "\x1b[90m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+};
+
+const PALETTE = [C.orange, C.cyan, C.green, C.yellow];
+function color(i: number) {
+  return PALETTE[i % PALETTE.length]!;
+}
+
+function renderBar(input: ChartInput): string {
+  const { values, labels, title, fill = "█" } = input;
+  const max = Math.max(...values, 1);
+  const termW = process.stdout.columns ?? 80;
+  const maxLabelLen = labels
+    ? Math.max(...labels.map((l) => l.length), 0)
+    : String(values.length).length + 1;
+  const barMaxW = Math.max(20, termW - maxLabelLen - 12);
+
+  const lines: string[] = [];
+  if (title) lines.push(`${C.bold}${C.white}${title}${C.reset}\n`);
+
+  values.forEach((v, i) => {
+    const label = labels?.[i] ?? String(i + 1);
+    const barLen = Math.round((v / max) * barMaxW);
+    const bar = fill.repeat(barLen);
+    const valueStr = String(v);
+    lines.push(
+      `${C.gray}${label.padStart(maxLabelLen)}${C.reset} ` +
+        `${color(i)}${bar}${C.reset} ` +
+        `${C.dim}${valueStr}${C.reset}`,
+    );
+  });
+
+  lines.push(
+    `${" ".repeat(maxLabelLen + 1)}${C.gray}${"─".repeat(barMaxW)}${C.reset}`,
+  );
+  lines.push(
+    `${" ".repeat(maxLabelLen + 1)}${C.gray}0${" ".repeat(barMaxW - String(max).length)}${max}${C.reset}`,
+  );
+
+  return lines.join("\n");
+}
+
+const SPARK_CHARS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+
+function renderSparkline(input: ChartInput): string {
+  const { values, title } = input;
+  const min = Math.min(...values);
+  const max = Math.max(...values, min + 1);
+  const range = max - min;
+  const spark = values
+    .map((v) => {
+      const idx = Math.floor(((v - min) / range) * (SPARK_CHARS.length - 1));
+      return `${color(0)}${SPARK_CHARS[idx] ?? "▁"}${C.reset}`;
+    })
+    .join("");
+
+  const lines: string[] = [];
+  if (title) lines.push(`${C.bold}${C.white}${title}${C.reset}`);
+  lines.push(spark);
+  lines.push(`${C.gray}min ${min}  max ${max}  n=${values.length}${C.reset}`);
+  return lines.join("\n");
+}
+
+async function renderLine(input: ChartInput): Promise<string> {
+  let asciichart: any;
+  try {
+    asciichart = await import("asciichart");
+    asciichart = asciichart.default ?? asciichart;
+  } catch {
+    return (
+      `${C.yellow}asciichart not installed (npm install asciichart). ` +
+      `Falling back to sparkline:${C.reset}\n` +
+      renderSparkline(input)
+    );
+  }
+
+  const termW = process.stdout.columns ?? 80;
+  const height = input.height ?? 10;
+
+  const lines: string[] = [];
+  if (input.title) {
+    lines.push(`${C.bold}${C.white}${input.title}${C.reset}\n`);
+  }
+
+  const chart = asciichart.plot(input.values, {
+    height,
+    width: Math.min(input.values.length, termW - 14),
+    colors: [asciichart.cyan],
+  });
+
+  lines.push(chart);
+
+  if (input.labels && input.labels.length === input.values.length) {
+    const step = Math.max(
+      1,
+      Math.floor(input.labels.length / Math.min(input.labels.length, 10)),
+    );
+    const labelRow = input.labels
+      .filter((_, i) => i % step === 0)
+      .map((l) => l.slice(0, 6).padEnd(6))
+      .join(" ");
+    lines.push(`${C.gray}${" ".repeat(8)}${labelRow}${C.reset}`);
+  }
+
+  return lines.join("\n");
+}
+
+async function renderChart(input: ChartInput): Promise<string> {
+  switch (input.type) {
+    case "bar":
+      return renderBar(input);
+    case "sparkline":
+      return renderSparkline(input);
+    case "line":
+      return await renderLine(input);
+    default:
+      return renderBar(input);
+  }
+}
+
+export const chartDataTool: Tool<ChartInput> = {
+  name: "chart-data",
+  description:
+    "render a bar, line, or sparkline chart in the terminal from given data",
+  safe: true,
+  permissionLabel: "chart",
+
+  systemPromptEntry: (i) =>
+    `### ${i}. chart-data — render a chart in the terminal\n` +
+    `Types: "bar" (default), "line", "sparkline"\n` +
+    `<chart-data>\n` +
+    `{"type": "bar", "title": "Commits per month", "labels": ["Jan","Feb","Mar"], "values": [12, 34, 21]}\n` +
+    `</chart-data>\n` +
+    `<chart-data>\n` +
+    `{"type": "line", "title": "Stars over time", "values": [1,3,6,10,15,21,28], "height": 8}\n` +
+    `</chart-data>\n` +
+    `<chart-data>\n` +
+    `{"type": "sparkline", "title": "Daily commits", "values": [2,5,1,8,3,7,4]}\n` +
+    `</chart-data>`,
+
+  parseInput: parseChartInput,
+
+  summariseInput: ({ type, title }) =>
+    title ? `${type} chart — ${title}` : `${type} chart`,
+
+  execute: async (input, _ctx) => {
+    try {
+      const rendered = await renderChart(input);
+      return { kind: "image" as any, value: rendered };
+    } catch (err) {
+      return {
+        kind: "text",
+        value: `Error rendering chart: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  },
+};