changebook 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AppAtlas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# ChangeBook for coding agents (MCP server + CLI)
+
+MCP (Model Context Protocol) server that lets coding agents — Claude Code,
+Codex, Cursor — query the **ChangeBook product memory** (the module map and the
+analyzed change history stored in Supabase) instead of re-reading the
+codebase, plus a CLI that feeds that memory from any terminal: sign in,
+analyze uncommitted changes, sync the product map. All MCP tools are
+read-only, and Row Level Security scopes every query to the signed-in user.
+
+## Quick start
+
+```bash
+npx changebook init   # login (browser) + register in Claude Code/Codex + sync
+```
+
+`init` does four things: opens the browser so you sign in on changebook.app
+(one Authorize click — no token copy-pasting), registers the MCP server in
+Claude Code (user scope) and Codex (`~/.codex/config.toml`), installs the
+post-commit hook so the atlas updates itself, and writes the product map
+into the project's `CLAUDE.md`/`AGENTS.md`.
+
+## CLI commands
+
+| Command | What it does |
+| --- | --- |
+| `changebook login` | Browser sign-in; stores the session in `~/.changebook/credentials.json` (0600). |
+| `changebook logout` | Forget the stored session. |
+| `changebook analyze [dir]` | Analyze the repo's uncommitted changes (`git diff HEAD`) and update the atlas — same pipeline as the VS Code extension, no editor needed. |
+| `changebook analyze --commit [ref]` | Analyze one commit. Deduped by hash server-side, so re-runs never bill. |
+| `changebook hook install\|uninstall\|status [dir]` | Git post-commit hook: every new commit is analyzed in the background (never blocks the commit). One hook covers Claude Code, Codex and manual commits — they all commit through git. |
+| `changebook sync [dir]` | Refresh the product map inside `CLAUDE.md`/`AGENTS.md`. |
+| `changebook init [dir]` | login + register MCP server + install hook + sync, in one go. |
+| `changebook open` | Open the web atlas in the browser. |
+| `changebook serve` | Run the MCP server on stdio (also the default with no arguments). |
+
+Every command also works as `npx changebook <command>` with no install.
+
+## MCP tools
+
+| Tool | What it does |
+| --- | --- |
+| `atlas_recent_changes` | Recent analyzed changes: business impact, tech summary, modules touched. Supports `limit`, `offset`, `search`. |
+| `atlas_modules` | Aggregated module map: domain, category, risk, change count, last change, files. Optional `domain` filter. |
+| `atlas_module_detail` | One module's history: impact, notes, files and verbatim diff excerpts. |
+
+### Manual registration (instead of `init`)
+
+```bash
+claude mcp add --scope user changebook -- npx -y changebook serve
+```
+
+Or in the project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "changebook": {
+      "command": "npx",
+      "args": ["-y", "changebook", "serve"]
+    }
+  }
+}
+```
+
+Credentials come from `changebook login` (`~/.changebook/credentials.json`); the
+env vars below override them for CI/headless setups.
+
+### Environment variables
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `CHANGEBOOK_REFRESH_TOKEN` | — | Session token override (CI/headless; wins over the credentials file). |
+| `CHANGEBOOK_ACCESS_TOKEN` | — | Short-lived JWT; refreshed automatically when it expires. |
+| `CHANGEBOOK_PROJECT` | — | Scope every query to one project (matched by slug, then exact name — usually the workspace folder name). Unset = all projects. |
+| `CHANGEBOOK_WEB_URL` | `https://changebook.app` | Web app used by `login`/`open` and printed after `analyze`. |
+| `CHANGEBOOK_SUPABASE_URL` | production project | Override for other environments. |
+| `CHANGEBOOK_SUPABASE_ANON_KEY` | production public key | Override for other environments. |
+
+The embedded anon key is the same public key the web app ships — it grants
+nothing by itself; your session token plus RLS decide what you can read.
+
+## `sync`: product map inside CLAUDE.md / AGENTS.md
+
+```bash
+npx changebook sync [dir]
+```
+
+Writes (or refreshes, idempotently) an auto-generated section between
+`<!-- changebook:start -->` / `<!-- changebook:end -->` markers in the target
+directory's `CLAUDE.md` and `AGENTS.md`: the module map, the latest changes
+and a hint telling agents to use the `atlas_*` tools. Those files load into
+every Claude Code / Codex session and get prompt-cached, so the map orients
+agents at near-zero marginal cost. Content outside the markers is never
+touched. Re-run after analyzing changes (or wire it to a git hook).
+
+## Security notes
+
+- MCP tools are read-only; only `analyze` writes (through the same audited
+  Edge Function as the extension, with the same quotas).
+- `login` uses a loopback-only handoff: the web app asks for an explicit
+  Authorize click and redirects the tokens to `http://127.0.0.1:<port>` in
+  the URL fragment — they never leave your machine, and a `state` nonce ties
+  the handoff to the CLI process that requested it.
+- Your session lives in `~/.changebook/credentials.json` (0600) — treat it like
+  a password. `changebook logout` removes it.

package/dist/analyze.js

@@ -0,0 +1,126 @@
+/**
+ * `changebook analyze [dir]` — capture the working tree's uncommitted changes,
+ * compress them and send them to the analyze-diff Edge Function. Same
+ * pipeline as the VS Code extension, editor-free, so Claude Code / Codex
+ * hooks (or the user) can feed the atlas from any terminal.
+ */
+import * as path from "node:path";
+import { atlasWebUrl } from "./browser.js";
+import { commitDiff, execFileAsync, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, } from "./git.js";
+import { optimizeTokensForAI, truncateAtFileBoundary } from "./optimize.js";
+export async function analyze(db, options = {}) {
+    const cwd = path.resolve(options.dir ?? process.cwd());
+    const projectName = path.basename(cwd);
+    let rawDiff;
+    let commitHash;
+    let committedAt;
+    if (options.commit) {
+        const meta = await commitMeta(cwd, options.commit);
+        commitHash = meta.hash;
+        committedAt = meta.committedAt;
+        rawDiff = await commitDiff(cwd, meta.hash);
+        if (!rawDiff.trim()) {
+            console.error(`Commit ${meta.hash.slice(0, 8)} has no analyzable diff (merge?). Skipped.`);
+            return;
+        }
+    }
+    else {
+        rawDiff = await gitDiffHead(cwd);
+        if (!rawDiff.trim()) {
+            console.error("No uncommitted changes to analyze (git diff HEAD is empty).");
+            return;
+        }
+    }
+    let compressedDiff = optimizeTokensForAI(rawDiff);
+    if (compressedDiff.length > MAX_DIFF_CHARACTERS) {
+        console.error(`Diff is large (${compressedDiff.length} chars); truncating to ${MAX_DIFF_CHARACTERS}.`);
+        // Cut at a file boundary so no `### path` header is split (the server
+        // reads those to filter the atlas context).
+        compressedDiff = truncateAtFileBoundary(compressedDiff, MAX_DIFF_CHARACTERS);
+    }
+    if (!compressedDiff) {
+        console.error("Nothing left to analyze after compression. Skipped.");
+        return;
+    }
+    console.error(`Analyzing ${compressedDiff.length} chars of changes in "${projectName}"…`);
+    const { status, body } = await db.invokeFunction("analyze-diff", {
+        compressedDiff,
+        rawDiffChars: rawDiff.length,
+        projectName,
+        commitHash,
+        committedAt,
+    });
+    if (status !== 200 || body.error) {
+        // The server's messages are user-facing (quota, waitlist…): pass through.
+        throw new Error(body.error ?? `analyze-diff failed with status ${status}`);
+    }
+    if (body.skipped) {
+        console.error(`Commit already in the atlas — nothing billed.`);
+        return;
+    }
+    const lines = [""];
+    if (body.summary)
+        lines.push(body.summary, "");
+    if (body.summaryTech)
+        lines.push(`Tech: ${body.summaryTech}`, "");
+    if (body.modules && body.modules.length > 0) {
+        const mods = body.modules
+            .map((m) => (m.module ?? "") + (m.risk && m.risk !== "low" ? ` [${m.risk}]` : ""))
+            .filter(Boolean)
+            .join(", ");
+        if (mods)
+            lines.push(`Modules: ${mods}`);
+    }
+    if (body.regressionWarnings && body.regressionWarnings.length > 0) {
+        lines.push("", "⚠ Posible regresión:");
+        for (const w of body.regressionWarnings) {
+            if (w.plain)
+                lines.push(`  - ${w.plain}`);
+        }
+        lines.push("");
+    }
+    if (body.credits?.limit != null && body.credits.used != null) {
+        lines.push(`Credits: ${body.credits.used}/${body.credits.limit} this month`);
+    }
+    lines.push(`✓ Atlas updated → ${atlasWebUrl()}`);
+    console.error(lines.join("\n"));
+}
+async function commitMeta(cwd, ref) {
+    try {
+        const { stdout } = await execFileAsync("git", 
+        // --end-of-options so a user-supplied ref beginning with "-" is treated as
+        // a revision, not as a git option.
+        ["log", "-1", "--pretty=format:%H|%cI", "--end-of-options", ref], { cwd, encoding: "utf8" });
+        const [hash, committedAt] = stdout.trim().split("|");
+        if (!hash)
+            throw new Error("empty git log output");
+        return { hash, committedAt };
+    }
+    catch (error) {
+        throw new Error(`Could not resolve commit "${ref}" in "${cwd}": ${gitErrorMessage(error)}`);
+    }
+}
+async function gitDiffHead(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["diff", "HEAD", "-U0"], {
+            cwd,
+            encoding: "utf8",
+            maxBuffer: GIT_MAX_BUFFER_BYTES,
+        });
+        return stdout;
+    }
+    catch (error) {
+        const message = gitErrorMessage(error);
+        if (message.includes("not a git repository")) {
+            throw new Error(`"${cwd}" is not a git repository.`);
+        }
+        if (message.includes("Needed a single revision") ||
+            message.includes("unknown revision") ||
+            message.includes("ambiguous argument") ||
+            message.includes("bad revision")) {
+            throw new Error(`The repository at "${cwd}" has no commits yet; create the first commit and retry.`);
+        }
+        throw new Error(`Could not read the git diff in "${cwd}": ${message}`);
+    }
+}
+//# sourceMappingURL=analyze.js.map

package/dist/browser.js

@@ -0,0 +1,33 @@
+import { spawn } from "node:child_process";
+/** Web app base URL (login handoff, `changebook open`). */
+export function atlasWebUrl(env = process.env) {
+    return (env.CHANGEBOOK_WEB_URL ?? "https://changebook.app").replace(/\/+$/, "");
+}
+/**
+ * Best-effort browser open; callers always print the URL too, so a headless
+ * machine can still finish the flow by hand.
+ */
+export function openInBrowser(url) {
+    // Windows: use rundll32 FileProtocolHandler rather than `cmd /c start`. The
+    // URL is a single argv element (no shell), so query separators like `&` in
+    // the login URL (…?connect=cli&port=…&state=…) aren't parsed as command
+    // separators — `cmd start` splits on them and the login can't complete.
+    const [cmd, args] = process.platform === "darwin"
+        ? ["open", [url]]
+        : process.platform === "win32"
+            ? ["rundll32", ["url.dll,FileProtocolHandler", url]]
+            : ["xdg-open", [url]];
+    try {
+        const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+        // ENOENT arrives as an async 'error' event (try/catch can't see it);
+        // without a listener it would crash the process on headless machines.
+        child.on("error", () => {
+            /* the printed URL is the fallback */
+        });
+        child.unref();
+    }
+    catch {
+        // The printed URL is the fallback.
+    }
+}
+//# sourceMappingURL=browser.js.map

package/dist/credentials.js

@@ -0,0 +1,64 @@
+/**
+ * Credential storage for the CLI: ~/.changebook/credentials.json (0600).
+ *
+ * `changebook login` writes it; the MCP server and every subcommand fall back
+ * to it when the CHANGEBOOK_* env vars are not set. Supabase rotates refresh
+ * tokens on use, so whoever refreshes must persist the new one back here or
+ * the stored token dies after the reuse window.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const DIR = path.join(os.homedir(), ".changebook");
+const FILE = path.join(DIR, "credentials.json");
+export function credentialsPath() {
+    return FILE;
+}
+export function loadCredentials() {
+    try {
+        const raw = fs.readFileSync(FILE, "utf8");
+        const data = JSON.parse(raw);
+        if (typeof data.refresh_token !== "string" || !data.refresh_token) {
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(creds) {
+    fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
+    const data = {
+        ...creds,
+        updated_at: new Date().toISOString(),
+    };
+    // Write to a temp file in the same directory, then rename over the target.
+    // rename is atomic on POSIX and NTFS, so a concurrent reader (the MCP server
+    // and the post-commit hook share this file) never sees a half-written JSON,
+    // and two writers can't interleave into a corrupt file.
+    const tmp = path.join(DIR, `credentials.json.${process.pid}.tmp`);
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
+    try {
+        fs.renameSync(tmp, FILE);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            // best-effort cleanup
+        }
+        throw err;
+    }
+}
+export function clearCredentials() {
+    try {
+        fs.unlinkSync(FILE);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=credentials.js.map

package/dist/git.js

@@ -0,0 +1,37 @@
+/**
+ * Shared git helpers for the CLI subcommands (`analyze`, `import`). Both read
+ * commit diffs the same way, so the invocation, buffer limit and error
+ * normalization live here — a drift between them would make the same commit
+ * compress differently across subcommands and break the server-side dedup.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+export const execFileAsync = promisify(execFile);
+export const GIT_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+// Mirror of the extension's default changebook.maxDiffCharacters (the server
+// rejects anything above 60k anyway).
+export const MAX_DIFF_CHARACTERS = 25_000;
+/** `git show <hash> -U0` — the unified diff of a single commit, no context. */
+export async function commitDiff(cwd, hash) {
+    try {
+        const { stdout } = await execFileAsync("git", 
+        // --end-of-options so a ref that starts with "-" (e.g. "-n5") is treated
+        // as a revision, never as a git option (argument injection).
+        ["show", "--pretty=format:", "-U0", "--end-of-options", hash], { cwd, encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES });
+        return stdout;
+    }
+    catch (error) {
+        throw new Error(`Could not read the diff of ${hash.slice(0, 8)}: ${gitErrorMessage(error)}`);
+    }
+}
+/** Pulls git's stderr out of an execFile rejection for a readable message. */
+export function gitErrorMessage(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "stderr" in error &&
+        typeof error.stderr === "string") {
+        return error.stderr;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=git.js.map

package/dist/hook.js

@@ -0,0 +1,69 @@
+/**
+ * `changebook hook install|uninstall|status [dir]` — git post-commit hook that
+ * analyzes each new commit into the atlas, in the background, without ever
+ * blocking the commit. One analysis per commit, deduped server-side by hash,
+ * so the cost is bounded and re-runs are free. This one hook covers every
+ * client that commits: Claude Code, Codex, the terminal, any editor.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileAsync } from "./git.js";
+const MARKER = "# changebook post-commit hook";
+function hookScript() {
+    const entry = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
+    // Background subshell + `|| true`: a broken analyze (offline, out of
+    // credits, logged out) must never make `git commit` fail or feel slow.
+    // The log keeps only the last run so it can't grow unbounded.
+    return `#!/bin/sh
+${MARKER} — analyzes each commit into your ChangeBook atlas.
+# Runs in the background and never blocks the commit. Remove with:
+#   changebook hook uninstall
+( ${JSON.stringify(process.execPath)} ${JSON.stringify(entry)} analyze --commit HEAD > "$(git rev-parse --git-dir)/changebook-hook.log" 2>&1 & ) || true
+`;
+}
+async function hookPath(dir) {
+    // --git-path (not --git-dir + "/hooks") resolves core.hooksPath — set by
+    // Husky in most modern JS repos to .husky/ — and linked worktrees' common
+    // dir. Building <git-dir>/hooks/post-commit by hand ignores both, so the hook
+    // installed to a path git never runs and the atlas silently stops updating.
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", "hooks/post-commit"], {
+        cwd: dir,
+        encoding: "utf8",
+    }).catch(() => {
+        throw new Error(`"${dir}" is not a git repository.`);
+    });
+    // The path is relative to `dir`.
+    return path.resolve(dir, stdout.trim());
+}
+export async function installHook(dir) {
+    const file = await hookPath(dir);
+    if (fs.existsSync(file)) {
+        const current = fs.readFileSync(file, "utf8");
+        if (!current.includes(MARKER)) {
+            throw new Error(`A post-commit hook already exists at ${file} and it isn't ChangeBook's — not overwriting it. Add this line to it manually if you want both:\n\n` +
+                hookScript().split("\n").slice(-2).join("\n"));
+        }
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, hookScript(), { mode: 0o755 });
+    console.error(`✓ post-commit hook installed (${file}).`);
+    console.error("Every new commit is analyzed into your atlas in the background (1 credit each; re-runs of the same commit are free).");
+}
+export async function uninstallHook(dir) {
+    const file = await hookPath(dir);
+    if (!fs.existsSync(file) || !fs.readFileSync(file, "utf8").includes(MARKER)) {
+        console.error("No ChangeBook post-commit hook found.");
+        return;
+    }
+    fs.unlinkSync(file);
+    console.error("✓ post-commit hook removed.");
+}
+export async function hookStatus(dir) {
+    const file = await hookPath(dir);
+    const installed = fs.existsSync(file) && fs.readFileSync(file, "utf8").includes(MARKER);
+    console.error(installed
+        ? `✓ ChangeBook post-commit hook installed (${file}).`
+        : "No ChangeBook post-commit hook in this repository. Install it with: changebook hook install");
+}
+//# sourceMappingURL=hook.js.map

package/dist/import.js

@@ -0,0 +1,164 @@
+/**
+ * `changebook import [dir] [--commits N]` — backfill the atlas from git history
+ * through the import-batch Edge Function, which runs the analyses on the
+ * Anthropic Message Batches API (50% cheaper than the interactive path).
+ *
+ * Flow: resume any batch left pending by an interrupted run, then list the
+ * last N commits, skip trivial ones locally, compress each diff, submit in
+ * chunks and poll until every chunk is ingested. Already-imported commits are
+ * deduped server-side and never billed.
+ */
+import * as path from "node:path";
+import { atlasWebUrl } from "./browser.js";
+import { commitDiff, execFileAsync, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, } from "./git.js";
+import { optimizeTokensForAI } from "./optimize.js";
+// Under the server's MAX_BATCH_ITEMS (25) to leave headroom.
+const CHUNK_SIZE = 20;
+const POLL_INTERVAL_MS = 15_000;
+const POLL_TIMEOUT_MS = 30 * 60_000;
+// Files that never justify an analysis credit on their own (kept in sync
+// with the VS Code extension's importHistory).
+const SKIP_FILE_PATTERNS = [
+    /(^|\/)package-lock\.json$/,
+    /(^|\/)pnpm-lock\.yaml$/,
+    /(^|\/)yarn\.lock$/,
+    /(^|\/)(dist|build|out|node_modules|vendor)\//,
+    /\.min\.(js|css)$/,
+    /\.(png|jpe?g|gif|webp|ico|svg|woff2?|ttf|otf|eot|mp4|mov|pdf|zip)$/i,
+];
+export async function importHistory(db, options = {}) {
+    const cwd = path.resolve(options.dir ?? process.cwd());
+    const projectName = path.basename(cwd);
+    const count = Math.max(1, Math.min(options.commits ?? 25, 100));
+    // A previous run may have been interrupted after submitting: the Anthropic
+    // batch keeps running server-side, so finish those before spending more.
+    await resumePendingBatches(db);
+    console.error(`Leyendo los últimos ${count} commits de "${projectName}"…`);
+    const commits = await listCommits(cwd, count);
+    if (commits.length === 0) {
+        console.error("No hay commits que importar en este repositorio.");
+        return;
+    }
+    const items = [];
+    let trivial = 0;
+    for (const commit of commits) {
+        if (await isTrivialCommit(cwd, commit.hash)) {
+            trivial += 1;
+            continue;
+        }
+        const diff = await commitDiff(cwd, commit.hash);
+        const compressed = optimizeTokensForAI(diff);
+        if (!compressed || compressed.length > MAX_DIFF_CHARACTERS) {
+            trivial += 1;
+            continue;
+        }
+        items.push({
+            compressedDiff: compressed,
+            rawDiffChars: diff.length,
+            commitHash: commit.hash,
+            committedAt: commit.date,
+        });
+    }
+    if (items.length === 0) {
+        console.error(`Nada que importar: ${trivial} commits triviales (locks, assets, diffs enormes).`);
+        return;
+    }
+    console.error(`${items.length} commits analizables (${trivial} triviales saltados). ` +
+        `Se envían por lotes al Batch API (50% de descuento); puede tardar varios minutos.`);
+    let imported = 0;
+    let failed = 0;
+    let duplicates = 0;
+    for (let i = 0; i < items.length; i += CHUNK_SIZE) {
+        const chunk = items.slice(i, i + CHUNK_SIZE);
+        const { status, body } = await db.invokeFunction("import-batch", { action: "submit", projectName, items: chunk });
+        if (status !== 200 || body.error) {
+            // The server's messages are user-facing (quota, waitlist…). Everything
+            // ingested so far is already saved.
+            throw new Error(body.error ?? `import-batch failed with status ${status}`);
+        }
+        duplicates += body.skippedDuplicates ?? 0;
+        if (!body.batchId)
+            continue; // whole chunk was already in the atlas
+        console.error(`Lote enviado (${body.submitted} commits). Esperando resultados…`);
+        const result = await pollBatch(db, body.batchId);
+        imported += result.imported ?? 0;
+        failed += result.failed ?? 0;
+    }
+    const lines = [
+        "",
+        `✓ Import terminado: ${imported} importados` +
+            (duplicates > 0 ? `, ${duplicates} ya estaban en el atlas` : "") +
+            (trivial > 0 ? `, ${trivial} triviales saltados` : "") +
+            (failed > 0 ? `, ${failed} fallidos` : "") +
+            ".",
+        `Atlas → ${atlasWebUrl()}`,
+    ];
+    if (failed > 0) {
+        lines.push("Los commits fallidos pueden reintentarse ejecutando el import de nuevo.");
+    }
+    console.error(lines.join("\n"));
+}
+async function resumePendingBatches(db) {
+    const { status, body } = await db.invokeFunction("import-batch", { action: "pending" });
+    if (status !== 200 || body.error || !body.batches?.length)
+        return;
+    for (const batch of body.batches) {
+        console.error(`Reanudando un lote pendiente de una ejecución anterior (${batch.submitted} commits)…`);
+        await pollBatch(db, batch.batchId);
+    }
+}
+async function pollBatch(db, batchId) {
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    for (;;) {
+        const { status, body } = await db.invokeFunction("import-batch", { action: "status", batchId });
+        if (status !== 200 || body.error) {
+            throw new Error(body.error ?? `import-batch status failed (${status})`);
+        }
+        if (body.status === "ended") {
+            return body;
+        }
+        if (Date.now() > deadline) {
+            throw new Error("El lote sigue procesándose tras 30 minutos. Vuelve a ejecutar `changebook import` más tarde: lo retomará donde quedó.");
+        }
+        if (body.succeeded != null || body.processing != null) {
+            console.error(`  …procesando (${body.succeeded ?? 0} listos, ${body.processing ?? "?"} en cola)`);
+        }
+        await sleep(POLL_INTERVAL_MS);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ── git helpers ───────────────────────────────────────────────────────────────
+async function listCommits(cwd, count) {
+    try {
+        const { stdout } = await execFileAsync("git", ["log", "-n", String(count), "--no-merges", "--pretty=format:%H|%cI"], { cwd, encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES });
+        return stdout
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            const [hash, date] = line.split("|");
+            return { hash, date };
+        })
+            .filter((c) => c.hash && c.date);
+    }
+    catch (error) {
+        const message = gitErrorMessage(error);
+        if (message.includes("not a git repository")) {
+            throw new Error(`"${cwd}" is not a git repository.`);
+        }
+        if (message.includes("does not have any commits") ||
+            message.includes("bad default revision")) {
+            return [];
+        }
+        throw new Error(`Could not read the git history in "${cwd}": ${message}`);
+    }
+}
+async function isTrivialCommit(cwd, hash) {
+    const { stdout } = await execFileAsync("git", ["show", "--name-only", "--pretty=format:", "--end-of-options", hash], { cwd, encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES });
+    const files = stdout.split("\n").filter(Boolean);
+    if (files.length === 0)
+        return true;
+    return files.every((file) => SKIP_FILE_PATTERNS.some((pattern) => pattern.test(file)));
+}
+//# sourceMappingURL=import.js.map