@malloy-publisher/create-malloy-package 0.0.28 → 0.0.30

package/dist/index.js

@@ -2,8 +2,8 @@
 
 // src/index.ts
 import * as crypto from "node:crypto";
-import * as fs5 from "node:fs";
-import * as path4 from "node:path";
+import * as fs4 from "node:fs";
+import * as path3 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { Command, Option } from "commander";
 
@@ -406,8 +406,8 @@ function staleScaffolderWarning(running, latest) {
 }
 
 // src/scaffold.ts
-import * as fs4 from "node:fs";
-import * as path3 from "node:path";
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
 
 // src/config.ts
 import * as fs from "node:fs";
@@ -528,126 +528,24 @@ function addPackage(config, envName, pkg) {
   return { added: true, envName: env.name };
 }
 
+// src/scaffold.ts
+import { installSkills, isWithinDirectory } from "@malloy-publisher/skills";
+
 // src/skills.ts
-import * as fs2 from "node:fs";
-import * as path from "node:path";
-import { skillsDir } from "@malloy-publisher/skills";
+import { countSkills, 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 * as fs2 from "node:fs";
+import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-var templatesDir = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", "templates");
+var templatesDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "templates");
 function renderTemplate(name, vars) {
-  const raw = fs3.readFileSync(path2.join(templatesDir, name), "utf8");
+  const raw = fs2.readFileSync(path.join(templatesDir, name), "utf8");
   const referenced = new Set;
   const rendered = raw.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
     if (!(key in vars)) {
@@ -675,7 +573,7 @@ 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.9.2";
+var SERVER_VERSION = "0.9.4";
 function startCommandFor(envName) {
   return `npx -y @malloy-publisher/server@${SERVER_VERSION} --server_root . ` + `--config ./publisher.config.json --host ${BIND_HOST} ` + `--watch-env ${envName}`;
 }
@@ -746,8 +644,8 @@ function scaffold(options) {
     mcpEntryReplaced: false,
     skillsInstalled: 0
   };
-  const configPath = path3.join(options.cwd, "publisher.config.json");
-  const configExists = fs4.existsSync(configPath);
+  const configPath = path2.join(options.cwd, "publisher.config.json");
+  const configExists = fs3.existsSync(configPath);
   const config = configExists ? readConfig(configPath) : defaultConfig(ENV_NAME);
   const targetEnv = targetEnvironment(config, ENV_NAME);
   if (targetEnv !== undefined) {
@@ -774,9 +672,9 @@ function createPackage(options, result) {
   const sourceName = toMalloyIdentifier(name);
   const modelIsIndex = sourceName.toLowerCase() === "index";
   const modelFile = modelIsIndex ? INDEX_MODEL_NAME : `${sourceName}.malloy`;
-  const packageDir = path3.join(options.cwd, name);
-  const packageDirExists = fs4.existsSync(packageDir);
-  if (packageDirExists && !fs4.lstatSync(packageDir).isDirectory()) {
+  const packageDir = path2.join(options.cwd, name);
+  const packageDirExists = fs3.existsSync(packageDir);
+  if (packageDirExists && !fs3.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.`);
@@ -789,25 +687,25 @@ function createPackage(options, result) {
 ` + `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@latest ${name} -- --force`);
   }
-  const dataDir = path3.join(packageDir, "data");
+  const dataDir = path2.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) + `
+  fs3.mkdirSync(dataDir, { recursive: true });
+  writeFile(path2.join(packageDir, "publisher.json"), JSON.stringify({ name }, null, 2) + `
 `, options.cwd);
-  writeFile(path3.join(packageDir, "malloy-config.json"), JSON.stringify({
+  writeFile(path2.join(packageDir, "malloy-config.json"), JSON.stringify({
     connections: {
       duckdb: {
         is: "duckdb",
-        workingDirectory: path3.resolve(packageDir)
+        workingDirectory: path2.resolve(packageDir)
       }
     }
   }, null, 2) + `
 `, options.cwd);
   let dataPath;
   if (options.dataFile !== undefined) {
-    const sourceBase = path3.basename(options.dataFile);
+    const sourceBase = path2.basename(options.dataFile);
     const destBase = sanitizeFileName(sourceBase);
-    copyFile(options.dataFile, path3.join(dataDir, destBase), options.cwd, `${name}/data/${destBase}`);
+    copyFile(options.dataFile, path2.join(dataDir, destBase), options.cwd, `${name}/data/${destBase}`);
     dataPath = `data/${destBase}`;
     if (destBase !== sourceBase) {
       result.dataFileRenamedFrom = sourceBase;
@@ -816,14 +714,14 @@ function createPackage(options, result) {
     if (siblings.length > 0) {
       result.siblingDataFiles = siblings;
     }
-    writeFile(path3.join(packageDir, modelFile), renderTemplate(isSpreadsheet(dataPath) ? "model.custom.xlsx.malloy" : "model.custom.malloy", { sourceName, dataPath }), options.cwd);
+    writeFile(path2.join(packageDir, modelFile), renderTemplate(isSpreadsheet(dataPath) ? "model.custom.xlsx.malloy" : "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`);
+    copyFile(path2.join(templatesDir, "sales.csv"), path2.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);
+    writeFile(path2.join(packageDir, modelFile), renderTemplate("model.default.malloy", { sourceName }), options.cwd);
   }
   if (!modelIsIndex) {
-    writeFile(path3.join(packageDir, INDEX_MODEL_NAME), renderTemplate(INDEX_MODEL_NAME, { sourceName, modelFile }), options.cwd);
+    writeFile(path2.join(packageDir, INDEX_MODEL_NAME), renderTemplate(INDEX_MODEL_NAME, { sourceName, modelFile }), options.cwd);
   }
   result.packageCreated = true;
   result.packageName = name;
@@ -862,7 +760,7 @@ function wireWorkspace(options, config, configExists, configPath, packageEntry,
   } 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.needsReset = result.packageCreated && (fs3.existsSync(path2.join(cwd, "publisher_data")) || fs3.existsSync(path2.join(cwd, "publisher.db")));
   result.startCommand = startCommandFor(result.envName);
   result.resetCommand = resetCommandFor(result.envName);
   writeWorkspacePackageJson(cwd, options, result);
@@ -884,8 +782,8 @@ function wireWorkspace(options, config, configExists, configPath, packageEntry,
 function writeAgentsFile(cwd, content, options, result) {
   assertBriefingIsRecognisable(content);
   const relPath = "AGENTS.md";
-  const target = path3.join(cwd, relPath);
-  const exists = fs4.existsSync(target);
+  const target = path2.join(cwd, relPath);
+  const exists = fs3.existsSync(target);
   const ours = exists && isGeneratedBriefing(target);
   if (!exists || ours || options.force) {
     writeFile(target, content, cwd);
@@ -895,14 +793,14 @@ function writeAgentsFile(cwd, content, options, result) {
     } else if (exists) {
       result.replaced.push(relPath);
     }
-    if (fs4.existsSync(path3.join(cwd, MALLOY_AGENTS_FILE))) {
+    if (fs3.existsSync(path2.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);
+  const existed = fs3.existsSync(path2.join(cwd, MALLOY_AGENTS_FILE));
+  writeFile(path2.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) {
@@ -911,7 +809,7 @@ function writeAgentsFile(cwd, content, options, result) {
 }
 function isGeneratedBriefing(target) {
   try {
-    return fs4.readFileSync(target, "utf8").includes(BRIEFING_MARKER);
+    return fs3.readFileSync(target, "utf8").includes(BRIEFING_MARKER);
   } catch {
     return false;
   }
@@ -922,27 +820,27 @@ function assertBriefingIsRecognisable(content) {
   }
 }
 function installWorkspaceSkills(cwd, result) {
-  const relDir = path3.join(".claude", "skills");
-  const skills = installSkills(path3.join(cwd, relDir), cwd);
+  const relDir = path2.join(".claude", "skills");
+  const skills = installSkills(path2.join(cwd, relDir), cwd);
   result.skillsInstalled = skills.installed;
   if (skills.refused) {
-    result.skipped.push(`${relDir}${path3.sep} (${skills.refused}; no skills were installed)`);
+    result.skipped.push(`${relDir}${path2.sep} (${skills.refused}; no skills were installed)`);
   }
   for (const name of skills.skipped) {
-    result.skipped.push(`${path3.join(relDir, name)} (symlink, not written through)`);
+    result.skipped.push(`${path2.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)`);
+    result.replaced.push(`${relDir}${path2.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 shown2 = skills.removed.slice(0, 5).map((entry) => printable(path2.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 absolute = path2.resolve(cwd);
   for (const character of absolute) {
     if (!isServablePathCharacter(character)) {
       const codePoint = character.codePointAt(0);
@@ -977,7 +875,7 @@ function assertWorkspacePathsContained(options, mcpConfigPath) {
     relatives.push(options.name);
   }
   for (const relative2 of relatives) {
-    assertWithinWorkspace(path3.join(options.cwd, relative2), options.cwd, relative2);
+    assertWithinWorkspace(path2.join(options.cwd, relative2), options.cwd, relative2);
   }
 }
 function assertWithinWorkspace(target, root, label) {
@@ -991,13 +889,13 @@ function assertNotReservedName(name) {
   }
 }
 function readWorkspacePackageJson(cwd) {
-  const target = path3.join(cwd, "package.json");
-  if (!fs4.existsSync(target)) {
+  const target = path2.join(cwd, "package.json");
+  if (!fs3.existsSync(target)) {
     return { kind: "absent" };
   }
   let text;
   try {
-    text = fs4.readFileSync(target, "utf8");
+    text = fs3.readFileSync(target, "utf8");
   } catch (err) {
     return {
       kind: "unusable",
@@ -1262,7 +1160,7 @@ function readMergeablePackageJson(cwd) {
 }
 function writeWorkspacePackageJson(cwd, options, result) {
   const relPath = "package.json";
-  const target = path3.join(cwd, relPath);
+  const target = path2.join(cwd, relPath);
   const manifest = readWorkspacePackageJson(cwd);
   if (manifest.kind === "absent") {
     writeFile(target, workspacePackageJson(cwd, result), cwd);
@@ -1296,8 +1194,8 @@ function writeWorkspacePackageJson(cwd, options, result) {
   }
 }
 function writeMcpConfig(cwd, relPath, result) {
-  const target = path3.join(cwd, relPath);
-  if (!fs4.existsSync(target)) {
+  const target = path2.join(cwd, relPath);
+  if (!fs3.existsSync(target)) {
     writeFile(target, mcpConfig(), cwd);
     result.written.push(relPath);
     result.mcpWired = true;
@@ -1306,7 +1204,7 @@ function writeMcpConfig(cwd, relPath, result) {
   let parsed;
   let parses = true;
   try {
-    parsed = parseJson(fs4.readFileSync(target, "utf8"));
+    parsed = parseJson(fs3.readFileSync(target, "utf8"));
   } catch {
     parses = false;
   }
@@ -1439,7 +1337,7 @@ function isNameableHere(name) {
 }
 function workspacePackageJson(cwd, result) {
   return JSON.stringify({
-    name: toNpmName(path3.basename(path3.resolve(cwd))),
+    name: toNpmName(path2.basename(path2.resolve(cwd))),
     version: "0.1.0",
     private: true,
     engines: {
@@ -1469,8 +1367,8 @@ function workspaceGitignore() {
 }
 function mergeGitignore(cwd, result) {
   const relPath = ".gitignore";
-  const target = path3.join(cwd, relPath);
-  if (!fs4.existsSync(target)) {
+  const target = path2.join(cwd, relPath);
+  if (!fs3.existsSync(target)) {
     writeFile(target, workspaceGitignore(), cwd);
     result.written.push(relPath);
     return;
@@ -1478,7 +1376,7 @@ function mergeGitignore(cwd, result) {
   assertWithinWorkspace(target, cwd, relPath);
   let existing;
   try {
-    existing = fs4.readFileSync(target, "utf8");
+    existing = fs3.readFileSync(target, "utf8");
   } catch (err) {
     result.skipped.push(`${relPath} (could not be read, so Publisher's files are not ` + `ignored here: ${err.message})`);
     return;
@@ -1494,7 +1392,7 @@ function mergeGitignore(cwd, result) {
 ` : `
 
 `;
-  fs4.appendFileSync(target, `${prefix}${GITIGNORE_HEADER}
+  fs3.appendFileSync(target, `${prefix}${GITIGNORE_HEADER}
 ${missing.join(`
 `)}
 `);
@@ -1533,27 +1431,27 @@ var LOADABLE_DATA_EXTENSIONS = [
   ".xlsx"
 ];
 function isLoadableDataFile(file) {
-  return LOADABLE_DATA_EXTENSIONS.includes(path3.extname(file).toLowerCase());
+  return LOADABLE_DATA_EXTENSIONS.includes(path2.extname(file).toLowerCase());
 }
 function isSpreadsheet(dataPath) {
-  return path3.extname(dataPath).toLowerCase() === ".xlsx";
+  return path2.extname(dataPath).toLowerCase() === ".xlsx";
 }
 function validateDataFile(dataFile) {
-  if (!fs4.existsSync(dataFile) || !fs4.statSync(dataFile).isFile()) {
+  if (!fs3.existsSync(dataFile) || !fs3.statSync(dataFile).isFile()) {
     throw new ScaffoldError(`--data file not found: ${printable(dataFile)}`);
   }
   if (!isLoadableDataFile(dataFile)) {
-    throw new ScaffoldError(`--data must be one of ${LOADABLE_DATA_EXTENSIONS.join(", ")} (got "${printable(path3.basename(dataFile))}").`);
+    throw new ScaffoldError(`--data must be one of ${LOADABLE_DATA_EXTENSIONS.join(", ")} (got "${printable(path2.basename(dataFile))}").`);
   }
 }
 function findSiblingDataFiles(dataFile) {
   let entries;
   try {
-    entries = fs4.readdirSync(path3.dirname(dataFile));
+    entries = fs3.readdirSync(path2.dirname(dataFile));
   } catch {
     return [];
   }
-  const chosen = path3.basename(dataFile);
+  const chosen = path2.basename(dataFile);
   return entries.filter((e) => e !== chosen && isLoadableDataFile(e)).sort().map(printable);
 }
 function toNpmName(base) {
@@ -1564,8 +1462,8 @@ 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);
+  const target = path2.join(cwd, relPath);
+  const exists = fs3.existsSync(target);
   if (exists && !options.force) {
     result.skipped.push(relPath);
     return false;
@@ -1578,20 +1476,20 @@ function writeIfAbsent(cwd, relPath, content, options, result) {
   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);
+  assertWithinWorkspace(target, root, path2.relative(root, target) || target);
+  fs3.mkdirSync(path2.dirname(target), { recursive: true });
+  fs3.writeFileSync(target, content);
 }
 function copyFile(source, target, root, label) {
   assertWithinWorkspace(target, root, label);
-  fs4.copyFileSync(source, target);
+  fs3.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"));
+    const pkg = JSON.parse(fs4.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
   } catch {
     return "unknown";
@@ -1607,7 +1505,7 @@ function resolveDataFile(cwd, data) {
   if (data.trim() === "") {
     throw new ScaffoldError(`--data was given an empty filename. Pass the CSV, Parquet, JSON, NDJSON, or XLSX ` + `file to seed the package from, or leave --data off to use the ` + `sample data.`);
   }
-  return path4.resolve(cwd, data);
+  return path3.resolve(cwd, data);
 }
 async function run(name, options) {
   const cwd = process.cwd();
@@ -1648,11 +1546,11 @@ function artifactCandidates(name) {
     "publisher.config.json",
     "package.json",
     ".mcp.json",
-    path4.join(".cursor", "mcp.json"),
+    path3.join(".cursor", "mcp.json"),
     ".gitignore",
     "AGENTS.md",
     "CLAUDE.md",
-    path4.join(".claude", "skills")
+    path3.join(".claude", "skills")
   ];
   if (name !== undefined && name !== "" && name !== "." && name !== ".." && !name.includes("/") && !name.includes("\\")) {
     paths.unshift(name);
@@ -1683,10 +1581,10 @@ function changesSince(cwd, name, before) {
   return changes;
 }
 function fingerprint(cwd, relPath) {
-  const target = path4.join(cwd, relPath);
+  const target = path3.join(cwd, relPath);
   let stat;
   try {
-    stat = fs5.lstatSync(target);
+    stat = fs4.lstatSync(target);
   } catch {
     return;
   }
@@ -1695,7 +1593,7 @@ function fingerprint(cwd, relPath) {
       return `dir:${digest(listDirectory(target))}`;
     }
     if (stat.isFile()) {
-      return `file:${digest(fs5.readFileSync(target))}`;
+      return `file:${digest(fs4.readFileSync(target))}`;
     }
     return `other:${stat.mode}:${linkTarget(target)}`;
   } catch {
@@ -1709,13 +1607,13 @@ function listDirectory(dir, cap = 5000) {
     const current = stack.pop();
     let children;
     try {
-      children = fs5.readdirSync(current, { withFileTypes: true });
+      children = fs4.readdirSync(current, { withFileTypes: true });
     } catch {
-      entries.push(`${path4.relative(dir, current)} unreadable`);
+      entries.push(`${path3.relative(dir, current)} unreadable`);
       continue;
     }
     for (const child of children) {
-      const full = path4.join(current, child.name);
+      const full = path3.join(current, child.name);
       if (child.isDirectory()) {
         stack.push(full);
         continue;
@@ -1723,11 +1621,11 @@ function listDirectory(dir, cap = 5000) {
       let size = -1;
       let mtime = -1;
       try {
-        const childStat = fs5.lstatSync(full);
+        const childStat = fs4.lstatSync(full);
         size = childStat.size;
         mtime = childStat.mtimeMs;
       } catch {}
-      entries.push(`${path4.relative(dir, full)} ${size} ${mtime}`);
+      entries.push(`${path3.relative(dir, full)} ${size} ${mtime}`);
     }
   }
   entries.sort();
@@ -1736,7 +1634,7 @@ function listDirectory(dir, cap = 5000) {
 }
 function linkTarget(target) {
   try {
-    return fs5.readlinkSync(target);
+    return fs4.readlinkSync(target);
   } catch {
     return "";
   }
@@ -1815,12 +1713,12 @@ function describeFailure(err) {
   return String(err);
 }
 function relativeToCwd(target) {
-  const relative3 = path4.relative(process.cwd(), target);
-  return relative3 && !relative3.startsWith("..") && !path4.isAbsolute(relative3) ? `./${relative3}` : target;
+  const relative3 = path3.relative(process.cwd(), target);
+  return relative3 && !relative3.startsWith("..") && !path3.isAbsolute(relative3) ? `./${relative3}` : target;
 }
 function readWorkspaceFile(cwd, relPath) {
   try {
-    return fs5.readFileSync(path4.join(cwd, relPath), "utf8");
+    return fs4.readFileSync(path3.join(cwd, relPath), "utf8");
   } catch {
     return;
   }
@@ -2160,7 +2058,7 @@ function startedAsProgram() {
     return true;
   }
   try {
-    return fs5.realpathSync(entry) === fs5.realpathSync(fileURLToPath2(import.meta.url));
+    return fs4.realpathSync(entry) === fs4.realpathSync(fileURLToPath2(import.meta.url));
   } catch {
     return true;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/create-malloy-package",
    "description": "Scaffold a Malloy Publisher package and a local agent workspace, so one command takes you from nothing to an agent that can query your data.",
-   "version": "0.0.28",
+   "version": "0.0.30",
    "license": "MIT",
    "type": "module",
    "engines": {
@@ -45,12 +45,12 @@
       "test:e2e": "bun test --timeout 180000 ./tests/e2e"
    },
    "dependencies": {
-      "@malloy-publisher/skills": "^0.1.34",
+      "@malloy-publisher/skills": "^0.1.35",
       "commander": "^12.1.0"
    },
    "devDependencies": {
       "@eslint/js": "^8.57.0",
-      "@malloydata/malloy": "^0.0.434",
+      "@malloydata/malloy": "^0.0.435",
       "@modelcontextprotocol/sdk": "^1.31.0",
       "@types/bun": "^1.2.21",
       "@types/node": "^24.10.0",
@@ -59,5 +59,5 @@
       "eslint": "^8.50.0",
       "typescript": "^5.3.3"
    },
-   "publisherServer": "0.9.2"
+   "publisherServer": "0.9.4"
 }