@yadurajfleetos/cli 0.10.0 → 0.10.2

package/dist/commands/services.js

@@ -465,14 +465,22 @@ async function theOnlyNode(flags) {
 async function reviewed(draft, flags) {
     const { repoMap } = await import('../repomap.js');
     const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
-    const review = (map, answers) => task(answers ? 'applying your answers' : 'reading the repository for a second opinion', async () => request('POST', `/fleets/${fleetId}/manifest/assist`, {
-        body: { draft, repoMap: map, ...(answers ? { answers } : {}) },
+    // The second pass is a different, smaller question.
+    //
+    // It used to resend the original draft and the whole repository map, which
+    // on this project meant ~6,000 tokens seconds after the first call had spent
+    // ~3,000 — straight through a per-minute budget, and the answer the user had
+    // just given was discarded. Applying an answer needs the manifest it applies
+    // to and the answer, not the evidence that produced it: the model has
+    // already read the repository and written its conclusions down.
+    const review = (base, map, answers) => task(answers ? 'applying your answers' : 'reading the repository for a second opinion', async () => request('POST', `/fleets/${fleetId}/manifest/assist`, {
+        body: { draft: base, repoMap: map, ...(answers ? { answers } : {}) },
     }), { done: () => (answers ? 'done' : 'reviewed') });
     let map;
     let out;
     try {
         map = await repoMap();
-        out = (await review(map)).body;
+        out = (await review(draft, map)).body;
     }
     catch (err) {
         console.log(`${glyph.warn} ${c.yellow('review skipped')}  ${err instanceof Error ? err.message : 'the control plane could not be reached'}`);
@@ -506,7 +514,9 @@ async function reviewed(draft, flags) {
     const answered = await answerQuestions(out.questions, flags);
     if (answered) {
         try {
-            const second = (await review(map, answered)).body;
+            // The reviewed manifest is what the answer applies to, and the tree
+            // alone is enough context to keep names straight.
+            const second = (await review(out.manifest, map.split('\n## ')[0] ?? map, answered)).body;
             if (second.status === 'ok') {
                 for (const note of second.notes)
                     console.log(c.dim(`  · ${note}`));

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.10.0",
+  "version": "0.10.2",
   "description": "Fleet OS command-line interface for deploying and orchestrating services on user-owned hardware",
   "type": "module",
   "license": "MIT",