turnzero 0.25.0-next.1 → 0.25.1-next.1

package/dist/turnzero-cloud.mjs

@@ -8618,8 +8618,66 @@ var applicationStandsLines = (template, takeLines) => {
     STANDS_DEPLOY_LINE
   ];
 };
+var TAKE_MADE_FILES = Object.freeze({
+  "package.json": "file",
+  lib: "folder",
+  "package-lock.json": "file",
+  node_modules: "folder"
+});
+var TAKE_MADE_FILE_LIMIT = 65536;
+var LIBRARY_COPIES = "lib";
+var takeMadeEntriesOf = (io2, app) => {
+  try {
+    const names = io2.listFolder(app) ?? [];
+    if (!names.includes("package.json") || !names.includes(LIBRARY_COPIES)) return null;
+    for (const name2 of names) {
+      const kind = Object.hasOwn(TAKE_MADE_FILES, name2) ? TAKE_MADE_FILES[name2] : void 0;
+      const standing = io2.stat(join10(app, name2));
+      if (kind === void 0 || standing === null || standing.folder !== (kind === "folder")) return null;
+    }
+    const packageFile = join10(app, "package.json");
+    if ((io2.stat(packageFile)?.size ?? Infinity) > TAKE_MADE_FILE_LIMIT) return null;
+    const parsed = JSON.parse(jsonTextOf(io2.readFile(packageFile)));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const members = parsed;
+    const { name, private: privateFlag, dependencies, ...rest } = members;
+    const { type, ...others } = rest;
+    if (Object.keys(others).length > 0 || typeof name !== "string" || privateFlag !== true) return null;
+    if (Object.hasOwn(members, "type") && type !== "module") return null;
+    if (dependencies === null || typeof dependencies !== "object" || Array.isArray(dependencies)) return null;
+    const entries = [];
+    for (const [packageName, spec] of Object.entries(dependencies)) {
+      const entry = packageName.slice(PACKAGE_SCOPE.length);
+      if (!packageName.startsWith(PACKAGE_SCOPE) || entry.includes("/") || !LIBRARY_ENTRY_NAME_FORM.test(entry) || spec !== `file:${LIBRARY_COPIES}/${entry}`) return null;
+      entries.push(entry);
+    }
+    const lib = join10(app, LIBRARY_COPIES);
+    const copies = io2.listFolder(lib) ?? [];
+    if (entries.length === 0 || copies.length !== entries.length || !copies.every((copy) => entries.includes(copy))) return null;
+    return entries.every((entry) => io2.stat(join10(lib, entry))?.folder === true) ? entries : null;
+  } catch {
+    return null;
+  }
+};
+var takeMadeLines = (template, entries, lineOf) => {
+  const own = new Set(TEMPLATE_FACTS[template].takes.map((take) => take.entry));
+  const again = entries.filter((entry) => !own.has(entry));
+  const first = `The project's root holds ${APPLICATION_FOLDER}/ with only what a library take made, its package.json and the copies under ${LIBRARY_COPIES}/, and ${SCAFFOLD_SUBCOMMAND} writes into no ${APPLICATION_FOLDER}/ that holds files. ${NOTHING_WRITTEN2}`;
+  const opening = `To start a new application here, delete ${APPLICATION_FOLDER}/, then run the same line again`;
+  if (again.length === 0) {
+    const taken = entries.length === 1 ? `the ${entries[0]} entry` : `the ${listedAnd(entries)} entries`;
+    return [first, `${opening}, which takes ${taken} itself.`];
+  }
+  const lines = again.map(lineOf);
+  if (again.length === 1) return [first, `${opening}, then run this line at the project's root, which takes the ${again[0]} entry again into the new ${APPLICATION_FOLDER}/: ${lines[0]}`];
+  return [
+    first,
+    `${opening}, then run each of these ${LINE_COUNT_WORDS[lines.length] ?? lines.length} lines at the project's root, in order, which take the ${listedAnd(again)} entries again into the new ${APPLICATION_FOLDER}/:`,
+    ...lines
+  ];
+};
 var STAGE_NOT_OWN = `Something that is not this run's own stands at ${STAGE_FOLDER} in the project's root, the name the scaffold writes under, an earlier run's files under another template or another resource name among it: move or remove ${STAGE_FOLDER}, then run the line again. ${NOTHING_WRITTEN2}`;
-var folderRefusalOf = (io2, options, files, takeLines) => {
+var folderRefusalOf = (io2, options, files, takeLines, lineOf) => {
   const { root } = options;
   for (let at = root; ; at = dirname6(at)) {
     const standing2 = io2.stat(at);
@@ -8634,7 +8692,10 @@ var folderRefusalOf = (io2, options, files, takeLines) => {
   const notOwn = STAGE_NOT_OWN;
   const standing = io2.stat(app);
   if (standing === null ? danglingAt(io2, root, APPLICATION_FOLDER) : !standing.folder) return [noFolderSentence(APPLICATION_FOLDER, "the scaffold writes the application")];
-  if (standing !== null && (io2.listFolder(app) ?? []).length > 0) return applicationStandsLines(options.template, takeLines);
+  if (standing !== null && (io2.listFolder(app) ?? []).length > 0) {
+    const taken = takeMadeEntriesOf(io2, app);
+    return taken !== null ? takeMadeLines(options.template, taken, lineOf) : applicationStandsLines(options.template, takeLines);
+  }
   if (!heldInside(io2, root, app)) return [scaffoldLinkSentence(`The application's folder, ${APPLICATION_FOLDER}/,`)];
   const staged = io2.stat(stage);
   if (staged === null && danglingAt(io2, root, STAGE_FOLDER)) return [notOwn];
@@ -8814,8 +8875,10 @@ async function scaffold(call, io2) {
   const files = writtenFilesOf(template, options.names, options.fields);
   const app = join10(root, APPLICATION_FOLDER);
   const stage = join10(root, STAGE_FOLDER);
-  const takeLinesFor = (at) => takes.map((take) => machineLineOf(libraryTakeLineOf({ origin: at, entry: take.entry }), { windows: io2.windows ?? LINES_IN_WINDOWS_FORM, npx: ranThroughNpx(io2) }, at));
+  const takeLineFor = (entry, at) => machineLineOf(libraryTakeLineOf({ origin: at, entry }), { windows: io2.windows ?? LINES_IN_WINDOWS_FORM, npx: ranThroughNpx(io2) }, at);
+  const takeLinesFor = (at) => takes.map((take) => takeLineFor(take.entry, at));
   let lineOrigin = origin;
+  const lineOf = (entry) => takeLineFor(entry, lineOrigin);
   let takeLines = takeLinesFor(lineOrigin);
   let finishWords = FINISH_WORDS;
   let reached = "checks";
@@ -8835,7 +8898,7 @@ async function scaffold(call, io2) {
   };
   let release = () => void 0;
   try {
-    const refused = folderRefusalOf(io2, options, files, takeLines);
+    const refused = folderRefusalOf(io2, options, files, takeLines, lineOf);
     if (refused !== null) return refuse(...refused);
     const checks = [];
     let held;
@@ -8878,7 +8941,7 @@ async function scaffold(call, io2) {
         held = { library: checks[0].library, fresh: checks[0].fresh, packages: takenPackagesOf(checks) };
       }
     }
-    const arrived = folderRefusalOf(io2, options, files, takeLines);
+    const arrived = folderRefusalOf(io2, options, files, takeLines, lineOf);
     if (arrived !== null) return refuse(...arrived);
     const toolsStands = standsAt(io2, root, TOOLS_FILE);
     const claudeStands = standsAt(io2, root, CLAUDE_FILE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turnzero",
-  "version": "0.25.0-next.1",
+  "version": "0.25.1-next.1",
   "type": "module",
   "description": "The Turn Zero Cloud command, which an AI coding tool runs on your machine to deploy an application, store a secret, upload a file, download an export, take a library entry, write a local run's settings, start the application locally, and scaffold a new service from a template.",
   "license": "Apache-2.0",