@mono-labs/cli 0.0.206 → 0.0.208

package/dist/project/build-mono-readme.js

@@ -1,36 +1,33 @@
 "use strict";
-// scripts/generate-readme.ts
-// Node >= 18 recommended
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// scripts/generate-readme.mjs
+// Node >= 18 recommended
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const generate_docs_js_1 = require("./generate-docs.js");
-/* -------------------------------------------------------------------------- */
-/*                               Path helpers                                 */
-/* -------------------------------------------------------------------------- */
-// Always use the working directory as the root for all file actions
 const REPO_ROOT = node_path_1.default.resolve(process.cwd());
 const MONO_DIR = node_path_1.default.join(REPO_ROOT, '.mono');
 const ROOT_PKG_JSON = node_path_1.default.join(REPO_ROOT, 'package.json');
 const OUTPUT_PATH = node_path_1.default.join(REPO_ROOT, 'docs');
 const OUTPUT_README = node_path_1.default.join(OUTPUT_PATH, 'command-line.md');
-/* -------------------------------------------------------------------------- */
-/*                                   Utils                                    */
-/* -------------------------------------------------------------------------- */
 async function ensureParentDir(filePath) {
-    // Always resolve parent dir relative to working directory
-    const dir = node_path_1.default.resolve(process.cwd(), node_path_1.default.dirname(filePath));
+    const dir = node_path_1.default.dirname(filePath);
+    console.log(`[ensureParentDir] Ensuring directory:`, dir);
     await node_fs_1.promises.mkdir(dir, { recursive: true });
 }
+// ---------- utils ----------
 async function exists(p) {
     try {
         await node_fs_1.promises.access(p);
+        // Log existence check
+        console.log(`[exists] Path exists:`, p);
         return true;
     }
     catch {
+        console.log(`[exists] Path does NOT exist:`, p);
         return false;
     }
 }
@@ -41,110 +38,135 @@ function toPosix(p) {
     return p.split(node_path_1.default.sep).join('/');
 }
 async function readJson(filePath) {
-    // Always resolve filePath relative to working directory
-    const absPath = node_path_1.default.resolve(process.cwd(), filePath);
-    const raw = await node_fs_1.promises.readFile(absPath, 'utf8');
-    return JSON.parse(raw);
+    console.log(`[readJson] Reading JSON file:`, filePath);
+    const raw = await node_fs_1.promises.readFile(filePath, 'utf8');
+    try {
+        const parsed = JSON.parse(raw);
+        console.log(`[readJson] Successfully parsed:`, filePath);
+        return parsed;
+    }
+    catch (err) {
+        console.error(`[readJson] Failed to parse JSON:`, filePath, err);
+        throw err;
+    }
 }
 async function listDir(dir) {
-    // Always resolve dir relative to working directory
-    const absDir = node_path_1.default.resolve(process.cwd(), dir);
-    return node_fs_1.promises.readdir(absDir, { withFileTypes: true });
+    console.log(`[listDir] Listing directory:`, dir);
+    const entries = await node_fs_1.promises.readdir(dir, { withFileTypes: true });
+    console.log(`[listDir] Found ${entries.length} entries in:`, dir);
+    return entries;
 }
 function normalizeWorkspacePatterns(workspacesField) {
     if (Array.isArray(workspacesField))
         return workspacesField;
     if (isObject(workspacesField) &&
-        Array.isArray(workspacesField.packages)) {
+        Array.isArray(workspacesField.packages))
         return workspacesField.packages;
-    }
     return [];
 }
-function mdEscapeInline(value) {
-    return String(value ?? '').replaceAll('`', '\\`');
+function mdEscapeInline(s) {
+    return String(s ?? '').replaceAll('`', '\`');
 }
 function indentLines(s, spaces = 2) {
     const pad = ' '.repeat(spaces);
-    return s
+    return String(s ?? '')
         .split('\n')
-        .map((line) => pad + line)
+        .map((l) => pad + l)
         .join('\n');
 }
-/* -------------------------------------------------------------------------- */
-/*                      Workspace glob pattern expansion                       */
-/* -------------------------------------------------------------------------- */
+// ---------- workspace glob matching (supports *, **, and plain segments) ----------
 function matchSegment(patternSeg, name) {
     if (patternSeg === '*')
         return true;
     if (!patternSeg.includes('*'))
         return patternSeg === name;
     const escaped = patternSeg.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-    const regex = new RegExp(`^${escaped.replaceAll('*', '.*')}$`);
+    const regex = new RegExp('^' + escaped.replaceAll('*', '.*') + '$');
     return regex.test(name);
 }
 async function expandWorkspacePattern(root, pattern) {
-    const segments = toPosix(pattern).split('/').filter(Boolean);
-    async function expandFrom(dir, index) {
-        // Always resolve dir relative to working directory
-        const absDir = node_path_1.default.resolve(process.cwd(), dir);
-        if (index >= segments.length)
-            return [absDir];
-        const seg = segments[index];
+    console.log(`[expandWorkspacePattern] Expanding pattern:`, pattern, `from root:`, root);
+    const segs = toPosix(pattern).split('/').filter(Boolean);
+    async function expandFrom(dir, segIndex) {
+        console.log(`[expandFrom] Directory:`, dir, `Segment index:`, segIndex);
+        if (segIndex >= segs.length)
+            return [dir];
+        const seg = segs[segIndex];
+        console.log(`[expandFrom] Segment:`, seg);
         if (seg === '**') {
             const results = [];
-            results.push(...(await expandFrom(absDir, index + 1)));
+            results.push(...(await expandFrom(dir, segIndex + 1)));
             const entries = await node_fs_1.promises
-                .readdir(absDir, { withFileTypes: true })
+                .readdir(dir, { withFileTypes: true })
                 .catch(() => []);
-            for (const entry of entries) {
-                if (!entry.isDirectory())
+            console.log(`[expandFrom] '**' entries in ${dir}:`, entries.map((e) => e.name));
+            for (const e of entries) {
+                if (!e.isDirectory())
                     continue;
-                results.push(...(await expandFrom(node_path_1.default.join(absDir, entry.name), index)));
+                console.log(`[expandFrom] Recursing into subdir:`, node_path_1.default.join(dir, e.name));
+                results.push(...(await expandFrom(node_path_1.default.join(dir, e.name), segIndex)));
             }
             return results;
         }
         const entries = await node_fs_1.promises
-            .readdir(absDir, { withFileTypes: true })
+            .readdir(dir, { withFileTypes: true })
             .catch(() => []);
+        console.log(`[expandFrom] Entries in ${dir}:`, entries.map((e) => e.name));
         const results = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory())
+        for (const e of entries) {
+            if (!e.isDirectory())
                 continue;
-            if (!matchSegment(seg, entry.name))
+            if (!matchSegment(seg, e.name))
                 continue;
-            results.push(...(await expandFrom(node_path_1.default.join(absDir, entry.name), index + 1)));
+            console.log(`[expandFrom] Matched segment '${seg}' with directory:`, e.name);
+            results.push(...(await expandFrom(node_path_1.default.join(dir, e.name), segIndex + 1)));
         }
         return results;
     }
     const dirs = await expandFrom(root, 0);
+    console.log(`[expandWorkspacePattern] Expanded directories:`, dirs);
     const pkgDirs = [];
     for (const d of dirs) {
-        if (await exists(node_path_1.default.join(d, 'package.json'))) {
+        const pkgPath = node_path_1.default.join(d, 'package.json');
+        if (await exists(pkgPath)) {
+            console.log(`[expandWorkspacePattern] Found package.json:`, pkgPath);
             pkgDirs.push(d);
         }
+        else {
+            console.log(`[expandWorkspacePattern] No package.json in:`, d);
+        }
     }
-    return Array.from(new Set(pkgDirs));
+    console.log(`[expandWorkspacePattern] Final package directories:`, pkgDirs);
+    return [...new Set(pkgDirs)];
 }
-async function findWorkspacePackageDirs(repoRoot, patterns) {
+async function findWorkspacePackageDirs(repoRoot, workspacePatterns) {
+    console.log(`[findWorkspacePackageDirs] repoRoot:`, repoRoot, `workspacePatterns:`, workspacePatterns);
     const dirs = [];
-    for (const pat of patterns) {
-        dirs.push(...(await expandWorkspacePattern(repoRoot, pat)));
+    for (const pat of workspacePatterns) {
+        console.log(`[findWorkspacePackageDirs] Expanding pattern:`, pat);
+        const expanded = await expandWorkspacePattern(repoRoot, pat);
+        console.log(`[findWorkspacePackageDirs] Expanded dirs for pattern '${pat}':`, expanded);
+        dirs.push(...expanded);
     }
-    return Array.from(new Set(dirs));
+    const uniqueDirs = [...new Set(dirs)];
+    console.log(`[findWorkspacePackageDirs] Final unique package dirs:`, uniqueDirs);
+    return uniqueDirs;
 }
-/* -------------------------------------------------------------------------- */
-/*                             .mono configuration                             */
-/* -------------------------------------------------------------------------- */
+// ---------- .mono parsing ----------
 async function readMonoConfig() {
-    // Always resolve configPath relative to working directory
-    const configPath = node_path_1.default.resolve(process.cwd(), node_path_1.default.join(MONO_DIR, 'config.json'));
-    if (!(await exists(configPath)))
+    const configPath = node_path_1.default.join(MONO_DIR, 'config.json');
+    console.log(`[readMonoConfig] Looking for mono config at:`, configPath);
+    if (!(await exists(configPath))) {
+        console.log(`[readMonoConfig] No mono config found.`);
         return null;
+    }
     try {
         const config = await readJson(configPath);
+        console.log(`[readMonoConfig] Loaded mono config.`);
         return { path: configPath, config };
     }
-    catch {
+    catch (err) {
+        console.error(`[readMonoConfig] Failed to load mono config:`, err);
         return null;
     }
 }
@@ -152,44 +174,52 @@ function commandNameFromFile(filePath) {
     return node_path_1.default.basename(filePath).replace(/\.json$/i, '');
 }
 async function readMonoCommands() {
-    // Always resolve MONO_DIR relative to working directory
-    const monoDirAbs = node_path_1.default.resolve(process.cwd(), MONO_DIR);
-    if (!(await exists(monoDirAbs)))
+    console.log(`[readMonoCommands] Reading mono commands from:`, MONO_DIR);
+    if (!(await exists(MONO_DIR))) {
+        console.log(`[readMonoCommands] Mono directory does not exist.`);
         return [];
-    const entries = await listDir(monoDirAbs);
+    }
+    const entries = await listDir(MONO_DIR);
     const jsonFiles = entries
-        .filter((e) => e.isFile() && e.name.endsWith('.json'))
-        .map((e) => node_path_1.default.join(monoDirAbs, e.name))
-        .filter((p) => node_path_1.default.basename(p) !== 'config.json');
+        .filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.json'))
+        .map((e) => node_path_1.default.join(MONO_DIR, e.name))
+        .filter((p) => node_path_1.default.basename(p).toLowerCase() !== 'config.json');
+    console.log(`[readMonoCommands] Found JSON files:`, jsonFiles);
     const commands = [];
     for (const file of jsonFiles) {
         try {
-            const json = await readJson(file);
+            console.log(`[readMonoCommands] Reading command file:`, file);
+            const j = await readJson(file);
             commands.push({
                 name: commandNameFromFile(file),
                 file,
-                json,
+                json: j,
             });
+            console.log(`[readMonoCommands] Successfully loaded command:`, commandNameFromFile(file));
         }
-        catch {
-            /* ignore invalid JSON */
+        catch (err) {
+            console.error(`[readMonoCommands] Failed to load command file:`, file, err);
+            // skip invalid json
         }
     }
-    return commands.sort((a, b) => a.name.localeCompare(b.name));
+    commands.sort((a, b) => a.name.localeCompare(b.name));
+    console.log(`[readMonoCommands] Final sorted commands:`, commands.map((c) => c.name));
+    return commands;
 }
-/* -------------------------------------------------------------------------- */
-/*                          Options schema parsing                             */
-/* -------------------------------------------------------------------------- */
 function parseOptionsSchema(optionsObj) {
+    // New structure supports:
+    // - optionKey: { type: "string", default, options: [], allowAll, shortcut, description }
+    // - boolean toggle: { shortcut, description } (no type)
     if (!isObject(optionsObj))
         return [];
     const entries = Object.entries(optionsObj).map(([key, raw]) => {
         const o = isObject(raw) ? raw : {};
-        const hasType = typeof o.type === 'string' && o.type.length > 0;
+        const hasType = typeof o.type === 'string' && o.type.trim().length > 0;
+        const isBoolToggle = !hasType; // in your examples, booleans omit `type`
         return {
             key,
-            kind: hasType ? 'value' : 'boolean',
-            type: hasType ? o.type : 'boolean',
+            kind: isBoolToggle ? 'boolean' : 'value',
+            type: hasType ? String(o.type) : 'boolean',
             description: typeof o.description === 'string' ? o.description : '',
             shortcut: typeof o.shortcut === 'string' ? o.shortcut : '',
             default: o.default,
@@ -197,81 +227,274 @@ function parseOptionsSchema(optionsObj) {
             allowAll: o.allowAll === true,
         };
     });
-    return entries.sort((a, b) => a.key.localeCompare(b.key));
+    entries.sort((a, b) => a.key.localeCompare(b.key));
+    return entries;
 }
-/* -------------------------------------------------------------------------- */
-/*                                 Formatting                                 */
-/* -------------------------------------------------------------------------- */
 function buildUsageExample(commandName, cmdJson, options) {
-    const arg = cmdJson.argument;
+    const arg = cmdJson?.argument;
     const hasArg = isObject(arg);
-    const parts = [`yarn mono ${commandName}`];
-    if (hasArg)
-        parts.push(`<${commandName}-arg>`);
+    const argToken = hasArg ? `<${commandName}-arg>` : '';
+    // choose a representative value option to show
     const valueOpts = options.filter((o) => o.kind === 'value');
     const boolOpts = options.filter((o) => o.kind === 'boolean');
+    const exampleParts = [`yarn mono ${commandName}`];
+    if (argToken)
+        exampleParts.push(argToken);
+    // include at most 2 value options and 1 boolean in the example for readability
     for (const o of valueOpts.slice(0, 2)) {
-        const value = o.default !== undefined ?
-            String(o.default)
-            : (o.allowed?.[0] ?? '<value>');
-        parts.push(`--${o.key} ${value}`);
+        const flag = `--${o.key}`;
+        const val = o.default !== undefined ? o.default : (o.allowed?.[0] ?? '<value>');
+        exampleParts.push(`${flag} ${val}`);
     }
-    if (boolOpts[0]) {
-        parts.push(`--${boolOpts[0].key}`);
+    if (boolOpts.length) {
+        exampleParts.push(`--${boolOpts[0].key}`);
     }
-    return parts.join(' ');
+    return exampleParts.join(' ');
 }
-/* -------------------------------------------------------------------------- */
-/*                                    Main                                    */
-/* -------------------------------------------------------------------------- */
-async function main() {
-    // Always resolve all paths relative to working directory
-    if (!(await exists(ROOT_PKG_JSON))) {
-        throw new Error(`Missing ${ROOT_PKG_JSON}`);
+function formatMonoConfigSection(monoConfig) {
+    const lines = [];
+    lines.push('## Mono configuration');
+    lines.push('');
+    if (!monoConfig) {
+        lines.push('_No `.mono/config.json` found._');
+        return lines.join('\n');
+    }
+    const c = monoConfig.config;
+    lines.push(`Source: \`${toPosix(node_path_1.default.relative(REPO_ROOT, monoConfig.path))}\``);
+    lines.push('');
+    if (Array.isArray(c.envMap) && c.envMap.length) {
+        lines.push('### envMap');
+        lines.push('');
+        lines.push('- ' + c.envMap.map((x) => `\`${mdEscapeInline(x)}\``).join(', '));
+        lines.push('');
+    }
+    const pkgMaps = c?.workspace?.packageMaps;
+    if (pkgMaps && isObject(pkgMaps) && Object.keys(pkgMaps).length) {
+        lines.push('### Workspace aliases (packageMaps)');
+        lines.push('');
+        const entries = Object.entries(pkgMaps).sort(([a], [b]) => a.localeCompare(b));
+        for (const [alias, target] of entries) {
+            lines.push(`- \`${mdEscapeInline(alias)}\` → \`${mdEscapeInline(String(target))}\``);
+        }
+        lines.push('');
+    }
+    const pre = c?.workspace?.preactions;
+    if (Array.isArray(pre) && pre.length) {
+        lines.push('### Global preactions');
+        lines.push('');
+        lines.push('```bash');
+        for (const p of pre)
+            lines.push(String(p));
+        lines.push('```');
+        lines.push('');
     }
+    if (typeof c.prodFlag === 'string' && c.prodFlag.trim()) {
+        lines.push('### prodFlag');
+        lines.push('');
+        lines.push(`Production flag keyword: \`${mdEscapeInline(c.prodFlag.trim())}\``);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function formatMonoCommandsSection(commands) {
+    const lines = [];
+    lines.push('## Mono commands');
+    lines.push('');
+    lines.push('Generated from `.mono/*.json` (excluding `config.json`). Each filename becomes a command:');
+    lines.push('');
+    lines.push('```bash');
+    lines.push('yarn mono <command> [argument] [--options]');
+    lines.push('```');
+    lines.push('');
+    if (!commands.length) {
+        lines.push('_No mono command JSON files found._');
+        return lines.join('\n');
+    }
+    // Index
+    lines.push('### Command index');
+    lines.push('');
+    for (const c of commands) {
+        const desc = typeof c.json?.description === 'string' ? c.json.description.trim() : '';
+        const suffix = desc ? ` — ${desc}` : '';
+        lines.push(`- [\`${mdEscapeInline(c.name)}\`](#mono-command-${mdEscapeInline(c.name).toLowerCase()})${suffix}`);
+    }
+    lines.push('');
+    for (const c of commands) {
+        const j = c.json || {};
+        const rel = toPosix(node_path_1.default.relative(REPO_ROOT, c.file));
+        const anchor = `mono-command-${c.name.toLowerCase()}`;
+        const desc = typeof j.description === 'string' ? j.description.trim() : '';
+        const arg = j.argument;
+        const options = parseOptionsSchema(j.options);
+        lines.push('---');
+        lines.push(`### Mono command: ${c.name}`);
+        lines.push(`<a id="${anchor}"></a>`);
+        lines.push('');
+        lines.push(`Source: \`${rel}\``);
+        lines.push('');
+        if (desc) {
+            lines.push(`**Description:** ${mdEscapeInline(desc)}`);
+            lines.push('');
+        }
+        // Usage
+        lines.push('**Usage**');
+        lines.push('');
+        lines.push('```bash');
+        lines.push(`yarn mono ${c.name}${isObject(arg) ? ` <${c.name}-arg>` : ''} [--options]`);
+        lines.push('```');
+        lines.push('');
+        lines.push('Example:');
+        lines.push('');
+        lines.push('```bash');
+        lines.push(buildUsageExample(c.name, j, options));
+        lines.push('```');
+        lines.push('');
+        // Argument
+        if (isObject(arg)) {
+            lines.push('**Argument**');
+            lines.push('');
+            const bits = [];
+            if (typeof arg.type === 'string')
+                bits.push(`type: \`${mdEscapeInline(arg.type)}\``);
+            if (arg.default !== undefined)
+                bits.push(`default: \`${mdEscapeInline(String(arg.default))}\``);
+            if (typeof arg.description === 'string')
+                bits.push(mdEscapeInline(arg.description));
+            lines.push(`- ${bits.join(' • ') || '_(no details)_'} `);
+            lines.push('');
+        }
+        // Options
+        if (options.length) {
+            lines.push('**Options**');
+            lines.push('');
+            lines.push('| Option | Type | Shortcut | Default | Allowed | Notes |');
+            lines.push('|---|---:|:---:|---:|---|---|');
+            for (const o of options) {
+                const optCol = o.kind === 'boolean' ?
+                    `\`--${mdEscapeInline(o.key)}\``
+                    : `\`--${mdEscapeInline(o.key)} <${mdEscapeInline(o.key)}>\``;
+                const typeCol = `\`${mdEscapeInline(o.type)}\``;
+                const shortCol = o.shortcut ? `\`-${mdEscapeInline(o.shortcut)}\`` : '';
+                const defCol = o.default !== undefined ? `\`${mdEscapeInline(o.default)}\`` : '';
+                const allowedCol = o.allowed ?
+                    o.allowed.map((x) => `\`${mdEscapeInline(x)}\``).join(', ')
+                    : '';
+                const notes = [
+                    o.allowAll ? 'allowAll' : '',
+                    o.description ? mdEscapeInline(o.description) : '',
+                ]
+                    .filter(Boolean)
+                    .join(' • ');
+                lines.push(`| ${optCol} | ${typeCol} | ${shortCol} | ${defCol} | ${allowedCol} | ${notes} |`);
+            }
+            lines.push('');
+        }
+        // Environments
+        if (j.environments &&
+            isObject(j.environments) &&
+            Object.keys(j.environments).length) {
+            lines.push('**Environment Variables**');
+            lines.push('');
+            const envs = Object.entries(j.environments).sort(([a], [b]) => a.localeCompare(b));
+            for (const [envName, envObj] of envs) {
+                lines.push(`- \`${mdEscapeInline(envName)}\``);
+                if (isObject(envObj) && Object.keys(envObj).length) {
+                    const kv = Object.entries(envObj).sort(([a], [b]) => a.localeCompare(b));
+                    lines.push(indentLines(kv
+                        .map(([k, v]) => `- \`${mdEscapeInline(k)}\` = \`${mdEscapeInline(String(v))}\``)
+                        .join('\n'), 2));
+                }
+            }
+            lines.push('');
+        }
+        // preactions/actions
+        if (Array.isArray(j.preactions) && j.preactions.length) {
+            lines.push('**Preactions**');
+            lines.push('');
+            lines.push('```bash');
+            for (const p of j.preactions)
+                lines.push(String(p));
+            lines.push('```');
+            lines.push('');
+        }
+        if (Array.isArray(j.actions) && j.actions.length) {
+            lines.push('**Actions**');
+            lines.push('');
+            lines.push('```bash');
+            for (const a of j.actions)
+                lines.push(String(a));
+            lines.push('```');
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}
+function collectScripts(packages) {
+    const scriptToPackages = new Map();
+    for (const p of packages) {
+        for (const scriptName of Object.keys(p.scripts || {})) {
+            if (!scriptToPackages.has(scriptName))
+                scriptToPackages.set(scriptName, []);
+            scriptToPackages.get(scriptName).push(p.name);
+        }
+    }
+    return scriptToPackages;
+}
+// ---------- main ----------
+async function main() {
+    if (!(await exists(ROOT_PKG_JSON)))
+        throw new Error(`Missing: ${ROOT_PKG_JSON}`);
     await ensureParentDir(OUTPUT_PATH);
     const rootPkg = await readJson(ROOT_PKG_JSON);
     const workspacePatterns = normalizeWorkspacePatterns(rootPkg.workspaces);
     const monoConfig = await readMonoConfig();
     const monoCommands = await readMonoCommands();
     const pkgDirs = await findWorkspacePackageDirs(REPO_ROOT, workspacePatterns);
+    console.log(`[main] Package directories found:`, pkgDirs);
     const packages = [];
     for (const dir of pkgDirs) {
         try {
-            const pkg = await readJson(node_path_1.default.join(dir, 'package.json'));
+            const pkgPath = node_path_1.default.join(dir, 'package.json');
+            console.log(`[main] Reading package.json:`, pkgPath);
+            const pj = await readJson(pkgPath);
             packages.push({
-                name: pkg.name ??
-                    toPosix(node_path_1.default.relative(REPO_ROOT, dir)) ??
+                name: pj.name ||
+                    toPosix(node_path_1.default.relative(REPO_ROOT, dir)) ||
                     node_path_1.default.basename(dir),
                 dir,
-                scripts: pkg.scripts ?? {},
+                scripts: pj.scripts || {},
             });
+            console.log(`[main] Loaded package:`, pj.name || dir);
         }
-        catch {
-            /* ignore */
+        catch (err) {
+            console.error(`[main] Failed to load package.json for:`, dir, err);
+            // skip
         }
     }
     const parts = [];
     parts.push(`# Mono Command-Line Reference
 
-> Generated by \`scripts/generate-readme.ts\`.
+> Generated by \`scripts/generate-readme.mjs\`.
+> Update \`.mono/config.json\`, \`.mono/*.json\`, and workspace package scripts to change this output.
 
 `);
-    // Reuse your existing formatters here
-    // (unchanged logic, now fully typed)
-    const docsIndex = await (0, generate_docs_js_1.generateDocsIndex)({
+    parts.push(formatMonoConfigSection(monoConfig));
+    parts.push('');
+    parts.push(formatMonoCommandsSection(monoCommands));
+    parts.push('');
+    const val = await (0, generate_docs_js_1.generateDocsIndex)({
         docsDir: node_path_1.default.join(REPO_ROOT, 'docs'),
         excludeFile: 'command-line.md',
     });
-    parts.push(docsIndex);
+    val.split('\n').forEach((line) => parts.push(line));
     await ensureParentDir(OUTPUT_README);
     await node_fs_1.promises.writeFile(OUTPUT_README, parts.join('\n'), 'utf8');
-    console.log(`Generated: ${OUTPUT_README}`);
-    console.log(`- mono config: ${monoConfig ? 'yes' : 'no'}`);
-    console.log(`- mono commands: ${monoCommands.length}`);
-    console.log(`- workspace packages: ${packages.length}`);
+    console.log(`[main] Generated: ${OUTPUT_README}`);
+    console.log(`[main] mono config: ${monoConfig ? 'yes' : 'no'}`);
+    console.log(`[main] mono commands: ${monoCommands.length}`);
+    console.log(`[main] workspace packages: ${packages.length}`);
 }
 main().catch((err) => {
-    console.error(err instanceof Error ? err.stack : err);
-    process.exit(1);
+    console.error(err?.stack || String(err));
+    process.exitCode = 1;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mono-labs/cli",
-    "version": "0.0.206",
+    "version": "0.0.208",
     "description": "A CLI tool for building and deploying projects",
     "main": "dist/index.js",
     "types": "dist/types.d.ts",