@fourtwelvelabs/fetch-contentful 0.1.0 → 0.3.0

package/dist/cli/index.mjs

@@ -0,0 +1,949 @@
+#!/usr/bin/env node
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
+import { resolve, dirname, relative, isAbsolute, sep, join } from 'path';
+import { getIntrospectionQuery, printSchema, buildClientSchema } from 'graphql';
+
+// src/env.ts
+function orUndefined(value) {
+  return value || void 0;
+}
+function readEnvSettings() {
+  if (typeof process === "undefined" || !process.env) {
+    return {
+      space: void 0,
+      environment: void 0,
+      token: void 0,
+      previewToken: void 0
+    };
+  }
+  return {
+    space: orUndefined(
+      process.env.CONTENTFUL_SPACE_ID || process.env.NEXT_PUBLIC_CONTENTFUL_SPACE_ID
+    ),
+    environment: orUndefined(
+      process.env.CONTENTFUL_ENVIRONMENT || process.env.NEXT_PUBLIC_CONTENTFUL_ENVIRONMENT
+    ),
+    token: orUndefined(
+      process.env.CONTENTFUL_ACCESS_TOKEN || process.env.NEXT_PUBLIC_CONTENTFUL_ACCESS_TOKEN
+    ),
+    previewToken: orUndefined(
+      process.env.CONTENTFUL_PREVIEW_ACCESS_TOKEN || process.env.NEXT_PUBLIC_CONTENTFUL_PREVIEW_ACCESS_TOKEN
+    )
+  };
+}
+
+// src/cli/errors.ts
+var CliError = class extends Error {
+  name = "CliError";
+};
+function redact(text, token) {
+  if (!token) return text;
+  return text.split(token).join("[redacted]");
+}
+
+// src/cli/args.ts
+var BOOLEAN_FLAGS = ["dry-run", "force", "help"];
+var VALUE_FLAGS = [
+  "space",
+  "environment",
+  "token",
+  "schema-path",
+  "tada-output",
+  "graphql-file",
+  "tsconfig",
+  "cwd"
+];
+function isBooleanFlag(name) {
+  return BOOLEAN_FLAGS.includes(name);
+}
+function isValueFlag(name) {
+  return VALUE_FLAGS.includes(name);
+}
+function parseArgs(argv) {
+  const parsed = {
+    positionals: [],
+    values: {},
+    flags: /* @__PURE__ */ new Set()
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "-h") {
+      parsed.flags.add("help");
+      continue;
+    }
+    if (!argument.startsWith("--")) {
+      parsed.positionals.push(argument);
+      continue;
+    }
+    const equals = argument.indexOf("=");
+    const name = argument.slice(2, equals === -1 ? void 0 : equals);
+    const inlineValue = equals === -1 ? void 0 : argument.slice(equals + 1);
+    if (isBooleanFlag(name)) {
+      if (inlineValue !== void 0) {
+        throw new CliError(`--${name} does not take a value.`);
+      }
+      parsed.flags.add(name);
+      continue;
+    }
+    if (!isValueFlag(name)) {
+      throw new CliError(`Unknown option "--${name}".`);
+    }
+    const value = inlineValue ?? argv[++index];
+    if (value === void 0) {
+      throw new CliError(`--${name} needs a value.`);
+    }
+    parsed.values[name] = value;
+  }
+  return parsed;
+}
+
+// src/cli/diff.ts
+var MAX_LINES = 400;
+function lcsTable(before, after) {
+  const table = Array.from(
+    { length: before.length + 1 },
+    () => new Array(after.length + 1).fill(0)
+  );
+  for (let i = before.length - 1; i >= 0; i -= 1) {
+    for (let j = after.length - 1; j >= 0; j -= 1) {
+      const row = table[i];
+      const next = table[i + 1];
+      row[j] = before[i] === after[j] ? next[j + 1] + 1 : Math.max(next[j], row[j + 1]);
+    }
+  }
+  return table;
+}
+function lineDiff(before, after) {
+  if (before === after) return [];
+  const beforeLines = before.split("\n");
+  const afterLines = after.split("\n");
+  if (beforeLines.length + afterLines.length > MAX_LINES * 2) {
+    return [
+      `  (${String(beforeLines.length)} lines \u2192 ${String(
+        afterLines.length
+      )} lines; too large to diff)`
+    ];
+  }
+  const table = lcsTable(beforeLines, afterLines);
+  const output = [];
+  let i = 0;
+  let j = 0;
+  while (i < beforeLines.length && j < afterLines.length) {
+    if (beforeLines[i] === afterLines[j]) {
+      output.push(`   ${beforeLines[i]}`);
+      i += 1;
+      j += 1;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      output.push(` - ${beforeLines[i]}`);
+      i += 1;
+    } else {
+      output.push(` + ${afterLines[j]}`);
+      j += 1;
+    }
+  }
+  while (i < beforeLines.length) {
+    output.push(` - ${beforeLines[i]}`);
+    i += 1;
+  }
+  while (j < afterLines.length) {
+    output.push(` + ${afterLines[j]}`);
+    j += 1;
+  }
+  return output;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${String(bytes)} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} kB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var PACKAGE_NAME = "@fourtwelvelabs/fetch-contentful";
+function relativeSpecifier(fromFile, toFile) {
+  const path = relative(dirname(fromFile), toFile).split(sep).join("/");
+  return path.startsWith(".") ? path : `./${path}`;
+}
+function renderGraphqlModule(introspectionImport) {
+  return `/**
+ * gql.tada, bound to this space's schema.
+ *
+ * Generated by \`fetch-contentful tada-init\`. Safe to edit and to commit;
+ * re-running \`tada-init\` will not overwrite it without \`--force\`.
+ *
+ * Refresh the schema after a content-model change with:
+ *   fetch-contentful tada-refresh
+ */
+import { initGraphQLTada } from 'gql.tada';
+import type { ContentfulScalars } from '${PACKAGE_NAME}/tada';
+import type { introspection } from '${introspectionImport}';
+
+export const graphql = initGraphQLTada<{
+  introspection: introspection;
+  scalars: ContentfulScalars;
+}>();
+
+export { readFragment } from 'gql.tada';
+export type { FragmentOf, ResultOf, VariablesOf } from 'gql.tada';
+`;
+}
+function graphqlEndpoint(space, environment) {
+  return `https://graphql.contentful.com/content/v1/spaces/${encodeURIComponent(
+    space
+  )}/environments/${encodeURIComponent(environment)}`;
+}
+
+// src/cli/introspect.ts
+function bodySnippet(body, token) {
+  const cleaned = redact(body, token).trim();
+  if (cleaned === "") return "(empty response body)";
+  return cleaned.length > 300 ? `${cleaned.slice(0, 300)}\u2026` : cleaned;
+}
+async function fetchSchemaSdl(options) {
+  const url = graphqlEndpoint(options.space, options.environment);
+  let response;
+  try {
+    response = await options.fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${options.token}`
+      },
+      body: JSON.stringify({ query: getIntrospectionQuery() })
+    });
+  } catch (cause) {
+    throw new CliError(
+      `Could not reach Contentful at ${url}: ${redact(
+        String(cause),
+        options.token
+      )}`
+    );
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new CliError(
+      `Contentful rejected the access token (HTTP ${String(
+        response.status
+      )}).
+  Check that the token is a Content Delivery API token for space "${options.space}", and that it has access to environment "${options.environment}".`
+    );
+  }
+  if (!response.ok) {
+    const body = bodySnippet(await response.text().catch(() => ""), options.token);
+    throw new CliError(
+      `Contentful responded with HTTP ${String(response.status)}.
+  ${body}`
+    );
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new CliError("Contentful returned an unreadable response body.");
+  }
+  if (payload.errors && payload.errors.length > 0) {
+    const messages = payload.errors.map((error) => error.message ?? "unknown error").join("; ");
+    throw new CliError(
+      `Contentful returned GraphQL errors during introspection: ${redact(
+        messages,
+        options.token
+      )}`
+    );
+  }
+  if (!payload.data) {
+    throw new CliError(
+      "Contentful returned no introspection data. Check the space and environment ids."
+    );
+  }
+  try {
+    return `${printSchema(buildClientSchema(payload.data))}
+`;
+  } catch (cause) {
+    throw new CliError(
+      `Could not build a schema from Contentful's introspection response: ${String(
+        cause
+      )}`
+    );
+  }
+}
+var LOCKFILES = [
+  ["bun", "bun.lock"],
+  ["bun", "bun.lockb"],
+  ["pnpm", "pnpm-lock.yaml"],
+  ["yarn", "yarn.lock"],
+  ["npm", "package-lock.json"]
+];
+function detectPackageManager(cwd) {
+  for (const [manager, lockfile] of LOCKFILES) {
+    if (existsSync(join(cwd, lockfile))) return manager;
+  }
+  return "npm";
+}
+function installCommand(manager, packages) {
+  const list = packages.join(" ");
+  switch (manager) {
+    case "bun":
+      return `bun add -d ${list}`;
+    case "pnpm":
+      return `pnpm add -D ${list}`;
+    case "yarn":
+      return `yarn add -D ${list}`;
+    case "npm":
+      return `npm install -D ${list}`;
+  }
+}
+function missingDependencies(cwd, packages) {
+  let manifest;
+  try {
+    manifest = JSON.parse(
+      readFileSync(join(cwd, "package.json"), "utf8")
+    );
+  } catch {
+    return [...packages];
+  }
+  const declared = /* @__PURE__ */ new Set();
+  for (const field of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ]) {
+    const section = manifest[field];
+    if (typeof section === "object" && section !== null) {
+      for (const name of Object.keys(section)) declared.add(name);
+    }
+  }
+  return packages.filter((name) => !declared.has(name));
+}
+
+// src/cli/jsonc.ts
+var JsoncError = class extends Error {
+  name = "JsoncError";
+};
+var WHITESPACE = " 	\n\r";
+var Scanner = class {
+  constructor(source) {
+    this.source = source;
+  }
+  source;
+  index = 0;
+  /** Skips whitespace, `//` line comments and `/* *\/` block comments. */
+  skipTrivia() {
+    for (; ; ) {
+      while (this.index < this.source.length && WHITESPACE.includes(this.source[this.index])) {
+        this.index += 1;
+      }
+      if (this.source.startsWith("//", this.index)) {
+        const newline = this.source.indexOf("\n", this.index);
+        this.index = newline === -1 ? this.source.length : newline + 1;
+        continue;
+      }
+      if (this.source.startsWith("/*", this.index)) {
+        const close = this.source.indexOf("*/", this.index + 2);
+        if (close === -1) {
+          throw new JsoncError("Unterminated block comment.");
+        }
+        this.index = close + 2;
+        continue;
+      }
+      return;
+    }
+  }
+  peek() {
+    this.skipTrivia();
+    if (this.index >= this.source.length) {
+      throw new JsoncError("Unexpected end of input.");
+    }
+    return this.source[this.index];
+  }
+  expect(character) {
+    if (this.peek() !== character) {
+      throw new JsoncError(
+        `Expected "${character}" at offset ${String(this.index)}.`
+      );
+    }
+    this.index += 1;
+  }
+  parseRoot() {
+    const node = this.parseValue();
+    this.skipTrivia();
+    if (this.index !== this.source.length) {
+      throw new JsoncError(
+        `Unexpected trailing content at offset ${String(this.index)}.`
+      );
+    }
+    return node;
+  }
+  parseValue() {
+    const character = this.peek();
+    if (character === "{") return this.parseObject();
+    if (character === "[") return this.parseArray();
+    if (character === '"') return this.parseString();
+    return this.parseLiteral();
+  }
+  parseObject() {
+    const start = this.index;
+    this.expect("{");
+    const members = [];
+    for (; ; ) {
+      if (this.peek() === "}") {
+        this.index += 1;
+        return { kind: "object", start, end: this.index, members };
+      }
+      const memberStart = this.index;
+      const key = this.parseString();
+      this.expect(":");
+      const value = this.parseValue();
+      members.push({
+        key: key.value,
+        start: memberStart,
+        end: value.end,
+        value
+      });
+      if (this.peek() === ",") {
+        this.index += 1;
+      }
+    }
+  }
+  parseArray() {
+    const start = this.index;
+    this.expect("[");
+    const elements = [];
+    for (; ; ) {
+      if (this.peek() === "]") {
+        this.index += 1;
+        return { kind: "array", start, end: this.index, elements };
+      }
+      elements.push(this.parseValue());
+      if (this.peek() === ",") {
+        this.index += 1;
+      }
+    }
+  }
+  parseString() {
+    this.skipTrivia();
+    const start = this.index;
+    if (this.source[start] !== '"') {
+      throw new JsoncError(`Expected a string at offset ${String(start)}.`);
+    }
+    this.index += 1;
+    while (this.index < this.source.length) {
+      const character = this.source[this.index];
+      if (character === "\\") {
+        this.index += 2;
+        continue;
+      }
+      this.index += 1;
+      if (character === '"') {
+        const end = this.index;
+        return {
+          kind: "string",
+          start,
+          end,
+          value: JSON.parse(this.source.slice(start, end))
+        };
+      }
+    }
+    throw new JsoncError(`Unterminated string at offset ${String(start)}.`);
+  }
+  /** Numbers, `true`, `false` and `null` — read as an opaque token. */
+  parseLiteral() {
+    this.skipTrivia();
+    const start = this.index;
+    while (this.index < this.source.length && !",]}".includes(this.source[this.index]) && !WHITESPACE.includes(this.source[this.index])) {
+      this.index += 1;
+    }
+    if (this.index === start) {
+      throw new JsoncError(`Unexpected character at offset ${String(start)}.`);
+    }
+    return { kind: "literal", start, end: this.index };
+  }
+};
+function parseJsonc(source) {
+  return new Scanner(source).parseRoot();
+}
+function findMember(node, key) {
+  if (node.kind !== "object") return void 0;
+  return node.members.find((member) => member.key === key);
+}
+
+// src/cli/tsconfig.ts
+var GRAPHQLSP_PLUGIN = "@0no-co/graphqlsp";
+function applyEdits(source, edits) {
+  let result = source;
+  for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return result;
+}
+function indentAt(source, offset) {
+  const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+  const line = source.slice(lineStart, offset);
+  return line.slice(0, line.length - line.trimStart().length);
+}
+function detectIndentUnit(source) {
+  const match = /\n([ \t]+)\S/.exec(source);
+  return match?.[1] ?? "  ";
+}
+function renderPluginEntry(indent, unit, config) {
+  return [
+    "{",
+    `${indent}${unit}"name": ${JSON.stringify(GRAPHQLSP_PLUGIN)},`,
+    `${indent}${unit}"schema": ${JSON.stringify(config.schema)},`,
+    `${indent}${unit}"tadaOutputLocation": ${JSON.stringify(
+      config.tadaOutputLocation
+    )}`,
+    `${indent}}`
+  ].join("\n");
+}
+function insertMember(source, object, key, renderValue, unit) {
+  const last = object.members[object.members.length - 1];
+  if (last) {
+    const indent2 = indentAt(source, last.start);
+    return {
+      start: last.end,
+      end: last.end,
+      text: `,
+${indent2}"${key}": ${renderValue(indent2)}`
+    };
+  }
+  const closeIndent = indentAt(source, object.start);
+  const indent = `${closeIndent}${unit}`;
+  return {
+    start: object.start + 1,
+    end: object.end - 1,
+    text: `
+${indent}"${key}": ${renderValue(indent)}
+${closeIndent}`
+  };
+}
+function renderPluginsArray(indent, unit, config) {
+  const entryIndent = `${indent}${unit}`;
+  return `[
+${entryIndent}${renderPluginEntry(
+    entryIndent,
+    unit,
+    config
+  )}
+${indent}]`;
+}
+function patchTsconfig(source, config) {
+  let root;
+  try {
+    root = parseJsonc(source);
+  } catch (cause) {
+    const reason = cause instanceof JsoncError ? cause.message : String(cause);
+    return { status: "manual", reason: `could not be parsed (${reason})` };
+  }
+  if (root.kind !== "object") {
+    return { status: "manual", reason: "its root is not an object" };
+  }
+  const unit = detectIndentUnit(source);
+  const compilerOptions = findMember(root, "compilerOptions");
+  if (!compilerOptions) {
+    const edit = insertMember(
+      source,
+      root,
+      "compilerOptions",
+      (indent) => `{
+${indent}${unit}"plugins": ${renderPluginsArray(
+        `${indent}${unit}`,
+        unit,
+        config
+      )}
+${indent}}`,
+      unit
+    );
+    return { status: "patched", source: applyEdits(source, [edit]) };
+  }
+  if (compilerOptions.value.kind !== "object") {
+    return { status: "manual", reason: '"compilerOptions" is not an object' };
+  }
+  const plugins = findMember(compilerOptions.value, "plugins");
+  if (!plugins) {
+    const edit = insertMember(
+      source,
+      compilerOptions.value,
+      "plugins",
+      (indent) => renderPluginsArray(indent, unit, config),
+      unit
+    );
+    return { status: "patched", source: applyEdits(source, [edit]) };
+  }
+  if (plugins.value.kind !== "array") {
+    return { status: "manual", reason: '"compilerOptions.plugins" is not an array' };
+  }
+  const existing = plugins.value.elements.find((element) => {
+    const name = findMember(element, "name");
+    return name?.value.kind === "string" && name.value.value === GRAPHQLSP_PLUGIN;
+  });
+  if (existing) {
+    if (existing.kind !== "object") {
+      return { status: "manual", reason: "its graphqlsp plugin entry is not an object" };
+    }
+    const edits = [];
+    for (const [key, value] of [
+      ["schema", config.schema],
+      ["tadaOutputLocation", config.tadaOutputLocation]
+    ]) {
+      const member = findMember(existing, key);
+      if (member) {
+        edits.push({
+          start: member.value.start,
+          end: member.value.end,
+          text: JSON.stringify(value)
+        });
+      } else {
+        edits.push(
+          insertMember(source, existing, key, () => JSON.stringify(value), unit)
+        );
+      }
+    }
+    const patched = applyEdits(source, edits);
+    return patched === source ? { status: "unchanged" } : { status: "patched", source: patched };
+  }
+  const last = plugins.value.elements[plugins.value.elements.length - 1];
+  if (last) {
+    const indent = indentAt(source, last.start);
+    return {
+      status: "patched",
+      source: applyEdits(source, [
+        {
+          start: last.end,
+          end: last.end,
+          text: `,
+${indent}${renderPluginEntry(indent, unit, config)}`
+        }
+      ])
+    };
+  }
+  const closeIndent = indentAt(source, plugins.value.start);
+  const entryIndent = `${closeIndent}${unit}`;
+  return {
+    status: "patched",
+    source: applyEdits(source, [
+      {
+        start: plugins.value.start + 1,
+        end: plugins.value.end - 1,
+        text: `
+${entryIndent}${renderPluginEntry(
+          entryIndent,
+          unit,
+          config
+        )}
+${closeIndent}`
+      }
+    ])
+  };
+}
+function manualPluginBlock(config) {
+  return renderPluginEntry("", "  ", config);
+}
+
+// src/cli/run.ts
+var REQUIRED_PEERS = ["gql.tada", GRAPHQLSP_PLUGIN];
+var DEFAULTS = {
+  schemaPath: "./contentful-schema.graphql",
+  tadaOutput: "./src/contentful-env.d.ts",
+  graphqlFile: "./src/graphql.ts",
+  tsconfig: "./tsconfig.json"
+};
+var VERB_WIDTH = 12;
+var HELP = `fetch-contentful \u2014 gql.tada setup for a Contentful space
+
+Usage:
+  fetch-contentful tada-init [options]      Set up gql.tada in this project
+  fetch-contentful tada-refresh [options]   Re-download the schema only
+
+Configuration (flags win over environment variables):
+  --space <id>            CONTENTFUL_SPACE_ID
+  --environment <id>      CONTENTFUL_ENVIRONMENT (default "master")
+  --token <token>         CONTENTFUL_ACCESS_TOKEN (Content Delivery API)
+
+Paths (relative to the working directory):
+  --schema-path <path>    default ${DEFAULTS.schemaPath}
+  --tada-output <path>    default ${DEFAULTS.tadaOutput}
+  --graphql-file <path>   default ${DEFAULTS.graphqlFile}
+  --tsconfig <path>       default ${DEFAULTS.tsconfig}
+
+Other:
+  --dry-run               Show what would change; write nothing
+  --force                 Overwrite an existing graphql file (tada-init)
+  --cwd <path>            Run against another directory
+  -h, --help              Show this help
+
+The NEXT_PUBLIC_-prefixed variable names are read as fallbacks, exactly as
+the library reads them at runtime.`;
+function resolveConfig(args) {
+  const env = readEnvSettings();
+  const space = args.values.space ?? env.space;
+  const token = args.values.token ?? env.token;
+  const environment = args.values.environment ?? env.environment ?? "master";
+  const missing = [];
+  if (!space) {
+    missing.push(
+      "space (pass --space, or set CONTENTFUL_SPACE_ID / NEXT_PUBLIC_CONTENTFUL_SPACE_ID)"
+    );
+  }
+  if (!token) {
+    missing.push(
+      "access token (pass --token, or set CONTENTFUL_ACCESS_TOKEN / NEXT_PUBLIC_CONTENTFUL_ACCESS_TOKEN)"
+    );
+  }
+  if (!space || !token) {
+    throw new CliError(
+      `Missing required Contentful configuration:
+  - ${missing.join(
+        "\n  - "
+      )}`
+    );
+  }
+  return { space, environment, token };
+}
+function resolvePaths(args, io) {
+  const root = resolve(io.cwd, args.values.cwd ?? ".");
+  const at = (value, fallback) => resolve(root, value ?? fallback);
+  return {
+    root,
+    schema: at(args.values["schema-path"], DEFAULTS.schemaPath),
+    tadaOutput: at(args.values["tada-output"], DEFAULTS.tadaOutput),
+    graphqlFile: at(args.values["graphql-file"], DEFAULTS.graphqlFile),
+    tsconfig: at(args.values.tsconfig, DEFAULTS.tsconfig)
+  };
+}
+function display(root, path) {
+  const shown = relative(root, path);
+  return shown === "" || shown.startsWith("..") || isAbsolute(shown) ? path : shown;
+}
+function readIfExists(path) {
+  return existsSync(path) ? readFileSync(path, "utf8") : void 0;
+}
+function planSchema(sdl, paths) {
+  const before = readIfExists(paths.schema);
+  if (before === sdl) return { kind: "unchanged", path: paths.schema };
+  return {
+    kind: "write",
+    path: paths.schema,
+    before,
+    after: sdl,
+    preview: "size"
+  };
+}
+function planTsconfig(paths) {
+  const before = readIfExists(paths.tsconfig);
+  if (before === void 0) {
+    throw new CliError(
+      `No tsconfig at ${display(paths.root, paths.tsconfig)}. Pass --tsconfig if it lives elsewhere.`
+    );
+  }
+  const config = {
+    schema: relativeSpecifier(paths.tsconfig, paths.schema),
+    tadaOutputLocation: relativeSpecifier(paths.tsconfig, paths.tadaOutput)
+  };
+  const result = patchTsconfig(before, config);
+  if (result.status === "unchanged") {
+    return { kind: "unchanged", path: paths.tsconfig };
+  }
+  if (result.status === "manual") {
+    return {
+      kind: "manual",
+      path: paths.tsconfig,
+      reason: result.reason,
+      block: manualPluginBlock(config)
+    };
+  }
+  return {
+    kind: "write",
+    path: paths.tsconfig,
+    before,
+    after: result.source,
+    preview: "diff"
+  };
+}
+function planGraphqlModule(paths, force) {
+  const before = readIfExists(paths.graphqlFile);
+  const after = renderGraphqlModule(
+    relativeSpecifier(paths.graphqlFile, paths.tadaOutput)
+  );
+  if (before !== void 0 && !force) {
+    return {
+      kind: "skip",
+      path: paths.graphqlFile,
+      reason: "already exists; pass --force to overwrite"
+    };
+  }
+  if (before === after) return { kind: "unchanged", path: paths.graphqlFile };
+  return {
+    kind: "write",
+    path: paths.graphqlFile,
+    before,
+    after,
+    preview: "content"
+  };
+}
+function logAction(io, verb, detail) {
+  io.stdout(`  ${verb.padEnd(VERB_WIDTH)} ${detail}`);
+}
+function report(action, paths, dryRun, io) {
+  const name = display(paths.root, action.path);
+  if (action.kind === "unchanged") {
+    logAction(io, "unchanged", name);
+    return;
+  }
+  if (action.kind === "skip") {
+    logAction(io, "skipped", `${name} (${action.reason})`);
+    return;
+  }
+  if (action.kind === "manual") {
+    logAction(io, "manual", `${name} (${action.reason})`);
+    return;
+  }
+  const created = action.before === void 0;
+  const verb = dryRun ? created ? "would create" : "would update" : created ? "created" : "updated";
+  const size = action.preview === "size" ? ` (${formatBytes(Buffer.byteLength(action.after))})` : "";
+  logAction(io, verb, `${name}${size}`);
+  if (!dryRun) return;
+  if (action.preview === "content") {
+    for (const line of action.after.replace(/\n$/, "").split("\n")) {
+      io.stdout(`   + ${line}`);
+    }
+    return;
+  }
+  if (action.before === void 0) return;
+  if (action.preview === "diff") {
+    for (const line of lineDiff(action.before, action.after)) {
+      io.stdout(`  ${line}`);
+    }
+    return;
+  }
+  const beforeBytes = Buffer.byteLength(action.before);
+  const afterBytes = Buffer.byteLength(action.after);
+  const delta = afterBytes - beforeBytes;
+  io.stdout(
+    `     ${String(beforeBytes)} \u2192 ${String(afterBytes)} bytes (${delta >= 0 ? "+" : ""}${String(delta)})`
+  );
+}
+function apply(action) {
+  if (action.kind !== "write") return;
+  mkdirSync(dirname(action.path), { recursive: true });
+  writeFileSync(action.path, action.after, "utf8");
+}
+function reportManual(action, paths, io) {
+  if (action.kind !== "manual") return;
+  io.stdout("");
+  io.stdout(
+    `${display(paths.root, action.path)} was left untouched because ${action.reason}.`
+  );
+  io.stdout('Add this entry to "compilerOptions.plugins" by hand:');
+  io.stdout("");
+  for (const line of action.block.split("\n")) io.stdout(`  ${line}`);
+}
+function reportPeers(paths, io) {
+  const missing = missingDependencies(paths.root, REQUIRED_PEERS);
+  if (missing.length === 0) return;
+  io.stdout("");
+  io.stdout(`Install the packages the generated setup needs:`);
+  io.stdout(`  ${installCommand(detectPackageManager(paths.root), missing)}`);
+}
+async function tadaInit(args, io) {
+  const config = resolveConfig(args);
+  const paths = resolvePaths(args, io);
+  const dryRun = args.flags.has("dry-run");
+  const tsconfigAction = planTsconfig(paths);
+  const sdl = await fetchSchemaSdl({ ...config, fetch: io.fetch });
+  const actions = [
+    planSchema(sdl, paths),
+    tsconfigAction,
+    planGraphqlModule(paths, args.flags.has("force"))
+  ];
+  io.stdout(
+    dryRun ? `Dry run \u2014 nothing will be written (space ${config.space}, environment ${config.environment}).` : `Configuring gql.tada for space ${config.space}, environment ${config.environment}.`
+  );
+  for (const action of actions) {
+    if (!dryRun) apply(action);
+    report(action, paths, dryRun, io);
+  }
+  for (const action of actions) reportManual(action, paths, io);
+  reportPeers(paths, io);
+  if (dryRun) return 0;
+  io.stdout("");
+  io.stdout("Next steps:");
+  io.stdout(`  1. Restart the TypeScript server so ${GRAPHQLSP_PLUGIN} loads.`);
+  io.stdout(
+    `  2. Write a query with the \`graphql\` helper from ${display(
+      paths.root,
+      paths.graphqlFile
+    )},`
+  );
+  io.stdout(
+    `     then pass it to fetchContentful from ${PACKAGE_NAME}.`
+  );
+  io.stdout("     Result and variable types are inferred from the document.");
+  io.stdout(
+    "  3. After a content-model change, run `fetch-contentful tada-refresh`."
+  );
+  return 0;
+}
+async function tadaRefresh(args, io) {
+  const config = resolveConfig(args);
+  const paths = resolvePaths(args, io);
+  const dryRun = args.flags.has("dry-run");
+  const sdl = await fetchSchemaSdl({ ...config, fetch: io.fetch });
+  const action = planSchema(sdl, paths);
+  if (action.kind === "unchanged") {
+    io.stdout(
+      `Schema is already up to date \u2014 ${display(
+        paths.root,
+        paths.schema
+      )} left untouched.`
+    );
+    return 0;
+  }
+  if (!dryRun) apply(action);
+  report(action, paths, dryRun, io);
+  return 0;
+}
+async function dispatch(argv, io) {
+  const args = parseArgs(argv);
+  const command = args.positionals.join("-");
+  if (args.flags.has("help") || command === "" || command === "help") {
+    io.stdout(HELP);
+    return 0;
+  }
+  if (command === "tada-init") return tadaInit(args, io);
+  if (command === "tada-refresh") return tadaRefresh(args, io);
+  throw new CliError(
+    `Unknown command "${args.positionals.join(
+      " "
+    )}". Run with --help to see the available commands.`
+  );
+}
+function knownTokens(argv) {
+  const env = readEnvSettings();
+  const tokens = [env.token, env.previewToken];
+  for (const [index, argument] of argv.entries()) {
+    if (argument.startsWith("--token=")) tokens.push(argument.slice(8));
+    else if (argument === "--token") tokens.push(argv[index + 1]);
+  }
+  return tokens;
+}
+async function run(argv, io) {
+  try {
+    return await dispatch(argv, io);
+  } catch (error) {
+    const raw = error instanceof CliError ? error.message : `Unexpected failure: ${String(error)}`;
+    let message = raw;
+    for (const token of knownTokens(argv)) message = redact(message, token);
+    io.stderr(`error: ${message}`);
+    return 1;
+  }
+}
+
+// src/cli/index.ts
+var code = await run(process.argv.slice(2), {
+  cwd: process.cwd(),
+  fetch: globalThis.fetch,
+  stdout: (line) => process.stdout.write(`${line}
+`),
+  stderr: (line) => process.stderr.write(`${line}
+`)
+});
+process.exitCode = code;
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map