crack-code 0.1.0

package/src/repl.ts

@@ -0,0 +1,284 @@
+import * as readline from "node:readline";
+import type { ModelMessage, LanguageModel } from "ai";
+import type { Config } from "./config.js";
+import type { ToolRegistry } from "./tools/registry.js";
+import type { PermissionManager } from "./permissions/index.js";
+import { runAgent, type TokenUsage } from "./agent.js";
+import * as ui from "./ui/renderer.js";
+
+// Types
+
+interface ReplContext {
+  model: LanguageModel;
+  config: Config;
+  tools: ToolRegistry;
+  permissions: PermissionManager;
+  messages: ModelMessage[];
+  totalUsage: TokenUsage;
+}
+
+// Slash Commands
+
+interface SlashCommand {
+  description: string;
+  handler: (ctx: ReplContext, args: string) => void | Promise<void>;
+}
+
+const commands: Record<string, SlashCommand> = {
+  "/help": {
+    description: "Show available commands",
+    handler: () => {
+      console.log();
+      for (const [name, cmd] of Object.entries(commands)) {
+        console.log(`  \x1b[36m${name.padEnd(14)}\x1b[0m ${cmd.description}`);
+      }
+      console.log();
+    },
+  },
+
+  "/exit": {
+    description: "Exit Crack Code",
+    handler: () => {
+      ui.info("Goodbye.");
+      process.exit(0);
+    },
+  },
+
+  "/clear": {
+    description: "Clear conversation history",
+    handler: (ctx) => {
+      ctx.messages = [];
+      ctx.totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+      ctx.permissions.clearSession();
+      ui.success("Conversation cleared.");
+    },
+  },
+
+  "/usage": {
+    description: "Show token usage for this session",
+    handler: (ctx) => {
+      console.log();
+      ui.dim(`  Input tokens:      ${ctx.totalUsage.inputTokens}`);
+      ui.dim(`  Output tokens:     ${ctx.totalUsage.outputTokens}`);
+      ui.dim(`  Total tokens:      ${ctx.totalUsage.totalTokens}`);
+      ui.dim(`  Messages in context: ${ctx.messages.length}`);
+      console.log();
+    },
+  },
+
+  "/mode": {
+    description: "Toggle read-only ↔ edit mode",
+    handler: (ctx) => {
+      ctx.config.allowEdits = !ctx.config.allowEdits;
+      if (ctx.config.allowEdits) {
+        ui.warn("Edit mode enabled. The AI can now modify files.");
+      } else {
+        ui.success("Read-only mode. The AI can only read and analyze.");
+      }
+    },
+  },
+
+  "/model": {
+    description: "Show current model and provider",
+    handler: (ctx) => {
+      console.log();
+      ui.dim(`  Provider: ${ctx.config.provider}`);
+      ui.dim(`  Model:    ${ctx.config.model}`);
+      console.log();
+    },
+  },
+
+  "/policy": {
+    description: "Show or set permission policy (ask/skip/allow-all/deny-all)",
+    handler: (ctx, args) => {
+      if (!args) {
+        ui.dim(`  Current policy: ${ctx.permissions.getPolicy()}`);
+        return;
+      }
+      const valid = ["ask", "skip", "allow-all", "deny-all"];
+      if (!valid.includes(args)) {
+        ui.error(`Invalid policy. Use: ${valid.join(", ")}`);
+        return;
+      }
+      ctx.permissions.setPolicy(args as any);
+      ui.success(`Permission policy set to: ${args}`);
+    },
+  },
+
+  "/compact": {
+    description: "Summarize conversation to reduce context size",
+    handler: async (ctx) => {
+      const count = ctx.messages.length;
+      if (count <= 2) {
+        ui.info("Conversation too short to compact.");
+        return;
+      }
+
+      const loading = ui.spinner("Compacting conversation...");
+
+      // Keep the last exchange, summarize everything before it
+      const toSummarize = ctx.messages.slice(0, -2);
+      const recent = ctx.messages.slice(-2);
+
+      const summaryText = toSummarize
+        .map((m) => {
+          const content =
+            typeof m.content === "string"
+              ? m.content
+              : JSON.stringify(m.content);
+          return `[${m.role}]: ${content.slice(0, 200)}`;
+        })
+        .join("\n");
+
+      ctx.messages = [
+        {
+          role: "user",
+          content: `[Previous conversation summary — ${count - 2} messages]\n${summaryText.slice(0, 2000)}`,
+        },
+        ...recent,
+      ];
+
+      loading.stop();
+      ui.success(
+        `Compacted ${count} messages → ${ctx.messages.length} messages.`,
+      );
+    },
+  },
+};
+
+// Input Handling
+
+function createInput(): {
+  readLine: () => Promise<string>;
+  close: () => void;
+} {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+  });
+
+  // Handle Ctrl+C gracefully
+  rl.on("SIGINT", () => {
+    console.log();
+    ui.info("Goodbye.");
+    process.exit(0);
+  });
+
+  return {
+    readLine: () =>
+      new Promise<string>((resolve) => {
+        ui.userPrompt();
+        rl.once("line", (line) => resolve(line.trim()));
+      }),
+    close: () => rl.close(),
+  };
+}
+
+// Main REPL Loop
+
+export async function startRepl(
+  model: LanguageModel,
+  config: Config,
+  tools: ToolRegistry,
+  permissions: PermissionManager,
+): Promise<void> {
+  const ctx: ReplContext = {
+    model,
+    config,
+    tools,
+    permissions,
+    messages: [],
+    totalUsage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+  };
+
+  const mode = config.allowEdits ? "edits enabled" : "read-only";
+  ui.banner(config.model, mode);
+
+  const input = createInput();
+
+  while (true) {
+    const line = await input.readLine();
+
+    if (!line) continue;
+
+    // Slash command
+    const spaceIdx = line.indexOf(" ");
+    const cmdName = spaceIdx === -1 ? line : line.slice(0, spaceIdx);
+    const cmdArgs = spaceIdx === -1 ? "" : line.slice(spaceIdx + 1).trim();
+
+    if (cmdName.startsWith("/")) {
+      const command = commands[cmdName];
+      if (command) {
+        await command.handler(ctx, cmdArgs);
+      } else {
+        ui.error(
+          `Unknown command: ${cmdName}. Type /help for available commands.`,
+        );
+      }
+      continue;
+    }
+
+    // Send to agent
+    ctx.messages.push({ role: "user", content: line });
+    ui.newline();
+
+    try {
+      const loading = ui.spinner("Thinking...");
+      let firstToken = true;
+
+      ctx.messages = await runAgent(
+        ctx.messages,
+        {
+          model: ctx.model,
+          tools: ctx.tools,
+          permissions: ctx.permissions,
+          systemPrompt: ctx.config.systemPrompt,
+          maxSteps: ctx.config.maxSteps,
+          maxTokens: ctx.config.maxTokens,
+        },
+        {
+          onText: (delta) => {
+            if (firstToken) {
+              loading.stop();
+              firstToken = false;
+            }
+            ui.streamText(delta);
+          },
+
+          onToolStart: (name, args) => {
+            if (firstToken) {
+              loading.stop();
+              firstToken = false;
+            }
+            ui.toolStart(name, args);
+          },
+
+          onToolEnd: (name, result) => {
+            ui.toolEnd(name, result);
+          },
+
+          onUsage: (usage) => {
+            ctx.totalUsage.inputTokens += usage.inputTokens;
+            ctx.totalUsage.outputTokens += usage.outputTokens;
+            ctx.totalUsage.totalTokens += usage.totalTokens;
+          },
+
+          onError: (err) => {
+            loading.stop();
+            ui.error(err);
+          },
+        },
+      );
+
+      // If spinner never stopped (empty response), stop it now
+      if (firstToken) loading.stop();
+
+      ui.newline();
+    } catch (e: any) {
+      // Agent threw — keep previous messages intact
+      ctx.messages.pop(); // remove the user message that caused the error
+      ui.error(e.message);
+    }
+  }
+}

package/src/tools/file-read.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { resolve, relative } from "node:path";
+import type { ToolDef } from "./registry.js";
+
+const MAX_SIZE = 256 * 1024; // 256 KB
+
+const schema = z.object({
+  path: z.string().describe("Relative or absolute path to the file"),
+  start_line: z.number().optional().describe("First line to read (1-based)"),
+  end_line: z
+    .number()
+    .optional()
+    .describe("Last line to read (1-based, inclusive)"),
+});
+
+export const readFileTool: ToolDef<typeof schema> = {
+  name: "read_file",
+  description:
+    "Read the contents of a file. Returns numbered lines. " +
+    "Use start_line/end_line to read a specific range. " +
+    "Files larger than 256 KB are truncated.",
+  inputSchema: schema,
+  requiresApproval: false,
+
+  async execute({ path: filePath, start_line, end_line }) {
+    const cwd = process.cwd();
+    const abs = resolve(cwd, filePath);
+    const rel = relative(cwd, abs);
+
+    // Block path traversal outside cwd
+    if (rel.startsWith("..")) {
+      return `Error: path "${filePath}" is outside the working directory.`;
+    }
+
+    const file = Bun.file(abs);
+    if (!(await file.exists())) {
+      return `Error: file not found — ${rel}`;
+    }
+
+    const size = file.size;
+    if (size > MAX_SIZE) {
+      const partial = await file.text();
+      const truncated = partial.slice(0, MAX_SIZE);
+      const lines = truncated.split("\n");
+      return (
+        `⚠ File truncated (${(size / 1024).toFixed(0)} KB > 256 KB limit). Showing first ${lines.length} lines.\n\n` +
+        numberLines(lines, 1)
+      );
+    }
+
+    const content = await file.text();
+    let lines = content.split("\n");
+
+    // Apply line range
+    const start = start_line ? Math.max(1, start_line) : 1;
+    const end = end_line ? Math.min(lines.length, end_line) : lines.length;
+    lines = lines.slice(start - 1, end);
+
+    if (lines.length === 0) {
+      return `File is empty — ${rel}`;
+    }
+
+    const header =
+      start_line || end_line
+        ? `${rel} (lines ${start}–${end})`
+        : `${rel} (${lines.length} lines)`;
+
+    return `${header}\n\n${numberLines(lines, start)}`;
+  },
+};
+
+function numberLines(lines: string[], startAt: number): string {
+  const width = String(startAt + lines.length - 1).length;
+  return lines
+    .map((line, i) => `${String(startAt + i).padStart(width)} │ ${line}`)
+    .join("\n");
+}

package/src/tools/file-write.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { resolve, relative, dirname } from "node:path";
+import { mkdir } from "node:fs/promises";
+import type { ToolDef } from "./registry.js";
+
+const schema = z.object({
+  path: z.string().describe("Relative or absolute path to the file"),
+  content: z.string().describe("The full content to write to the file"),
+});
+
+export const writeFileTool: ToolDef<typeof schema> = {
+  name: "write_file",
+  description:
+    "Write content to a file. Creates the file if it doesn't exist, " +
+    "overwrites if it does. Parent directories are created automatically. " +
+    "Always requires user approval.",
+  inputSchema: schema,
+  requiresApproval: true,
+
+  async execute({ path: filePath, content }) {
+    const cwd = process.cwd();
+    const abs = resolve(cwd, filePath);
+    const rel = relative(cwd, abs);
+
+    // Block path traversal outside cwd
+    if (rel.startsWith("..")) {
+      return `Error: path "${filePath}" is outside the working directory.`;
+    }
+
+    // Ensure parent directories exist
+    await mkdir(dirname(abs), { recursive: true });
+
+    const existed = await Bun.file(abs).exists();
+    await Bun.write(abs, content);
+
+    const lines = content.split("\n").length;
+    const bytes = Buffer.byteLength(content, "utf-8");
+    const action = existed ? "Updated" : "Created";
+
+    return `${action} ${rel} (${lines} lines, ${bytes} bytes)`;
+  },
+};

package/src/tools/glob.ts

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import type { ToolDef } from "./registry.js";
+
+const MAX_RESULTS = 500;
+
+const schema = z.object({
+  pattern: z
+    .string()
+    .describe('Glob pattern to match (e.g. "**/*.ts", "src/**/*.js")'),
+  ignore: z
+    .array(z.string())
+    .optional()
+    .describe("Additional glob patterns to ignore"),
+});
+
+export const listFilesTool: ToolDef<typeof schema> = {
+  name: "list_files",
+  description:
+    "List files matching a glob pattern in the working directory. " +
+    "Common ignore patterns (node_modules, .git, dist, etc.) are excluded by default. " +
+    "Returns up to 500 matching paths sorted alphabetically.",
+  inputSchema: schema,
+  requiresApproval: false,
+
+  async execute({ pattern, ignore }) {
+    const cwd = process.cwd();
+
+    const defaultIgnore = [
+      "node_modules/**",
+      ".git/**",
+      "dist/**",
+      "build/**",
+      "coverage/**",
+      ".next/**",
+      "__pycache__/**",
+      "vendor/**",
+      "target/**",
+    ];
+
+    const ignorePatterns = [...defaultIgnore, ...(ignore ?? [])];
+
+    const glob = new Bun.Glob(pattern);
+    const matches: string[] = [];
+
+    for await (const path of glob.scan({ cwd, dot: false })) {
+      if (shouldIgnore(path, ignorePatterns)) continue;
+      matches.push(path);
+      if (matches.length >= MAX_RESULTS) break;
+    }
+
+    matches.sort();
+
+    if (matches.length === 0) {
+      return `No files matched pattern "${pattern}"`;
+    }
+
+    const header =
+      matches.length >= MAX_RESULTS
+        ? `Found ${MAX_RESULTS}+ files (showing first ${MAX_RESULTS}):`
+        : `Found ${matches.length} file${matches.length === 1 ? "" : "s"}:`;
+
+    return `${header}\n\n${matches.join("\n")}`;
+  },
+};
+
+function shouldIgnore(path: string, patterns: string[]): boolean {
+  for (const pattern of patterns) {
+    // Simple prefix match for directory globs like "node_modules/**"
+    if (pattern.endsWith("/**")) {
+      const dir = pattern.slice(0, -3);
+      if (path === dir || path.startsWith(dir + "/")) return true;
+    }
+
+    // Simple extension match for patterns like "*.lock"
+    if (pattern.startsWith("*.")) {
+      const ext = pattern.slice(1);
+      if (path.endsWith(ext)) return true;
+    }
+
+    // Exact match
+    if (path === pattern) return true;
+  }
+  return false;
+}

package/src/tools/registry.ts

@@ -0,0 +1,63 @@
+import type { ToolSet } from "ai";
+import type { z } from "zod";
+import type { PermissionManager } from "../permissions/index.js";
+import * as ui from "../ui/renderer.js";
+
+// Each tool module exports one of these
+export interface ToolDef<
+  TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,
+> {
+  name: string;
+  description: string;
+  inputSchema: TSchema;
+  requiresApproval: boolean;
+  execute: (input: z.infer<TSchema>) => Promise<string>;
+}
+
+export class ToolRegistry {
+  private defs: ToolDef[] = [];
+
+  register(def: ToolDef): void {
+    this.defs.push(def);
+  }
+
+  registerAll(...defs: ToolDef[]): void {
+    for (const def of defs) this.defs.push(def);
+  }
+
+  // Convert to AI SDK ToolSet with permission gating and UI hooks
+  toAISDKTools(permissions: PermissionManager): ToolSet {
+    const tools: ToolSet = {};
+
+    for (const def of this.defs) {
+      tools[def.name] = {
+        description: def.description,
+        inputSchema: def.inputSchema,
+        execute: async (input: Record<string, unknown>) => {
+          ui.toolStart(def.name, input);
+
+          if (def.requiresApproval) {
+            const allowed = await permissions.check(def.name, input);
+            if (!allowed) return "⛔ Tool call denied by user.";
+          }
+
+          try {
+            const result = await def.execute(input);
+            ui.toolEnd(def.name, result);
+            return result;
+          } catch (err: any) {
+            const msg = `Error: ${err.message ?? err}`;
+            ui.toolEnd(def.name, msg);
+            return msg;
+          }
+        },
+      };
+    }
+
+    return tools;
+  }
+
+  getNames(): string[] {
+    return this.defs.map((d) => d.name);
+  }
+}

package/src/tools/shell.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import type { ToolDef } from "./registry.js";
+
+const DEFAULT_TIMEOUT = 30_000; // 30 seconds
+const MAX_OUTPUT = 128 * 1024; // 128 KB
+
+const schema = z.object({
+  command: z.string().describe("The shell command to execute"),
+  timeout_ms: z
+    .number()
+    .optional()
+    .describe("Max runtime in milliseconds (default 30000)"),
+});
+
+export const runCommandTool: ToolDef<typeof schema> = {
+  name: "run_command",
+  description:
+    "Execute a shell command in the working directory. " +
+    "Output is captured from stdout and stderr. " +
+    "Commands are killed after the timeout (default 30s). " +
+    "Always requires user approval.",
+  inputSchema: schema,
+  requiresApproval: true,
+
+  async execute({ command, timeout_ms }) {
+    const timeout = timeout_ms ?? DEFAULT_TIMEOUT;
+    const cwd = process.cwd();
+
+    try {
+      const proc = Bun.spawn(["sh", "-c", command], {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+        env: process.env,
+      });
+
+      const timer = setTimeout(() => proc.kill(), timeout);
+
+      const [stdoutBuf, stderrBuf] = await Promise.all([
+        new Response(proc.stdout).arrayBuffer(),
+        new Response(proc.stderr).arrayBuffer(),
+      ]);
+
+      clearTimeout(timer);
+
+      const code = proc.exitCode ?? (await proc.exited);
+      let stdout = new TextDecoder().decode(stdoutBuf);
+      let stderr = new TextDecoder().decode(stderrBuf);
+
+      // Truncate if too large
+      if (stdout.length > MAX_OUTPUT) {
+        stdout = stdout.slice(0, MAX_OUTPUT) + "\n… (stdout truncated)";
+      }
+      if (stderr.length > MAX_OUTPUT) {
+        stderr = stderr.slice(0, MAX_OUTPUT) + "\n… (stderr truncated)";
+      }
+
+      const parts: string[] = [`Exit code: ${code}`];
+      if (stdout.trim()) parts.push(`stdout:\n${stdout.trim()}`);
+      if (stderr.trim()) parts.push(`stderr:\n${stderr.trim()}`);
+
+      return parts.join("\n\n");
+    } catch (err: any) {
+      if (err.message?.includes("kill")) {
+        return `Error: command timed out after ${timeout}ms — "${command}"`;
+      }
+      return `Error: ${err.message ?? err}`;
+    }
+  },
+};