@maintainer-pro/ai-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1057 @@
+// src/detect.ts
+import { execa as execa2 } from "execa";
+
+// src/prompt.ts
+function buildConversationPrompt(messages) {
+  if (messages.length === 0) return "";
+  const lines = messages.map(
+    (m) => `${m.role === "user" ? "Human" : "Assistant"}: ${m.content}`
+  );
+  return lines.join("\n\n");
+}
+function formatClientContext(context) {
+  if (!context) return "";
+  const lines = [
+    "Client context (live UI snapshot):",
+    `- Route: ${context.route}`,
+    `- Page title: ${context.pageTitle}`
+  ];
+  if (context.visiblePanels?.length) {
+    lines.push(`- Visible panels: ${context.visiblePanels.join(", ")}`);
+  }
+  if (context.focusedElement) {
+    lines.push(`- Focused element: ${context.focusedElement}`);
+  }
+  if (context.relevantFiles?.length) {
+    lines.push(`- Relevant files: ${context.relevantFiles.join(", ")}`);
+  }
+  if (context.data && Object.keys(context.data).length > 0) {
+    lines.push("- App state:");
+    lines.push(JSON.stringify(context.data, null, 2));
+  }
+  return lines.join("\n");
+}
+function splitMessages(messages) {
+  let latestUserIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      latestUserIndex = i;
+      break;
+    }
+  }
+  const request = latestUserIndex >= 0 ? messages[latestUserIndex].content.trim() : "";
+  const history = latestUserIndex > 0 ? messages.slice(0, latestUserIndex) : [];
+  return { request, history };
+}
+function buildUserFacingPrompt(systemPrompt, messages, context, attachmentPaths, priorConversationsContext) {
+  const { request, history } = splitMessages(messages);
+  const historyBlock = history.length > 0 ? `Conversation so far:
+${buildConversationPrompt(history)}
+
+` : "";
+  const contextBlock = formatClientContext(context);
+  const contextSection = contextBlock ? `${contextBlock}
+
+` : "";
+  const systemSection = systemPrompt ? `${systemPrompt}
+
+` : "";
+  const priorSection = priorConversationsContext?.trim() ? `${priorConversationsContext.trim()}
+
+` : "";
+  const attachmentsSection = attachmentPaths && attachmentPaths.length > 0 ? `Screenshots / images attached by the user (open and inspect these image files):
+${attachmentPaths.map((p) => `- ${p}`).join("\n")}
+
+` : "";
+  return `${systemSection}${contextSection}${priorSection}${historyBlock}${attachmentsSection}Current user request:
+${request || "(See the attached screenshot(s).)"}
+
+Do the work now (or ask one short clarifying question if needed). Reply in English, non-technical and user-facing. If it's not resolving, offer a quick call.`;
+}
+function buildCursorPrompt(systemPrompt, messages, context, attachmentPaths, priorConversationsContext) {
+  return buildUserFacingPrompt(
+    systemPrompt,
+    messages,
+    context,
+    attachmentPaths,
+    priorConversationsContext
+  );
+}
+function buildClaudeUserPrompt(messages, context, attachmentPaths, priorConversationsContext) {
+  return buildUserFacingPrompt(
+    null,
+    messages,
+    context,
+    attachmentPaths,
+    priorConversationsContext
+  );
+}
+
+// src/parser.ts
+function parseAiResponse(raw, provider) {
+  const toolCalls = [];
+  const jsonBlockRegex = /```json\s*\n?([\s\S]*?)\n?```/g;
+  let match;
+  while ((match = jsonBlockRegex.exec(raw)) !== null) {
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      if (parsed !== null && typeof parsed === "object" && "tool" in parsed && typeof parsed.tool === "string") {
+        toolCalls.push(parsed);
+      }
+    } catch {
+    }
+  }
+  const text = raw.replace(/```json\s*\n?[\s\S]*?\n?```/g, "").trim();
+  return { text, toolCalls, provider };
+}
+
+// src/resolve-command.ts
+import fs from "fs";
+import path from "path";
+function parseVersionRank(versionName) {
+  const datePart = versionName.split("-")[0] ?? "";
+  const parts = datePart.split(".");
+  if (parts.length !== 3) return 0;
+  const [year, month, day] = parts;
+  return Number(`${year}${month.padStart(2, "0")}${day.padStart(2, "0")}`);
+}
+function findLatestCursorVersionDir(installDir) {
+  const versionsRoot = path.join(installDir, "versions");
+  if (!fs.existsSync(versionsRoot)) return null;
+  const dirs = fs.readdirSync(versionsRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).filter(
+    (name) => /^\d{4}\.\d{1,2}\.\d{1,2}(-\d{2}-\d{2}-\d{2})?-[a-f0-9]+$/.test(name)
+  ).sort((a, b) => parseVersionRank(b) - parseVersionRank(a));
+  return dirs[0] ? path.join(versionsRoot, dirs[0]) : null;
+}
+function cursorInstallDirFromCommand(command) {
+  const normalized = command.replace(/\//g, path.sep);
+  if (path.isAbsolute(normalized) || normalized.includes(path.sep)) {
+    const dir = path.dirname(normalized);
+    if (fs.existsSync(path.join(dir, "versions"))) return dir;
+  }
+  const localAppData = process.env.LOCALAPPDATA;
+  if (localAppData) {
+    const candidate = path.join(localAppData, "cursor-agent");
+    if (fs.existsSync(path.join(candidate, "versions"))) return candidate;
+  }
+  return null;
+}
+function resolveCliCommand(provider, command) {
+  if (provider === "cursor" && process.platform === "win32") {
+    const installDir = cursorInstallDirFromCommand(command);
+    if (installDir) {
+      const versionDir = findLatestCursorVersionDir(installDir);
+      if (versionDir) {
+        const nodePath = path.join(versionDir, "node.exe");
+        const indexPath = path.join(versionDir, "index.js");
+        if (fs.existsSync(nodePath) && fs.existsSync(indexPath)) {
+          return {
+            file: nodePath,
+            argsPrefix: [indexPath],
+            shell: false
+          };
+        }
+      }
+    }
+  }
+  const isWinBatch = process.platform === "win32" && /\.(cmd|bat)$/i.test(command);
+  const isBare = process.platform === "win32" && !command.includes("\\") && !command.includes("/");
+  const isAbsoluteExe = process.platform === "win32" && path.isAbsolute(command) && /\.exe$/i.test(command);
+  return {
+    file: command,
+    argsPrefix: [],
+    shell: isAbsoluteExe ? false : isWinBatch || isBare
+  };
+}
+
+// src/run-cli.ts
+import { execa } from "execa";
+async function runCli(resolved, args, options = {}) {
+  const result = await execa(resolved.file, [...resolved.argsPrefix, ...args], {
+    shell: resolved.shell,
+    input: options.stdin,
+    cwd: options.cwd,
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return result.stdout;
+}
+
+// src/providers/claude.ts
+function createClaudeProvider() {
+  return {
+    id: "claude",
+    label: "Claude CLI",
+    async isAvailable() {
+      return await resolveCliBinary("claude") !== null;
+    },
+    async call(messages, context, options) {
+      const command = await resolveCliBinary("claude");
+      if (!command) throw new Error("Claude CLI is not available");
+      return callClaudeCli(command, messages, context, options);
+    }
+  };
+}
+async function callClaudeCli(command, messages, context, options) {
+  const prompt = buildClaudeUserPrompt(
+    messages,
+    context,
+    options.attachmentPaths,
+    options.priorConversationsContext
+  );
+  const resolved = resolveCliCommand("claude", command);
+  const workspace = options.workspaceDir ?? process.env.AI_CLI_WORKSPACE ?? process.cwd();
+  const stdout = await runCli(
+    resolved,
+    [
+      "--print",
+      "--system-prompt",
+      options.systemPrompt,
+      "--no-session-persistence",
+      prompt
+    ],
+    { cwd: workspace }
+  );
+  return parseAiResponse(stdout, "claude");
+}
+
+// src/providers/cursor.ts
+function createCursorProvider() {
+  return {
+    id: "cursor",
+    label: "Cursor Agent CLI",
+    async isAvailable() {
+      return await resolveCliBinary("cursor") !== null;
+    },
+    async call(messages, context, options) {
+      const command = await resolveCliBinary("cursor");
+      if (!command) throw new Error("Cursor Agent CLI is not available");
+      return callCursorCli(command, messages, context, options);
+    }
+  };
+}
+async function callCursorCli(command, messages, context, options) {
+  const prompt = buildCursorPrompt(
+    options.systemPrompt,
+    messages,
+    context,
+    options.attachmentPaths,
+    options.priorConversationsContext
+  );
+  const resolved = resolveCliCommand("cursor", command);
+  const workspace = options.workspaceDir ?? process.env.AI_CLI_WORKSPACE ?? process.cwd();
+  const stdout = await runCli(
+    resolved,
+    [
+      "--print",
+      "--output-format",
+      "text",
+      "--trust",
+      "--force",
+      "--workspace",
+      workspace
+    ],
+    { stdin: prompt, cwd: workspace }
+  );
+  return parseAiResponse(stdout, "cursor");
+}
+
+// src/providers/antigravity.ts
+function createAntigravityProvider() {
+  return {
+    id: "antigravity",
+    label: "Antigravity CLI",
+    async isAvailable() {
+      return await resolveCliBinary("antigravity") !== null;
+    },
+    async call(messages, context, options) {
+      const command = await resolveCliBinary("antigravity");
+      if (!command) throw new Error("Antigravity CLI is not available");
+      return callAntigravityCli(command, messages, context, options);
+    }
+  };
+}
+async function callAntigravityCli(command, messages, context, options) {
+  const basePrompt = buildCursorPrompt(
+    options.systemPrompt,
+    messages,
+    context,
+    options.attachmentPaths,
+    options.priorConversationsContext
+  );
+  const prompt = `You are operating as a coding agent with full permission to read and edit files in this workspace. Do not introduce yourself. Do not ask what you are. Execute the user's latest request now (edit files and/or emit runtime tool JSON as instructed).
+
+${basePrompt}`;
+  const resolved = resolveCliCommand("antigravity", command);
+  const workspace = options.workspaceDir ?? process.env.AI_CLI_WORKSPACE ?? process.cwd();
+  const args = [
+    "-p",
+    prompt,
+    "--mode",
+    "accept-edits",
+    "--output-format",
+    "text",
+    "--dangerously-skip-permissions",
+    "--add-dir",
+    workspace,
+    "--print-timeout",
+    "10m"
+  ];
+  const stdout = await runCli(resolved, args, { cwd: workspace });
+  return parseAiResponse(stdout, "antigravity");
+}
+
+// src/detect.ts
+var DEFAULT_COMMANDS = {
+  claude: ["claude"],
+  cursor: ["agent"],
+  antigravity: ["agy", "antigravity"]
+};
+async function resolveCommandPath(command) {
+  try {
+    if (process.platform === "win32") {
+      const result2 = await execa2("where.exe", [command], { reject: false });
+      if (result2.exitCode !== 0) return null;
+      const lines = result2.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      const exe = lines.find((line) => /\.exe$/i.test(line));
+      return exe ?? lines[0] ?? null;
+    }
+    const result = await execa2("which", [command], { reject: false });
+    if (result.exitCode !== 0) return null;
+    const path5 = result.stdout.trim().split(/\r?\n/)[0]?.trim();
+    return path5 || null;
+  } catch {
+    return null;
+  }
+}
+async function commandExists(command) {
+  return await resolveCommandPath(command) !== null;
+}
+function getProviderPreference(override) {
+  if (override) return override;
+  const raw = (process.env.AI_CLI_PROVIDER ?? "auto").toLowerCase().trim();
+  if (raw === "claude" || raw === "cursor" || raw === "antigravity" || raw === "agy" || raw === "auto") {
+    return raw === "agy" ? "antigravity" : raw;
+  }
+  console.warn(
+    `Unknown AI_CLI_PROVIDER="${raw}", falling back to "auto". Use auto|claude|cursor|antigravity.`
+  );
+  return "auto";
+}
+function matchOverrideToProvider(override, provider) {
+  const lower = override.toLowerCase();
+  if (provider === "claude") return lower.includes("claude");
+  if (provider === "antigravity") {
+    return lower.includes("agy") || lower.includes("antigravity");
+  }
+  return lower.includes("agent") || lower.includes("cursor") || !lower.includes("claude") && !lower.includes("agy") && !lower.includes("antigravity");
+}
+async function resolveCliBinary(provider) {
+  const override = process.env.AI_CLI_COMMAND?.trim();
+  const pref = getProviderPreference();
+  if (override) {
+    if (pref === provider) return override;
+    if (pref === "auto" && matchOverrideToProvider(override, provider)) {
+      return override;
+    }
+  }
+  for (const command of DEFAULT_COMMANDS[provider]) {
+    const resolved = await resolveCommandPath(command);
+    if (resolved) return resolved;
+  }
+  return null;
+}
+function createBuiltinProviders() {
+  return [
+    createClaudeProvider(),
+    createCursorProvider(),
+    createAntigravityProvider()
+  ];
+}
+async function resolveProvider(options) {
+  const preference = getProviderPreference(options?.preference);
+  const providers = options?.providers?.length ? options.providers : createBuiltinProviders();
+  const order = preference === "auto" ? providers : providers.filter((p) => p.id === preference);
+  for (const provider of order) {
+    if (await provider.isAvailable()) return provider;
+  }
+  if (preference === "auto") {
+    throw new Error(
+      "No AI provider available. Install Claude CLI (`claude`), Cursor Agent CLI (`agent`), or Antigravity CLI (`agy`), set AI_CLI_PROVIDER / AI_CLI_COMMAND, or pass custom providers."
+    );
+  }
+  throw new Error(
+    `AI provider "${preference}" is not available. Or set AI_CLI_COMMAND / pass a custom provider.`
+  );
+}
+function providerLabel(providerId) {
+  if (providerId === "claude") return "Claude CLI";
+  if (providerId === "cursor") return "Cursor Agent CLI";
+  if (providerId === "antigravity" || providerId === "agy") {
+    return "Antigravity CLI";
+  }
+  return providerId;
+}
+
+// src/call-ai.ts
+async function callAi(messages, context, options) {
+  if (!options.systemPrompt?.trim()) {
+    throw new Error("callAi requires options.systemPrompt");
+  }
+  const provider = await resolveProvider({
+    preference: options.providerPreference,
+    providers: options.providers
+  });
+  return provider.call(messages, context, options);
+}
+
+// src/system-prompt.ts
+function createDefaultSystemPrompt(input) {
+  const files = input.relevantFilesHint ? `Key UI files (use internally only; never name them in your reply):
+${input.relevantFilesHint}` : "";
+  const tools = input.runtimeToolsHint ? `## When to use runtime tools
+Only when the user wants to change live in-app data (not source code), return a short user-facing sentence PLUS a JSON tool call in a \`\`\`json fence:
+
+${input.runtimeToolsHint}
+
+Only use those runtime tools for live state. Never invent runtime tools.` : "";
+  return `You are a helpful product assistant for an app the user is looking at right now.
+
+${input.productDescription}
+
+Behind the scenes you can edit this repository and update live app data, but the user is an end user \u2014 not a developer.
+
+## How to talk
+- Always reply in English, even if the user writes in another language.
+- Reply like a friendly product assistant, short and clear \u2014 keep the chat light so they don't get bored.
+- Describe what changed in the UI, then invite them to check it.
+- If the user attaches screenshots, inspect those image files and use them to understand the request.
+- Ask a quick clarifying question when the request is vague or has more than one reasonable option (one question at a time, easy choices when you can).
+- After you make a change, check in briefly: did that look right? want another tweak?
+- If you are stuck, the request is unclear after a couple of tries, or they seem frustrated, offer a call: e.g. "Happy to jump on a quick call if that's easier \u2014 just say when."
+- Do NOT mention file paths, component names, repos, commits, diffs, TypeScript, React, or tools.
+- Do NOT use technical phrasing like "updated in Foo.tsx".
+
+## When to edit the codebase
+Edit source files when the user asks to change labels, layout, styling, copy, or behavior in the app.
+${files}
+
+${tools}
+
+Do not refuse UI/label changes \u2014 implement them in source files.
+Answer the user's latest request directly \u2014 never reply with a generic greeting.`;
+}
+
+// src/http/attachments.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+var MAX_ATTACHMENTS = 5;
+var MAX_BYTES = 4 * 1024 * 1024;
+var ALLOWED = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/jpg", "image/webp", "image/gif"]);
+function extForMime(mime) {
+  switch (mime) {
+    case "image/jpeg":
+    case "image/jpg":
+      return ".jpg";
+    case "image/webp":
+      return ".webp";
+    case "image/gif":
+      return ".gif";
+    default:
+      return ".png";
+  }
+}
+async function saveChatAttachments(attachments, workspaceDir) {
+  if (!attachments?.length) return [];
+  const selected = attachments.slice(0, MAX_ATTACHMENTS);
+  const dir = path2.join(workspaceDir, ".maintainer-pro", "uploads");
+  await fs2.mkdir(dir, { recursive: true });
+  const paths = [];
+  const stamp = Date.now();
+  for (let i = 0; i < selected.length; i++) {
+    const item = selected[i];
+    const mime = (item.mimeType || "").toLowerCase();
+    if (!ALLOWED.has(mime)) {
+      throw new Error(`Unsupported image type: ${item.mimeType}`);
+    }
+    if (!item.data?.trim()) {
+      throw new Error("Attachment data is empty");
+    }
+    const buffer = Buffer.from(item.data, "base64");
+    if (buffer.byteLength > MAX_BYTES) {
+      throw new Error(`Screenshot too large (max ${MAX_BYTES / (1024 * 1024)}MB)`);
+    }
+    const safeBase = (item.name || `screenshot-${i + 1}`).replace(/[^\w.\-]+/g, "_").slice(0, 64);
+    const fileName = `${stamp}-${i + 1}-${safeBase}${extForMime(mime)}`;
+    const filePath = path2.join(dir, fileName);
+    await fs2.writeFile(filePath, buffer);
+    paths.push(filePath);
+  }
+  return paths;
+}
+
+// src/http/prior-conversations.ts
+var DEFAULT_MAX_CONVERSATIONS = 3;
+var DEFAULT_MAX_MESSAGES = 8;
+var MAX_MESSAGE_CHARS = 400;
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/i).filter((w) => w.length > 3);
+}
+function truncate(text, max = MAX_MESSAGE_CHARS) {
+  const trimmed = text.trim().replace(/\s+/g, " ");
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, max - 1)}\u2026`;
+}
+function scoreConversation(messages, requestTokens) {
+  if (requestTokens.length === 0) return 0;
+  const blob = messages.map((m) => m.content.toLowerCase()).join(" ");
+  let score = 0;
+  for (const token of requestTokens) {
+    if (blob.includes(token)) score += 1;
+  }
+  return score;
+}
+async function buildPriorConversationsContext(db, options) {
+  if (!db.listConversations) return "";
+  const conversations = await db.listConversations();
+  const others = conversations.filter(
+    (c) => c.id !== options.excludeConversationId && c.messages.some((m) => m.role === "user" || m.role === "assistant")
+  );
+  if (others.length === 0) return "";
+  const requestTokens = tokenize(options.currentRequest);
+  const maxConversations = options.maxConversations ?? DEFAULT_MAX_CONVERSATIONS;
+  const maxMessages = options.maxMessagesPerConversation ?? DEFAULT_MAX_MESSAGES;
+  const ranked = others.map((c) => ({
+    ...c,
+    score: scoreConversation(c.messages, requestTokens),
+    updatedMs: Date.parse(c.updatedAt) || 0
+  })).sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.updatedMs - a.updatedMs;
+  }).slice(0, maxConversations);
+  const selected = requestTokens.length > 0 && ranked.every((c) => c.score === 0) ? [...others].sort(
+    (a, b) => (Date.parse(b.updatedAt) || 0) - (Date.parse(a.updatedAt) || 0)
+  ).slice(0, maxConversations) : ranked;
+  const blocks = selected.map((c) => {
+    const slice = c.messages.length > maxMessages ? c.messages.slice(-maxMessages) : c.messages;
+    const lines = slice.filter((m) => m.role === "user" || m.role === "assistant").map(
+      (m) => `${m.role === "user" ? "Human" : "Assistant"}: ${truncate(m.content)}`
+    );
+    const when = c.updatedAt ? ` (updated ${c.updatedAt.slice(0, 10)})` : "";
+    return `--- Prior conversation ${c.id.slice(0, 8)}\u2026${when} ---
+${lines.join("\n")}`;
+  });
+  if (blocks.length === 0) return "";
+  return `Prior conversations from this workspace (use only if relevant to the current request; ignore if unrelated):
+
+${blocks.join("\n\n")}`;
+}
+
+// src/http/tools.ts
+function createToolValidator(schemas) {
+  return function validateToolCall(toolCall) {
+    const schema = schemas[toolCall.tool];
+    if (!schema) {
+      return { valid: false, error: `Unknown tool: ${toolCall.tool}` };
+    }
+    const result = schema.safeParse(toolCall.args);
+    if (!result.success) {
+      return { valid: false, error: result.error.message };
+    }
+    return {
+      valid: true,
+      name: toolCall.tool,
+      args: result.data
+    };
+  };
+}
+
+// src/http/handler.ts
+var SHARED_CONVERSATION_ID = "shared";
+var conversationTurnSeq = /* @__PURE__ */ new Map();
+function beginConversationTurn(conversationId) {
+  const next = (conversationTurnSeq.get(conversationId) ?? 0) + 1;
+  conversationTurnSeq.set(conversationId, next);
+  return next;
+}
+function isActiveConversationTurn(conversationId, turn) {
+  const current = conversationTurnSeq.get(conversationId);
+  if (current === void 0) return true;
+  return current === turn;
+}
+function resolveConversationId(request, options, bodyId) {
+  if (bodyId) return bodyId;
+  const urlId = new URL(request.url).searchParams.get("conversationId");
+  if (urlId) return urlId;
+  if (typeof options.conversationId === "function") {
+    return options.conversationId(request);
+  }
+  return options.conversationId;
+}
+async function resolveSharedConversationId(request, options, bodyId) {
+  const explicit = resolveConversationId(request, options, bodyId);
+  if (explicit) return explicit;
+  if (options.db?.listConversations) {
+    const conversations = await options.db.listConversations();
+    const latest = conversations.find(
+      (c) => c.messages.some((m) => m.role === "user" || m.role === "assistant")
+    );
+    if (latest) return latest.id;
+  }
+  return SHARED_CONVERSATION_ID;
+}
+function createChatHandler(options) {
+  const validate = options.tools ? createToolValidator(options.tools) : null;
+  const workspaceDir = options.workspaceDir ?? process.env.AI_CLI_WORKSPACE ?? process.cwd();
+  const baseCallOptions = {
+    systemPrompt: options.systemPrompt,
+    workspaceDir,
+    providerPreference: options.providerPreference,
+    providers: options.providers
+  };
+  return {
+    async GET(request) {
+      try {
+        const provider = await resolveProvider({
+          preference: options.providerPreference,
+          providers: options.providers
+        });
+        const conversationId = await resolveSharedConversationId(
+          request,
+          options
+        );
+        let messages;
+        if (options.db?.listMessages) {
+          messages = await options.db.listMessages(conversationId);
+        }
+        return Response.json({
+          provider: provider.id,
+          providerLabel: provider.label || providerLabel(provider.id),
+          conversationId,
+          messages: messages ?? []
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "No AI CLI provider available";
+        return Response.json(
+          { error: message, provider: null },
+          { status: 503 }
+        );
+      }
+    },
+    async POST(request) {
+      try {
+        const body = await request.json();
+        const conversationId = await resolveSharedConversationId(
+          request,
+          options,
+          body.conversationId
+        );
+        if (body.type === "status") {
+          const content = body.content?.trim();
+          if (!conversationId || !content) {
+            return Response.json(
+              { error: "conversationId and content are required" },
+              { status: 400 }
+            );
+          }
+          if (options.db) {
+            await options.db.ensureConversation(conversationId);
+            await options.db.saveMessage({
+              conversationId,
+              role: "assistant",
+              content
+            });
+          }
+          return Response.json({ ok: true, conversationId });
+        }
+        if (body.type === "reply") {
+          const content = body.content?.trim();
+          if (!conversationId || !content) {
+            return Response.json(
+              { error: "conversationId and content are required" },
+              { status: 400 }
+            );
+          }
+          if (options.db) {
+            await options.db.ensureConversation(conversationId);
+            await options.db.saveMessage({
+              conversationId,
+              role: "assistant",
+              content,
+              provider: "developer",
+              senderType: "developer",
+              senderName: body.senderName?.trim() || void 0
+            });
+          }
+          return Response.json({ ok: true, conversationId });
+        }
+        const { messages, context, attachments } = body;
+        if (!Array.isArray(messages) || messages.length === 0) {
+          return Response.json(
+            { error: "messages array is required" },
+            { status: 400 }
+          );
+        }
+        let attachmentPaths = [];
+        let persistAttachmentPaths = [];
+        if (options.db?.uploadAttachments) {
+          const uploaded = await options.db.uploadAttachments(
+            conversationId,
+            attachments
+          );
+          attachmentPaths = uploaded.localPaths;
+          persistAttachmentPaths = uploaded.refs;
+        } else {
+          attachmentPaths = await saveChatAttachments(
+            attachments,
+            workspaceDir
+          );
+          persistAttachmentPaths = attachmentPaths;
+        }
+        const turn = beginConversationTurn(conversationId);
+        const signal = request.signal;
+        if (options.db && conversationId) {
+          const latest = messages[messages.length - 1];
+          const persistContent = body.userMessage?.trim() || (latest?.role === "user" ? latest.content : "");
+          if (persistContent) {
+            await options.db.ensureConversation(conversationId);
+            await options.db.saveMessage({
+              conversationId,
+              role: "user",
+              content: persistContent,
+              attachmentPaths: persistAttachmentPaths.length > 0 ? persistAttachmentPaths : void 0,
+              senderType: body.senderType === "client" ? "client" : void 0,
+              senderName: body.senderName?.trim() || void 0
+            });
+          }
+        }
+        const latestUser = [...messages].reverse().find((m) => m.role === "user");
+        const priorConversationsContext = options.db ? await buildPriorConversationsContext(options.db, {
+          excludeConversationId: conversationId,
+          currentRequest: latestUser?.content ?? ""
+        }) : "";
+        if (signal.aborted || !isActiveConversationTurn(conversationId, turn)) {
+          return Response.json({
+            superseded: true,
+            conversationId: conversationId ?? null
+          });
+        }
+        const aiResponse = await callAi(messages, context, {
+          ...baseCallOptions,
+          attachmentPaths,
+          priorConversationsContext: priorConversationsContext || void 0
+        });
+        if (!isActiveConversationTurn(conversationId, turn)) {
+          return Response.json({
+            superseded: true,
+            conversationId: conversationId ?? null
+          });
+        }
+        const validatedToolCalls = validate ? aiResponse.toolCalls.filter((tc) => validate(tc).valid) : aiResponse.toolCalls;
+        if (options.onToolCalls && validatedToolCalls.length > 0) {
+          await options.onToolCalls(validatedToolCalls, context);
+        }
+        if (options.db && conversationId) {
+          await options.db.ensureConversation(conversationId);
+          await options.db.saveMessage({
+            conversationId,
+            role: "assistant",
+            content: aiResponse.text,
+            provider: aiResponse.provider,
+            senderType: "ai"
+          });
+          if (validatedToolCalls.length > 0) {
+            await options.db.saveToolEvents?.(
+              conversationId,
+              validatedToolCalls
+            );
+          }
+        }
+        return Response.json({
+          text: aiResponse.text,
+          toolCalls: validatedToolCalls,
+          provider: aiResponse.provider,
+          providerLabel: providerLabel(aiResponse.provider),
+          conversationId: conversationId ?? null
+        });
+      } catch (err) {
+        console.error("Chat API error:", err);
+        return Response.json(
+          {
+            error: "Sorry about that \u2014 I couldn't finish this right now. Happy to jump on a quick call if you'd like help \u2014 just let us know when works."
+          },
+          { status: 500 }
+        );
+      }
+    }
+  };
+}
+function toNextRoute(handlers) {
+  return {
+    GET: (request) => handlers.GET(request),
+    POST: (request) => handlers.POST(request)
+  };
+}
+
+// src/http/local-store.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import { randomUUID } from "crypto";
+async function readConversation(filePath) {
+  try {
+    const raw = await fs3.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function writeConversation(filePath, data) {
+  await fs3.mkdir(path3.dirname(filePath), { recursive: true });
+  await fs3.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
+}
+function createLocalDirectoryStore(baseDir) {
+  const fileFor = (id) => path3.join(baseDir, `${id}.json`);
+  return {
+    async ensureConversation(id) {
+      const existing = await readConversation(fileFor(id));
+      if (existing) return;
+      await writeConversation(fileFor(id), {
+        id,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        messages: []
+      });
+    },
+    async saveMessage(input) {
+      const filePath = fileFor(input.conversationId);
+      const existing = await readConversation(filePath) ?? {
+        id: input.conversationId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        messages: []
+      };
+      const message = {
+        id: randomUUID(),
+        conversationId: input.conversationId,
+        role: input.role,
+        content: input.content,
+        provider: input.provider ?? null,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        attachmentPaths: input.attachmentPaths,
+        senderType: input.senderType ?? null,
+        senderName: input.senderName ?? null
+      };
+      existing.messages.push(message);
+      existing.updatedAt = message.createdAt;
+      await writeConversation(filePath, existing);
+      return message;
+    },
+    async listMessages(conversationId) {
+      const existing = await readConversation(fileFor(conversationId));
+      return existing?.messages ?? [];
+    },
+    async listConversations() {
+      await fs3.mkdir(baseDir, { recursive: true });
+      const entries = await fs3.readdir(baseDir);
+      const conversations = [];
+      for (const entry of entries) {
+        if (!entry.endsWith(".json")) continue;
+        const filePath = path3.join(baseDir, entry);
+        const existing = await readConversation(filePath);
+        if (!existing?.id) continue;
+        conversations.push({
+          id: existing.id,
+          updatedAt: existing.updatedAt,
+          messages: existing.messages
+        });
+      }
+      return conversations.sort(
+        (a, b) => (Date.parse(b.updatedAt) || 0) - (Date.parse(a.updatedAt) || 0)
+      );
+    },
+    async saveToolEvents(conversationId, events) {
+      if (events.length === 0) return;
+      const existing = await readConversation(fileFor(conversationId));
+      if (!existing) return;
+      const toolFile = path3.join(baseDir, `${conversationId}.tools.jsonl`);
+      const lines = events.map(
+        (e) => JSON.stringify({
+          conversationId,
+          ...e,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      ).join("\n");
+      await fs3.appendFile(toolFile, `${lines}
+`, "utf8");
+    }
+  };
+}
+
+// src/http/maintainer-pro-store.ts
+import fs4 from "fs/promises";
+import os from "os";
+import path4 from "path";
+async function mpFetch(baseUrl, apiKey, pathName, init, fetchImpl) {
+  const url = `${baseUrl.replace(/\/$/, "")}${pathName}`;
+  const res = await fetchImpl(url, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      ...init?.headers ?? {}
+    }
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(
+      `Maintainer Pro ${pathName} failed (${res.status}): ${text || res.statusText}`
+    );
+  }
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return res.json();
+  }
+  return res;
+}
+function createMaintainerProStore(options) {
+  const baseUrl = options.baseUrl;
+  const apiKey = options.apiKey;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const tempDir = options.tempDir ?? path4.join(os.tmpdir(), "maintainer-pro-store");
+  const store = {
+    async ensureConversation(id) {
+      await mpFetch(
+        baseUrl,
+        apiKey,
+        `/api/v1/store/conversations/${encodeURIComponent(id)}/ensure`,
+        { method: "POST", body: "{}" },
+        fetchImpl
+      );
+    },
+    async saveMessage(input) {
+      const attachmentIds = (input.attachmentPaths ?? []).map((p) => {
+        const m = /^maintainer-pro:\/\/(.+)$/.exec(p);
+        return m?.[1];
+      }).filter((id) => Boolean(id));
+      const data = await mpFetch(
+        baseUrl,
+        apiKey,
+        `/api/v1/store/conversations/${encodeURIComponent(input.conversationId)}/messages`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            role: input.role,
+            content: input.content,
+            provider: input.provider,
+            senderType: input.senderType,
+            senderName: input.senderName,
+            attachmentIds
+          })
+        },
+        fetchImpl
+      );
+      return data.message;
+    },
+    async listMessages(conversationId) {
+      const data = await mpFetch(
+        baseUrl,
+        apiKey,
+        `/api/v1/store/conversations/${encodeURIComponent(conversationId)}/messages`,
+        { method: "GET" },
+        fetchImpl
+      );
+      return data.messages ?? [];
+    },
+    async listConversations() {
+      const data = await mpFetch(
+        baseUrl,
+        apiKey,
+        `/api/v1/store/conversations`,
+        { method: "GET" },
+        fetchImpl
+      );
+      return data.conversations ?? [];
+    },
+    async saveToolEvents(conversationId, events) {
+      if (!events.length) return;
+      await mpFetch(
+        baseUrl,
+        apiKey,
+        `/api/v1/store/conversations/${encodeURIComponent(conversationId)}/tool-events`,
+        {
+          method: "POST",
+          body: JSON.stringify({ events })
+        },
+        fetchImpl
+      );
+    },
+    async uploadAttachments(conversationId, attachments) {
+      if (!attachments?.length) {
+        return { refs: [], localPaths: [], attachmentIds: [] };
+      }
+      await fs4.mkdir(tempDir, { recursive: true });
+      const refs = [];
+      const localPaths = [];
+      const attachmentIds = [];
+      for (const item of attachments.slice(0, 5)) {
+        const data = await mpFetch(
+          baseUrl,
+          apiKey,
+          `/api/v1/store/attachments`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              conversationId,
+              name: item.name,
+              mimeType: item.mimeType,
+              data: item.data
+            })
+          },
+          fetchImpl
+        );
+        const id = data.attachment.id;
+        attachmentIds.push(id);
+        refs.push(data.attachment.ref || `maintainer-pro://${id}`);
+        const ext = item.mimeType.includes("jpeg") || item.mimeType.includes("jpg") ? ".jpg" : item.mimeType.includes("webp") ? ".webp" : item.mimeType.includes("gif") ? ".gif" : ".png";
+        const localPath = path4.join(
+          tempDir,
+          `${conversationId}-${id}${ext}`
+        );
+        await fs4.writeFile(localPath, Buffer.from(item.data, "base64"));
+        localPaths.push(localPath);
+      }
+      return { refs, localPaths, attachmentIds };
+    }
+  };
+  return store;
+}
+function createMaintainerProStoreFromEnv() {
+  const baseUrl = process.env.MAINTAINER_PRO_URL?.trim();
+  const apiKey = process.env.MAINTAINER_PRO_API_KEY?.trim();
+  if (!baseUrl || !apiKey) return null;
+  return createMaintainerProStore({ baseUrl, apiKey });
+}
+export {
+  buildClaudeUserPrompt,
+  buildConversationPrompt,
+  buildCursorPrompt,
+  buildPriorConversationsContext,
+  callAi,
+  commandExists,
+  createAntigravityProvider,
+  createBuiltinProviders,
+  createChatHandler,
+  createClaudeProvider,
+  createCursorProvider,
+  createDefaultSystemPrompt,
+  createLocalDirectoryStore,
+  createMaintainerProStore,
+  createMaintainerProStoreFromEnv,
+  createToolValidator,
+  formatClientContext,
+  getProviderPreference,
+  parseAiResponse,
+  providerLabel,
+  resolveCliBinary,
+  resolveProvider,
+  saveChatAttachments,
+  toNextRoute
+};