@usegraft/cli 0.1.0

package/dist/merge-CZUNMMB5.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+import {
+  discoverMigrations
+} from "./chunk-LTFTDG6Z.js";
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-BUPFXTUG.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,
+        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-RRW4Z6RB.js

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

package/dist/serve-Q63UTTER.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import {
+  createNodeListener,
+  createServeRouter,
+  serveCommand,
+  startServe
+} from "./chunk-TUWL7WFD.js";
+import "./chunk-BUPFXTUG.js";
+export {
+  createNodeListener,
+  createServeRouter,
+  serveCommand,
+  startServe
+};

package/dist/studio-TNPOB665.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import {
+  createNodeListener
+} from "./chunk-TUWL7WFD.js";
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-BUPFXTUG.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 operatorName() {
+  try {
+    return userInfo().username;
+  } catch {
+    return 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 authorize = !loopback && devToken ? (request) => {
+    const header = request.headers.get("authorization") ?? "";
+    return header === `Bearer ${devToken}`;
+  } : !loopback ? () => false : void 0;
+  const handler = createStudioHandler({
+    db: branch.db,
+    collections: config.collections,
+    contentDir: config.contentDir,
+    defaultBranch: writeBranch,
+    decidedBy: operatorName,
+    authorize
+  });
+  const server = createServer(createNodeListener(handler));
+  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,46 @@
+{
+  "name": "@usegraft/cli",
+  "version": "0.1.0",
+  "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": {
+    "jiti": "^2.4.0",
+    "@usegraft/content-migrations": "0.1.0",
+    "@usegraft/compiler": "0.1.0",
+    "@usegraft/auth": "0.1.0",
+    "@usegraft/assets": "0.1.0",
+    "@usegraft/core": "0.1.0",
+    "@usegraft/contracts": "0.1.0",
+    "@usegraft/db": "0.1.0",
+    "@usegraft/mcp": "0.1.0",
+    "@usegraft/registry": "0.1.0",
+    "@usegraft/studio": "0.1.0"
+  },
+  "devDependencies": {
+    "@usegraft/sdk-core": "0.1.0"
+  },
+  "engines": {
+    "node": ">=22.16"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "lint": "oxlint ."
+  }
+}