agentful 0.4.15 → 0.4.16

package/README.md

@@ -51,11 +51,14 @@ in or creates a project.
 
 `agentful push --dry-run` shows that check on its own: what would be uploaded
 and what is left out, the largest files, identical copies, media embedded in
-HTML, and every reason the upload would be rejected. It uploads nothing,
-creates no project and changes no file; it exits with 1 when the push would be
-blocked. `--dry-run --json` prints the same analysis as one JSON document
+HTML, and every reason the upload would be rejected. A file that is larger
+than a whole push on its own is named as such: it cannot be uploaded at all,
+whatever else is left out. It uploads nothing, creates no project and changes
+no file; it exits with 1 when the push would be blocked. `--dry-run --json`
+prints the same analysis as one JSON document
 (`"schema": "agentful.push-analysis"`) for scripts and agents; with `--summary`
-it leaves out the list of every file and keeps totals, limits and findings.
+it leaves out the list of every file, keeps totals, limits and findings, and
+prints every size as text next to its byte count.
 
 ## What you can deploy
 

package/dist/index.cjs

@@ -3044,7 +3044,7 @@ var VERSION, brand, useColor, wrap, paint, tuiDesign, sym, ui;
 var init_branding = __esm({
   "src/branding.ts"() {
     "use strict";
-    VERSION = "0.4.15" ? "0.4.15" : null.version;
+    VERSION = "0.4.16" ? "0.4.16" : null.version;
     brand = {
       name: "agentful",
       // the command users type
@@ -6561,7 +6561,7 @@ function formatBytes(bytes2, rounding = "nearest") {
   }
   if (unit === 0 || Number.isInteger(value)) return `${value} ${units[unit]}`;
   const tenths = value * 10;
-  const rounded = (rounding === "down" ? Math.floor(tenths) : Math.round(tenths)) / 10;
+  const rounded = (rounding === "down" ? Math.floor(tenths) : rounding === "up" ? Math.ceil(tenths) : Math.round(tenths)) / 10;
   return `${rounded.toFixed(1)} ${units[unit]}`;
 }
 function sizeOverLimit(bytes2, limit) {
@@ -6728,6 +6728,10 @@ function analyzePush(options) {
   }
   duplicates.sort((a, b) => b.redundant_zip_bytes - a.redundant_zip_bytes || (a.paths[0] < b.paths[0] ? -1 : 1));
   const redundantZipBytes = duplicates.reduce((total, group) => total + group.redundant_zip_bytes, 0);
+  const maxZipBytes = maxZipBytesForUpload(mode, mode === "source" ? readBackendDeclaration(rootDir) : null);
+  const oversized = measured.filter((file) => file.zipLower > maxZipBytes).sort((a, b) => b.zipLower - a.zipLower || byPath(a, b));
+  const oversizedPaths = new Set(oversized.map((file) => file.path));
+  const restZipLower = zipLower - oversized.reduce((total, file) => total + file.zipLower, 0);
   const preflight = mode === "source" ? runPreflight(rootDir) : null;
   const framework = preflight?.framework ?? null;
   const hasManifest = storedNames.has("package.json");
@@ -6739,12 +6743,14 @@ function analyzePush(options) {
     return {
       path: file.path,
       bytes: file.bytes,
+      zip_bytes: file.zip_bytes,
       title: file.title,
       sha256: file.sha256,
-      same_content_as: first && first !== file.path ? first : null
+      same_content_as: first && first !== file.path ? first : null,
+      ...file.zipLower > maxZipBytes ? { larger_than_a_push: true } : {}
     };
   });
-  const maxZipBytes = maxZipBytesForUpload(mode, mode === "source" ? readBackendDeclaration(rootDir) : null);
+  const fittingCandidates = candidates.filter((candidate) => !candidate.larger_than_a_push);
   const zipLimit = formatBytes(maxZipBytes, "down");
   const blockers = [];
   const warnings = [];
@@ -6782,10 +6788,18 @@ function analyzePush(options) {
   }
   if (zipLower > maxZipBytes) {
     const [size, allowed] = sizeOverLimit(zipExact ? zipBytes : zipLower, maxZipBytes);
+    let message = `The upload is ${zipExact ? "" : "at least "}${size} compressed \u2014 a push carries at most ${allowed} compressed.`;
+    if (oversized.length > 0) {
+      const one = oversized.length === 1;
+      const named = samplePaths(oversized.map((file) => `${file.path} (${sizeOverLimit(file.zipLower, maxZipBytes)[0]})`));
+      message += one ? ` ${named} is larger than that on its own, so no push can carry it.` : ` ${plural(oversized.length, "file")} are each larger than that on their own, so no push can carry them: ${named}.`;
+      message += ` Without ${one ? "it" : "them"} the upload is ${restZipLower > maxZipBytes ? `still ${sizeOverLimit(restZipLower, maxZipBytes)[0]} compressed` : `${formatBytes(restZipLower)} compressed, which is within that limit`}.`;
+    }
     blockers.push({
       code: "zip_too_large",
       overridable: false,
-      message: `The upload is ${zipExact ? "" : "at least "}${size} compressed \u2014 a push carries at most ${allowed} compressed.`
+      message,
+      ...oversized.length > 0 ? { paths: oversized.map((file) => file.path).slice(0, FINDING_PATHS) } : {}
     });
   } else if (!zipExact && zipBytes > maxZipBytes) {
     warnings.push({
@@ -6794,10 +6808,12 @@ function analyzePush(options) {
     });
   }
   if (entryMissing) {
+    const tooBig = candidates.filter((candidate) => candidate.larger_than_a_push);
+    const cannotBecomeIt = tooBig.length === 0 ? "" : fittingCandidates.length === 0 ? candidates.length === 1 ? " The one HTML file here cannot become it as it is: it is larger than a whole push." : ` None of the ${candidates.length} HTML files here can become it as they are: each is larger than a whole push.` : ` ${tooBig.length} of the ${candidates.length} HTML files here cannot become it as ${tooBig.length === 1 ? "it is" : "they are"}, larger than a whole push: ${samplePaths(tooBig.map((candidate) => candidate.path))}.`;
     blockers.push({
       code: "entry_missing",
       overridable: false,
-      message: mode === "dist" ? `No index.html at the top level of ${dirLabel === "." ? "the uploaded folder" : `${dirLabel}/`}. A prebuilt upload is served as it is, and index.html is its start page.` : "No index.html at the top level. Without a package.json this is a static site, and the platform serves index.html as its start page."
+      message: (mode === "dist" ? `No index.html at the top level of ${dirLabel === "." ? "the uploaded folder" : `${dirLabel}/`}. A prebuilt upload is served as it is, and index.html is its start page.` : "No index.html at the top level. Without a package.json this is a static site, and the platform serves index.html as its start page.") + cannotBecomeIt
     });
   }
   const backend = mode === "source" ? checkBackendDeclaration(rootDir) : null;
@@ -6838,11 +6854,11 @@ function analyzePush(options) {
   }
   const tooLarge = blockers.some((b) => b.code === "zip_too_large" || b.code === "unpacked_too_large");
   if (entryMissing) {
-    if (candidates.length > 0) {
+    if (fittingCandidates.length > 0) {
       suggestions.push({
         code: "name_start_page",
         message: "Rename or copy the page that should open first to index.html at the top level, check that its relative links still resolve, then push again.",
-        paths: candidates.map((candidate) => candidate.path).slice(0, FINDING_PATHS)
+        paths: fittingCandidates.map((candidate) => candidate.path).slice(0, FINDING_PATHS)
       });
     }
     const siteDirs = /* @__PURE__ */ new Set();
@@ -6864,29 +6880,31 @@ function analyzePush(options) {
     }
   }
   if (tooLarge) {
-    const oversized = measured.filter((file) => file.zipLower > maxZipBytes).sort((a, b) => b.bytes - a.bytes || byPath(a, b));
-    if (oversized.length > 0) {
-      suggestions.push({
-        code: "oversized_files",
-        message: `${samplePaths(oversized.map((file) => `${file.path} (${formatBytes(file.zipLower)} compressed)`))} ${oversized.length === 1 ? "is" : "are each"} larger than a whole push can carry. The upload cannot fit while ${oversized.length === 1 ? "it is" : "they are"} part of it.`,
-        paths: oversized.map((file) => file.path).slice(0, FINDING_PATHS)
-      });
-    }
-    if (duplicates.length > 0 && redundantZipBytes >= zipBytes / 20) {
-      const copies = duplicates.reduce((total, group) => total + group.paths.length - 1, 0);
-      const remaining = zipBytes - redundantZipBytes;
+    const overZip = zipLower - maxZipBytes;
+    const overFiles = storedBytes - MAX_UNPACKED_BYTES;
+    const mustStayOut = [
+      overZip > 0 ? `${formatBytes(overZip, "up")} of the ${formatBytes(zipLower)} compressed` : "",
+      overFiles > 0 ? `${formatBytes(overFiles, "up")} of the ${formatBytes(storedBytes)} of files` : ""
+    ].filter(Boolean);
+    const toFit = ` To fit, at least ${mustStayOut.join(" and ")} ${mustStayOut.length > 1 ? "have" : "has"} to stay out.`;
+    const spareCopies = duplicates.filter((group) => !oversizedPaths.has(group.paths[0]));
+    const spareZipBytes = spareCopies.reduce((total, group) => total + group.redundant_zip_bytes, 0);
+    const base = oversized.length > 0 ? restZipLower : zipBytes;
+    if (spareCopies.length > 0 && spareZipBytes >= base / 20) {
+      const copies = spareCopies.reduce((total, group) => total + group.paths.length - 1, 0);
+      const remaining = base - spareZipBytes;
       suggestions.push({
         code: "remove_identical_copies",
-        message: `${plural(copies, "file is an identical copy", "files are identical copies")} of another file and ${copies === 1 ? "adds" : "add"} ${formatBytes(redundantZipBytes)} to the compressed upload. If nothing links to the extra names, one copy each brings it to ${formatBytes(remaining)}${remaining > maxZipBytes ? ` \u2014 still above the ${zipLimit} limit` : ""}.`,
-        paths: duplicates.flatMap((group) => group.paths.slice(1)).slice(0, FINDING_PATHS)
+        message: `${plural(copies, "file is an identical copy", "files are identical copies")} of another file and ${copies === 1 ? "adds" : "add"} ${formatBytes(spareZipBytes)} to the compressed upload. If nothing links to the extra names, one copy each brings ${oversized.length > 0 ? "what is left without the files no push can carry" : "it"} to ${formatBytes(remaining)}${remaining > maxZipBytes ? ` \u2014 still above the ${zipLimit} limit` : ""}.`,
+        paths: spareCopies.flatMap((group) => group.paths.slice(1)).slice(0, FINDING_PATHS)
       });
     }
     suggestions.push(mode === "source" ? {
       code: "exclude_with_gitignore",
-      message: "Files and folders listed in .gitignore are not uploaded. Leave out what the site does not serve \u2014 originals, working files, exports."
+      message: `Files and folders listed in .gitignore are not uploaded. Leave out what the site does not serve \u2014 originals, working files, exports.${toFit}`
     } : {
       code: "narrow_prebuilt_directory",
-      message: "A prebuilt upload takes every file in the folder. Put the finished site into a folder of its own and pass it with --dir."
+      message: `A prebuilt upload takes every file in the folder. Put the finished site into a folder of its own and pass it with --dir.${toFit}`
     });
     suggestions.push({
       code: "upload_limit",
@@ -6961,7 +6979,19 @@ var SUMMARY_LISTS = {
   finding_paths: 8
 };
 var SUMMARY_MAX_BYTES = 24 * 1024;
-var printAnalysis = (analysis) => `${JSON.stringify(analysis, null, 2)}
+var sizeLabelKey = (key) => key === "base64_chars" ? "base64_size" : /(^|_)bytes(_|$)/.test(key) ? key.replace("bytes", "size") : null;
+function withSizeLabels(value) {
+  if (Array.isArray(value)) return value.map(withSizeLabels);
+  if (!value || typeof value !== "object") return value;
+  const labelled = {};
+  for (const [key, inner] of Object.entries(value)) {
+    labelled[key] = withSizeLabels(inner);
+    const label = typeof inner === "number" ? sizeLabelKey(key) : null;
+    if (label) labelled[label] = formatBytes(inner, key.startsWith("max_") ? "down" : "nearest");
+  }
+  return labelled;
+}
+var printAnalysis = (analysis) => `${JSON.stringify(analysis.view === "summary" ? withSizeLabels(analysis) : analysis, null, 2)}
 `;
 function summarize(analysis, divisor) {
   const shortened = {};
@@ -7088,7 +7118,7 @@ function renderAnalysis(analysis, options = {}) {
         lines.push("  HTML files found:");
         for (const candidate of analysis.entry.candidates.slice(0, SHOWN_FILES)) {
           lines.push(
-            `  ${sizeColumn(candidate.bytes)}  ${candidate.path}` + (candidate.title ? paint.dim(`  "${candidate.title}"`) : "") + (candidate.same_content_as ? paint.dim(`  (same content as ${candidate.same_content_as})`) : "")
+            `  ${sizeColumn(candidate.bytes)}  ${candidate.path}` + (candidate.title ? paint.dim(`  "${candidate.title}"`) : "") + (candidate.same_content_as ? paint.dim(`  (same content as ${candidate.same_content_as})`) : "") + (candidate.larger_than_a_push ? paint.dim("  (larger than a whole push)") : "")
           );
         }
         lines.push(...more(analysis.entry.candidates.length, SHOWN_FILES, "HTML file"));
@@ -8193,36 +8223,53 @@ compatibility finding.
 reports what a push would upload: no sign-in, no project, no upload, nothing
 written. Sizes, limits, what is left out and what blocks the upload come from
 that report and from nowhere else: quote its figures, never estimate or
-recompute them (\`limits.max_zip_bytes\` is the exact limit for this push).
-Run it before the first push of a session, after a push was stopped, and after
-you changed what gets uploaded. In between, \`agentful push\` applies the same
+recompute them. Next to every byte count the report prints the size as text
+(\`size\` for \`bytes\`, \`zip_size\` for \`zip_bytes\`): use that text, do not
+convert bytes yourself. \`limits.max_zip_bytes\` is the exact limit for this
+push. Run it before the first push of a session, after a push was stopped,
+and after you changed what gets uploaded. In between, \`agentful push\` applies the same
 check itself and stops before sign-in when something blocks. A blocker with
 \`"overridable": false\` is final, the platform rejects that upload: do not
 retry, do not add \`--force\`, do not look for another route.
 
 Every change to the user's files for a push (including \`.gitignore\`) and every
 project script you run for it needs the user's OK first: name the concrete
-change, ask, wait for the answer.
+change, ask, wait for the answer. One question per reply: one decision, not
+several joined together. Never ask what the report or the project files
+answer, such as whether a \`.gitignore\` is in effect
+(\`excluded.gitignore_applied\`), which files are large or which are copies.
 
 - **No start page** (\`entry_missing\`): the platform serves \`index.html\` from
   the top level. With \`entry.candidates\`: show them (path and title;
-  \`same_content_as\` marks copies) and ask which page opens first. A candidate
-  at the top level can be renamed to \`index.html\`, or copied, which keeps the
-  old address and adds the file's size to the upload: ask which. A candidate
-  in a subfolder must not be copied up, its relative links would break. If
-  that folder is the whole site, push the folder (\`suggestions\` carries the
-  command); otherwise adjust the links and show the diff. Without candidates,
-  ask which folder holds the site.
+  \`same_content_as\` marks copies, \`larger_than_a_push\` marks pages no push
+  can carry: they cannot be the start page as they are, say so) and ask which
+  of the others opens first. A candidate at the top level can be renamed to
+  \`index.html\`, or copied, which keeps the old address and adds the file's
+  size to the upload: ask which. A candidate in a subfolder must not be copied
+  up, its relative links would break. If that folder is the whole site, push
+  the folder (\`suggestions\` carries the command); otherwise adjust the links
+  and show the diff. Without candidates, ask which folder holds the site.
 - **Too large or too many files** (\`zip_too_large\`, \`unpacked_too_large\`,
-  \`too_many_files\`): explain where the size is, from \`largest_files\`,
-  \`by_top_level\`, \`duplicates\` and \`embedded_media\` (media stored inside text
-  files as \`data:\` URLs). The ways out that exist: leave out files the site
-  does not load (\`.gitignore\`, source push), or push only the finished output
-  folder (prebuilt). Before proposing to leave a file out, search the sources
-  for references to it and say what you checked: identical content does not
-  make a copy unused. Never shrink, re-encode, move or delete the user's files
-  on your own. If what the site needs stays above the limits, say plainly that
-  it cannot be pushed yet. Larger uploads are not available.
+  \`too_many_files\`): settle first whether the site can fit at all. The
+  \`zip_too_large\` blocker names the files that are each larger than a whole
+  push on their own (all of them in its \`paths\`), and its message says what
+  is left without them. Such a file can only stay out. If
+  the site needs one of them (the page the user wants as the start page, or a
+  file a page loads: search the sources for references), the site cannot be
+  pushed yet: say that plainly, with the file and its size. Do not offer
+  \`.gitignore\` or a prebuilt push as a way around it, neither lifts a limit,
+  and larger uploads are not available.
+  Where no such file is needed: explain where the size is, from
+  \`largest_files\`, \`by_top_level\`, \`duplicates\` and \`embedded_media\` (media
+  stored inside text files as \`data:\` URLs), and propose which files the site
+  does not load to leave out with \`.gitignore\`. The \`exclude_with_gitignore\`
+  suggestion says how much has to stay out; if the site needs more than fits,
+  say plainly that it cannot be pushed yet. Before proposing to leave a file
+  out, search the sources for references to it and say what you checked:
+  identical content does not make a copy unused. A prebuilt push is smaller
+  than a source push only where a build produces the output folder; a site
+  without a build step is the same upload either way. Never shrink,
+  re-encode, move or delete the user's files on your own.
 - **Compatibility findings** (\`"overridable": true\`): fix the cause in the
   code. \`--force\` only when the user asks to try the cloud build anyway.
 - **Files that would be missing on the site:** the warnings
@@ -8434,8 +8481,8 @@ var SLASH_COMMANDS = {
     description: `${brand.displayName}: check, deploy and get a preview URL`,
     template: `Deploy this project, following "Pushing to the platform" in AGENTFUL_CLOUD.md. Run every command from the project root using the bash tool. What I typed after the command (may be empty): "$ARGUMENTS". If it names \`--prebuilt\`, a folder for \`--dir\`, or \`--force\`, pass that on to both commands below.
 
-1. Run \`${PUSH_ANALYSIS_COMMAND}\`. It only reads files: no sign-in, no upload. Its JSON report is the only source for sizes, limits and what blocks the upload: quote its figures, never estimate them.
-2. If the report or the project calls for a decision (a blocker, a file the site needs that would not be uploaded, a build step the cloud does not run), explain the finding in plain words with the figures of the report and ask me how to proceed. One question at a time, then wait for my answer. Until then do not change any file, do not run project scripts and do not push.
+1. Run \`${PUSH_ANALYSIS_COMMAND}\`. It only reads files: no sign-in, no upload. Its JSON report is the only source for sizes, limits and what blocks the upload: quote its figures as printed (the \`size\` texts next to the byte counts), never estimate or convert them.
+2. If the report or the project calls for a decision (a blocker, a file the site needs that would not be uploaded, a build step the cloud does not run), explain the finding in plain words with the figures of the report. If the report shows that what I want to publish cannot fit (a page or file it needs is larger than a whole push, or it stays above the limits without the files it does not load), say that plainly and do not offer ways out that do not get it under the limits. Otherwise ask me how to proceed: exactly one question per reply, and never one the report or the project files answer. Then wait for my answer. Until then do not change any file, do not run project scripts and do not push.
 3. After a change I approved, run the analysis again.
 4. When nothing blocks, run \`agentful push\` with the bash tool's \`timeout\` set to ${PUSH_TOOL_TIMEOUT_MS} (milliseconds): the cloud build takes minutes and the default timeout would cut the push off halfway. The command never waits for input. It creates the project automatically if this directory is not linked yet.
 5. Report the preview URL on its own line and what the push printed about the backend. If it fails: quote the printed error verbatim, and if the failure happened in the cloud (not before the upload), also run \`agentful build-status\` and quote its phase/error/details as the cause. Diagnose ONLY from those records \u2014 never invent causes, env vars, or settings they do not show.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentful",
-  "version": "0.4.15",
+  "version": "0.4.16",
   "description": "Agentful in your terminal — local development with push-to-cloud previews",
   "license": "Apache-2.0",
   "homepage": "https://agentful.dev",