@usegraft/cli 0.0.0-canary-20260831153011

package/dist/chunk-6Z27SGVO.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-2NH6KYTL.js";
+
+// src/commands/migrate.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { basename, join } from "path";
+import { GraftError } from "@usegraft/contracts";
+import {
+  runContentMigration
+} from "@usegraft/content-migrations";
+import { runDataMigration } from "@usegraft/core";
+import { createJiti } from "jiti";
+async function discoverMigrations(migrationsDir) {
+  if (!existsSync(migrationsDir) || !statSync(migrationsDir).isDirectory()) return [];
+  const files = readdirSync(migrationsDir).filter((name) => /\.(ts|mts|js|mjs)$/.test(name)).sort().map((name) => join(migrationsDir, name));
+  const jiti = createJiti(migrationsDir, { moduleCache: false });
+  const discovered = [];
+  for (const file of files) {
+    const id = basename(file).replace(/\.(ts|mts|js|mjs)$/, "");
+    let mod;
+    try {
+      mod = await jiti.import(file);
+    } catch (error) {
+      throw new GraftError({
+        code: "MIGRATION_FAILED",
+        message: `Migration file ${basename(file)} failed to load: ${error instanceof Error ? error.message : String(error)}`,
+        fix: "Fix the error in the file \u2014 it must be importable and default-export defineContentMigration(\u2026) or defineDataMigration(\u2026).",
+        details: { file }
+      });
+    }
+    const migration = mod.default;
+    if (!migration || migration.kind !== "content" && migration.kind !== "data" || typeof migration.transform !== "function") {
+      throw new GraftError({
+        code: "MIGRATION_FAILED",
+        message: `${basename(file)} does not default-export a migration.`,
+        fix: `Add \`export default defineContentMigration({ \u2026 })\` (from "@usegraft/content-migrations") or \`export default defineDataMigration({ \u2026 })\` (from "@usegraft/core").`,
+        details: { file, exports: Object.keys(mod) }
+      });
+    }
+    discovered.push({ id, file, migration });
+  }
+  return discovered;
+}
+async function migrateCommand(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  const branchId = options.branchId ?? "main";
+  const migrations = await discoverMigrations(config.migrationsDir);
+  if (migrations.length === 0) {
+    console.log(
+      `No migrations found in ${config.migrationsDir}.
+Author one as migrations/0001-<name>.ts default-exporting defineContentMigration or defineDataMigration.`
+    );
+    return { applied: [], pending: [], didApply: false };
+  }
+  const url = requireDatabaseUrl();
+  const [
+    { compile, resolveGitSha },
+    {
+      createDb,
+      listAppliedMigrations,
+      recordAppliedMigration,
+      resolveBranchHandle,
+      scopeWriteBranch
+    }
+  ] = await Promise.all([import("@usegraft/compiler"), import("@usegraft/db")]);
+  const control = createDb(url);
+  const branch = await resolveBranchHandle(control.db, branchId, { databaseUrl: url });
+  const writeBranch = scopeWriteBranch(branch.scope);
+  try {
+    const appliedRows = await listAppliedMigrations(branch.db, writeBranch);
+    const appliedIds = new Set(appliedRows.map((row) => row.migrationId));
+    const applied = migrations.filter((m) => appliedIds.has(m.id)).map((m) => m.id);
+    const pending = migrations.filter((m) => !appliedIds.has(m.id));
+    if (applied.length > 0) {
+      console.log(`Already applied on "${branchId}": ${applied.join(", ")}`);
+    }
+    if (pending.length === 0) {
+      console.log("Nothing pending \u2014 the branch is up to date.");
+      return { applied, pending: [], didApply: false };
+    }
+    const gitSha = resolveGitSha(config.projectDir);
+    const outcomes = [];
+    for (const { id, migration } of pending) {
+      const label = `${id} [${migration.kind}] ${migration.collection.name} \u2014 ${migration.description}`;
+      if (migration.kind === "content") {
+        const report = await runContentMigration({
+          contentDir: config.contentDir,
+          migration,
+          apply: options.apply
+        });
+        if (options.apply) {
+          const compiled = await compile({
+            db: branch.db,
+            contentDir: config.contentDir,
+            collections: config.collections,
+            mdxTrust: config.mdxTrust,
+            branchId: writeBranch,
+            gitSha
+          });
+          await recordAppliedMigration(branch.db, {
+            branchId: writeBranch,
+            migrationId: id,
+            kind: "content",
+            collection: migration.collection.name,
+            docCount: report.changed,
+            gitSha
+          });
+          console.log(
+            `applied ${label}
+  ${report.changed} file(s) rewritten, ${report.unchanged} unchanged; compiled: +${compiled.changes.added.length} ~${compiled.changes.changed.length} -${compiled.changes.removed.length}`
+          );
+        } else {
+          console.log(
+            `pending ${label}
+  would rewrite ${report.changed} file(s) (${report.unchanged} unchanged)`
+          );
+        }
+        outcomes.push({
+          id,
+          kind: "content",
+          collection: migration.collection.name,
+          description: migration.description,
+          report
+        });
+      } else {
+        const report = await runDataMigration({
+          db: branch.db,
+          migration,
+          migrationId: id,
+          branchId: writeBranch,
+          gitSha,
+          apply: options.apply
+        });
+        console.log(
+          options.apply ? `applied ${label}
+  ${report.changed} row(s) updated, ${report.unchanged} unchanged` : `pending ${label}
+  would update ${report.changed} of ${report.rows} row(s)`
+        );
+        outcomes.push({
+          id,
+          kind: "data",
+          collection: migration.collection.name,
+          description: migration.description,
+          report
+        });
+      }
+    }
+    if (!options.apply) {
+      console.log(`
+Dry run \u2014 nothing was written. Run \`graft migrate --apply\` to execute.`);
+    } else {
+      console.log(
+        `
+${outcomes.length} migration(s) applied. Commit the changes \u2014 git is the version history.`
+      );
+    }
+    return { applied, pending: outcomes, didApply: options.apply === true };
+  } finally {
+    await branch.close();
+    await control.close();
+  }
+}
+
+export {
+  discoverMigrations,
+  migrateCommand
+};

package/dist/chunk-GDTOV3DU.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import {
+  formatCompileResult
+} from "./chunk-GPA66AP5.js";
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-2NH6KYTL.js";
+
+// src/commands/compile.ts
+import { GraftError } from "@usegraft/contracts";
+function assertNoStaticBranch(branchId) {
+  if (branchId === void 0 || branchId === "main") return;
+  throw new GraftError({
+    code: "NEEDS_DATABASE",
+    message: `--branch ${branchId} needs the Postgres index: this project runs in static mode, where a "branch" is just your git branch.`,
+    fix: `Check out the git branch and compile (each checkout builds its own artifact), or upgrade to Postgres for DB branching: set DATABASE_URL and \`export const index = "postgres"\` in graft.config.`,
+    details: { branchId }
+  });
+}
+async function compileCommand(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  if (config.index.driver === "static") {
+    assertNoStaticBranch(options.branchId);
+    const { compileStatic } = await import("@usegraft/compiler");
+    const result = await compileStatic({
+      contentDir: config.contentDir,
+      collections: config.collections,
+      mdxTrust: config.mdxTrust,
+      indexPath: config.index.path
+    });
+    console.log(formatCompileResult(result));
+    return result;
+  }
+  const url = requireDatabaseUrl();
+  const [{ compile }, { createDb, resolveBranchHandle, scopeWriteBranch }] = await Promise.all([
+    import("@usegraft/compiler"),
+    import("@usegraft/db")
+  ]);
+  const control = createDb(url);
+  try {
+    const branch = await resolveBranchHandle(control.db, options.branchId ?? "main", {
+      databaseUrl: url
+    });
+    try {
+      if (branch.scope.kind === "physical") {
+        console.log(`neon branch "${branch.name}" \u2014 compiling into its own database`);
+      }
+      const result = await compile({
+        db: branch.db,
+        contentDir: config.contentDir,
+        collections: config.collections,
+        mdxTrust: config.mdxTrust,
+        branchId: scopeWriteBranch(branch.scope),
+        pruneUnknown: options.pruneUnknown
+      });
+      console.log(formatCompileResult(result));
+      return result;
+    } finally {
+      await branch.close();
+    }
+  } finally {
+    await control.close();
+  }
+}
+
+export {
+  assertNoStaticBranch,
+  compileCommand
+};

package/dist/chunk-GPA66AP5.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+// src/report.ts
+function printGraftError(error) {
+  console.error(`error ${error.code}: ${error.message}`);
+  if (error.fix) console.error(`  fix: ${error.fix}`);
+  if (error.details) console.error(`  details: ${JSON.stringify(error.details)}`);
+}
+function formatCompileResult(result) {
+  const { added, changed, removed, unchanged } = result.changes;
+  const lines = [
+    `Compiled ${result.count} doc(s) @ ${result.gitSha?.slice(0, 7) ?? "no-git"}: +${added.length} added, ~${changed.length} changed, -${removed.length} removed, ${unchanged} unchanged`
+  ];
+  for (const key of [...added, ...changed]) lines.push(`  upserted ${key}`);
+  for (const key of removed) lines.push(`  removed  ${key}`);
+  return lines.join("\n");
+}
+
+export {
+  printGraftError,
+  formatCompileResult
+};

package/dist/chunk-WKRIEXBQ.js

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-2NH6KYTL.js";
+
+// src/commands/serve.ts
+import { execFileSync } from "child_process";
+import { createServer } from "http";
+import { createActorResolver } from "@usegraft/auth";
+import { GraftError } from "@usegraft/contracts";
+import { setRequestPeer } from "@usegraft/core";
+function createServeRouter(routes) {
+  return async (request) => {
+    const { pathname } = new URL(request.url);
+    if (pathname === "/healthz") return routes.health(request);
+    if (pathname === "/api/mcp") return routes.mcp(request);
+    if (pathname === "/api/fn" || pathname.startsWith("/api/fn/")) return routes.fn(request);
+    if (pathname === "/api/content/v1" || pathname.startsWith("/api/content/v1/")) {
+      return routes.content(request);
+    }
+    if (routes.studio && (pathname === "/studio" || pathname.startsWith("/studio/") || pathname.startsWith("/api/studio/"))) {
+      return routes.studio(request);
+    }
+    const studioHint = routes.studio ? ", GET /studio (opt-in Studio)" : " \u2014 or pass --studio / GRAFT_STUDIO=1 for the opt-in Studio UI";
+    const error = new GraftError({
+      code: "ROUTE_NOT_FOUND",
+      message: `Nothing is mounted at ${pathname}.`,
+      fix: `Use POST /api/fn/<name> (typed functions), POST /api/mcp (MCP Streamable HTTP), GET /api/content/v1/documents (authored content), GET /api/content/v1/search, or GET /healthz${studioHint}.`,
+      details: { pathname }
+    });
+    return new Response(JSON.stringify(error.toJSON()), {
+      status: 404,
+      headers: { "content-type": "application/json" }
+    });
+  };
+}
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "content-length",
+  "upgrade",
+  "proxy-connection"
+]);
+function allowedHostsFor(host) {
+  if (host === "0.0.0.0" || host === "::" || host === "") return void 0;
+  if (host === "127.0.0.1" || host === "localhost" || host === "::1") {
+    return ["127.0.0.1", "localhost", "[::1]"];
+  }
+  return [host];
+}
+function hostname(host) {
+  const trimmed = host.trim().toLowerCase();
+  if (trimmed.startsWith("[")) return trimmed.slice(0, trimmed.indexOf("]") + 1);
+  const colon = trimmed.lastIndexOf(":");
+  return colon === -1 ? trimmed : trimmed.slice(0, colon);
+}
+function createNodeListener(handler, options = {}) {
+  const allowed = options.allowedHosts?.map(hostname);
+  return async (req, res) => {
+    try {
+      if (allowed && !allowed.includes(hostname(req.headers.host ?? ""))) {
+        res.writeHead(400, { "content-type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: "INPUT_VALIDATION_FAILED",
+            message: `This server does not answer to Host "${req.headers.host ?? ""}".`,
+            fix: `Reach it at one of: ${allowed.join(", ")}. A mismatched Host is either a misconfigured proxy or a DNS-rebinding attempt.`
+          })
+        );
+        return;
+      }
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      const body = Buffer.concat(chunks);
+      const headers = new Headers();
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value === void 0 || HOP_BY_HOP.has(key)) continue;
+        if (Array.isArray(value)) for (const v of value) headers.append(key, v);
+        else headers.set(key, value);
+      }
+      const method = req.method ?? "GET";
+      const request = new Request(`http://${req.headers.host ?? "localhost"}${req.url ?? "/"}`, {
+        method,
+        headers,
+        body: method === "GET" || method === "HEAD" || body.length === 0 ? void 0 : body
+      });
+      const peer = req.socket.remoteAddress;
+      if (peer) setRequestPeer(request, peer);
+      const response = await handler(request);
+      const outHeaders = {};
+      response.headers.forEach((value, key) => {
+        if (!HOP_BY_HOP.has(key)) outHeaders[key] = value;
+      });
+      res.writeHead(response.status, outHeaders);
+      res.end(Buffer.from(await response.arrayBuffer()));
+    } catch (error) {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "FUNCTION_EXECUTION_FAILED",
+          message: `graft serve failed to relay the request: ${error instanceof Error ? error.message : String(error)}`,
+          fix: "Check the server logs; if this reproduces, file it \u2014 the adapter should never throw."
+        })
+      );
+    }
+  };
+}
+function localGitSha(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function trustedIssuersFromEnv() {
+  return (process.env.GRAFT_TRUSTED_ISSUERS ?? "").split(/[,\s]+/).map((issuer) => issuer.trim()).filter(Boolean).map((issuer) => ({ issuer }));
+}
+async function startServe(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  const url = requireDatabaseUrl();
+  const enableStudio = options.studio === true || process.env.GRAFT_STUDIO === "1";
+  const [
+    { createFunctionsHandler },
+    { createGraftMcpHandler },
+    { createContentApiHandler },
+    { createDb, createDbIndexReader, resolveBranchHandle, scopeWriteBranch, sql },
+    studioMod
+  ] = await Promise.all([
+    import("@usegraft/core"),
+    import("@usegraft/mcp"),
+    import("@usegraft/content-api"),
+    import("@usegraft/db"),
+    enableStudio ? import("@usegraft/studio") : Promise.resolve(null)
+  ]);
+  const control = createDb(url);
+  const branchName = options.branchId ?? "main";
+  const branch = await resolveBranchHandle(control.db, branchName, { databaseUrl: url });
+  const writeBranch = scopeWriteBranch(branch.scope);
+  const devToken = process.env.GRAFT_DEV_TOKEN;
+  const scopes = (process.env.GRAFT_DEV_SCOPES ?? "").split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+  const issuers = trustedIssuersFromEnv();
+  const resolveActor = createActorResolver({
+    issuers,
+    devTokens: devToken ? { [devToken]: { kind: "agent", id: "graft-serve", scopes } } : void 0
+  });
+  const approvalPolicy = process.env.GRAFT_APPROVAL_POLICY === "human" ? "human" : process.env.GRAFT_APPROVAL_POLICY === "unattended" ? "unattended" : "none";
+  const host = options.host ?? process.env.HOST ?? "127.0.0.1";
+  const loopback = host === "127.0.0.1" || host === "localhost" || host === "::1";
+  const anonymousOptIn = process.env.GRAFT_MCP_ALLOW_ANONYMOUS === "1";
+  const allowAnonymousMcp = loopback || anonymousOptIn;
+  const functions = config.functions ?? {};
+  const gitSha = localGitSha(options.cwd);
+  const fnHandler = createFunctionsHandler({
+    functions,
+    db: branch.db,
+    branch: writeBranch,
+    actor: resolveActor,
+    approvalPolicy,
+    // Backstop; per-function rateLimit overrides it.
+    rateLimit: { limit: 60, windowSeconds: 60 },
+    gitSha
+  });
+  const mcpHandler = createGraftMcpHandler({
+    name: "graft-serve",
+    contentDir: config.contentDir,
+    collections: config.collections,
+    functions,
+    mdxTrust: config.mdxTrust,
+    db: branch.db,
+    branchId: writeBranch,
+    scope: branch.scope,
+    actor: resolveActor,
+    allowAnonymous: allowAnonymousMcp
+  });
+  const allowedOriginsRaw = process.env.GRAFT_CONTENT_ALLOWED_ORIGINS?.trim();
+  const allowedOrigins = allowedOriginsRaw === void 0 || allowedOriginsRaw === "" ? void 0 : allowedOriginsRaw === "*" ? "*" : allowedOriginsRaw.split(",").map((entry) => entry.trim()).filter(Boolean);
+  const contentHandler = createContentApiHandler({
+    collections: Object.keys(config.collections),
+    branch: writeBranch,
+    index: createDbIndexReader(branch.db),
+    ...allowedOrigins === void 0 ? {} : { allowedOrigins },
+    // The same backstop the functions handler gets, for the same reason. These
+    // routes authenticate nobody and run database listings and full-text
+    // searches, so without a limit here one anonymous caller can keep the index
+    // busy indefinitely — and `graft serve` is the mount most likely to face
+    // the open internet.
+    rateLimit: { limit: 60, windowSeconds: 60 }
+  });
+  const health = async () => {
+    try {
+      await branch.db.execute(sql`select 1`);
+    } catch (error) {
+      return new Response(
+        JSON.stringify({
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }),
+        { status: 503, headers: { "content-type": "application/json" } }
+      );
+    }
+    return new Response(
+      JSON.stringify({
+        ok: true,
+        branch: branchName,
+        collections: Object.keys(config.collections).length,
+        functions: Object.keys(functions).length,
+        gitSha: gitSha ?? null
+      }),
+      { status: 200, headers: { "content-type": "application/json" } }
+    );
+  };
+  const requestedPort = options.port ?? Number(process.env.PORT ?? 3903);
+  if (!Number.isInteger(requestedPort) || requestedPort < 0 || requestedPort > 65535) {
+    await branch.close();
+    await control.close();
+    throw new GraftError({
+      code: "INPUT_VALIDATION_FAILED",
+      message: `"${options.port ?? process.env.PORT}" is not a valid port.`,
+      fix: "Pass --port <0-65535> (0 picks a free port) or set PORT."
+    });
+  }
+  if (!loopback && anonymousOptIn) {
+    console.warn(
+      "[graft serve] WARNING: GRAFT_MCP_ALLOW_ANONYMOUS=1 while bound beyond loopback \u2014 unauthenticated callers can write content, upload assets and decide approvals. Only do this behind an auth proxy you control."
+    );
+  } else if (!loopback && issuers.length === 0 && !devToken) {
+    console.warn(
+      "[graft serve] WARNING: binding beyond loopback with no identity configured \u2014 MCP will refuse every caller, because there is nothing to authenticate them against. Set GRAFT_DEV_TOKEN or GRAFT_TRUSTED_ISSUERS."
+    );
+  }
+  if (approvalPolicy === "unattended") {
+    console.warn(
+      "[graft serve] WARNING: GRAFT_APPROVAL_POLICY=unattended \u2014 destructive functions run without human approval. Deletes are not recoverable from git: deleteRecord removes rows outright and the asset store keeps no history. Audit rows are still written. This applies to POST /api/fn only; run_function over /api/mcp stays gated, because the policy is not part of the MCP surface."
+    );
+  }
+  let studioHandler;
+  if (studioMod) {
+    const authenticate = !loopback && (devToken || issuers.length > 0) ? async (request) => {
+      const actor = await resolveActor(request);
+      if (actor.kind === "anonymous" || !actor.id) return null;
+      return { kind: actor.kind, id: actor.id, scopes: actor.scopes ?? [] };
+    } : !loopback ? () => null : void 0;
+    studioHandler = studioMod.createStudioHandler({
+      db: branch.db,
+      collections: config.collections,
+      contentDir: config.contentDir,
+      mdxTrust: config.mdxTrust,
+      defaultBranch: writeBranch,
+      // Only reached on a loopback mount, where there is no caller identity to
+      // attribute to. Off loopback the authenticated principal is used instead.
+      decider: { kind: "agent", id: "studio-serve" },
+      uiBasePath: "/studio",
+      authenticate
+    });
+  }
+  const server = createServer(
+    createNodeListener(
+      createServeRouter({
+        fn: fnHandler,
+        mcp: mcpHandler,
+        content: contentHandler,
+        health,
+        studio: studioHandler
+      }),
+      { allowedHosts: allowedHostsFor(host) }
+    )
+  );
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(requestedPort, host, () => resolve());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : requestedPort;
+  return {
+    port,
+    host,
+    branch: branchName,
+    close: async () => {
+      await new Promise((resolve, reject) => {
+        server.close((err) => err ? reject(err) : resolve());
+      });
+      await branch.close();
+      await control.close();
+    }
+  };
+}
+async function serveCommand(options) {
+  const running = await startServe(options);
+  const base = `http://${running.host}:${running.port}`;
+  const studioOn = options.studio === true || process.env.GRAFT_STUDIO === "1";
+  console.log(
+    [
+      `graft serve \u2014 branch "${running.branch}"`,
+      `  functions  POST ${base}/api/fn/<name>`,
+      `  mcp        POST ${base}/api/mcp`,
+      `  documents  GET  ${base}/api/content/v1/documents`,
+      `  search     GET  ${base}/api/content/v1/search`,
+      `  health     GET  ${base}/healthz`,
+      ...studioOn ? [
+        `  studio     GET  ${base}/studio`,
+        `  openapi    GET  ${base}/api/studio/v1/openapi.json`
+      ] : []
+    ].join("\n")
+  );
+  await new Promise((resolve) => {
+    const stop = () => resolve();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  await running.close();
+}
+
+export {
+  createServeRouter,
+  allowedHostsFor,
+  createNodeListener,
+  startServe,
+  serveCommand
+};

package/dist/compilations-72DJ2VEP.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import {
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-2NH6KYTL.js";
+
+// src/commands/compilations.ts
+async function compilationsListCommand(options) {
+  loadProjectEnv(options.cwd);
+  const url = requireDatabaseUrl();
+  const { createDb, listCompilations } = await import("@usegraft/db");
+  const handle = createDb(url);
+  try {
+    return await listCompilations(handle.db, {
+      branchId: options.branchId,
+      limit: options.limit
+    });
+  } finally {
+    await handle.close();
+  }
+}
+function formatCompilation(row) {
+  const sha = row.gitSha ? row.gitSha.slice(0, 7) : "no-sha";
+  return `${row.createdAt.toISOString()}  ${row.branchId}  ${sha}  docs=${row.docCount}  +${row.added} ~${row.changed} -${row.removed}  ${row.id}`;
+}
+export {
+  compilationsListCommand,
+  formatCompilation
+};

package/dist/compile-TCBGZZAU.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  assertNoStaticBranch,
+  compileCommand
+} from "./chunk-GDTOV3DU.js";
+import "./chunk-GPA66AP5.js";
+import "./chunk-2NH6KYTL.js";
+export {
+  assertNoStaticBranch,
+  compileCommand
+};

package/dist/content-VLKNYIHL.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-2NH6KYTL.js";
+
+// src/commands/content.ts
+async function contentListCommand(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  const url = requireDatabaseUrl();
+  const { createDb, readContent, resolveBranchScope } = await import("@usegraft/db");
+  const handle = createDb(url);
+  const branch = options.branchId ?? "main";
+  try {
+    const scope = await resolveBranchScope(handle.db, branch);
+    const lines = [];
+    for (const name of Object.keys(config.collections).sort()) {
+      const rows = await readContent(handle.db, scope, { collection: name });
+      for (const row of rows) {
+        const title = typeof row.data.title === "string" ? row.data.title : typeof row.data.name === "string" ? row.data.name : void 0;
+        lines.push({
+          collection: name,
+          slug: row.slug,
+          sourcePath: row.sourcePath,
+          ...title ? { title } : {}
+        });
+      }
+    }
+    return { branch, lines };
+  } finally {
+    await handle.close();
+  }
+}
+function formatContentLine(line) {
+  const label = line.title ? `${line.slug}  (${line.title})` : line.slug;
+  return `${line.collection}/${label}  ${line.sourcePath}`;
+}
+export {
+  contentListCommand,
+  formatContentLine
+};