ashlrcode 1.0.0

package/src/tools/diff.ts

@@ -0,0 +1,137 @@
+/**
+ * DiffTool — show differences between file versions or git changes.
+ */
+
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import type { Tool, ToolContext } from "./types.ts";
+
+export const diffTool: Tool = {
+  name: "Diff",
+
+  prompt() {
+    return `Show differences between files or git changes. Modes:
+- git: show git diff for a file or the whole repo
+- files: compare two files
+- string: compare two strings (useful for showing before/after)`;
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        mode: {
+          type: "string",
+          enum: ["git", "files", "string"],
+          description: "Diff mode (default: git)",
+        },
+        file_path: {
+          type: "string",
+          description: "File path for git diff, or first file for files mode",
+        },
+        file_path_2: {
+          type: "string",
+          description: "Second file path (for files mode)",
+        },
+        old_string: {
+          type: "string",
+          description: "Old string (for string mode)",
+        },
+        new_string: {
+          type: "string",
+          description: "New string (for string mode)",
+        },
+        staged: {
+          type: "boolean",
+          description: "Show staged changes (git mode, default: false)",
+        },
+      },
+      required: [],
+    };
+  },
+
+  isReadOnly() { return true; },
+  isDestructive() { return false; },
+  isConcurrencySafe() { return true; },
+
+  validateInput() { return null; },
+
+  async call(input, context) {
+    const mode = (input.mode as string) ?? "git";
+
+    switch (mode) {
+      case "git":
+        return await gitDiff(input, context);
+      case "files":
+        return await filesDiff(input, context);
+      case "string":
+        return stringDiff(input);
+      default:
+        return `Unknown mode: ${mode}`;
+    }
+  },
+};
+
+async function gitDiff(input: Record<string, unknown>, context: ToolContext): Promise<string> {
+  const args = ["git", "diff"];
+  if (input.staged) args.push("--staged");
+  if (input.file_path) args.push("--", input.file_path as string);
+
+  const proc = Bun.spawn(args, {
+    cwd: context.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const stdout = await new Response(proc.stdout).text();
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0 || !stdout.trim()) {
+    return "No changes found.";
+  }
+
+  return stdout.trim();
+}
+
+async function filesDiff(input: Record<string, unknown>, context: ToolContext): Promise<string> {
+  const path1 = resolve(context.cwd, input.file_path as string);
+  const path2 = resolve(context.cwd, input.file_path_2 as string);
+
+  if (!existsSync(path1)) return `File not found: ${path1}`;
+  if (!existsSync(path2)) return `File not found: ${path2}`;
+
+  const proc = Bun.spawn(["diff", "-u", path1, path2], {
+    cwd: context.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const stdout = await new Response(proc.stdout).text();
+  return stdout.trim() || "Files are identical.";
+}
+
+function stringDiff(input: Record<string, unknown>): string {
+  const oldStr = (input.old_string as string) ?? "";
+  const newStr = (input.new_string as string) ?? "";
+
+  const oldLines = oldStr.split("\n");
+  const newLines = newStr.split("\n");
+
+  const lines: string[] = [];
+  const maxLen = Math.max(oldLines.length, newLines.length);
+
+  for (let i = 0; i < maxLen; i++) {
+    const oldLine = oldLines[i];
+    const newLine = newLines[i];
+
+    if (oldLine === newLine) {
+      if (oldLine !== undefined) lines.push(`  ${oldLine}`);
+    } else {
+      if (oldLine !== undefined) lines.push(`- ${oldLine}`);
+      if (newLine !== undefined) lines.push(`+ ${newLine}`);
+    }
+  }
+
+  return lines.join("\n") || "No differences.";
+}

package/src/tools/file-edit.ts

@@ -0,0 +1,123 @@
+/**
+ * FileEditTool — exact string replacement in files.
+ * Follows Claude Code's Edit pattern.
+ */
+
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import type { Tool, ToolContext } from "./types.ts";
+import { getFileHistory } from "../state/file-history.ts";
+
+export const fileEditTool: Tool = {
+  name: "Edit",
+
+  prompt() {
+    return "Perform exact string replacement in a file. The old_string must be unique in the file. Use replace_all: true to replace all occurrences.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Absolute path to the file to edit",
+        },
+        old_string: {
+          type: "string",
+          description: "The exact text to find and replace",
+        },
+        new_string: {
+          type: "string",
+          description: "The replacement text",
+        },
+        replace_all: {
+          type: "boolean",
+          description: "Replace all occurrences (default: false)",
+        },
+      },
+      required: ["file_path", "old_string", "new_string"],
+    };
+  },
+
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return false; // Reversible via edit
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+
+  validateInput(input) {
+    if (!input.file_path || typeof input.file_path !== "string") {
+      return "file_path is required";
+    }
+    if (typeof input.old_string !== "string") {
+      return "old_string is required";
+    }
+    if (typeof input.new_string !== "string") {
+      return "new_string is required";
+    }
+    if (input.old_string === input.new_string) {
+      return "old_string and new_string must be different";
+    }
+    return null;
+  },
+
+  async call(input, context) {
+    const filePath = resolve(context.cwd, input.file_path as string);
+    const oldString = input.old_string as string;
+    const newString = input.new_string as string;
+    const replaceAll = (input.replace_all as boolean) ?? false;
+
+    if (!existsSync(filePath)) {
+      return `File not found: ${filePath}`;
+    }
+
+    // Snapshot before editing
+    const history = getFileHistory();
+    if (history) {
+      await history.capture(filePath, "Edit", context.turnNumber ?? 0);
+    }
+
+    const content = await readFile(filePath, "utf-8");
+
+    if (!replaceAll) {
+      const occurrences = content.split(oldString).length - 1;
+      if (occurrences === 0) {
+        return `old_string not found in ${filePath}`;
+      }
+      if (occurrences > 1) {
+        return `old_string found ${occurrences} times — must be unique. Provide more context or use replace_all: true.`;
+      }
+    }
+
+    const updated = replaceAll
+      ? content.replaceAll(oldString, newString)
+      : content.replace(oldString, newString);
+
+    await writeFile(filePath, updated, "utf-8");
+
+    const replacements = replaceAll
+      ? content.split(oldString).length - 1
+      : 1;
+
+    // Show a mini diff
+    const oldLines = oldString.split("\n");
+    const newLines = newString.split("\n");
+    const diffLines: string[] = [];
+    for (const line of oldLines.slice(0, 3)) {
+      diffLines.push(`- ${line}`);
+    }
+    if (oldLines.length > 3) diffLines.push(`  ... (${oldLines.length} lines)`);
+    for (const line of newLines.slice(0, 3)) {
+      diffLines.push(`+ ${line}`);
+    }
+    if (newLines.length > 3) diffLines.push(`  ... (${newLines.length} lines)`);
+
+    return `Replaced ${replacements} occurrence(s) in ${filePath}\n${diffLines.join("\n")}`;
+  },
+};

package/src/tools/file-read.ts

@@ -0,0 +1,82 @@
+/**
+ * FileReadTool — read file contents with line numbers.
+ */
+
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import type { Tool, ToolContext } from "./types.ts";
+
+export const fileReadTool: Tool = {
+  name: "Read",
+
+  prompt() {
+    return "Read a file from the filesystem. Returns contents with line numbers. Supports offset and limit for reading specific portions of large files.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Absolute path to the file to read",
+        },
+        offset: {
+          type: "number",
+          description: "Line number to start reading from (0-based)",
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of lines to read",
+        },
+      },
+      required: ["file_path"],
+    };
+  },
+
+  isReadOnly() {
+    return true;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+
+  validateInput(input) {
+    if (!input.file_path || typeof input.file_path !== "string") {
+      return "file_path is required and must be a string";
+    }
+    return null;
+  },
+
+  async call(input, context) {
+    const filePath = resolve(context.cwd, input.file_path as string);
+
+    if (!existsSync(filePath)) {
+      return `File not found: ${filePath}`;
+    }
+
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+
+    const offset = (input.offset as number) ?? 0;
+    const limit = (input.limit as number) ?? 2000;
+    const slice = lines.slice(offset, offset + limit);
+
+    const numbered = slice
+      .map((line, i) => `${offset + i + 1}\t${line}`)
+      .join("\n");
+
+    const total = lines.length;
+    const showing = slice.length;
+    const header =
+      showing < total
+        ? `(Showing lines ${offset + 1}-${offset + showing} of ${total})\n`
+        : "";
+
+    return header + numbered;
+  },
+};

package/src/tools/file-write.ts

@@ -0,0 +1,82 @@
+/**
+ * FileWriteTool — create or overwrite files.
+ */
+
+import { writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import type { Tool, ToolContext } from "./types.ts";
+import { getFileHistory } from "../state/file-history.ts";
+
+export const fileWriteTool: Tool = {
+  name: "Write",
+
+  prompt() {
+    return "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Creates parent directories as needed.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Absolute path to the file to write",
+        },
+        content: {
+          type: "string",
+          description: "The content to write to the file",
+        },
+      },
+      required: ["file_path", "content"],
+    };
+  },
+
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+
+  validateInput(input) {
+    if (!input.file_path || typeof input.file_path !== "string") {
+      return "file_path is required and must be a string";
+    }
+    if (typeof input.content !== "string") {
+      return "content is required and must be a string";
+    }
+    return null;
+  },
+
+  checkPermissions(input: Record<string, unknown>, context: ToolContext): string | null {
+    const filePath = input.file_path as string;
+    if (!filePath) return null;
+    const resolved = resolve(context.cwd, filePath);
+    const sensitive = ["/etc/", "/usr/bin/", "/sbin/", "/.ssh/"];
+    for (const s of sensitive) {
+      if (resolved.includes(s)) return `Cannot write to sensitive path: ${s}`;
+    }
+    return null;
+  },
+
+  async call(input, context) {
+    const filePath = resolve(context.cwd, input.file_path as string);
+    const content = input.content as string;
+
+    // Snapshot before overwriting (captures new files too for undo-as-delete)
+    const history = getFileHistory();
+    if (history) {
+      await history.capture(filePath, "Write", context.turnNumber ?? 0);
+    }
+
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf-8");
+
+    const lines = content.split("\n").length;
+    return `Wrote ${lines} lines to ${filePath}`;
+  },
+};

package/src/tools/glob.ts

@@ -0,0 +1,76 @@
+/**
+ * GlobTool — fast file pattern matching.
+ */
+
+import fg from "fast-glob";
+import { resolve } from "path";
+import type { Tool, ToolContext } from "./types.ts";
+
+export const globTool: Tool = {
+  name: "Glob",
+
+  prompt() {
+    return 'Find files matching a glob pattern. Returns matching file paths sorted by modification time. Example patterns: "**/*.ts", "src/**/*.tsx", "*.json"';
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Glob pattern to match files against",
+        },
+        path: {
+          type: "string",
+          description: "Directory to search in (defaults to cwd)",
+        },
+      },
+      required: ["pattern"],
+    };
+  },
+
+  isReadOnly() {
+    return true;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+
+  validateInput(input) {
+    if (!input.pattern || typeof input.pattern !== "string") {
+      return "pattern is required";
+    }
+    return null;
+  },
+
+  async call(input, context) {
+    const pattern = input.pattern as string;
+    const searchPath = resolve(context.cwd, (input.path as string) ?? ".");
+
+    const files = await fg(pattern, {
+      cwd: searchPath,
+      absolute: true,
+      dot: false,
+      ignore: ["**/node_modules/**", "**/.git/**"],
+      stats: true,
+    });
+
+    // Sort by modification time (most recent first)
+    files.sort((a, b) => {
+      const aTime = a.stats?.mtimeMs ?? 0;
+      const bTime = b.stats?.mtimeMs ?? 0;
+      return bTime - aTime;
+    });
+
+    if (files.length === 0) {
+      return `No files matching "${pattern}" in ${searchPath}`;
+    }
+
+    const paths = files.map((f) => f.path).join("\n");
+    return `${files.length} file(s) found:\n${paths}`;
+  },
+};

package/src/tools/grep.ts

@@ -0,0 +1,187 @@
+/**
+ * GrepTool — content search. Tries ripgrep first, falls back to grep.
+ */
+
+import { resolve } from "path";
+import type { Tool, ToolContext } from "./types.ts";
+
+export const grepTool: Tool = {
+  name: "Grep",
+
+  prompt() {
+    return "Search file contents using regex patterns. Returns matching lines with file paths and line numbers.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Regex pattern to search for",
+        },
+        path: {
+          type: "string",
+          description: "File or directory to search in (defaults to cwd)",
+        },
+        glob: {
+          type: "string",
+          description: 'Glob pattern to filter files (e.g. "*.ts", "*.{js,jsx}")',
+        },
+        output_mode: {
+          type: "string",
+          enum: ["content", "files_with_matches", "count"],
+          description: "Output mode (default: files_with_matches)",
+        },
+      },
+      required: ["pattern"],
+    };
+  },
+
+  isReadOnly() {
+    return true;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+
+  validateInput(input) {
+    if (!input.pattern || typeof input.pattern !== "string") {
+      return "pattern is required";
+    }
+    return null;
+  },
+
+  async call(input, context) {
+    const pattern = input.pattern as string;
+    const searchPath = resolve(context.cwd, (input.path as string) ?? ".");
+    const globFilter = input.glob as string | undefined;
+    const outputMode = (input.output_mode as string) ?? "files_with_matches";
+
+    // Try ripgrep first (use bash -c to resolve shell functions/aliases)
+    try {
+      const result = await runRipgrep(pattern, searchPath, globFilter, outputMode, context);
+      if (result !== null) return result;
+    } catch {
+      // ripgrep not available, fall through to grep
+    }
+
+    // Fallback to system grep
+    return await runGrep(pattern, searchPath, globFilter, outputMode, context);
+  },
+};
+
+async function runRipgrep(
+  pattern: string,
+  searchPath: string,
+  globFilter: string | undefined,
+  outputMode: string,
+  context: ToolContext
+): Promise<string | null> {
+  const rgArgs: string[] = [];
+
+  switch (outputMode) {
+    case "files_with_matches":
+      rgArgs.push("-l");
+      break;
+    case "count":
+      rgArgs.push("-c");
+      break;
+    case "content":
+      rgArgs.push("-n");
+      break;
+  }
+
+  if (globFilter) {
+    rgArgs.push("--glob", globFilter);
+  }
+
+  rgArgs.push("--max-count", "250", "--no-heading");
+  rgArgs.push(pattern, searchPath);
+
+  // Use bash -c to resolve shell functions/aliases for rg
+  const cmd = `rg ${rgArgs.map(shellEscape).join(" ")}`;
+  const proc = Bun.spawn(["bash", "-c", cmd], {
+    cwd: context.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env },
+  });
+
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+
+  if (exitCode === 1 && !stderr) {
+    return `No matches found for "${pattern}"`;
+  }
+
+  if (exitCode !== 0 && exitCode !== 1) {
+    if (stderr.includes("not found") || stderr.includes("command not found")) {
+      return null; // rg not available
+    }
+    return `Search error: ${stderr}`;
+  }
+
+  return stdout.trim() || `No matches found for "${pattern}"`;
+}
+
+async function runGrep(
+  pattern: string,
+  searchPath: string,
+  globFilter: string | undefined,
+  outputMode: string,
+  context: ToolContext
+): Promise<string> {
+  const args = ["grep", "-r"];
+
+  switch (outputMode) {
+    case "files_with_matches":
+      args.push("-l");
+      break;
+    case "count":
+      args.push("-c");
+      break;
+    case "content":
+      args.push("-n");
+      break;
+  }
+
+  if (globFilter) {
+    args.push(`--include=${globFilter}`);
+  } else {
+    args.push("--include=*.ts", "--include=*.js", "--include=*.tsx",
+      "--include=*.jsx", "--include=*.py", "--include=*.go",
+      "--include=*.rs", "--include=*.md", "--include=*.json");
+  }
+
+  args.push(pattern, searchPath);
+
+  const proc = Bun.spawn(args, {
+    cwd: context.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const stdout = await new Response(proc.stdout).text();
+  const exitCode = await proc.exited;
+
+  if (exitCode === 1) {
+    return `No matches found for "${pattern}"`;
+  }
+
+  // Limit output
+  const lines = stdout.trim().split("\n");
+  if (lines.length > 250) {
+    return lines.slice(0, 250).join("\n") + `\n\n[... ${lines.length - 250} more matches]`;
+  }
+
+  return stdout.trim() || `No matches found for "${pattern}"`;
+}
+
+function shellEscape(s: string): string {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}