@yadurajfleetos/cli 0.7.0 → 0.8.0

package/dist/commands/services.js

@@ -40,6 +40,35 @@ export const applyCommand = {
     async run(args, flags) {
         const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
         const manifest = await readManifest(manifestPath(args[0]));
+        // --dry-run used to be accepted and ignored, so `fleet apply --dry-run`
+        // applied. `fleet init` prints that exact command as the safe way to check
+        // its output, which made the one command the tool recommends for looking
+        // before you leap the command that leapt. The control plane has always had
+        // an endpoint for this, labelled "validate without touching anything"; the
+        // CLI simply never called it.
+        if (flags['dry-run'] || flags.plan) {
+            const { body } = await request('POST', `/fleets/${fleetId}/services/validate`, { body: { manifest } });
+            if (flags.json)
+                return console.log(JSON.stringify(body, null, 2));
+            if (!body.valid) {
+                for (const issue of body.issues ?? []) {
+                    console.log(`${glyph.fail} ${c.red('invalid')}  ${issue}`);
+                }
+                throw new CliError('The manifest was not applied.', EXIT.usage);
+            }
+            console.log(`${glyph.ok} ${c.green('valid')}  fleet ${c.bold(body.fleet ?? '?')}`);
+            for (const svc of body.services ?? []) {
+                // arch is empty when the manifest does not constrain it, which is the
+                // common case; printing a trailing separator for nothing reads like a
+                // value failed to load.
+                const facts = [svc.placement, `${svc.ramMb}Mi`, svc.arch?.join(', ')].filter(Boolean);
+                console.log(`  ${c.bold(svc.name)}  ${c.dim(facts.join(' · '))}`);
+            }
+            for (const w of body.warnings ?? []) {
+                console.log(`${glyph.warn} ${c.yellow('warning')}  ${w}`);
+            }
+            return console.log(c.dim('\nnothing was changed. Drop --dry-run to apply.'));
+        }
         const body = await task(`applying ${manifestPath(args[0])}`, async () => (await request('POST', `/fleets/${fleetId}/services`, {
             body: { manifest, project: projectNameFor(process.cwd()) },
         })).body, {
@@ -386,6 +415,55 @@ export const logsCommand = {
         }
     },
 };
+/**
+ * A second opinion on the draft, when --ai is given.
+ *
+ * Opt-in, because it sends a description of the repository to whatever
+ * provider the control plane is configured with, and that should never be a
+ * surprise. Never fatal: the draft is what `init` produced without it, so any
+ * failure here leaves the user exactly where they would have been anyway.
+ *
+ * The changes are printed rather than applied silently. A manifest that
+ * appeared with different ports and no explanation is worse than one with a
+ * mistake in it -- at least the mistake is yours to find.
+ */
+async function reviewed(draft, flags) {
+    const { repoMap } = await import('../repomap.js');
+    const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+    let out;
+    try {
+        const map = await repoMap();
+        out = (await task('reading the repository for a second opinion', async () => request('POST', `/fleets/${fleetId}/manifest/assist`, {
+            body: { draft, repoMap: map },
+        }), { done: () => 'reviewed' })).body;
+    }
+    catch (err) {
+        console.log(`${glyph.warn} ${c.yellow('review skipped')}  ${err instanceof Error ? err.message : 'the control plane could not be reached'}`);
+        return draft;
+    }
+    if (out.status === 'disabled') {
+        console.log(`${glyph.warn} ${c.yellow('review skipped')}  ${out.reason}`);
+        return draft;
+    }
+    if (out.status === 'rate_limited') {
+        console.log(`${glyph.warn} ${c.yellow('review skipped')}  ${out.limit} reviews a day is the limit; it resets in ${Math.ceil(out.resetsInSec / 3600)}h.`);
+        return draft;
+    }
+    if (out.status === 'kept_draft') {
+        // Worth saying out loud: silence here would read as "the review agreed".
+        console.log(`${glyph.warn} ${c.yellow('kept the draft')}  ${out.reason}`);
+        return draft;
+    }
+    if (!out.changed) {
+        console.log(`${glyph.ok} ${c.green('reviewed')}  ${c.dim('nothing to change')}`);
+        return out.manifest;
+    }
+    console.log(`${glyph.ok} ${c.green('reviewed')}  ${c.dim(out.model)}`);
+    for (const note of out.notes)
+        console.log(c.dim(`  · ${note}`));
+    console.log(c.dim(`  ${out.usage.used}/${out.usage.limit} reviews used today`));
+    return out.manifest;
+}
 export const initCommand = {
     async run(args, flags) {
         const { detect, manifestTemplate } = await import('../detect.js');
@@ -409,10 +487,12 @@ export const initCommand = {
         const { discover, manifestFromDiscovery } = await import('../discover.js');
         const found = await discover();
         if (found.services.length > 1 || found.databases.length) {
-            const { manifest, questions } = manifestFromDiscovery(found, {
+            const drafted = manifestFromDiscovery(found, {
                 fleet: typeof flags.fleet === 'string' ? flags.fleet : undefined,
                 node: typeof flags.node === 'string' ? flags.node : undefined,
             });
+            const questions = drafted.questions;
+            const manifest = flags.ai ? await reviewed(drafted.manifest, flags) : drafted.manifest;
             await writeFile(path, manifest);
             console.log(`${c.green('created')} ${path}`);
             if (found.layout)

package/dist/discover.js

@@ -31,6 +31,17 @@ const readJson = async (p) => {
 const IGNORED = new Set([
     'node_modules', '.git', 'dist', 'build', 'target', 'vendor', '.next',
     'coverage', '__pycache__', '.venv', 'venv', 'tmp', '.turbo', '.cache',
+    // Parts of a project rather than projects of their own.
+    //
+    // These are picked up by the immediate-children fallback, which exists for
+    // repositories that keep their services in plain top-level folders. A Vite
+    // app has src/ next to package.json, and the fallback happily proposed
+    // deploying it: a second service, built from the source directory of the
+    // first, serving raw .ts and .html instead of the built site — while the
+    // real build sat one level up. `src` is never a deployable unit on its own,
+    // and neither are the rest of these.
+    'src', 'public', 'static', 'assets', 'test', 'tests', '__tests__',
+    'migrations', 'fixtures', 'examples',
 ]);
 /**
  * Dependencies that mean "this service talks to a database".

package/dist/index.js

@@ -17,6 +17,7 @@ const GROUPS = [
         [
             ['up [service]', 'Deploy the whole fleet.yaml, in dependency order'],
             ['init', 'Read the repository — monorepo, databases, secrets — and write a fleet.yaml'],
+            ['init --ai', 'The same, then have the control plane review the draft against the repository'],
             ['import [file]', 'Convert a docker-compose.yml into a fleet.yaml'],
             ['config show', 'Show the saved control plane and selected fleet'],
             ['use <fleet>', 'Select the default fleet for later commands'],

package/dist/repomap.js

@@ -0,0 +1,121 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+/**
+ * What a repository says about itself, small enough to read.
+ *
+ * `discover()` reads a repository with rules and produces a draft. This is the
+ * same repository as evidence: the tree, the files that declare dependencies
+ * and ports, and the first lines of anything already describing how to run it.
+ * The two go together — the draft says what was concluded, this says what it
+ * was concluded from, and a reviewer needs both.
+ *
+ * Deliberately not source code. A manifest is decided by package manifests,
+ * Dockerfiles, compose files and entry points; shipping the whole tree would
+ * cost tokens, leak more than anyone intended, and bury the three files that
+ * actually answer the question.
+ */
+/** Never read: build output, dependencies, and anything that is not evidence. */
+const SKIP = new Set([
+    'node_modules', '.git', 'dist', 'build', 'target', 'vendor', '.next', '.nuxt',
+    'coverage', '__pycache__', '.venv', 'venv', '.turbo', '.cache', 'tmp', '.DS_Store',
+]);
+/**
+ * Files worth quoting, and how much of each.
+ *
+ * Entry points get a small window because the useful part — a listen() call, a
+ * route prefix, a PORT default — is near the top or in the last few lines, and
+ * 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 },
+];
+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;
+function windowOf(text, lines) {
+    const all = text.split('\n');
+    if (all.length <= lines)
+        return text.trimEnd();
+    // Head and tail: a server file declares its framework at the top and starts
+    // listening at the bottom, and the port is usually in the second half.
+    const head = all.slice(0, Math.ceil(lines * 0.7)).join('\n');
+    const tail = all.slice(-Math.floor(lines * 0.3)).join('\n');
+    return `${head}\n…\n${tail}`.trimEnd();
+}
+/** The tree, breadth-first so the interesting top levels survive the cap. */
+async function tree(root) {
+    const out = [];
+    let frontier = [{ dir: root, depth: 0 }];
+    while (frontier.length && out.length < MAX_TREE_ENTRIES) {
+        const next = [];
+        for (const { dir, depth } of frontier) {
+            let entries;
+            try {
+                entries = await readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const e of entries) {
+                if (e.name.startsWith('.') && e.name !== '.env.example')
+                    continue;
+                if (SKIP.has(e.name))
+                    continue;
+                const full = join(dir, e.name);
+                const rel = relative(root, full) || e.name;
+                if (out.length >= MAX_TREE_ENTRIES)
+                    break;
+                out.push(e.isDirectory() ? `${rel}/` : rel);
+                if (e.isDirectory() && depth + 1 < MAX_DEPTH)
+                    next.push({ dir: full, depth: depth + 1 });
+            }
+        }
+        frontier = next;
+    }
+    return out.sort();
+}
+/** 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 budget = MAX_TOTAL_CHARS - sections.join('\n').length;
+    for (const rel of paths) {
+        if (rel.endsWith('/'))
+            continue;
+        const base = rel.split('/').pop() ?? rel;
+        const rule = EVIDENCE.find((e) => e.name.test(base));
+        if (!rule)
+            continue;
+        const full = join(root, rel);
+        try {
+            const info = await stat(full);
+            // A megabyte of lockfile-shaped JSON is not evidence.
+            if (info.size > 512 * 1024)
+                continue;
+            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;
+        }
+        catch {
+            // Unreadable is not fatal; it is simply not evidence.
+        }
+    }
+    return sections.join('\n');
+}

package/package.json

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