burgee 0.6.1 → 0.7.0

package/dist/yargs/cliui.js

@@ -1,4 +1,5 @@
 import { strip, width, wrap } from "linegauge";
+import { host } from "../runtime.js";
 /**
  * cliui 9 — the column layout yargs' usage renders through — with the wrap-ansi it depends
  * on, ported for `burgee/yargs`. Width and escape-stripping come from linegauge. The wrapping
@@ -141,7 +142,7 @@ export class UI {
                 if (r === 0 && lines.length > 0)
                     str = this.renderInline(str, lines.at(-1));
             });
-            lines.push({ text: str.replace(/ +$/, ""), span: row.span });
+            lines.push({ text: trimTrailingSpaces(str), span: row.span });
         });
         return lines;
     }
@@ -221,6 +222,27 @@ export class UI {
         return widths.map((w, i) => w === undefined ? Math.max(unsetWidth, minWidth(row[i])) : w);
     }
 }
+/*
+ * `str.replace(/ +$/, "")` was the upstream spelling, and it is the same quadratic shape
+ * `measurePadding` had: the start is unanchored, so the engine retries the match at every
+ * position in the run of spaces and each attempt walks to the end before failing on the
+ * character that is not the end. A row built from a cell of 50,000 spaces then an `x` is
+ * 100,001 characters of which the first 50,000 are the left padding, and trimming it cost
+ * 1,049 ms of `toString()`'s 1,223 ms. Doubling the cell quadrupled it.
+ *
+ * `trimEnd()` is linear but not the same function — it also removes tabs, newlines and the
+ * rest of `\s`. A trailing tab does reach here: with `wrap: false`, `rasterize` only splits
+ * the cell on newlines, so nothing expands the tab and nothing routes the string through
+ * `applyLayoutDSL` (that check is behind `this.wrap`). `cliui({ wrap: false }).div('a\t')`
+ * renders `'a\t'` today and would render `'a'` under `trimEnd`, and the yargs usage tests
+ * compare whole help screens. This removes exactly U+0020, exactly as the regex did.
+ */
+function trimTrailingSpaces(str) {
+    let end = str.length;
+    while (end > 0 && str[end - 1] === " ")
+        end--;
+    return end === str.length ? str : str.slice(0, end);
+}
 function addBorder(col, ts, style) {
     if (col.border) {
         if (/[.']-+[.']/.test(ts))
@@ -239,9 +261,9 @@ function minWidth(col) {
     return min;
 }
 function getWindowWidth() {
-    if (typeof process === "object" && process.stdout && process.stdout.columns)
-        return process.stdout.columns;
-    return 80;
+    // `host.columns` carries the upstream's guard on the process global itself, so a bundle
+    // that has no process at all still falls back to 80 rather than throwing.
+    return host.columns || 80;
 }
 function alignRight(str, width) {
     str = str.trim();

package/dist/yargs/factory.d.ts

@@ -5,7 +5,7 @@
  * `getInternalMethods()` seam are the upstream's — that is what makes a user's
  * existing program run unchanged (J2).
  */
-import { type Effects, Manifest, type Plugin } from '../manifest.js';
+import { type DeclaredEffects, Manifest, type Plugin } from '../manifest.js';
 import { type CommandInstance } from './command.js';
 import { type CompletionFunction } from './completion.js';
 import { type Middleware } from './middleware.js';
@@ -179,7 +179,7 @@ export declare class YargsInstance {
      */
     get manifest(): Manifest;
     /** burgee: declare what the command does to the world (N6); what exposes it as an MCP tool (N2). */
-    effects(value: Effects): this;
+    effects(value: DeclaredEffects): this;
     /** Additive: plugins yargs never had. `preRun`/`postRun` fire around every handler. */
     use(plugin: Plugin): this;
     /**

package/dist/yargs/factory.js

@@ -9,7 +9,7 @@ var _a;
 import { ExitCode } from '../exit-code.js';
 import { Manifest } from '../manifest.js';
 import { serveMcp } from '../mcp.js';
-import { schemaOf } from '../schema.js';
+import { machineJson, schemaOf } from '../schema.js';
 import { tokenizeArgString } from '../yargs-parser.js';
 import { projectManifest, render } from './burgee.js';
 import { command as Command, isCommandBuilderCallback } from './command.js';
@@ -1315,7 +1315,12 @@ export class YargsInstance {
             });
         }
         if (head.includes('--schema') && !this.#declares('schema')) {
-            this.#logger.log(JSON.stringify(schemaOf(this.manifest), null, 2));
+            // R1, through the same seam the engine and the commander façade use. Hand-rolling
+            // `JSON.stringify(…, null, 2)` here made this façade the one front-end that could not
+            // see `--format=json-pretty`, and emitted a different document from the other two for
+            // the same CLI. `--schema` is burgee's surface, not yargs', so it answers to burgee's
+            // byte discipline.
+            this.#logger.log(machineJson(schemaOf(this.manifest), head));
             this.exit(0);
             return true;
         }

package/dist/yargs/shim.js

@@ -9,6 +9,7 @@ import { createRequire } from 'node:module';
 import { basename, dirname, extname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { inspect } from 'node:util';
+import { host } from '../runtime.js';
 import { Parser } from '../yargs-parser.js';
 import { cliui, stringWidth } from './cliui.js';
 import { getProcessArgvBin } from './utils.js';
@@ -71,24 +72,30 @@ export const shim = {
     assert: { notStrictEqual, strictEqual },
     cliui,
     findUp,
-    getEnv: (key) => process.env[key],
+    getEnv: (key) => host.env[key],
     inspect,
     getProcessArgvBin,
-    mainFilename: mainFilename || process.cwd(),
+    mainFilename: mainFilename || host.cwd(),
     Parser,
     path: { basename, dirname, extname, relative, resolve, join },
     process: {
-        argv: () => process.argv,
-        cwd: process.cwd,
-        emitWarning: (warning, type) => process.emitWarning(warning, type),
-        execPath: () => process.execPath,
+        argv: () => host.argv,
+        cwd: () => host.cwd(),
+        emitWarning: (warning, type) => {
+            host.emitWarning(warning, type);
+        },
+        execPath: () => host.execPath,
         exit: (code) => {
-            process.exit(code);
+            host.exit(code);
+        },
+        nextTick: (fn, ...args) => {
+            host.nextTick(fn, ...args);
         },
-        nextTick: process.nextTick,
-        stdColumns: typeof process.stdout.columns !== 'undefined' ? process.stdout.columns : null,
-        stdin: () => process.stdin,
-        stdout: () => process.stdout,
+        // Captured, as it was before the seam: `stdColumns` is a value in `PlatformShim`, not
+        // a thunk, so yargs reads whatever this object was built with. Unchanged on purpose.
+        stdColumns: typeof host.stdout.columns !== 'undefined' ? host.stdout.columns : null,
+        stdin: () => host.stdin,
+        stdout: () => host.stdout,
     },
     readFileSync,
     readdirSync,

package/dist/yargs/utils.js

@@ -7,6 +7,7 @@
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, resolve } from 'node:path';
+import { host } from '../runtime.js';
 export class YError extends Error {
     constructor(msg) {
         super(msg || 'yargs error');
@@ -139,7 +140,7 @@ export function maybeAsyncResult(getResult, resultHandler, errorHandler = (err)
 export function setBlocking(blocking) {
     if (typeof process === 'undefined')
         return;
-    [process.stdout, process.stderr].forEach((_stream) => {
+    [host.stdout, host.stderr].forEach((_stream) => {
         const stream = _stream;
         if (stream._handle && stream.isTTY && typeof stream._handle.setBlocking === 'function')
             stream._handle.setBlocking(blocking);
@@ -151,16 +152,16 @@ function getProcessArgvBinIndex() {
     return 1;
 }
 function isBundledElectronApp() {
-    return isElectronApp() && !process.defaultApp;
+    return isElectronApp() && !host.defaultApp;
 }
 function isElectronApp() {
-    return !!process.versions.electron;
+    return !!host.versions['electron'];
 }
 export function hideBin(argv) {
     return argv.slice(getProcessArgvBinIndex() + 1);
 }
 export function getProcessArgvBin() {
-    return process.argv[getProcessArgvBinIndex()];
+    return host.argv[getProcessArgvBinIndex()];
 }
 const nodeRequire = createRequire(import.meta.url);
 let previouslyVisitedConfigs = [];

package/dist/yargs-parser.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { normalize, resolve } from 'node:path';
 import { format } from 'node:util';
+import { host } from './runtime.js';
 export function camelCase(str) {
     const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();
     if (!isCamelCase)
@@ -902,11 +903,10 @@ function sanitizeKey(key) {
 function stripQuotes(val) {
     return typeof val === 'string' && (val[0] === "'" || val[0] === '"') && val.at(-1) === val[0] ? val.substring(1, val.length - 1) : val;
 }
-const env = process.env;
 const nodeRequire = createRequire(import.meta.url);
 const parser = new YargsParser({
-    cwd: process.cwd,
-    env: () => env,
+    cwd: () => host.cwd(),
+    env: () => host.env,
     format,
     normalize,
     resolve,

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "burgee",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "An agent-native CLI framework, drop-in compatible with commander and yargs. One declaration; help, --json, --schema, --mcp and completions all projected from it.",
   "license": "MIT",
   "type": "module",
+  "sideEffects": [
+    "./dist/cli.js"
+  ],
   "engines": {
     "node": ">=24"
   },
@@ -13,6 +16,12 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./schema.json": "./dist/schema.json",
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js",
+      "default": "./dist/plugin.js"
+    },
     "./brand": {
       "types": "./dist/brand.d.ts",
       "import": "./dist/brand.js",
@@ -66,7 +75,7 @@
     "locales"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node ../../scripts/strip-comments.mjs dist",
+    "build": "tsc -p tsconfig.build.json && node ../../scripts/schema-to-dist.mjs && node ../../scripts/strip-comments.mjs dist",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run --passWithNoTests",
     "coverage": "vitest run --coverage.enabled",
@@ -96,9 +105,11 @@
     "provenance": true
   },
   "dependencies": {
-    "linegauge": "^0.2.0",
-    "roundel": "^0.3.0",
-    "seniority": "^0.1.0"
+    "bellpull": "^0.1.0",
+    "closeout": "^0.2.0",
+    "linegauge": "^0.3.0",
+    "roundel": "^0.3.1",
+    "seniority": "^0.2.0"
   },
   "devDependencies": {
     "vitest": "^5.0.0"