@aayambansal/squint 0.1.0

package/dist/chunk-YIVPCWSG.js

@@ -0,0 +1,402 @@
+#!/usr/bin/env node
+
+// src/engines/registry.ts
+import fs from "fs";
+import path from "path";
+
+// src/engines/aider.ts
+var aider = {
+  id: "aider",
+  name: "Aider",
+  binary: "aider",
+  install: "python -m pip install aider-install && aider-install",
+  supportsResume: false,
+  buildArgs(opts) {
+    const args = ["--message", opts.prompt, "--yes-always", "--no-auto-commits"];
+    if (opts.model) args.push("--model", opts.model);
+    return args;
+  }
+};
+
+// src/util/stream.ts
+function lineSplitter(onLine) {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk;
+      let index;
+      while ((index = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, index).replace(/\r$/, "");
+        buffer = buffer.slice(index + 1);
+        if (line.trim().length > 0) onLine(line);
+      }
+    },
+    flush() {
+      if (buffer.trim().length > 0) onLine(buffer);
+      buffer = "";
+    }
+  };
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+
+// src/engines/claudeProtocol.ts
+function createClaudeStreamParser(readyLabel) {
+  let sawTextDelta = false;
+  return (line) => {
+    let data;
+    try {
+      data = JSON.parse(line);
+    } catch {
+      return [{ type: "text", text: line }];
+    }
+    switch (data?.type) {
+      case "system":
+        if (data.subtype === "init") {
+          const model = data.model ? ` \xB7 ${data.model}` : "";
+          return [{ type: "status", text: `${readyLabel} ready${model}` }];
+        }
+        return [];
+      case "stream_event": {
+        const delta = data.event?.delta;
+        if (data.event?.type === "content_block_delta" && delta?.type === "text_delta" && delta.text) {
+          sawTextDelta = true;
+          return [{ type: "delta", text: delta.text }];
+        }
+        return [];
+      }
+      case "assistant": {
+        if (data.parent_tool_use_id) return [];
+        const events = [];
+        for (const block of data.message?.content ?? []) {
+          if (block.type === "text" && block.text) {
+            events.push({ type: "text", text: block.text, streamed: sawTextDelta || void 0 });
+          } else if (block.type === "thinking" && block.thinking) {
+            events.push({ type: "thinking", text: block.thinking });
+          } else if (block.type === "tool_use") {
+            events.push({
+              type: "tool",
+              name: block.name ?? "tool",
+              detail: summarizeToolInput(block.input)
+            });
+          }
+        }
+        sawTextDelta = false;
+        return events;
+      }
+      case "result":
+        return [
+          {
+            type: "result",
+            ok: data.subtype === "success" && data.is_error !== true,
+            summary: typeof data.result === "string" ? data.result : void 0,
+            sessionId: data.session_id,
+            costUsd: data.total_cost_usd,
+            durationMs: data.duration_ms
+          }
+        ];
+      case "user":
+        return [];
+      case "rate_limit_event":
+        return [];
+      default:
+        return [{ type: "raw", data }];
+    }
+  };
+}
+function summarizeToolInput(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const obj = input;
+  const key = typeof obj.file_path === "string" ? obj.file_path : typeof obj.command === "string" ? obj.command : typeof obj.pattern === "string" ? obj.pattern : typeof obj.description === "string" ? obj.description : void 0;
+  if (key) return truncate(key, 80);
+  const json = JSON.stringify(obj);
+  return json === "{}" ? void 0 : truncate(json, 80);
+}
+
+// src/engines/amp.ts
+var amp = {
+  id: "amp",
+  name: "Amp",
+  binary: "amp",
+  install: "npm install -g @sourcegraph/amp",
+  supportsResume: true,
+  buildArgs(opts) {
+    if (opts.sessionId) {
+      return ["threads", "continue", "--execute", opts.prompt, "--stream-json"];
+    }
+    return ["-x", opts.prompt, "--stream-json"];
+  },
+  createParser: () => createClaudeStreamParser("amp")
+};
+
+// src/engines/claude.ts
+var claude = {
+  id: "claude",
+  name: "Claude Code",
+  binary: "claude",
+  install: "npm install -g @anthropic-ai/claude-code",
+  supportsResume: true,
+  buildArgs(opts) {
+    const args = [
+      "-p",
+      opts.prompt,
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--include-partial-messages",
+      "--permission-mode",
+      "acceptEdits"
+    ];
+    if (opts.model) args.push("--model", opts.model);
+    if (opts.sessionId) args.push("--resume", opts.sessionId);
+    return args;
+  },
+  createParser: () => createClaudeStreamParser("claude")
+};
+
+// src/engines/codex.ts
+var codex = {
+  id: "codex",
+  name: "Codex CLI",
+  binary: "codex",
+  install: "npm install -g @openai/codex",
+  supportsResume: true,
+  buildArgs(opts) {
+    const args = ["exec"];
+    if (opts.sessionId) args.push("resume", opts.sessionId);
+    args.push("--json", "--sandbox", "workspace-write", "--skip-git-repo-check");
+    if (opts.model) args.push("--model", opts.model);
+    args.push(opts.prompt);
+    return args;
+  },
+  createParser() {
+    let threadId;
+    return (line) => {
+      let data;
+      try {
+        data = JSON.parse(line);
+      } catch {
+        return [{ type: "text", text: line }];
+      }
+      if (typeof data?.type === "string") {
+        switch (data.type) {
+          case "thread.started":
+            threadId = data.thread_id;
+            return [{ type: "status", text: "codex ready" }];
+          case "item.started":
+            return itemToEvents(data.item, "started");
+          case "item.completed":
+            return itemToEvents(data.item, "completed");
+          case "turn.completed":
+            return [{ type: "result", ok: true, sessionId: threadId }];
+          case "turn.failed":
+          case "error":
+            return [
+              {
+                type: "result",
+                ok: false,
+                summary: data.error?.message ?? data.message ?? "turn failed",
+                sessionId: threadId
+              }
+            ];
+          default:
+            if (data.type.startsWith("item.") || data.type.startsWith("turn.")) return [];
+        }
+      }
+      const msg = data?.msg;
+      if (msg && typeof msg.type === "string") {
+        switch (msg.type) {
+          case "agent_message":
+            return msg.message ? [{ type: "text", text: msg.message }] : [];
+          case "agent_reasoning":
+            return [];
+          case "exec_command_begin":
+            return [
+              {
+                type: "tool",
+                name: "shell",
+                detail: Array.isArray(msg.command) ? truncate(msg.command.join(" "), 80) : void 0
+              }
+            ];
+          case "patch_apply_begin":
+            return [{ type: "tool", name: "edit" }];
+          case "task_complete":
+            return [{ type: "result", ok: true, summary: msg.last_agent_message }];
+          case "error":
+            return [{ type: "error", text: msg.message ?? "codex error" }];
+          default:
+            return [];
+        }
+      }
+      return [{ type: "raw", data }];
+    };
+  }
+};
+function itemToEvents(item, phase) {
+  if (!item) return [];
+  switch (item.type) {
+    case "agent_message":
+      return phase === "completed" && item.text ? [{ type: "text", text: item.text }] : [];
+    case "command_execution":
+      return phase === "started" ? [{ type: "tool", name: "shell", detail: item.command ? truncate(item.command, 80) : void 0 }] : [];
+    case "file_change": {
+      if (phase !== "completed") return [];
+      const changes = Array.isArray(item.changes) ? item.changes.map((c) => c.path).filter(Boolean).join(", ") : void 0;
+      return [{ type: "tool", name: "edit", detail: changes ? truncate(changes, 80) : void 0 }];
+    }
+    case "reasoning":
+      return phase === "completed" && item.text ? [{ type: "thinking", text: item.text }] : [];
+    case "todo_list":
+      return [];
+    default:
+      return [];
+  }
+}
+
+// src/engines/copilot.ts
+var copilot = {
+  id: "copilot",
+  name: "Copilot CLI",
+  binary: "copilot",
+  install: "npm install -g @github/copilot",
+  supportsResume: false,
+  buildArgs(opts) {
+    const args = ["-p", opts.prompt, "-s", "--allow-all-tools"];
+    if (opts.model) args.push("--model", opts.model);
+    return args;
+  }
+};
+
+// src/engines/cursor.ts
+var cursor = {
+  id: "cursor",
+  name: "Cursor CLI",
+  binary: "cursor-agent",
+  altBinaries: ["agent"],
+  install: "curl https://cursor.com/install -fsS | bash",
+  supportsResume: true,
+  buildArgs(opts) {
+    const args = ["-p", opts.prompt, "--output-format", "stream-json", "--force"];
+    if (opts.model) args.push("--model", opts.model);
+    if (opts.sessionId) args.push(`--resume=${opts.sessionId}`);
+    return args;
+  },
+  createParser: () => createClaudeStreamParser("cursor")
+};
+
+// src/engines/gemini.ts
+var gemini = {
+  id: "gemini",
+  name: "Gemini CLI",
+  binary: "gemini",
+  install: "npm install -g @google/gemini-cli",
+  supportsResume: false,
+  buildArgs(opts) {
+    const args = ["-p", opts.prompt, "--yolo"];
+    if (opts.model) args.push("-m", opts.model);
+    return args;
+  }
+};
+
+// src/engines/opencode.ts
+var opencode = {
+  id: "opencode",
+  name: "OpenCode",
+  binary: "opencode",
+  install: "npm install -g opencode-ai",
+  supportsResume: true,
+  buildArgs(opts) {
+    const args = ["run", "--format", "json"];
+    if (opts.model) args.push("--model", opts.model);
+    if (opts.sessionId) args.push("--session", opts.sessionId);
+    args.push(opts.prompt);
+    return args;
+  },
+  createParser() {
+    let sessionId;
+    return (line) => {
+      let data;
+      try {
+        data = JSON.parse(line);
+      } catch {
+        return [{ type: "text", text: line }];
+      }
+      if (data?.sessionID && !sessionId) sessionId = data.sessionID;
+      switch (data?.type) {
+        case "step_start":
+          return [];
+        case "text":
+          return data.part?.text ? [{ type: "text", text: data.part.text }] : [];
+        case "reasoning":
+          return data.part?.text ? [{ type: "thinking", text: data.part.text }] : [];
+        case "tool_use": {
+          const name = data.part?.tool ?? "tool";
+          const input = data.part?.state?.input;
+          const detail = input && typeof input === "object" ? truncate(
+            typeof input.command === "string" ? input.command : typeof input.filePath === "string" ? input.filePath : JSON.stringify(input),
+            80
+          ) : void 0;
+          if (data.part?.state?.status === "completed" || data.part?.state?.status === "running") {
+            return [{ type: "tool", name, detail }];
+          }
+          return [];
+        }
+        case "step_finish":
+          if (data.part?.reason === "stop" || data.reason === "stop") {
+            return [{ type: "result", ok: true, sessionId }];
+          }
+          return [];
+        case "error":
+          return [{ type: "error", text: data.message ?? "opencode error" }];
+        default:
+          return [{ type: "raw", data }];
+      }
+    };
+  }
+};
+
+// src/engines/registry.ts
+var engines = [claude, codex, gemini, opencode, amp, cursor, copilot, aider];
+function getEngine(id) {
+  const engine = engines.find((e) => e.id === id);
+  if (!engine) {
+    const known = engines.map((e) => e.id).join(", ");
+    throw new Error(`Unknown engine "${id}". Available: ${known}`);
+  }
+  return engine;
+}
+function findBinary(binary) {
+  const dirs = (process.env.PATH ?? "").split(path.delimiter);
+  for (const dir of dirs) {
+    if (!dir) continue;
+    const full = path.join(dir, binary);
+    try {
+      fs.accessSync(full, fs.constants.X_OK);
+      return full;
+    } catch {
+    }
+  }
+  return null;
+}
+function findEngineBinary(engine) {
+  for (const name of [engine.binary, ...engine.altBinaries ?? []]) {
+    const found = findBinary(name);
+    if (found) return found;
+  }
+  return null;
+}
+function detectEngines() {
+  return engines.map((engine) => ({ engine, path: findEngineBinary(engine) }));
+}
+
+export {
+  lineSplitter,
+  truncate,
+  engines,
+  getEngine,
+  findBinary,
+  findEngineBinary,
+  detectEngines
+};