@yadurajfleetos/cli 0.9.2 → 0.10.1

package/dist/progress.js

@@ -14,6 +14,7 @@
  * a persistently unreachable control plane as an error.
  */
 import { request, CliError, EXIT } from './api.js';
+import { bar } from './ui.js';
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /** A failure reason can be a build log tail; a one-line error gets one line of it. */
 export const firstLine = (text) => text.split('\n')[0].trim().slice(0, 200);
@@ -30,7 +31,51 @@ export function progressLine(p) {
         return undefined;
     const counter = p.step && p.ofSteps ? `${p.step}/${p.ofSteps} ` : '';
     const platform = p.platform ? `${p.platform.replace(/^linux\//, '')} ` : '';
-    return `${counter}${platform}${p.detail}`;
+    // Emulation is the answer to "why is this taking so long", and a build that
+    // takes three minutes instead of twenty seconds is almost always this. Said
+    // once, on the line already being drawn, rather than as a separate warning.
+    const how = p.emulated ? ' (emulated — slow)' : '';
+    return `${counter}${platform}${p.detail}${how}`;
+}
+/**
+ * A duration a person reads, not a step suffix.
+ *
+ * ui.ts has `duration`, which is dim, colour-wrapped, prefixed with a space
+ * and renders three minutes as "180s" — right for the end of a finished step,
+ * wrong for a sentence about how long is left.
+ */
+function human(ms) {
+    const total = Math.max(0, Math.round(ms / 1000));
+    if (total < 60)
+        return `${total}s`;
+    const minutes = Math.floor(total / 60);
+    const seconds = total % 60;
+    if (minutes < 60)
+        return seconds ? `${minutes}m ${seconds}s` : `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+}
+/**
+ * Elapsed against what this service usually takes.
+ *
+ * Only from real history: on a first deploy there is nothing honest to say,
+ * and a bar filled from a number nobody measured is the same lie as the "not
+ * needed" it replaces. Overrunning is shown as overrunning rather than parked
+ * at the end of the bar — a deploy that is genuinely slow today is exactly
+ * when somebody needs to know.
+ */
+export function etaLine(p, now = Date.now()) {
+    if (!p.typicalMs || !p.since)
+        return undefined;
+    const elapsed = now - new Date(p.since).getTime();
+    if (elapsed < 0)
+        return undefined;
+    const fraction = Math.min(1, elapsed / p.typicalMs);
+    const left = p.typicalMs - elapsed;
+    const tail = left > 0
+        ? `~${human(left)} left`
+        : `${human(-left)} over the usual ${human(p.typicalMs)}`;
+    return `${bar(fraction)} ${human(elapsed)} · ${tail}`;
 }
 /**
  * Poll `/progress` in the background while something else is being awaited.
@@ -184,7 +229,14 @@ export function phaseWalker(l, steps = DEPLOY_STEPS) {
                 // poll, and it belongs on the step that decided it.
                 advance(target, at === 0 ? (p.nodeName ?? undefined) : undefined);
             }
-            const line = progressLine(p);
+            // The build line, or the estimate when there is no build line to show.
+            //
+            // Both on one row rather than two: the ladder redraws a fixed region and
+            // a row that appears and disappears makes the whole block jump. During a
+            // build the sub-step is the more useful of the two — it is proof of
+            // movement — and the estimate carries the rest of the wait, when the
+            // node is pulling an image and nothing is being logged at all.
+            const line = progressLine(p) ?? etaLine(p);
             if (line && at < steps.length)
                 l.detail(steps[at].key, line);
         },

package/dist/repomap.js

@@ -27,20 +27,34 @@ const SKIP = new Set([
  * the middle of a server file is business logic nobody needs to see.
  */
 const EVIDENCE = [
-    { name: /^package\.json$/, lines: 60 },
-    { name: /^(requirements|requirements-prod)\.txt$/, lines: 40 },
-    { name: /^(pyproject\.toml|Pipfile|go\.mod|Cargo\.toml|Gemfile)$/, lines: 40 },
-    { name: /^Dockerfile(\..+)?$/, lines: 40 },
-    { name: /^(docker-)?compose\.ya?ml$/, lines: 60 },
-    { name: /^\.env\.(example|sample|template)$/, lines: 40 },
-    { name: /^(main|server|app|index)\.(js|ts|mjs|py|go|rb)$/, lines: 40 },
-    { name: /^(vite|next|nuxt|astro|svelte)\.config\.(js|ts|mjs)$/, lines: 25 },
-    { name: /^README(\.md)?$/, lines: 20 },
+    // Tier 1 answers "what is this and what port does it serve" — the two
+    // questions the manifest is actually made of.
+    { name: /^package\.json$/, lines: 45, tier: 1 },
+    { name: /^(requirements|requirements-prod)\.txt$/, lines: 30, tier: 1 },
+    { name: /^(pyproject\.toml|Pipfile|go\.mod|Cargo\.toml|Gemfile)$/, lines: 30, tier: 1 },
+    { name: /^Dockerfile(\..+)?$/, lines: 30, tier: 1 },
+    { name: /^(docker-)?compose\.ya?ml$/, lines: 50, tier: 1 },
+    // Tier 2 is where a route prefix or a listen() hides.
+    { name: /^(main|server|app|index)\.(js|ts|mjs|py|go|rb)$/, lines: 30, tier: 2 },
+    { name: /^(vite|next|nuxt|astro|svelte)\.config\.(js|ts|mjs)$/, lines: 20, tier: 2 },
+    { name: /^\.env\.(example|sample|template)$/, lines: 25, tier: 2 },
+    // Tier 3 is context, and the first thing to go.
+    { name: /^README(\.md)?$/, lines: 15, tier: 3 },
 ];
 const MAX_DEPTH = 3;
-const MAX_TREE_ENTRIES = 300;
-/** Comfortably inside the endpoint's limit, with room for the draft. */
-const MAX_TOTAL_CHARS = 48_000;
+/**
+ * Sized for a model's context, not for the endpoint's limit.
+ *
+ * A free Groq tier allows 8000 tokens a minute for the whole request. This
+ * repository's map came to 25kB — about 6,300 tokens — and with the system
+ * prompt and the draft on top the request was 8,901 and refused. Roughly four
+ * characters to the token, so 14kB of evidence leaves room for the prompt, the
+ * draft, and a reply containing a whole manifest.
+ */
+const MAX_TOTAL_CHARS = 14_000;
+/** The tree is orientation, not evidence, and it was a fifth of the budget. */
+const MAX_TREE_ENTRIES = 120;
+const MAX_TREE_CHARS = 2_500;
 function windowOf(text, lines) {
     const all = text.split('\n');
     if (all.length <= lines)
@@ -86,35 +100,66 @@ async function tree(root) {
 /** Build the evidence bundle for a repository root. */
 export async function repoMap(root = process.cwd()) {
     const paths = await tree(root);
-    const sections = [
-        '## Tree',
-        paths.join('\n'),
-    ];
+    let treeText = paths.join('\n');
+    if (treeText.length > MAX_TREE_CHARS) {
+        treeText = treeText.slice(0, MAX_TREE_CHARS).split('\n').slice(0, -1).join('\n') + '\n…';
+    }
+    const sections = ['## Tree', treeText];
     let budget = MAX_TOTAL_CHARS - sections.join('\n').length;
-    for (const rel of paths) {
-        if (rel.endsWith('/'))
-            continue;
+    // Candidates, tagged with which service they belong to.
+    //
+    // The directory is the unit that matters: a monorepo is several services,
+    // and one of them having a README is worth less than another having its
+    // Dockerfile. Reading files in path order spent the whole budget inside the
+    // first two directories and left the rest of the repository undescribed.
+    const candidates = paths
+        .filter((rel) => !rel.endsWith('/'))
+        .map((rel) => {
         const base = rel.split('/').pop() ?? rel;
         const rule = EVIDENCE.find((e) => e.name.test(base));
-        if (!rule)
-            continue;
-        const full = join(root, rel);
+        return rule ? { rel, rule, dir: rel.includes('/') ? rel.split('/')[0] : '.' } : null;
+    })
+        .filter((x) => x !== null);
+    const read = async (c) => {
         try {
+            const full = join(root, c.rel);
             const info = await stat(full);
             // A megabyte of lockfile-shaped JSON is not evidence.
             if (info.size > 512 * 1024)
-                continue;
+                return null;
             const text = await readFile(full, 'utf8');
-            const block = `\n## ${rel}\n${windowOf(text, rule.lines)}`;
-            // Stop cleanly at the budget rather than sending a truncated file that
-            // reads as though the repository itself is malformed.
-            if (block.length > budget)
-                break;
-            sections.push(block);
-            budget -= block.length;
+            return `\n## ${c.rel}\n${windowOf(text, c.rule.lines)}`;
         }
         catch {
             // Unreadable is not fatal; it is simply not evidence.
+            return null;
+        }
+    };
+    // Tier by tier, and within a tier one file per directory before any
+    // directory gets a second. Every service is described before any service is
+    // described twice, so trimming costs depth rather than whole services.
+    for (const tier of [1, 2, 3]) {
+        const inTier = candidates.filter((c) => c.rule.tier === tier);
+        const byDir = new Map();
+        for (const c of inTier) {
+            byDir.set(c.dir, [...(byDir.get(c.dir) ?? []), c]);
+        }
+        let round = 0;
+        let placed = true;
+        while (placed && budget > 0) {
+            placed = false;
+            for (const list of byDir.values()) {
+                const c = list[round];
+                if (!c)
+                    continue;
+                placed = true;
+                const block = await read(c);
+                if (!block || block.length > budget)
+                    continue;
+                sections.push(block);
+                budget -= block.length;
+            }
+            round++;
         }
     }
     return sections.join('\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yadurajfleetos/cli",
-  "version": "0.9.2",
+  "version": "0.10.1",
   "description": "Fleet OS command-line interface for deploying and orchestrating services on user-owned hardware",
   "type": "module",
   "license": "MIT",