@malloy-publisher/create-malloy-package 0.0.1

package/dist/index.js

@@ -0,0 +1,1869 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import * as crypto from "node:crypto";
+import * as fs5 from "node:fs";
+import * as path4 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { Command, Option } from "commander";
+
+// src/errors.ts
+class ScaffoldError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ScaffoldError";
+  }
+}
+
+// src/log.ts
+var useColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+function paint(code, text) {
+  return useColor ? `\x1B[${code}m${text}\x1B[0m` : text;
+}
+var bold = (text) => paint("1", text);
+var dim = (text) => paint("2", text);
+var green = (text) => paint("32", text);
+var cyan = (text) => paint("36", text);
+var yellow = (text) => paint("33", text);
+var red = (text) => paint("31", text);
+
+// src/names.ts
+var SAFE_NAME_RE = /^(?!\.\.?$)(?!\.)[A-Za-z0-9._-]+$/;
+var MAX_FILENAME = 255;
+var MAX_PACKAGE_NAME = MAX_FILENAME - ".malloy".length;
+function validatePackageName(name) {
+  if (!SAFE_NAME_RE.test(name)) {
+    throw new ScaffoldError(`Invalid package name "${preview(name)}": use letters, digits, "-", ` + `"_", or "." and do not start with ".".`);
+  }
+  if (name.length > MAX_PACKAGE_NAME) {
+    throw new ScaffoldError(`Package name is ${name.length} characters; the limit is ` + `${MAX_PACKAGE_NAME}, because the package also holds a ` + `"<name>.malloy" model file and a filename cannot exceed ` + `${MAX_FILENAME} characters.`);
+  }
+  const modelFile = `${toMalloyIdentifier(name)}.malloy`;
+  if (modelFile.length > MAX_FILENAME) {
+    throw new ScaffoldError(`Package name "${preview(name)}" would need a model file named ` + `"${modelFile}", ` + `which is ${modelFile.length} characters and cannot be written ` + `(the limit is ${MAX_FILENAME}). Shorten the name by ` + `${modelFile.length - MAX_FILENAME}.`);
+  }
+}
+var MAX_ENVIRONMENT_NAME = 255;
+function validateEnvironmentName(name) {
+  if (typeof name !== "string") {
+    throw new ScaffoldError(`publisher.config.json has an environment whose "name" is ` + `${name === null ? "null" : typeof name}, not a string. This tool ` + `writes that name into the start and reset commands, into ` + `AGENTS.md, and into the REST URLs it prints, where it would read ` + `as "${String(name)}". Give the environment a name, then run again.`);
+  }
+  if (!SAFE_NAME_RE.test(name)) {
+    throw new ScaffoldError(`Invalid environment name "${preview(name)}" in ` + `publisher.config.json${describeUnsafeCharacter(name)}: use ` + `letters, digits, "-", "_", or "." and do not start with ".". ` + `This tool writes the environment name into the ` + `--watch-env argument of the start and reset commands and into the ` + `shell blocks in AGENTS.md, so anything outside that set would be ` + `run as part of those commands. Publisher rejects the same names ` + `on its own URLs. Rename the environment, then run again.`);
+  }
+  if (name.length > MAX_ENVIRONMENT_NAME) {
+    throw new ScaffoldError(`Environment name "${preview(name)}" in publisher.config.json is ` + `${name.length} characters; the limit is ${MAX_ENVIRONMENT_NAME}, ` + `which is what Publisher accepts in a URL. Rename the environment, ` + `then run again.`);
+  }
+}
+function preview(value, max = 60) {
+  const shortened = value.length > max ? `${value.slice(0, max)}...` : value;
+  return printable(shortened);
+}
+function printable(value) {
+  let out = "";
+  for (const character of value) {
+    out += isControl(character) ? escapeCharacter(character) : character;
+  }
+  return out;
+}
+function isControl(character) {
+  const code = character.codePointAt(0);
+  return code < 32 || code === 127 || code >= 128 && code <= 159 || code === 8232 || code === 8233 || code === 8206 || code === 8207 || code === 1564 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297;
+}
+function escapeCharacter(character) {
+  switch (character) {
+    case `
+`:
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "\t":
+      return "\\t";
+    default:
+      return `\\u${codePointHex(character)}`;
+  }
+}
+function codePointHex(character) {
+  const code = character.codePointAt(0);
+  return code.toString(16).toUpperCase().padStart(4, "0");
+}
+function describeUnsafeCharacter(name) {
+  for (const character of name) {
+    if (/[A-Za-z0-9._-]/.test(character)) {
+      continue;
+    }
+    const code = character.codePointAt(0);
+    const shown = character === " " ? "a space" : character.trim() === "" || code < 32 || code === 127 ? `U+${codePointHex(character)}` : `"${printable(character)}"`;
+    return ` (the first character it cannot hold is ${shown})`;
+  }
+  return "";
+}
+var MALLOY_RESERVED = new Set([
+  "all",
+  "and",
+  "as",
+  "asc",
+  "avg",
+  "boolean",
+  "by",
+  "case",
+  "cast",
+  "compose",
+  "count",
+  "date",
+  "day",
+  "desc",
+  "distinct",
+  "else",
+  "end",
+  "exclude",
+  "export",
+  "extend",
+  "false",
+  "filter",
+  "for",
+  "from",
+  "full",
+  "has",
+  "hour",
+  "import",
+  "in",
+  "include",
+  "inner",
+  "internal",
+  "is",
+  "json",
+  "left",
+  "like",
+  "max",
+  "min",
+  "minute",
+  "month",
+  "not",
+  "now",
+  "null",
+  "number",
+  "on",
+  "or",
+  "pick",
+  "private",
+  "public",
+  "quarter",
+  "right",
+  "second",
+  "source",
+  "sql",
+  "string",
+  "sum",
+  "table",
+  "then",
+  "this",
+  "timestamp",
+  "timestamptz",
+  "to",
+  "true",
+  "virtual",
+  "week",
+  "when",
+  "with",
+  "year",
+  "abs",
+  "acos",
+  "ascii",
+  "asin",
+  "atan",
+  "atan2",
+  "avg_moving",
+  "byte_length",
+  "ceil",
+  "chr",
+  "coalesce",
+  "concat",
+  "cos",
+  "dense_rank",
+  "div",
+  "ends_with",
+  "exp",
+  "first_value",
+  "floor",
+  "greatest",
+  "ifnull",
+  "is_inf",
+  "is_nan",
+  "lag",
+  "last_value",
+  "lead",
+  "least",
+  "length",
+  "ln",
+  "log",
+  "lower",
+  "ltrim",
+  "max_cumulative",
+  "max_window",
+  "min_cumulative",
+  "min_window",
+  "nullif",
+  "pi",
+  "pow",
+  "rand",
+  "rank",
+  "regexp_extract",
+  "replace",
+  "round",
+  "row_number",
+  "rtrim",
+  "sign",
+  "sin",
+  "sql_boolean",
+  "sql_date",
+  "sql_number",
+  "sql_string",
+  "sql_timestamp",
+  "sqrt",
+  "starts_with",
+  "stddev",
+  "string_repeat",
+  "strpos",
+  "substr",
+  "sum_cumulative",
+  "sum_moving",
+  "sum_window",
+  "tan",
+  "trim",
+  "trunc",
+  "unicode",
+  "upper"
+]);
+function toMalloyIdentifier(name) {
+  let identifier = name.replace(/[^A-Za-z0-9_]/g, "_");
+  if (/^[0-9]/.test(identifier)) {
+    identifier = `_${identifier}`;
+  }
+  if (MALLOY_RESERVED.has(identifier.toLowerCase())) {
+    identifier = `${identifier}_source`;
+  }
+  return identifier;
+}
+
+// src/scaffold.ts
+import * as fs4 from "node:fs";
+import * as path3 from "node:path";
+
+// src/config.ts
+import * as fs from "node:fs";
+function shown(value, max = 120) {
+  const text = typeof value === "string" ? value : String(value);
+  return printable(text.length > max ? `${text.slice(0, max)}...` : text);
+}
+function defaultConfig(envName, pkg) {
+  return {
+    frozenConfig: false,
+    environments: [
+      {
+        name: envName,
+        packages: pkg ? [pkg] : [],
+        connections: []
+      }
+    ]
+  };
+}
+function parseJson(text) {
+  return JSON.parse(text.replace(/^\uFEFF/, ""));
+}
+function asJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function describeJsonValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "an array";
+  }
+  if (typeof value === "object") {
+    return "an object";
+  }
+  return `a ${typeof value}`;
+}
+function readConfig(configPath) {
+  let parsed;
+  try {
+    parsed = parseJson(fs.readFileSync(configPath, "utf8"));
+  } catch (err) {
+    throw new ScaffoldError(`Could not parse ${shown(configPath)}: ` + `${shown(err.message, 200)}. ` + `Fix or remove it, then run again.`);
+  }
+  if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.environments)) {
+    throw new ScaffoldError(`${shown(configPath)} is not a Publisher config (no "environments" array). ` + `Fix or remove it, then run again.`);
+  }
+  const config = parsed;
+  assertConfigShape(configPath, config);
+  return config;
+}
+function assertConfigShape(configPath, config) {
+  const total = config.environments.length;
+  config.environments.forEach((env, index) => {
+    const where = `entry ${index + 1} of ${total} in "environments"`;
+    if (!asJsonObject(env)) {
+      throw new ScaffoldError(`${shown(configPath)} has an environment that is ` + `${describeJsonValue(env)} rather than a JSON object ` + `(${where}). Publisher cannot load that file, and this tool ` + `cannot register a package in it. Fix or remove it, then run ` + `again.`);
+    }
+    if (env.packages === undefined) {
+      return;
+    }
+    if (!Array.isArray(env.packages)) {
+      throw new ScaffoldError(`${shown(configPath)} has an environment whose "packages" is ` + `${describeJsonValue(env.packages)} rather than an array ` + `(${where}). Registering a package there would replace that ` + `value with a list holding only the new package, so nothing was ` + `written. Fix or remove it, then run again.`);
+    }
+    env.packages.forEach((pkg, pkgIndex) => {
+      if (!asJsonObject(pkg)) {
+        throw new ScaffoldError(`${shown(configPath)} has a package that is ${describeJsonValue(pkg)} ` + `rather than a JSON object (entry ${pkgIndex + 1} of ` + `${env.packages.length} in the "packages" of ` + `${where}). Publisher cannot load that file, and this tool ` + `cannot tell whether the name you asked for is already taken ` + `by it. Fix or remove it, then run again.`);
+      }
+    });
+  });
+}
+function writeConfig(configPath, config) {
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + `
+`);
+}
+function targetEnvironment(config, envName) {
+  const environments = config.environments.filter((candidate) => asJsonObject(candidate) !== undefined);
+  return environments.find((candidate) => candidate.name === envName) ?? environments[0];
+}
+function resolveEnvironmentName(config, envName) {
+  return targetEnvironment(config, envName)?.name ?? envName;
+}
+function environmentPackageCount(config, envName) {
+  const env = targetEnvironment(config, envName);
+  return Array.isArray(env?.packages) ? env.packages.length : 0;
+}
+function environmentPackageNames(config, envName) {
+  const env = targetEnvironment(config, envName);
+  if (!Array.isArray(env?.packages)) {
+    return [];
+  }
+  return env.packages.map((entry) => asJsonObject(entry)?.name).filter((name) => typeof name === "string");
+}
+function assertCanAddPackage(config, envName, pkg) {
+  if (config.frozenConfig === true) {
+    throw new ScaffoldError(`publisher.config.json has "frozenConfig": true, which forbids adding ` + `packages. Set it to false, or register "${shown(pkg.name)}" by hand.`);
+  }
+  const env = targetEnvironment(config, envName);
+  const existing = Array.isArray(env?.packages) ? env.packages.find((entry) => asJsonObject(entry)?.name === pkg.name) : undefined;
+  if (existing && existing.location !== pkg.location) {
+    throw new ScaffoldError(`Package "${shown(pkg.name)}" is already registered in environment ` + `"${shown(env?.name)}" at a different location ` + `("${shown(existing.location)}"). ` + `Choose another name.`);
+  }
+}
+function addPackage(config, envName, pkg) {
+  assertCanAddPackage(config, envName, pkg);
+  let env = targetEnvironment(config, envName);
+  if (!env) {
+    env = { name: envName, packages: [], connections: [] };
+    config.environments.push(env);
+  }
+  if (!Array.isArray(env.packages)) {
+    env.packages = [];
+  }
+  if (env.packages.some((entry) => asJsonObject(entry)?.name === pkg.name)) {
+    return { added: false, envName: env.name };
+  }
+  env.packages.push(pkg);
+  return { added: true, envName: env.name };
+}
+
+// src/skills.ts
+import * as fs2 from "node:fs";
+import * as path from "node:path";
+import { skillsDir } from "@malloy-publisher/skills";
+function assertSkillsAvailable() {
+  if (countSkills(skillsDir) === 0) {
+    throw new ScaffoldError(`No Malloy skills found in ${skillsDir}. The @malloy-publisher/skills ` + `install looks incomplete; reinstall create-malloy-package and run again.`);
+  }
+}
+function installSkills(targetDir, workspaceRoot) {
+  const empty = { installed: 0, skipped: [], refreshed: [], removed: [] };
+  if (isSymlink(targetDir)) {
+    return {
+      ...empty,
+      refused: "it is a symlink, so writing into it would edit whatever it points at"
+    };
+  }
+  if (!isWithinDirectory(targetDir, workspaceRoot)) {
+    return {
+      ...empty,
+      refused: "it resolves outside the workspace, so writing into it would put " + "files somewhere else on this machine"
+    };
+  }
+  fs2.mkdirSync(targetDir, { recursive: true });
+  const skipped = [];
+  const refreshed = [];
+  const removed = [];
+  let installed = 0;
+  for (const entry of fs2.readdirSync(skillsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const source = path.join(skillsDir, entry.name);
+    if (!fs2.existsSync(path.join(source, "SKILL.md"))) {
+      continue;
+    }
+    const target = path.join(targetDir, entry.name);
+    if (isSymlink(target)) {
+      skipped.push(entry.name);
+      continue;
+    }
+    if (fs2.existsSync(target)) {
+      refreshed.push(entry.name);
+      for (const relative of pathsNotIn(target, source)) {
+        removed.push(path.join(entry.name, relative));
+      }
+    }
+    fs2.rmSync(target, { recursive: true, force: true });
+    fs2.cpSync(source, target, { recursive: true });
+    installed += 1;
+  }
+  return { installed, skipped, refreshed, removed };
+}
+function pathsNotIn(target, source, prefix = "") {
+  let entries;
+  try {
+    entries = fs2.readdirSync(path.join(target, prefix), {
+      withFileTypes: true
+    });
+  } catch {
+    return [];
+  }
+  const missing = [];
+  for (const entry of entries) {
+    const relative = path.join(prefix, entry.name);
+    if (!fs2.existsSync(path.join(source, relative))) {
+      missing.push(entry.isDirectory() ? relative + path.sep : relative);
+      continue;
+    }
+    if (entry.isDirectory()) {
+      missing.push(...pathsNotIn(target, source, relative));
+    }
+  }
+  return missing;
+}
+function countSkills(dir) {
+  if (!fs2.existsSync(dir)) {
+    return 0;
+  }
+  return fs2.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && fs2.existsSync(path.join(dir, entry.name, "SKILL.md"))).length;
+}
+function isWithinDirectory(target, root) {
+  const realRoot = realPathOf(root);
+  const realTarget = realPathOf(target);
+  return realTarget === realRoot || realTarget.startsWith(realRoot + path.sep);
+}
+function realPathOf(target, hops = 0) {
+  const resolved = path.resolve(target);
+  const parent = path.dirname(resolved);
+  if (parent === resolved) {
+    return resolved;
+  }
+  const here = path.join(realPathOf(parent, hops), path.basename(resolved));
+  if (hops >= 40) {
+    return here;
+  }
+  try {
+    if (!fs2.lstatSync(here).isSymbolicLink()) {
+      return here;
+    }
+    return realPathOf(path.resolve(path.dirname(here), fs2.readlinkSync(here)), hops + 1);
+  } catch {
+    return here;
+  }
+}
+function isSymlink(target) {
+  try {
+    return fs2.lstatSync(target).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+// src/templates.ts
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+import { fileURLToPath } from "node:url";
+var templatesDir = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", "templates");
+function renderTemplate(name, vars) {
+  const raw = fs3.readFileSync(path2.join(templatesDir, name), "utf8");
+  const referenced = new Set;
+  const rendered = raw.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    if (!(key in vars)) {
+      throw new Error(`Template ${name} references unknown variable {{${key}}}`);
+    }
+    referenced.add(key);
+    return vars[key];
+  });
+  const unused = Object.keys(vars).filter((key) => !referenced.has(key));
+  if (unused.length > 0) {
+    const names = unused.map((key) => `{{${key}}}`).join(", ");
+    const one = unused.length === 1;
+    throw new Error(`Template ${name} never references ${names}, so ` + `${one ? "that value is" : "those values are"} computed and then ` + `dropped. Either use ${one ? "it" : "them"} in the template or ` + `stop passing ${one ? "it" : "them"}.`);
+  }
+  return rendered;
+}
+
+// src/scaffold.ts
+var MALLOY_AGENTS_FILE = "AGENTS.malloy.md";
+var BRIEFING_MARKER = "This directory is a [Malloy Publisher](https://github.com/malloydata/publisher)";
+var ENV_NAME = "default";
+var PUBLISHER_PORT = 4000;
+var MCP_PORT = 4040;
+var ALT_PUBLISHER_PORT = PUBLISHER_PORT + 100;
+var ALT_MCP_PORT = MCP_PORT + 100;
+var BIND_HOST = "127.0.0.1";
+var SERVER_VERSION = "0.0.231";
+function startCommandFor(envName) {
+  return `npx -y @malloy-publisher/server@${SERVER_VERSION} --server_root . ` + `--config ./publisher.config.json --host ${BIND_HOST} ` + `--watch-env ${envName}`;
+}
+function resetCommandFor(envName) {
+  return `${startCommandFor(envName)} --init`;
+}
+var DUCKDB_SAFE_PATH_CHAR = /[A-Za-z0-9._~:/?#@!$&*+,=%-]/;
+var RESERVED_PACKAGE_NAMES = new Set([
+  "AGENTS.md",
+  MALLOY_AGENTS_FILE,
+  "CLAUDE.md",
+  "node_modules",
+  "package.json",
+  "package-lock.json",
+  "publisher.config.json",
+  "publisher.db",
+  "publisher_data"
+].map((name) => name.toLowerCase()));
+function scaffold(options) {
+  assertServablePath(options.cwd);
+  assertSkillsAvailable();
+  if (options.name === undefined && options.dataFile !== undefined) {
+    throw new ScaffoldError(`--data seeds a new package, so it needs a package name: ` + `create-malloy-package <name> --data ${options.dataFile}`);
+  }
+  if (options.name !== undefined) {
+    validatePackageName(options.name);
+    assertNotReservedName(options.name);
+  }
+  const mcpConfigPath = mcpConfigPathFor(options.host);
+  assertWorkspacePathsContained(options, mcpConfigPath);
+  if (options.force) {
+    readMergeablePackageJson(options.cwd);
+  }
+  const result = {
+    cwd: options.cwd,
+    packageCreated: false,
+    envName: ENV_NAME,
+    envPackageCount: 0,
+    publisherPort: PUBLISHER_PORT,
+    mcpPort: MCP_PORT,
+    host: options.host,
+    written: [],
+    skipped: [],
+    replaced: [],
+    agentsFile: "AGENTS.md",
+    configExtended: false,
+    needsReset: false,
+    hasStartScript: false,
+    startCommand: startCommandFor(ENV_NAME),
+    hasResetScript: false,
+    resetCommand: resetCommandFor(ENV_NAME),
+    mcpConfigPath,
+    mcpWired: false,
+    mcpMerged: false,
+    mcpOtherServers: 0,
+    mcpEntryReplaced: false,
+    skillsInstalled: 0
+  };
+  const configPath = path3.join(options.cwd, "publisher.config.json");
+  const configExists = fs4.existsSync(configPath);
+  const config = configExists ? readConfig(configPath) : defaultConfig(ENV_NAME);
+  const targetEnv = targetEnvironment(config, ENV_NAME);
+  if (targetEnv !== undefined) {
+    validateEnvironmentName(targetEnv.name);
+  }
+  result.envName = resolveEnvironmentName(config, ENV_NAME);
+  let packageEntry;
+  if (options.name !== undefined) {
+    packageEntry = { name: options.name, location: `./${options.name}` };
+    if (configExists) {
+      assertCanAddPackage(config, ENV_NAME, packageEntry);
+    }
+    createPackage(options, result);
+  }
+  wireWorkspace(options, config, configExists, configPath, packageEntry, result);
+  result.envPackageCount = environmentPackageCount(config, ENV_NAME);
+  return result;
+}
+function createPackage(options, result) {
+  const name = options.name;
+  if (options.dataFile !== undefined) {
+    validateDataFile(options.dataFile);
+  }
+  const sourceName = toMalloyIdentifier(name);
+  const modelFile = `${sourceName}.malloy`;
+  const packageDir = path3.join(options.cwd, name);
+  const packageDirExists = fs4.existsSync(packageDir);
+  if (packageDirExists && !fs4.lstatSync(packageDir).isDirectory()) {
+    throw new ScaffoldError(`"${name}" already exists here and is not a directory, so the package ` + `cannot be created there. --force does not help: it overwrites files ` + `inside a package directory, it does not replace something that is ` + `in the way.
+
+` + `Choose another name, or move or remove "${name}" first.`);
+  }
+  if (packageDirExists && !options.force) {
+    throw new ScaffoldError(`Directory "${name}" already exists. Choose another name, or re-run ` + `with --force.
+
+` + forceDescription(name, modelFile, options.host) + `
+
+` + `If you passed --force to \`npm create\`, npm read it as one of its ` + `own settings and it never reached this tool. Options need a \`--\` ` + `in front of them there:
+` + `  npm create @malloy-publisher/malloy-package ${name} -- --force`);
+  }
+  const dataDir = path3.join(packageDir, "data");
+  assertWithinWorkspace(dataDir, options.cwd, `${name}/data`);
+  fs4.mkdirSync(dataDir, { recursive: true });
+  writeFile(path3.join(packageDir, "publisher.json"), JSON.stringify({ name }, null, 2) + `
+`, options.cwd);
+  let dataPath;
+  if (options.dataFile !== undefined) {
+    const sourceBase = path3.basename(options.dataFile);
+    const destBase = sanitizeFileName(sourceBase);
+    copyFile(options.dataFile, path3.join(dataDir, destBase), options.cwd, `${name}/data/${destBase}`);
+    dataPath = `data/${destBase}`;
+    if (destBase !== sourceBase) {
+      result.dataFileRenamedFrom = sourceBase;
+    }
+    writeFile(path3.join(packageDir, modelFile), renderTemplate("model.custom.malloy", { sourceName, dataPath }), options.cwd);
+  } else {
+    copyFile(path3.join(templatesDir, "sales.csv"), path3.join(dataDir, "sales.csv"), options.cwd, `${name}/data/sales.csv`);
+    dataPath = "data/sales.csv";
+    writeFile(path3.join(packageDir, modelFile), renderTemplate("model.default.malloy", { sourceName }), options.cwd);
+  }
+  result.packageCreated = true;
+  result.packageName = name;
+  result.sourceName = sourceName;
+  result.modelFile = modelFile;
+  result.dataPath = dataPath;
+  result.written.push(`${name}/`);
+  if (packageDirExists) {
+    result.replaced.push(`${name}/`);
+  }
+}
+function forceDescription(name, modelFile, host) {
+  const agentFiles = host === "cursor" ? "AGENTS.md" : "AGENTS.md and CLAUDE.md";
+  const mcpPath = mcpConfigPathFor(host);
+  return `--force does not empty the directory. It rewrites ${name}/publisher.json, ` + `${name}/${modelFile} and the data file it copies into ${name}/data/, and ` + `leaves anything else in there alone. It also refreshes .claude/skills/ ` + `from the bundled copies, as every run does. Outside the package it ` + `replaces ${agentFiles}; in package.json it sets only the "start" and ` + `"reset" scripts and keeps the rest of the file as it is; in ${mcpPath} it ` + `sets only the "malloy" server and keeps the others. publisher.config.json ` + `is extended, never rewritten, and .gitignore only gains the lines it is ` + `missing, with or without --force. None of those merges is a rewrite even ` + `when the file cannot be read: a package.json that is not valid JSON aborts ` + `the run before anything is written, and an unreadable ${mcpPath} or ` + `.gitignore is left alone and reported. If this directory has an AGENTS.md ` + `of its own, --force is not what you want for it: a run without --force ` + `keeps that file and writes the Publisher briefing to ${MALLOY_AGENTS_FILE} ` + `beside it instead, regenerating that one on every run.`;
+}
+function mcpConfigPathFor(host) {
+  return host === "cursor" ? ".cursor/mcp.json" : ".mcp.json";
+}
+function wireWorkspace(options, config, configExists, configPath, packageEntry, result) {
+  const { cwd } = options;
+  if (packageEntry) {
+    const registration = addPackage(config, ENV_NAME, packageEntry);
+    result.envName = registration.envName;
+    if (!configExists || registration.added) {
+      writeConfig(configPath, config);
+      result.configExtended = configExists;
+      result.written.push(configExists ? "publisher.config.json (extended)" : "publisher.config.json");
+    } else {
+      result.skipped.push("publisher.config.json (already registered)");
+    }
+  } else if (!configExists) {
+    writeConfig(configPath, config);
+    result.written.push("publisher.config.json");
+  } else {
+    result.skipped.push("publisher.config.json");
+  }
+  result.needsReset = result.packageCreated && (fs4.existsSync(path3.join(cwd, "publisher_data")) || fs4.existsSync(path3.join(cwd, "publisher.db")));
+  result.startCommand = startCommandFor(result.envName);
+  result.resetCommand = resetCommandFor(result.envName);
+  writeWorkspacePackageJson(cwd, options, result);
+  const scripts = workspaceScripts(cwd);
+  const declinedStart = declineReasonFor(scripts?.start, result.envName, false);
+  const declinedReset = declineReasonFor(scripts?.reset, result.envName, true);
+  result.hasStartScript = typeof scripts?.start === "string" && declinedStart === undefined;
+  result.declinedStartScript = declinedStart;
+  result.hasResetScript = typeof scripts?.reset === "string" && declinedReset === undefined;
+  result.declinedResetScript = declinedReset;
+  writeMcpConfig(cwd, result.mcpConfigPath, result);
+  installWorkspaceSkills(cwd, result);
+  mergeGitignore(cwd, result);
+  writeAgentsFile(cwd, renderAgentsFile(result, options.host, environmentPackageNames(config, ENV_NAME)), options, result);
+  if (options.host !== "cursor") {
+    writeIfAbsent(cwd, "CLAUDE.md", claudeFile(result.agentsFile), options, result);
+  }
+}
+function writeAgentsFile(cwd, content, options, result) {
+  assertBriefingIsRecognisable(content);
+  const relPath = "AGENTS.md";
+  const target = path3.join(cwd, relPath);
+  const exists = fs4.existsSync(target);
+  const ours = exists && isGeneratedBriefing(target);
+  if (!exists || ours || options.force) {
+    writeFile(target, content, cwd);
+    result.written.push(relPath);
+    if (ours) {
+      result.replaced.push(`${relPath} (regenerated, as every run does)`);
+    } else if (exists) {
+      result.replaced.push(relPath);
+    }
+    if (fs4.existsSync(path3.join(cwd, MALLOY_AGENTS_FILE))) {
+      result.skipped.push(`${MALLOY_AGENTS_FILE} (left from an earlier run, when AGENTS.md ` + `was not ours to write; AGENTS.md now holds the briefing, so ` + `this copy is stale and can be deleted)`);
+    }
+    return;
+  }
+  result.skipped.push(relPath);
+  const existed = fs4.existsSync(path3.join(cwd, MALLOY_AGENTS_FILE));
+  writeFile(path3.join(cwd, MALLOY_AGENTS_FILE), content, cwd);
+  result.agentsFile = MALLOY_AGENTS_FILE;
+  result.written.push(`${MALLOY_AGENTS_FILE} (the Publisher briefing, because this ` + `directory's own AGENTS.md was left alone)`);
+  if (existed) {
+    result.replaced.push(`${MALLOY_AGENTS_FILE} (regenerated, as every run does)`);
+  }
+}
+function isGeneratedBriefing(target) {
+  try {
+    return fs4.readFileSync(target, "utf8").includes(BRIEFING_MARKER);
+  } catch {
+    return false;
+  }
+}
+function assertBriefingIsRecognisable(content) {
+  if (!content.includes(BRIEFING_MARKER)) {
+    throw new Error(`The rendered agent briefing no longer holds the line "` + `${BRIEFING_MARKER}". That line is how a later run recognises a ` + `briefing this tool wrote and regenerates it in place, so without ` + `it every AGENTS.md written so far would be read as the user's own ` + `and the briefing diverted to ${MALLOY_AGENTS_FILE}. Restore the ` + `line in templates/AGENTS.md, or update BRIEFING_MARKER to a line ` + `the template still has.`);
+  }
+}
+function installWorkspaceSkills(cwd, result) {
+  const relDir = path3.join(".claude", "skills");
+  const skills = installSkills(path3.join(cwd, relDir), cwd);
+  result.skillsInstalled = skills.installed;
+  if (skills.refused) {
+    result.skipped.push(`${relDir}${path3.sep} (${skills.refused}; no skills were installed)`);
+  }
+  for (const name of skills.skipped) {
+    result.skipped.push(`${path3.join(relDir, name)} (symlink, not written through)`);
+  }
+  if (skills.refreshed.length > 0) {
+    const count = skills.refreshed.length;
+    result.replaced.push(`${relDir}${path3.sep} (${count} skill${count === 1 ? "" : "s"} ` + `refreshed: every run deletes each skill directory and writes the ` + `bundled copy back, so edits to a skill are reverted and anything ` + `else you put inside one is removed, not just changed)`);
+  }
+  if (skills.removed.length > 0) {
+    const shown2 = skills.removed.slice(0, 5).map((entry) => printable(path3.join(relDir, entry)));
+    const rest = skills.removed.length - shown2.length;
+    result.replaced.push(`${shown2.join(", ")}${rest > 0 ? `, and ${rest} more` : ""} (not ` + `part of any bundled skill, so nothing wrote ` + `${shown2.length === 1 && rest === 0 ? "it" : "them"} back)`);
+  }
+}
+function assertServablePath(cwd) {
+  const absolute = path3.resolve(cwd);
+  const candidate = path3.sep === "\\" ? absolute.replace(/\\/g, "/") : absolute;
+  for (const character of candidate) {
+    if (!DUCKDB_SAFE_PATH_CHAR.test(character)) {
+      throw new ScaffoldError(`This workspace cannot live in ${printable(absolute)}: DuckDB ` + `cannot read a ` + `data file under a path containing ${describeCharacter(character)}, so every model here would fail to load with the server ` + `still reporting healthy. Move to a path made of letters, ` + `digits, "-", "_", "." and "/" (for example ` + `~/malloy-workspace) and run again.`);
+    }
+  }
+}
+function describeCharacter(character) {
+  const named = {
+    " ": "a space",
+    "'": "an apostrophe",
+    '"': "a double quote",
+    "\\": "a backslash",
+    "\t": "a tab"
+  };
+  const label = named[character] ?? `"${character}"`;
+  const codePoint = character.codePointAt(0);
+  return codePoint < 32 || codePoint > 126 ? `${label} (U+${codePoint.toString(16).toUpperCase().padStart(4, "0")})` : label;
+}
+function assertWorkspacePathsContained(options, mcpConfigPath) {
+  const relatives = [
+    "publisher.config.json",
+    "package.json",
+    ".gitignore",
+    "AGENTS.md",
+    MALLOY_AGENTS_FILE,
+    mcpConfigPath
+  ];
+  if (options.host !== "cursor") {
+    relatives.push("CLAUDE.md");
+  }
+  if (options.name !== undefined) {
+    relatives.push(options.name);
+  }
+  for (const relative2 of relatives) {
+    assertWithinWorkspace(path3.join(options.cwd, relative2), options.cwd, relative2);
+  }
+}
+function assertWithinWorkspace(target, root, label) {
+  if (!isWithinDirectory(target, root)) {
+    throw new ScaffoldError(`"${label}" in ${root} is a symlink (or sits under one) pointing ` + `outside the workspace, so writing it would change a file somewhere ` + `else on this machine. Nothing was written. Remove or repoint it, ` + `then run again.`);
+  }
+}
+function assertNotReservedName(name) {
+  if (RESERVED_PACKAGE_NAMES.has(name.toLowerCase())) {
+    throw new ScaffoldError(`Package name "${name}" is reserved: the workspace itself uses that ` + `path. Choose another name.`);
+  }
+}
+function readWorkspacePackageJson(cwd) {
+  const target = path3.join(cwd, "package.json");
+  if (!fs4.existsSync(target)) {
+    return { kind: "absent" };
+  }
+  let text;
+  try {
+    text = fs4.readFileSync(target, "utf8");
+  } catch (err) {
+    return {
+      kind: "unusable",
+      problem: `unreadable: ${printable(err.message)}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseJson(text);
+  } catch (err) {
+    return {
+      kind: "unusable",
+      problem: `not valid JSON: ${printable(err.message)}`
+    };
+  }
+  const pkg = asJsonObject(parsed);
+  return pkg ? { kind: "object", pkg } : {
+    kind: "unusable",
+    problem: `${describeJsonValue(parsed)}, not a JSON object`
+  };
+}
+function workspaceScripts(cwd) {
+  const manifest = readWorkspacePackageJson(cwd);
+  return manifest.kind === "object" ? asJsonObject(manifest.pkg.scripts) : undefined;
+}
+function isPublisherScript(script, envName, requireInit = false) {
+  return typeof script === "string" && declineReasonFor(script, envName, requireInit) === undefined;
+}
+function declineReasonFor(script, envName, requireInit = false) {
+  if (typeof script !== "string") {
+    return;
+  }
+  if (!script.includes("@malloy-publisher/server")) {
+    return { script, reason: "not-publisher" };
+  }
+  if (UNMODELLED_SHELL_SYNTAX.test(script)) {
+    return { script, reason: "unmodelled-shell-syntax" };
+  }
+  if (hasUnterminatedQuote(script)) {
+    return { script, reason: "unparseable" };
+  }
+  if (!isSingleServerInvocation(script)) {
+    return { script, reason: "unrecognised-shape" };
+  }
+  const host = hostFlagOf(script);
+  if (host === undefined) {
+    const joined = joinedHostFlagOf(script);
+    return joined === undefined ? { script, reason: "no-host-flag" } : { script, reason: "no-host-flag", joinedHostFlag: joined };
+  }
+  if (!isLoopbackHost(host)) {
+    return { script, reason: "non-loopback-host", host };
+  }
+  if (requireInit && !script.includes("--init")) {
+    return { script, reason: "no-init-flag", host };
+  }
+  if (!matchesGeneratedInvocation(script, envName, requireInit)) {
+    return { script, reason: "different-invocation" };
+  }
+  return;
+}
+var GENERATED_FLAGS = {
+  "--server_root": (value) => value === "." || value === "./",
+  "--config": (value) => value === "./publisher.config.json" || value === "publisher.config.json",
+  "--host": (value) => isLoopbackHost(value),
+  "--watch-env": (value, envName) => value === envName
+};
+var GENERATED_BOOLEAN_FLAGS = new Set(["--init"]);
+function matchesGeneratedInvocation(script, envName, requireInit) {
+  const tokens = splitOnShellWhitespace(script);
+  const index = tokens.findIndex((token) => unquote(token).startsWith("@malloy-publisher/server"));
+  if (index === -1) {
+    return false;
+  }
+  const values = new Map;
+  let init = false;
+  const rest = tokens.slice(index + 1).map(unquote);
+  for (let i = 0;i < rest.length; i++) {
+    const flag = rest[i];
+    if (GENERATED_BOOLEAN_FLAGS.has(flag)) {
+      init = init || flag === "--init";
+      continue;
+    }
+    const accepts = GENERATED_FLAGS[flag];
+    if (accepts === undefined) {
+      return false;
+    }
+    const value = rest[i + 1];
+    if (value === undefined) {
+      return false;
+    }
+    values.set(flag, value);
+    i++;
+  }
+  for (const [flag, accepts] of Object.entries(GENERATED_FLAGS)) {
+    const value = values.get(flag);
+    if (value === undefined || !accepts(value, envName)) {
+      return false;
+    }
+  }
+  return init === requireInit;
+}
+function unquote(token) {
+  return token.replace(/^["']|["']$/g, "");
+}
+var SHELL_CHAINING_CHARACTERS = /[&|;<>\n\r]/;
+var UNMODELLED_SHELL_SYNTAX = /[`$()#\\]/;
+var SH_WHITESPACE = /[ \t\n]/;
+function splitOnShellWhitespace(script) {
+  return script.split(/[ \t\n]+/).filter(Boolean);
+}
+var SCRIPT_RUNNER_PREFIXES = [
+  ["npx"],
+  ["bunx"],
+  ["pnpx"],
+  ["pnpm", "dlx"],
+  ["yarn", "dlx"],
+  ["bun", "x"]
+];
+function runnerPrefixLength(before) {
+  for (const prefix of SCRIPT_RUNNER_PREFIXES) {
+    if (prefix.every((word, i) => before[i] === word)) {
+      return prefix.length;
+    }
+  }
+  return 0;
+}
+var RUNNER_BOOLEAN_FLAGS = new Set([
+  "-y",
+  "--yes",
+  "-q",
+  "--quiet",
+  "--silent"
+]);
+function isSingleServerInvocation(script) {
+  if (SHELL_CHAINING_CHARACTERS.test(script)) {
+    return false;
+  }
+  const tokens = splitOnShellWhitespace(script);
+  const index = tokens.findIndex((token) => token.includes("@malloy-publisher/server"));
+  if (index === -1) {
+    return false;
+  }
+  const command = tokens[index].replace(/^["']|["']$/g, "");
+  if (command !== "@malloy-publisher/server") {
+    if (!command.startsWith("@malloy-publisher/server@")) {
+      return false;
+    }
+    const spec = command.slice("@malloy-publisher/server@".length);
+    if (!/^[A-Za-z0-9][A-Za-z0-9.-]*$/.test(spec)) {
+      return false;
+    }
+    if (/\.(?:tgz|tar\.gz|tar)$/i.test(spec)) {
+      return false;
+    }
+  }
+  const before = tokens.slice(0, index);
+  const runnerLength = runnerPrefixLength(before);
+  if (runnerLength === 0) {
+    return false;
+  }
+  return before.slice(runnerLength).every((token) => RUNNER_BOOLEAN_FLAGS.has(token));
+}
+var SERVER_VALUE_FLAGS = new Set([
+  "--port",
+  "--host",
+  "--server_root",
+  "--config",
+  "--mcp_port",
+  "--shutdown_drain_duration_seconds",
+  "--shutdown_graceful_close_timeout_seconds",
+  "--watch-env"
+]);
+function hasUnterminatedQuote(script) {
+  let quote;
+  for (const char of script) {
+    if (quote !== undefined) {
+      if (char === quote)
+        quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'")
+      quote = char;
+  }
+  return quote !== undefined;
+}
+function shellTokens(script) {
+  const tokens = [];
+  let current = "";
+  let quote;
+  let open = false;
+  for (const char of script) {
+    if (quote !== undefined) {
+      if (char === quote)
+        quote = undefined;
+      else
+        current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      open = true;
+      continue;
+    }
+    if (SH_WHITESPACE.test(char)) {
+      if (open)
+        tokens.push(current);
+      current = "";
+      open = false;
+      continue;
+    }
+    current += char;
+    open = true;
+  }
+  if (open)
+    tokens.push(current);
+  return tokens;
+}
+function hostFlagOf(script) {
+  const tokens = shellTokens(script);
+  const spec = tokens.findIndex((token) => token.includes("@malloy-publisher/server"));
+  if (spec === -1) {
+    return;
+  }
+  let value;
+  for (let i = spec + 1;i < tokens.length; i++) {
+    const token = tokens[i];
+    const next = tokens[i + 1];
+    if (!SERVER_VALUE_FLAGS.has(token) || !next) {
+      continue;
+    }
+    if (token === "--host") {
+      value = next;
+    }
+    i++;
+  }
+  return value;
+}
+function joinedHostFlagOf(script) {
+  let value;
+  for (const match of script.matchAll(/(?:^|\s)--host=("[^"]*"|'[^']*'|\S*)/g)) {
+    value = match[1].replace(/^["']|["']$/g, "");
+  }
+  return value;
+}
+function isLoopbackHost(host) {
+  if (host === undefined) {
+    return false;
+  }
+  const bare = host.replace(/^\[|\]$/g, "").toLowerCase();
+  return bare === "localhost" || bare === "::1" || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(bare);
+}
+function readMergeablePackageJson(cwd) {
+  const manifest = readWorkspacePackageJson(cwd);
+  if (manifest.kind === "absent") {
+    return;
+  }
+  if (manifest.kind === "unusable") {
+    throw new ScaffoldError(`package.json in ${cwd} is ${manifest.problem}. --force adds the ` + `Publisher scripts to an existing manifest and keeps everything ` + `else, which needs the file to be a JSON object this tool can read. ` + `Nothing was written. Fix or move it, then run again.`);
+  }
+  return manifest.pkg;
+}
+function writeWorkspacePackageJson(cwd, options, result) {
+  const relPath = "package.json";
+  const target = path3.join(cwd, relPath);
+  const manifest = readWorkspacePackageJson(cwd);
+  if (manifest.kind === "absent") {
+    writeFile(target, workspacePackageJson(cwd, result), cwd);
+    result.written.push(relPath);
+    return;
+  }
+  if (manifest.kind === "unusable") {
+    result.packageJsonProblem = manifest.problem;
+    result.skipped.push(`${relPath} (${manifest.problem}, so the Publisher start script was ` + `not added)`);
+    return;
+  }
+  if (!options.force) {
+    result.skipped.push(relPath);
+    return;
+  }
+  const pkg = manifest.pkg;
+  const scripts = asJsonObject(pkg.scripts) ?? {};
+  pkg.scripts = {
+    ...scripts,
+    start: result.startCommand,
+    reset: result.resetCommand
+  };
+  writeFile(target, JSON.stringify(pkg, null, 2) + `
+`, cwd);
+  result.written.push(`${relPath} (start and reset scripts set)`);
+  for (const name of ["start", "reset"]) {
+    const previous = scripts[name];
+    if (typeof previous === "string" && !isPublisherScript(previous, result.envName, name === "reset")) {
+      result.replaced.push(`${relPath} ${name} script ("${printable(previous)}")`);
+    }
+  }
+}
+function writeMcpConfig(cwd, relPath, result) {
+  const target = path3.join(cwd, relPath);
+  if (!fs4.existsSync(target)) {
+    writeFile(target, mcpConfig(), cwd);
+    result.written.push(relPath);
+    result.mcpWired = true;
+    return;
+  }
+  let parsed;
+  let parses = true;
+  try {
+    parsed = parseJson(fs4.readFileSync(target, "utf8"));
+  } catch {
+    parses = false;
+  }
+  const config = asJsonObject(parsed);
+  const servers = config && "mcpServers" in config ? asJsonObject(config.mcpServers) : undefined;
+  if (!config || config.mcpServers !== undefined && !servers) {
+    const problem = describeMcpProblem(parses, parsed, config);
+    result.skipped.push(`${relPath} (${problem})`);
+    result.mcpWired = false;
+    result.mcpConfigProblem = problem;
+    result.mcpPasteBlock = mcpConfig();
+    return;
+  }
+  const existingEntry = servers?.malloy;
+  const desired = malloyServer();
+  result.mcpWired = true;
+  result.mcpOtherServers = Object.keys(servers ?? {}).filter((name) => name !== "malloy").length;
+  if (JSON.stringify(existingEntry) === JSON.stringify(desired)) {
+    result.skipped.push(`${relPath} (malloy already wired)`);
+    return;
+  }
+  result.mcpEntryReplaced = existingEntry !== undefined;
+  config.mcpServers = { ...servers ?? {}, malloy: desired };
+  result.mcpMerged = true;
+  writeFile(target, JSON.stringify(config, null, 2) + `
+`, cwd);
+  result.written.push(`${relPath} (${existingEntry === undefined ? "added" : "updated"} the malloy server)`);
+  if (existingEntry !== undefined) {
+    result.replaced.push(`${relPath} malloy server`);
+  }
+}
+function describeMcpProblem(parses, parsed, config) {
+  if (!parses) {
+    return "not valid JSON";
+  }
+  if (!config) {
+    return `valid JSON, but ${describeJsonValue(parsed)} rather than a JSON object`;
+  }
+  return `valid JSON, but its "mcpServers" is ${describeJsonValue(config.mcpServers)} rather than a JSON object`;
+}
+function renderAgentsFile(result, host, envPackages) {
+  const mcpNote = !result.mcpWired ? `\`${result.mcpConfigPath}\` could not be updated automatically, so the \`malloy\` server may still need adding to it by hand.` : host === "cursor" ? "This workspace ships a `.cursor/mcp.json` that points Cursor at the endpoint." : "This workspace ships a `.mcp.json`, so Claude Code offers to connect on first run.";
+  const reconnectNote = host === "cursor" ? "ask the user to reload the MCP servers from Cursor's settings (the `malloy` server, then Refresh), or to restart Cursor." : "ask the user to run `/mcp`, select the `malloy` server, and choose Reconnect, or to restart Claude Code. That panel reports `Auth: not authenticated` and offers `Authenticate` first, which is a red herring: this endpoint has no auth, and Reconnect is the one that works.";
+  const skillsCount = String(result.skillsInstalled);
+  const skillsNote = result.skillsInstalled === 0 ? "This run installed no skills into `.claude/skills/` (the scaffolder's output says why), so there are none here to load. Pull the same guidance as MCP prompts from the endpoint above instead." : host === "cursor" ? `\`.claude/skills/\` holds ${skillsCount} Malloy agent skills as real files. Cursor reads \`AGENTS.md\`; these skills are the same guidance broken out by task, and any MCP client can also pull them as prompts from the endpoint above.` : `\`.claude/skills/\` holds ${skillsCount} Malloy agent skills as real files, so Claude Code auto-discovers them. Hosts that read \`AGENTS.md\` rather than Anthropic Agent Skills can pull the same guidance as MCP prompts from the endpoint above.`;
+  const startCommand = result.hasStartScript ? "npm start" : result.startCommand;
+  const portOverrideCommand = `${startCommand}${result.hasStartScript ? " --" : ""} ` + `--port ${ALT_PUBLISHER_PORT} --mcp_port ${ALT_MCP_PORT}`;
+  return renderTemplate("AGENTS.md", {
+    title: result.packageCreated ? `${result.packageName}: a Malloy Publisher package` : "A Malloy Publisher workspace",
+    startCommand,
+    portOverrideCommand,
+    resetCommand: result.hasResetScript ? "npm run reset" : result.resetCommand,
+    skillsCount,
+    envName: result.envName,
+    port: String(result.publisherPort),
+    mcpPort: String(result.mcpPort),
+    packageSection: packageSection(result, envPackages),
+    mcpNote,
+    reconnectNote,
+    skillsNote
+  });
+}
+function packageSection(result, envPackages) {
+  const others = envPackages.filter((name) => name !== result.packageName);
+  if (!result.packageCreated && others.length === 0) {
+    return "";
+  }
+  const restBase = (name) => `http://localhost:${result.publisherPort}/api/v0/environments/` + `${result.envName}/packages/${name}`;
+  const lines = [
+    "",
+    others.length > 0 ? "## The packages" : "## The package",
+    ""
+  ];
+  if (result.packageCreated) {
+    const base = restBase(result.packageName);
+    lines.push(`\`${result.packageName}/${result.modelFile}\` defines a Malloy source named \`${result.sourceName}\` over local data. Read it for the real source, field, and view names and use them verbatim; never guess them. The package's REST base is:`, "", "```", base, "```", "", "Run one of its views from a script:", "", "```bash", `curl -s -X POST ${base}/models/${result.modelFile}/query \\`, "  -H 'content-type: application/json' \\", `  -d '{"query":"run: ${result.sourceName} -> overview"}'`, "```", "");
+  }
+  if (others.length > 0) {
+    lines.push(otherPackagesParagraph(result, others, restBase), "");
+  }
+  return lines.join(`
+`);
+}
+function otherPackagesParagraph(result, others, restBase) {
+  const plural = others.length === 1 ? "" : "s";
+  const opening = result.packageCreated ? `This file is regenerated on every run and details only the package that run created. \`publisher.config.json\` registers ${others.length} other package${plural} in the \`${result.envName}\` environment` : `This run created no package. \`publisher.config.json\` registers ${others.length} package${plural} in the \`${result.envName}\` environment`;
+  const named = others.every(isNameableHere) ? `: ${others.map((name) => `\`${name}\``).join(", ")}` : `, whose names this file does not repeat because at least one of them is outside the character set Publisher accepts in a URL`;
+  const shape = result.packageCreated ? `the one above with the package name changed` : `\`${restBase("<package>")}\``;
+  return `${opening}${named}. Nothing here has read those models, so use ` + `\`malloy_getContext\`, or read the \`.malloy\` file in each package's ` + `own directory, for its source, field, and view names. Their REST bases ` + `are ${shape}. The packages endpoint further down lists what the running ` + `server actually mounted, which is the only answer that counts.`;
+}
+function isNameableHere(name) {
+  try {
+    validatePackageName(name);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function workspacePackageJson(cwd, result) {
+  return JSON.stringify({
+    name: toNpmName(path3.basename(path3.resolve(cwd))),
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      start: result.startCommand,
+      reset: result.resetCommand
+    }
+  }, null, 2) + `
+`;
+}
+var GITIGNORE_HEADER = "# Malloy Publisher";
+function workspaceGitignoreEntries() {
+  return [
+    "node_modules/",
+    "publisher_data/",
+    "publisher.db*",
+    "*.log",
+    ".DS_Store"
+  ];
+}
+function workspaceGitignore() {
+  return [GITIGNORE_HEADER, ...workspaceGitignoreEntries(), ""].join(`
+`);
+}
+function mergeGitignore(cwd, result) {
+  const relPath = ".gitignore";
+  const target = path3.join(cwd, relPath);
+  if (!fs4.existsSync(target)) {
+    writeFile(target, workspaceGitignore(), cwd);
+    result.written.push(relPath);
+    return;
+  }
+  assertWithinWorkspace(target, cwd, relPath);
+  let existing;
+  try {
+    existing = fs4.readFileSync(target, "utf8");
+  } catch (err) {
+    result.skipped.push(`${relPath} (could not be read, so Publisher's files are not ` + `ignored here: ${err.message})`);
+    return;
+  }
+  const present = new Set(existing.split(/\r?\n/).map(normalizeIgnoreEntry).filter(Boolean));
+  const missing = workspaceGitignoreEntries().filter((entry) => !present.has(normalizeIgnoreEntry(entry)));
+  if (missing.length === 0) {
+    result.skipped.push(`${relPath} (already ignores what Publisher writes)`);
+    return;
+  }
+  const prefix = existing === "" ? "" : existing.endsWith(`
+`) ? `
+` : `
+
+`;
+  fs4.appendFileSync(target, `${prefix}${GITIGNORE_HEADER}
+${missing.join(`
+`)}
+`);
+  const entries = missing.length === 1 ? "entry" : "entries";
+  result.written.push(`${relPath} (${missing.length} ${entries} appended, nothing removed)`);
+}
+function normalizeIgnoreEntry(line) {
+  const trimmed = line.trim();
+  if (trimmed === "" || trimmed.startsWith("#")) {
+    return "";
+  }
+  return trimmed.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function malloyServer() {
+  return { type: "http", url: `http://localhost:${MCP_PORT}/mcp` };
+}
+function mcpConfig() {
+  return JSON.stringify({ mcpServers: { malloy: malloyServer() } }, null, 2) + `
+`;
+}
+function claudeFile(agentsFile) {
+  const pointer = `See @${agentsFile} for how to start Publisher, connect an agent to the ` + `MCP endpoint, and use the bundled Malloy skills.
+`;
+  if (agentsFile === "AGENTS.md") {
+    return pointer;
+  }
+  return pointer + `
+This directory already had an AGENTS.md when the Malloy workspace was ` + `scaffolded, so that file was left exactly as it was and carries none of ` + `the above. ${agentsFile} is the generated briefing; read that one for ` + `anything about Publisher, Malloy, or the MCP endpoint.
+`;
+}
+function validateDataFile(dataFile) {
+  if (!fs4.existsSync(dataFile) || !fs4.statSync(dataFile).isFile()) {
+    throw new ScaffoldError(`--data file not found: ${printable(dataFile)}`);
+  }
+  const ext = path3.extname(dataFile).toLowerCase();
+  if (ext !== ".csv" && ext !== ".parquet" && ext !== ".xlsx") {
+    throw new ScaffoldError(`--data must be a .csv, .parquet, or .xlsx file (got "${printable(path3.basename(dataFile))}").`);
+  }
+}
+function toNpmName(base) {
+  const cleaned = base.toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^[._]+/, "");
+  return cleaned || "malloy-workspace";
+}
+function sanitizeFileName(base) {
+  return base.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function writeIfAbsent(cwd, relPath, content, options, result) {
+  const target = path3.join(cwd, relPath);
+  const exists = fs4.existsSync(target);
+  if (exists && !options.force) {
+    result.skipped.push(relPath);
+    return false;
+  }
+  writeFile(target, content, cwd);
+  result.written.push(relPath);
+  if (exists) {
+    result.replaced.push(relPath);
+  }
+  return true;
+}
+function writeFile(target, content, root) {
+  assertWithinWorkspace(target, root, path3.relative(root, target) || target);
+  fs4.mkdirSync(path3.dirname(target), { recursive: true });
+  fs4.writeFileSync(target, content);
+}
+function copyFile(source, target, root, label) {
+  assertWithinWorkspace(target, root, label);
+  fs4.copyFileSync(source, target);
+}
+
+// src/index.ts
+var CLIENTS = ["claude-code", "cursor"];
+function version() {
+  try {
+    const pkg = JSON.parse(fs5.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function asClient(value) {
+  return value === "cursor" ? "cursor" : "claude-code";
+}
+function resolveDataFile(cwd, data) {
+  if (data === undefined) {
+    return;
+  }
+  if (data.trim() === "") {
+    throw new ScaffoldError(`--data was given an empty filename. Pass the CSV, Parquet, or XLSX ` + `file to seed the package from, or leave --data off to use the ` + `sample data.`);
+  }
+  return path4.resolve(cwd, data);
+}
+function run(name, options) {
+  const cwd = process.cwd();
+  const before = snapshotArtifacts(cwd, name);
+  try {
+    const result = scaffold({
+      name,
+      cwd,
+      dataFile: resolveDataFile(cwd, options.data),
+      host: asClient(options.client),
+      force: Boolean(options.force)
+    });
+    process.stdout.write(formatSuccess(result));
+  } catch (err) {
+    process.stderr.write(formatFailure(err, changesSince(cwd, name, before), Boolean(options.force)));
+    process.exitCode = 1;
+  }
+}
+function artifactCandidates(name) {
+  const paths = [
+    "publisher.config.json",
+    "package.json",
+    ".mcp.json",
+    path4.join(".cursor", "mcp.json"),
+    ".gitignore",
+    "AGENTS.md",
+    "CLAUDE.md",
+    path4.join(".claude", "skills")
+  ];
+  if (name !== undefined && name !== "" && name !== "." && name !== ".." && !name.includes("/") && !name.includes("\\")) {
+    paths.unshift(name);
+  }
+  return paths;
+}
+function snapshotArtifacts(cwd, name) {
+  const snapshot = new Map;
+  for (const relPath of artifactCandidates(name)) {
+    snapshot.set(relPath, fingerprint(cwd, relPath));
+  }
+  return snapshot;
+}
+function changesSince(cwd, name, before) {
+  const changes = { created: [], changed: [] };
+  for (const relPath of artifactCandidates(name)) {
+    const was = before.get(relPath);
+    const now = fingerprint(cwd, relPath);
+    if (now === undefined || now === was) {
+      continue;
+    }
+    if (was === undefined) {
+      changes.created.push(relPath);
+    } else {
+      changes.changed.push(relPath);
+    }
+  }
+  return changes;
+}
+function fingerprint(cwd, relPath) {
+  const target = path4.join(cwd, relPath);
+  let stat;
+  try {
+    stat = fs5.lstatSync(target);
+  } catch {
+    return;
+  }
+  try {
+    if (stat.isDirectory()) {
+      return `dir:${digest(listDirectory(target))}`;
+    }
+    if (stat.isFile()) {
+      return `file:${digest(fs5.readFileSync(target))}`;
+    }
+    return `other:${stat.mode}:${linkTarget(target)}`;
+  } catch {
+    return "unreadable";
+  }
+}
+function listDirectory(dir, cap = 5000) {
+  const entries = [];
+  const stack = [dir];
+  while (stack.length > 0 && entries.length < cap) {
+    const current = stack.pop();
+    let children;
+    try {
+      children = fs5.readdirSync(current, { withFileTypes: true });
+    } catch {
+      entries.push(`${path4.relative(dir, current)} unreadable`);
+      continue;
+    }
+    for (const child of children) {
+      const full = path4.join(current, child.name);
+      if (child.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      let size = -1;
+      let mtime = -1;
+      try {
+        const childStat = fs5.lstatSync(full);
+        size = childStat.size;
+        mtime = childStat.mtimeMs;
+      } catch {}
+      entries.push(`${path4.relative(dir, full)} ${size} ${mtime}`);
+    }
+  }
+  entries.sort();
+  return entries.join(`
+`);
+}
+function linkTarget(target) {
+  try {
+    return fs5.readlinkSync(target);
+  } catch {
+    return "";
+  }
+}
+function digest(data) {
+  return crypto.createHash("sha1").update(data).digest("hex");
+}
+function formatFailure(err, changes, force) {
+  const lines = ["", `${red("Error:")} ${describeFailure(err)}`];
+  if (changes.created.length > 0) {
+    lines.push("");
+    lines.push(yellow("This run created these before it stopped:"));
+    for (const relPath of changes.created) {
+      lines.push(`  ${relPath}`);
+    }
+  }
+  if (changes.changed.length > 0) {
+    lines.push("");
+    lines.push(yellow("It also rewrote these, which were already here:"));
+    for (const relPath of changes.changed) {
+      lines.push(`  ${relPath}`);
+    }
+  }
+  if (changes.created.length > 0 || changes.changed.length > 0) {
+    lines.push(dim(`  Both lists come from comparing the paths this tool writes
+` + "  against this directory as it was when the run started."));
+    lines.push(dim(force ? `  Fix the cause and run again: --force is already set, so the
+` + "  next run writes over what is listed above." : `  Remove what it created before running again, or re-run with
+` + "  --force once the cause is fixed."));
+  }
+  const stack = err instanceof Error ? err.stack : undefined;
+  if (stack && !(err instanceof ScaffoldError) && !isErrno(err)) {
+    lines.push("");
+    lines.push(dim("  This looks like a bug in create-malloy-package. Re-run with " + "DEBUG=1 for the stack trace."));
+    if (process.env.DEBUG) {
+      lines.push("");
+      lines.push(dim(stack));
+    }
+  }
+  lines.push("");
+  return lines.join(`
+`) + `
+`;
+}
+function isErrno(err) {
+  return err instanceof Error && typeof err.code === "string" && /^E[A-Z]+$/.test(err.code);
+}
+var ERRNO_REASON = {
+  EACCES: "permission denied",
+  EEXIST: "it already exists",
+  EISDIR: "it is a directory, not a file",
+  ELOOP: "too many symbolic links to follow",
+  EMFILE: "too many open files",
+  ENAMETOOLONG: "the name is longer than this filesystem allows",
+  ENOENT: "no such file or directory",
+  ENOSPC: "there is no space left on the device",
+  ENOTDIR: "something along that path is a regular file, so it cannot hold a directory",
+  ENOTEMPTY: "the directory is not empty",
+  EPERM: "the operation is not permitted",
+  EROFS: "the filesystem is read-only"
+};
+function describeFailure(err) {
+  if (err instanceof ScaffoldError) {
+    return err.message;
+  }
+  if (isErrno(err)) {
+    const reason = ERRNO_REASON[err.code];
+    const target = err.path ?? err.dest;
+    const what = err.syscall ? `Could not ${err.syscall}` : "Failed";
+    const where = target ? ` ${relativeToCwd(target)}` : "";
+    return reason ? `${what}${where}: ${reason} (${err.code}).` : `${what}${where}: ${err.message}`;
+  }
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return String(err);
+}
+function relativeToCwd(target) {
+  const relative3 = path4.relative(process.cwd(), target);
+  return relative3 && !relative3.startsWith("..") && !path4.isAbsolute(relative3) ? `./${relative3}` : target;
+}
+function readWorkspaceFile(cwd, relPath) {
+  try {
+    return fs5.readFileSync(path4.join(cwd, relPath), "utf8");
+  } catch {
+    return;
+  }
+}
+function agentsFileNotes(result) {
+  if (!result.skipped.includes("AGENTS.md") || result.agentsFile === "AGENTS.md") {
+    return [];
+  }
+  const wroteClaudeFile = result.written.includes("CLAUDE.md") || result.replaced.includes("CLAUDE.md");
+  if (!wroteClaudeFile) {
+    return [
+      dim(`  That AGENTS.md is the project's own, so it carries no Publisher
+` + `  instructions and none were added to it. This run's briefing ` + `is in
+  ${result.agentsFile} instead.`)
+    ];
+  }
+  const claude = readWorkspaceFile(result.cwd, "CLAUDE.md") ?? "";
+  if (claude.includes(`@${result.agentsFile}`)) {
+    return [
+      dim(`  That AGENTS.md is the project's own, so it carries no Publisher
+` + `  instructions and none were added to it. This run's briefing ` + `is in
+  ${result.agentsFile} instead, and the CLAUDE.md this ` + `run wrote points there.`)
+    ];
+  }
+  return [
+    yellow(`  That AGENTS.md is the project's own: no start command, no ports, no
+` + `  MCP endpoint, no skills index. The briefing went to ` + `${result.agentsFile},
+  but the CLAUDE.md this run wrote does not ` + `point at that file, and
+  Claude Code reads CLAUDE.md on its own. ` + `Point it at ${result.agentsFile}
+  by hand.`)
+  ];
+}
+function declinedScriptReason(declined, kind) {
+  const noneAdded = `no Publisher ${kind} script was added to this directory's package.json`;
+  if (declined === undefined) {
+    return noneAdded;
+  }
+  switch (declined.reason) {
+    case "no-host-flag":
+      return declined.joinedHostFlag === undefined ? `this directory's ${kind} script boots Publisher with no --host, ` + "and Publisher binds every interface by default" : `this directory's ${kind} script writes ` + `--host=${printable(declined.joinedHostFlag)}, which ` + "Publisher's own argument parser does not accept: it reads " + "--host and the address as two arguments, drops the joined " + "form without a word, and binds every interface";
+    case "unrecognised-shape":
+      return `this directory's ${kind} script names the Publisher server inside ` + "a longer command line, so what it runs, and what it binds, is not " + "something this tool established";
+    case "unmodelled-shell-syntax":
+      return `this directory's ${kind} script uses shell syntax this tool does ` + "not read (a comment, an escape, or a substitution), so what the " + "server is handed, and what it binds, is not something this tool " + "established";
+    case "unparseable":
+      return `this directory's ${kind} script leaves a quote open, so the shell ` + "refuses to run it at all and it starts nothing";
+    case "different-invocation":
+      return `this directory's ${kind} script boots Publisher with different ` + "arguments to the ones here, so the ports and the workspace root " + "below are not what it would serve";
+    case "non-loopback-host":
+      return `this directory's ${kind} script boots Publisher on ` + `${printable(String(declined.host))}, which is not a loopback address`;
+    case "no-init-flag":
+      return `this directory's ${kind} script boots Publisher but carries no ` + "--init, so it would not rebuild the package list from the config";
+    case "not-publisher": {
+      const script = declined.script.trim();
+      return script === "" ? noneAdded : `this directory's ${kind} script runs something else: ` + `\`${preview(script)}\`, so it was left alone`;
+    }
+    default:
+      return `this directory's ${kind} script is not one this tool recognises ` + "as its own Publisher boot";
+  }
+}
+function bindRisk(declined) {
+  if (declined === undefined) {
+    return;
+  }
+  switch (declined.reason) {
+    case "not-publisher":
+      return;
+    case "no-init-flag":
+    case "different-invocation":
+      return;
+    case "no-host-flag":
+      return { known: true, address: "0.0.0.0, Publisher's default" };
+    case "non-loopback-host":
+      return declined.host === undefined ? { known: false } : { known: true, address: printable(declined.host) };
+    case "unparseable":
+      return;
+    case "unrecognised-shape":
+    case "unmodelled-shell-syntax":
+      return { known: false };
+    default:
+      return { known: false };
+  }
+}
+function exposureWarning(command, declined) {
+  const risk = bindRisk(declined);
+  if (risk === undefined) {
+    return [];
+  }
+  return [
+    yellow(risk.known ? `  Do not use \`${command}\` here: that script binds ${risk.address},
+` + `  which serves the unauthenticated REST API and MCP endpoint ` + `to your
+  whole network. The command above binds 127.0.0.1.` : `  Do not use \`${command}\` here: this tool could not establish ` + `what
+  that script binds, and Publisher serves an ` + `unauthenticated REST API
+  and MCP endpoint on whatever it ` + `binds. The command above binds
+  127.0.0.1.`)
+  ];
+}
+function wroteStartScript(result) {
+  return result.written.some((item) => item === "package.json" || item.startsWith("package.json "));
+}
+function formatSuccess(result) {
+  const lines = [""];
+  if (result.packageCreated) {
+    lines.push(`${green("✓")} Created package ${bold(result.packageName)} in ./${result.packageName}`);
+  }
+  if (result.dataFileRenamedFrom) {
+    lines.push(dim(`  ${result.dataFileRenamedFrom} was copied in as ${result.dataPath}, ` + `renamed to the characters a Malloy table path can carry.`));
+  }
+  if (result.configExtended) {
+    lines.push(`${green("✓")} Registered ${bold(result.packageName)} in the existing publisher.config.json`);
+  }
+  if (result.mcpWired) {
+    lines.push(`${green("✓")} Wired the agent workspace (${result.host}) in ${result.cwd}`);
+  } else {
+    lines.push(`${yellow("!")} Set up the agent workspace (${result.host}) in ${result.cwd}, but the MCP endpoint is not wired`);
+  }
+  if (result.skillsInstalled > 0) {
+    lines.push(`${green("✓")} Installed ${bold(String(result.skillsInstalled))} Malloy skills in .claude/skills/`);
+  } else {
+    lines.push(yellow("!") + " No Malloy skills were installed in .claude/skills/");
+  }
+  if (result.written.length > 0) {
+    lines.push("");
+    lines.push(bold("Wrote these:"));
+    for (const item of result.written) {
+      lines.push(`  ${printable(item)}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    lines.push("");
+    lines.push(yellow("Left these existing files alone:"));
+    for (const item of result.skipped) {
+      lines.push(`  ${printable(item)}`);
+    }
+    lines.push(...agentsFileNotes(result));
+  }
+  if (result.replaced.length > 0) {
+    lines.push("");
+    lines.push(yellow("Overwrote these:"));
+    for (const item of result.replaced) {
+      lines.push(`  ${printable(item)}`);
+    }
+  }
+  const url = `http://localhost:${result.publisherPort}`;
+  const environmentIsEmpty = result.envPackageCount === 0;
+  lines.push("");
+  lines.push(bold("Next steps:"));
+  if (environmentIsEmpty) {
+    lines.push(`  ${cyan("npx @malloy-publisher/create-malloy-package <name>")}   ${dim("add a package; the server has nothing to serve without one")}`);
+  }
+  if (result.needsReset) {
+    const served = `re-read the config, so ${result.packageName ?? "the new package"} is served`;
+    if (result.hasResetScript) {
+      lines.push(`  ${cyan("npm run reset")}   ${dim(served)}`);
+    } else {
+      lines.push(`  ${dim(`${served} (${declinedScriptReason(result.declinedResetScript, "reset")}):`)}`);
+      lines.push(`  ${cyan(result.resetCommand)}`);
+    }
+    lines.push(dim(`  Restarting is not enough: Publisher reads publisher.config.json
+` + `  once, and after that its persisted package list wins. This boot
+` + `  carries --init, which rebuilds the package list from the config
+` + `  and drops the rest of the persisted state with it: materialized
+` + `  tables, saved themes, and anything set through the API rather
+` + "  than the config file."));
+    lines.push(dim(`  Stop any Publisher already serving this directory first. One
+` + `  server per workspace: a second one dies on the lock over
+` + `  publisher.db, and moving it to free ports instead leaves it
+` + `  at initializing forever, because the lock is on the
+` + "  workspace, not the port."));
+    if (result.hasStartScript) {
+      lines.push(`  ${cyan("npm start")}   ${dim("for every boot after that")}`);
+    } else {
+      lines.push(`  ${dim("for every boot after that:")}`);
+      lines.push(`  ${cyan(result.startCommand)}`);
+    }
+    if (!result.hasResetScript) {
+      lines.push(...exposureWarning("npm run reset", result.declinedResetScript));
+    }
+  } else if (result.hasStartScript) {
+    lines.push(`  ${cyan("npm start")}   ${dim(startNote(result, environmentIsEmpty))}`);
+  } else {
+    lines.push(`  ${dim(`start Publisher (${declinedScriptReason(result.declinedStartScript, "start")}):`)}`);
+    lines.push(`  ${cyan(result.startCommand)}`);
+  }
+  if (!result.hasStartScript) {
+    lines.push(...exposureWarning("npm start", result.declinedStartScript));
+  }
+  lines.push(`  ${cyan(url)}   ${dim("explore in the browser")}`);
+  lines.push("");
+  lines.push(bold("Check it is ready:"));
+  lines.push(`  curl -s ${url}/api/v0/status`);
+  const packagesUrl = `${url}/api/v0/environments/${result.envName}/packages`;
+  if (environmentIsEmpty) {
+    lines.push(dim(`  It reports serving with nothing to serve. There is no
+` + `  environment to list packages from until a package exists, so
+` + `  ${packagesUrl}
+` + "  answers 404 until then."));
+  } else {
+    lines.push(`  curl -s ${packagesUrl}`);
+    lines.push(dim(`  The second one is the check that matters: the status says
+` + `  serving even when nothing loaded. A package the server could
+` + "  not mount is simply missing from that list, so " + (result.packageCreated ? `an empty []
+  means it could not load ${result.packageName}, and the reason is in the
+  server's own log.` : `a package
+  missing from it is one the server could not load, and the reason is
+  in the server's own log.`)));
+  }
+  lines.push("");
+  lines.push(bold("Connect an agent:"));
+  lines.push(`  MCP endpoint http://localhost:${result.mcpPort}/mcp`);
+  if (result.mcpMerged) {
+    const added = !result.mcpEntryReplaced;
+    const others = result.mcpOtherServers;
+    const alongside = others > 0 ? `, alongside the ${others} server${others === 1 ? "" : "s"} already in it` : "";
+    lines.push(dim(added ? `  the malloy server was added to your ${result.mcpConfigPath}${alongside}.` : `  your ${result.mcpConfigPath} already had a malloy server pointing ` + `somewhere else; it now points at the endpoint above${alongside}.`));
+  } else if (result.mcpWired) {
+    lines.push(dim(`  ${result.mcpConfigPath} points at it${result.host === "cursor" ? "" : ", so Claude Code offers it"}.`));
+  } else {
+    const problem = result.mcpConfigProblem ?? "not usable";
+    const paste = (result.mcpPasteBlock ?? "").trimEnd();
+    if (paste === "") {
+      lines.push(yellow(`  ${result.mcpConfigPath} is ${problem}, so it was left alone. ` + `Add an MCP server named "malloy" pointing at the endpoint ` + `above by hand; ${result.agentsFile} has the block.`));
+    } else {
+      lines.push(yellow(`  ${result.mcpConfigPath} is ${problem}, so it was left alone. ` + `Add this server to it by hand:`));
+      for (const line of paste.split(`
+`)) {
+        lines.push(`    ${line}`);
+      }
+    }
+  }
+  lines.push(dim(`  An agent that starts the server itself can't reconnect MCP in that
+` + `  session; ask the user to reconnect it. See ${result.agentsFile}.`));
+  lines.push("");
+  return lines.join(`
+`) + `
+`;
+}
+function startNote(result, environmentIsEmpty) {
+  if (!wroteStartScript(result)) {
+    return environmentIsEmpty ? "run this directory's own start script; it boots Publisher on a loopback address, with no environment to browse" : "run this directory's own start script, which boots Publisher on a loopback address";
+  }
+  if (environmentIsEmpty) {
+    return "start Publisher anyway; it reports serving, with no environment to browse";
+  }
+  if (result.packageCreated) {
+    return "start Publisher (web UI + MCP) with the package in watch mode";
+  }
+  return "start Publisher (web UI + MCP) with this workspace's packages in watch mode";
+}
+function excessArgumentsHint() {
+  const npmCreateFix = `  ${cyan("npm create @malloy-publisher/malloy-package sales -- --data mydata.csv")}`;
+  if (process.env.npm_command === "init") {
+    return [
+      "",
+      "npm parsed this command line before the scaffolder saw it, so the",
+      "options came through as bare arguments. Put a -- in front of them:",
+      npmCreateFix,
+      ""
+    ].join(`
+`);
+  }
+  return [
+    "",
+    "If you ran this through `npm create`, npm parsed the command line before",
+    "the scaffolder saw it and the options came through as bare arguments.",
+    "Put a -- in front of them:",
+    npmCreateFix,
+    "",
+    "With npx there is no separator: it forwards the flags as they are, and a",
+    "-- would be passed through and counted as another argument.",
+    `  ${cyan("npx @malloy-publisher/create-malloy-package sales --data mydata.csv")}`,
+    ""
+  ].join(`
+`);
+}
+var program = new Command;
+program.name("create-malloy-package").description("Scaffold a Malloy Publisher package and a local agent workspace.").version(version(), "-v, --version").argument("[name]", "package name to create; omit to only wire the agent workspace into the current directory").option("--data <file>", "seed the package from a CSV, Parquet, or XLSX file").addOption(new Option("--client <client>", "agent client to wire up").choices(CLIENTS).default("claude-code")).option("--force", "overwrite existing workspace files instead of keeping them").allowExcessArguments(false).exitOverride((err) => {
+  if (err.code === "commander.excessArguments") {
+    process.stderr.write(excessArgumentsHint());
+  }
+  if (err.code === "commander.unknownOption" && err.message.includes("--host")) {
+    process.stderr.write(`
+The flag that picks the agent client is ${cyan("--client")} (claude-code or cursor).
+` + `--host is Publisher's own flag for the address its server binds to.
+
+`);
+  }
+  process.exit(err.exitCode);
+}).action((name, options) => {
+  run(name, options);
+});
+function startedAsProgram() {
+  const entry = process.argv[1];
+  if (entry === undefined) {
+    return true;
+  }
+  try {
+    return fs5.realpathSync(entry) === fs5.realpathSync(fileURLToPath2(import.meta.url));
+  } catch {
+    return true;
+  }
+}
+if (startedAsProgram()) {
+  program.parse();
+}
+export {
+  snapshotArtifacts,
+  formatSuccess,
+  formatFailure,
+  changesSince
+};