@usegraft/cli 0.0.0-canary-20260831153011

package/dist/init-TRPSGUYW.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import {
+  CONFIG_FILENAMES
+} from "./chunk-2NH6KYTL.js";
+
+// src/commands/init.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { GraftError } from "@usegraft/contracts";
+import { barrelSource } from "@usegraft/registry";
+var configTemplate = (driver) => `/**
+ * The schema for this project \u2014 collections defined as owned code.
+ * Agents: this is the single source of truth for what content exists.
+ * Add fields here, then author documents in content/<collection>/<slug>.mdx.
+ *
+ * Primitives you add with \`graft add\` live under graft/ and are merged in via
+ * the generated graft/index.ts barrel \u2014 you never edit the import below.
+ */
+import { defineCollection, field, mergePrimitives } from "@usegraft/core";
+import * as primitives from "./graft";
+
+${driver === "static" ? `// Where the content index lives. "static" compiles to .graft/index.db \u2014
+// no database, no env vars. Switch to "postgres" (with DATABASE_URL) when you
+// need operational data, typed functions, or database branching.
+export const index = "static";` : `// The content index lives in Postgres (DATABASE_URL). Content-only projects
+// can use \`export const index = "static"\` instead and drop the database.
+export const index = "postgres";`}
+
+export const pages = defineCollection({
+  name: "pages",
+  description: "Pages rendered by your site.",
+  fields: {
+    title: field.string({ description: "Page headline and <title>." }),
+    tagline: field.string({ optional: true, description: "Short line under the headline." }),
+  },
+});
+
+// Your own collections/functions + everything under graft/ (added via \`graft add\`).
+// mergePrimitives throws CONFIG_INVALID on a duplicate key \u2014 never a silent override.
+export const { collections, functions } = mergePrimitives([{ collections: { pages } }, primitives]);
+`;
+var homeTemplate = (driver) => `---
+title: Hello, Graft
+tagline: ${driver === "static" ? "Content lives in git; the index is a file." : "Content lives in git; Postgres is the index."}
+---
+
+Edit this file, then run \`graft compile\` (or keep \`graft dev\` running) to
+project it into the content index.
+`;
+var GITIGNORE_TEMPLATE = `# The compiled content index \u2014 derived from the files in git.
+# Rebuild it any time with \`graft compile\`; build it in CI before your app builds.
+.graft/
+`;
+var llmsTemplate = (driver) => `# Graft project \u2014 agent guide
+
+Everything is code. Content lives in MDX files; git is authoritative; the
+content index is derived. If they disagree, git wins \u2014 recompile.
+
+- Schema: graft.config.ts (defineCollection/field over Zod). The single source of truth.
+- Documents: content/<collection>/<slug>.mdx \u2014 frontmatter must satisfy the collection schema.
+- Slugs are kebab-case; a frontmatter \`slug:\` overrides the filename.
+- Project into the index: \`graft compile\` (one-shot) or \`graft dev\` (watch mode).
+${driver === "static" ? `- This project uses the **static index** (\`index = "static"\` in graft.config):
+  compile writes .graft/index.db \u2014 a SQLite artifact. No database, no env vars.
+- The artifact is derived, so it is git-ignored. Run \`graft compile\` before your
+  app builds (e.g. build command: \`graft compile && next build\`) so it ships with
+  the deploy.
+- Read it from your app with \`openStaticIndex(".graft/index.db")\` from
+  "@usegraft/db", passed to \`createClient({ index, collections })\`.
+- Branches here are just **git branches**: each checkout compiles its own artifact.
+- Operational data (form submissions, orders, comments), typed functions, and
+  database branching need the Postgres tier. Adding one fails with NEEDS_DATABASE,
+  whose \`fix\` is the upgrade: set DATABASE_URL and \`export const index = "postgres"\`.` : `- Both need DATABASE_URL in .env (any parent directory works).
+- One project = one database. Never point DATABASE_URL at another project's
+  index \u2014 compile refuses with INDEX_OWNERSHIP rather than purge its documents.`}
+- Primitives: add owned building blocks with \`graft add <item>\` \u2014 they land under
+  graft/ and wire in automatically (the generated graft/index.ts barrel; no config
+  edit). Run \`graft add\` with no name to list what's available.
+- Every Graft error carries a \`fix\` \u2014 do what it says, then retry.
+- Ship changes as git commits; every projection records the git SHA it compiled from.
+`;
+function scaffoldFor(driver) {
+  const files = {
+    "graft.config.ts": configTemplate(driver),
+    // The generated barrel graft add regenerates; empty until the first `graft add`.
+    [join("graft", "index.ts")]: barrelSource([]),
+    [join("content", "pages", "home.mdx")]: homeTemplate(driver),
+    "llms.txt": llmsTemplate(driver)
+  };
+  if (driver === "static") files[".gitignore"] = GITIGNORE_TEMPLATE;
+  return files;
+}
+function initCommand(options) {
+  const projectDir = resolve(options.targetDir);
+  const driver = options.driver ?? "static";
+  for (const name of CONFIG_FILENAMES) {
+    if (existsSync(join(projectDir, name))) {
+      throw new GraftError({
+        code: "ALREADY_INITIALIZED",
+        message: `${name} already exists in ${projectDir}.`,
+        fix: "This is already a Graft project \u2014 evolve it by editing the existing graft.config.ts, or run `graft init <dir>` against an empty directory."
+      });
+    }
+  }
+  const created = [];
+  for (const [relPath, body] of Object.entries(scaffoldFor(driver))) {
+    const absPath = join(projectDir, relPath);
+    if (existsSync(absPath)) continue;
+    mkdirSync(dirname(absPath), { recursive: true });
+    writeFileSync(absPath, body, "utf8");
+    created.push(relPath);
+  }
+  return { projectDir, driver, created };
+}
+export {
+  initCommand
+};

package/dist/mcp-DKFT2M4Q.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import {
+  assertNoStaticBranch
+} from "./chunk-GDTOV3DU.js";
+import "./chunk-GPA66AP5.js";
+import {
+  operatorName
+} from "./chunk-3CP4IY73.js";
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-2NH6KYTL.js";
+
+// src/commands/mcp.ts
+import { createActorResolver } from "@usegraft/auth";
+async function mcpCommand(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  const isStatic = config.index.driver === "static";
+  if (isStatic) assertNoStaticBranch(options.branchId);
+  const url = isStatic ? void 0 : requireDatabaseUrl();
+  const [{ createGraftMcp, serveStdio }, { createDb, resolveBranchHandle, scopeWriteBranch }] = await Promise.all([import("@usegraft/mcp"), import("@usegraft/db")]);
+  const control = url !== void 0 ? createDb(url) : void 0;
+  const branchName = options.branchId ?? "main";
+  const branch = control !== void 0 && url !== void 0 ? await resolveBranchHandle(control.db, branchName, { databaseUrl: url }) : void 0;
+  try {
+    const devToken = process.env.GRAFT_DEV_TOKEN;
+    const scopes = (process.env.GRAFT_DEV_SCOPES ?? "").split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+    const cliActor = {
+      kind: "agent",
+      id: "graft-cli",
+      scopes: [.../* @__PURE__ */ new Set(["content:write", ...scopes])]
+    };
+    const resolveActor = createActorResolver({
+      issuers: [],
+      devTokens: devToken ? { [devToken]: cliActor } : void 0
+    });
+    const resolveStdioActor = async (request) => {
+      const resolved = await resolveActor(request);
+      return resolved.kind === "anonymous" ? cliActor : resolved;
+    };
+    const approvalElicitation = options.elicitApprovals ? { decider: { kind: "human", id: operatorName() } } : void 0;
+    const server = createGraftMcp({
+      name: "graft",
+      contentDir: config.contentDir,
+      collections: config.collections,
+      functions: config.functions,
+      mdxTrust: config.mdxTrust,
+      ...branch !== void 0 ? {
+        db: branch.db,
+        branchId: scopeWriteBranch(branch.scope),
+        // The handle's resolved scope makes search_content overlay-aware: an
+        // overlay branch searches its full parent chain, not just its own rows.
+        scope: branch.scope
+      } : { staticIndexPath: config.index.path },
+      actor: resolveStdioActor,
+      connectionActor: cliActor,
+      // Local agents may upload a file from the project; remote mounts get no
+      // `path` argument at all.
+      localUploadRoot: config.projectDir,
+      defaultAuthorization: devToken,
+      approvalElicitation
+    });
+    await serveStdio(server);
+  } finally {
+    await branch?.close();
+    await control?.close();
+  }
+}
+export {
+  mcpCommand
+};

package/dist/merge-XMTFPLHO.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+import {
+  discoverMigrations
+} from "./chunk-6Z27SGVO.js";
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-2NH6KYTL.js";
+
+// src/commands/merge.ts
+import { basename } from "path";
+import { GraftError } from "@usegraft/contracts";
+function pendingLedgerRows(branchRows, targetRows) {
+  const applied = new Set(targetRows.map((row) => row.migrationId));
+  return branchRows.filter((row) => !applied.has(row.migrationId)).sort((a, b) => a.migrationId.localeCompare(b.migrationId));
+}
+async function mergeCommand(options) {
+  const into = options.into ?? "main";
+  if (options.branch === into) {
+    throw new GraftError({
+      code: "BRANCH_INVALID",
+      message: `Cannot merge "${options.branch}" into itself.`,
+      fix: "Pass the preview branch as the argument and the target via --into (default: main).",
+      details: { branch: options.branch, into }
+    });
+  }
+  if (options.branch === "main") {
+    throw new GraftError({
+      code: "BRANCH_INVALID",
+      message: "main is the root of the topology and cannot be merged into another branch.",
+      fix: "Merge preview branches into main (graft merge <branch>), not the other way around.",
+      details: { branch: options.branch, into }
+    });
+  }
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  const url = requireDatabaseUrl();
+  const [
+    { compile, resolveGitSha },
+    {
+      createDb,
+      getBranch,
+      listAppliedMigrations,
+      recordAppliedMigration,
+      countBranchRows,
+      moveDataRecords,
+      copyDataRecords,
+      resolveBranchHandle,
+      scopeWriteBranch
+    },
+    { runDataMigration }
+  ] = await Promise.all([
+    import("@usegraft/compiler"),
+    import("@usegraft/db"),
+    import("@usegraft/core")
+  ]);
+  const control = createDb(url);
+  await getBranch(control.db, options.branch).catch(async (e) => {
+    await control.close();
+    throw e;
+  });
+  await getBranch(control.db, into).catch(async (e) => {
+    await control.close();
+    throw e;
+  });
+  const src = await resolveBranchHandle(control.db, options.branch, { databaseUrl: url });
+  const target = await resolveBranchHandle(control.db, into, { databaseUrl: url });
+  const srcWrite = scopeWriteBranch(src.scope);
+  const targetWrite = scopeWriteBranch(target.scope);
+  const sameDb = src.scope.kind === "overlay" && target.scope.kind === "overlay";
+  try {
+    const [branchLedger, targetLedger] = await Promise.all([
+      listAppliedMigrations(src.db, srcWrite),
+      listAppliedMigrations(target.db, targetWrite)
+    ]);
+    const pending = pendingLedgerRows(branchLedger, targetLedger);
+    const discovered = await discoverMigrations(config.migrationsDir);
+    const byId = new Map(discovered.map((m) => [m.id, m]));
+    const missing = pending.filter((row) => !byId.has(row.migrationId));
+    if (missing.length > 0) {
+      throw new GraftError({
+        code: "MIGRATION_FAILED",
+        message: `The "${options.branch}" ledger references ${missing.length} migration(s) with no file in ${basename(config.migrationsDir)}/: ${missing.map((row) => row.migrationId).join(", ")}.`,
+        fix: "git-merge the branch first \u2014 the merged tree must contain the branch's migrations/ files (and its rewritten content) before `graft merge` replays the ledger.",
+        details: { missing: missing.map((row) => row.migrationId) }
+      });
+    }
+    const gitSha = resolveGitSha(config.projectDir);
+    const replayed = [];
+    for (const row of pending) {
+      const entry = byId.get(row.migrationId);
+      if (!entry) continue;
+      const { migration } = entry;
+      const label = `${row.migrationId} [${row.kind}] ${row.collection}`;
+      if (migration.kind === "data") {
+        const report = await runDataMigration({
+          db: target.db,
+          migration,
+          migrationId: row.migrationId,
+          branchId: targetWrite,
+          gitSha,
+          apply: options.apply
+        });
+        console.log(
+          options.apply ? `replayed ${label} \u2014 ${report.changed} row(s) updated on "${into}", ${report.unchanged} unchanged` : `would replay ${label} \u2014 ${report.changed} of ${report.rows} row(s) on "${into}"`
+        );
+      } else if (options.apply) {
+        await recordAppliedMigration(target.db, {
+          branchId: targetWrite,
+          migrationId: row.migrationId,
+          kind: "content",
+          collection: row.collection,
+          docCount: row.docCount,
+          gitSha
+        });
+        console.log(`recorded ${label} \u2014 content arrived via the git merge`);
+      } else {
+        console.log(`would record ${label} \u2014 content arrives via the git merge`);
+      }
+      replayed.push(row.migrationId);
+    }
+    if (pending.length === 0) console.log(`Ledger: nothing to replay on "${into}".`);
+    const counts = await countBranchRows(src.db, srcWrite);
+    const verb = sameDb ? "move" : "copy";
+    let dataMoved = counts.data;
+    if (options.apply && counts.data > 0) {
+      dataMoved = sameDb ? await moveDataRecords(control.db, { from: options.branch, into }) : await copyDataRecords(src.db, target.db, {
+        fromBranch: srcWrite,
+        intoBranch: targetWrite
+      });
+      console.log(
+        `${verb === "move" ? "moved" : "copied"} ${dataMoved} data_records row(s) from "${options.branch}" onto "${into}"`
+      );
+    } else {
+      console.log(
+        counts.data > 0 ? `would ${verb} ${counts.data} data_records row(s) from "${options.branch}" onto "${into}"` : `Data: "${options.branch}" owns no data_records rows.`
+      );
+    }
+    let compiled;
+    if (options.apply) {
+      const result = await compile({
+        db: target.db,
+        contentDir: config.contentDir,
+        collections: config.collections,
+        mdxTrust: config.mdxTrust,
+        branchId: targetWrite,
+        gitSha
+      });
+      compiled = result.changes;
+      console.log(
+        `recompiled "${into}": +${compiled.added.length} ~${compiled.changed.length} -${compiled.removed.length} (${compiled.unchanged} unchanged)`
+      );
+      console.log(
+        `
+Merge complete. Drop the branch when you're done with it: graft branch drop ${options.branch}`
+      );
+    } else {
+      console.log(`would recompile the working tree into "${into}"`);
+      console.log(
+        `
+Dry run \u2014 nothing was written. git-merge the branch's commits first if you haven't, then run \`graft merge ${options.branch} --apply\`.`
+      );
+    }
+    return { replayed, dataMoved, compiled, didApply: options.apply === true };
+  } finally {
+    await src.close();
+    await target.close();
+    await control.close();
+  }
+}
+export {
+  mergeCommand,
+  pendingLedgerRows
+};

package/dist/migrate-QB44VL6R.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  discoverMigrations,
+  migrateCommand
+} from "./chunk-6Z27SGVO.js";
+import "./chunk-2NH6KYTL.js";
+export {
+  discoverMigrations,
+  migrateCommand
+};

package/dist/serve-5ABBWZU2.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  allowedHostsFor,
+  createNodeListener,
+  createServeRouter,
+  serveCommand,
+  startServe
+} from "./chunk-WKRIEXBQ.js";
+import "./chunk-2NH6KYTL.js";
+export {
+  allowedHostsFor,
+  createNodeListener,
+  createServeRouter,
+  serveCommand,
+  startServe
+};

package/dist/studio-6ZO3FMDR.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import {
+  allowedHostsFor,
+  createNodeListener
+} from "./chunk-WKRIEXBQ.js";
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-2NH6KYTL.js";
+
+// src/commands/studio.ts
+import { execFile } from "child_process";
+import { createServer } from "http";
+import { userInfo } from "os";
+import { GraftError } from "@usegraft/contracts";
+function isLoopback(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "::1";
+}
+function operatorIdentity() {
+  try {
+    return { kind: "human", id: userInfo().username };
+  } catch {
+    return { kind: "human", id: process.env.USERNAME ?? process.env.USER ?? "operator" };
+  }
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "win32" ? "cmd" : platform === "darwin" ? "open" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  execFile(cmd, args, () => {
+  });
+}
+async function studioCommand(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  const url = requireDatabaseUrl();
+  const [{ createStudioHandler }, { createDb, resolveBranchHandle, scopeWriteBranch }] = await Promise.all([import("@usegraft/studio"), import("@usegraft/db")]);
+  const control = createDb(url);
+  const branchName = options.branchId ?? "main";
+  const branch = await resolveBranchHandle(control.db, branchName, { databaseUrl: url });
+  const writeBranch = scopeWriteBranch(branch.scope);
+  const host = options.host ?? process.env.HOST ?? "127.0.0.1";
+  const requestedPort = options.port ?? Number(process.env.GRAFT_STUDIO_PORT ?? 4983);
+  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.GRAFT_STUDIO_PORT}" is not a valid port.`,
+      fix: "Pass --port <0-65535> (0 picks a free port)."
+    });
+  }
+  const loopback = isLoopback(host);
+  const devToken = process.env.GRAFT_DEV_TOKEN;
+  if (!loopback && !devToken) {
+    console.warn(
+      "[graft studio] WARNING: binding beyond loopback with no GRAFT_DEV_TOKEN \u2014 set a bearer token before exposing Studio to a network."
+    );
+  }
+  const authenticate = !loopback && devToken ? (request) => {
+    const header = request.headers.get("authorization") ?? "";
+    if (header !== `Bearer ${devToken}`) return null;
+    return {
+      ...operatorIdentity(),
+      scopes: ["studio:read", "studio:write", "approvals:decide"]
+    };
+  } : !loopback ? () => null : void 0;
+  const handler = createStudioHandler({
+    db: branch.db,
+    collections: config.collections,
+    contentDir: config.contentDir,
+    mdxTrust: config.mdxTrust,
+    defaultBranch: writeBranch,
+    decider: operatorIdentity,
+    authenticate
+  });
+  const server = createServer(createNodeListener(handler, { 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;
+  const base = `http://${host}:${port}`;
+  console.log(
+    [
+      `graft studio \u2014 branch "${branchName}" (opt-in)`,
+      `  ui         GET  ${base}/`,
+      `  openapi    GET  ${base}/api/studio/v1/openapi.json`,
+      `  Edit content, approve/deny \u2014 same ops as MCP/CLI.`
+    ].join("\n")
+  );
+  if (loopback) openBrowser(`${base}/?branch=${encodeURIComponent(branchName)}`);
+  await new Promise((resolve) => {
+    const stop = () => resolve();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  await new Promise((resolve, reject) => {
+    server.close((err) => err ? reject(err) : resolve());
+  });
+  await branch.close();
+  await control.close();
+}
+export {
+  studioCommand
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@usegraft/cli",
+  "version": "0.0.0-canary-20260831153011",
+  "description": "The graft CLI: scaffold, compile authored content, serve the runtime, and split your database credentials.",
+  "keywords": [
+    "agent",
+    "ai",
+    "cli",
+    "cms",
+    "content",
+    "graft",
+    "headless-cms",
+    "mcp",
+    "postgres",
+    "scaffolding",
+    "static-site",
+    "typescript"
+  ],
+  "homepage": "https://github.com/AndersonDesign1/graft#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AndersonDesign1/graft.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "graft": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@usegraft/assets": "0.0.0-canary-20260831153011",
+    "@usegraft/auth": "0.0.0-canary-20260831153011",
+    "@usegraft/compiler": "0.0.0-canary-20260831153011",
+    "@usegraft/content-api": "0.0.0-canary-20260831153011",
+    "@usegraft/content-migrations": "0.0.0-canary-20260831153011",
+    "@usegraft/contracts": "0.0.0-canary-20260831153011",
+    "@usegraft/core": "0.0.0-canary-20260831153011",
+    "@usegraft/db": "0.0.0-canary-20260831153011",
+    "@usegraft/mcp": "0.0.0-canary-20260831153011",
+    "@usegraft/mdx-safety": "0.0.0-canary-20260831153011",
+    "@usegraft/registry": "0.0.0-canary-20260831153011",
+    "@usegraft/studio": "0.0.0-canary-20260831153011",
+    "jiti": "^2.4.0"
+  },
+  "devDependencies": {
+    "@usegraft/sdk-core": "0.0.0-canary-20260831153011"
+  },
+  "engines": {
+    "node": ">=22.16"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  }
+}