@mono-labs/project 0.0.248

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { findProjectRoot, getRootDirectory, getRootJson, resolveMonoDirectory, getMonoFiles, getMonoConfig, } from './loadFromRoot';
+export type { MonoWorkspaceConfig, MonoProjectConfig, MonoFiles, MonoConfig, } from './loadFromRoot';
+export { loadAppConfig, loadProjectConfig, loadMergedEnv } from './project/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,oBAAoB,EACpB,YAAY,EACZ,aAAa,GACd,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,mBAAmB,EACnB,iBAAiB,EACjB,SAAS,EACT,UAAU,GACX,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+// @mono-labs/project barrel export
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMergedEnv = exports.loadProjectConfig = exports.loadAppConfig = exports.getMonoConfig = exports.getMonoFiles = exports.resolveMonoDirectory = exports.getRootJson = exports.getRootDirectory = exports.findProjectRoot = void 0;
+var loadFromRoot_1 = require("./loadFromRoot");
+Object.defineProperty(exports, "findProjectRoot", { enumerable: true, get: function () { return loadFromRoot_1.findProjectRoot; } });
+Object.defineProperty(exports, "getRootDirectory", { enumerable: true, get: function () { return loadFromRoot_1.getRootDirectory; } });
+Object.defineProperty(exports, "getRootJson", { enumerable: true, get: function () { return loadFromRoot_1.getRootJson; } });
+Object.defineProperty(exports, "resolveMonoDirectory", { enumerable: true, get: function () { return loadFromRoot_1.resolveMonoDirectory; } });
+Object.defineProperty(exports, "getMonoFiles", { enumerable: true, get: function () { return loadFromRoot_1.getMonoFiles; } });
+Object.defineProperty(exports, "getMonoConfig", { enumerable: true, get: function () { return loadFromRoot_1.getMonoConfig; } });
+var index_1 = require("./project/index");
+Object.defineProperty(exports, "loadAppConfig", { enumerable: true, get: function () { return index_1.loadAppConfig; } });
+Object.defineProperty(exports, "loadProjectConfig", { enumerable: true, get: function () { return index_1.loadProjectConfig; } });
+Object.defineProperty(exports, "loadMergedEnv", { enumerable: true, get: function () { return index_1.loadMergedEnv; } });

package/dist/loadFromRoot.d.ts

@@ -0,0 +1,33 @@
+export interface MonoWorkspaceConfig {
+    packageMaps: Record<string, string>;
+}
+export interface MonoProjectConfig {
+    envMap: string[];
+    workspace: MonoWorkspaceConfig;
+    prodFlag: string;
+}
+export type MonoFiles = Record<string, unknown>;
+export interface MonoConfig {
+    config: MonoProjectConfig;
+    files: MonoFiles;
+}
+/**
+ * Walk up from cwd until we find a directory containing package.json.
+ * This is treated as the project root.
+ */
+export declare function findProjectRoot(startDir?: string): string;
+export declare function getRootDirectory(): string;
+export declare function getRootJson(): Record<string, unknown>;
+/**
+ * Resolve the .mono directory.
+ * Priority:
+ *  1. project root/.mono
+ *  2. cwd/.mono
+ */
+export declare function resolveMonoDirectory(): string | null;
+export declare function getMonoFiles(): string[];
+/**
+ * Load and validate mono configuration.
+ */
+export declare function getMonoConfig(): MonoConfig;
+//# sourceMappingURL=loadFromRoot.d.ts.map

package/dist/loadFromRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadFromRoot.d.ts","sourceRoot":"","sources":["../src/loadFromRoot.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,mBAAmB;IACnC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEhD,MAAM,WAAW,UAAU;IAC1B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,KAAK,EAAE,SAAS,CAAC;CACjB;AAMD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,GAAE,MAAsB,GAAG,MAAM,CAexE;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASrD;AAYD;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,IAAI,CASpD;AAED,wBAAgB,YAAY,IAAI,MAAM,EAAE,CAQvC;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAwC1C"}

package/dist/loadFromRoot.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProjectRoot = findProjectRoot;
+exports.getRootDirectory = getRootDirectory;
+exports.getRootJson = getRootJson;
+exports.resolveMonoDirectory = resolveMonoDirectory;
+exports.getMonoFiles = getMonoFiles;
+exports.getMonoConfig = getMonoConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/* ------------------------------------------------------------------
+ * Helpers
+ * ------------------------------------------------------------------ */
+/**
+ * Walk up from cwd until we find a directory containing package.json.
+ * This is treated as the project root.
+ */
+function findProjectRoot(startDir = process.cwd()) {
+    let current = startDir;
+    while (true) {
+        const pkg = path_1.default.join(current, 'package.json');
+        if (fs_1.default.existsSync(pkg))
+            return current;
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    // Fallback: use cwd
+    return startDir;
+}
+function getRootDirectory() {
+    return findProjectRoot();
+}
+function getRootJson() {
+    const root = getRootDirectory();
+    const jsonPath = path_1.default.join(root, 'package.json');
+    if (!fs_1.default.existsSync(jsonPath)) {
+        throw new Error(`package.json not found in ${root}`);
+    }
+    return JSON.parse(fs_1.default.readFileSync(jsonPath, 'utf-8'));
+}
+/* ------------------------------------------------------------------
+ * Mono (.mono) handling
+ * ------------------------------------------------------------------ */
+const DISALLOWED_FILES = new Set(['tools']);
+function readJsonFile(filePath) {
+    return JSON.parse(fs_1.default.readFileSync(filePath, 'utf-8'));
+}
+/**
+ * Resolve the .mono directory.
+ * Priority:
+ *  1. project root/.mono
+ *  2. cwd/.mono
+ */
+function resolveMonoDirectory() {
+    const root = getRootDirectory();
+    const rootMono = path_1.default.join(root, '.mono');
+    if (fs_1.default.existsSync(rootMono))
+        return rootMono;
+    const cwdMono = path_1.default.join(process.cwd(), '.mono');
+    if (fs_1.default.existsSync(cwdMono))
+        return cwdMono;
+    return null;
+}
+function getMonoFiles() {
+    const dir = resolveMonoDirectory();
+    if (!dir)
+        return [];
+    return fs_1.default
+        .readdirSync(dir)
+        .filter((f) => f.endsWith('.json'))
+        .map((f) => path_1.default.join(dir, f));
+}
+/**
+ * Load and validate mono configuration.
+ */
+function getMonoConfig() {
+    const monoDir = resolveMonoDirectory();
+    if (!monoDir) {
+        return {
+            files: {},
+            config: {
+                envMap: [],
+                workspace: { packageMaps: {} },
+                prodFlag: 'live',
+            },
+        };
+    }
+    const files = {};
+    let config = {
+        envMap: [],
+        workspace: { packageMaps: {} },
+        prodFlag: 'live',
+    };
+    for (const filePath of getMonoFiles()) {
+        const fileName = path_1.default.basename(filePath, '.json');
+        if (DISALLOWED_FILES.has(fileName)) {
+            throw new Error(`Disallowed file name in .mono directory: ${fileName}`);
+        }
+        const data = readJsonFile(filePath);
+        if (fileName === 'config') {
+            if (typeof data === 'object' && data !== null) {
+                config = data;
+            }
+        }
+        else {
+            files[fileName] = data;
+        }
+    }
+    return { files, config };
+}

package/dist/project/build-mono-readme.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-mono-readme.d.ts.map

package/dist/project/build-mono-readme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-mono-readme.d.ts","sourceRoot":"","sources":["../../src/project/build-mono-readme.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,451 @@
+"use strict";
+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_1 = require("./generate-docs");
+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');
+async function ensureParentDir(filePath) {
+    const dir = node_path_1.default.dirname(filePath);
+    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
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function toPosix(p) {
+    return p.split(node_path_1.default.sep).join('/');
+}
+async function readJson(filePath) {
+    const raw = await node_fs_1.promises.readFile(filePath, 'utf8');
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch (err) {
+        throw err;
+    }
+}
+async function listDir(dir) {
+    const entries = await node_fs_1.promises.readdir(dir, { withFileTypes: true });
+    return entries;
+}
+function normalizeWorkspacePatterns(workspacesField) {
+    if (Array.isArray(workspacesField))
+        return workspacesField;
+    if (isObject(workspacesField) && Array.isArray(workspacesField.packages))
+        return workspacesField.packages;
+    return [];
+}
+function mdEscapeInline(s) {
+    return String(s ?? '').replaceAll('`', '\`');
+}
+function indentLines(s, spaces = 2) {
+    const pad = ' '.repeat(spaces);
+    return String(s ?? '')
+        .split('\n')
+        .map((l) => pad + l)
+        .join('\n');
+}
+// ---------- 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('*', '.*') + '$');
+    return regex.test(name);
+}
+async function expandWorkspacePattern(root, pattern) {
+    const segs = toPosix(pattern).split('/').filter(Boolean);
+    async function expandFrom(dir, segIndex) {
+        if (segIndex >= segs.length)
+            return [dir];
+        const seg = segs[segIndex];
+        if (seg === '**') {
+            const results = [];
+            results.push(...(await expandFrom(dir, segIndex + 1)));
+            const entries = await node_fs_1.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+            for (const e of entries) {
+                if (!e.isDirectory())
+                    continue;
+                results.push(...(await expandFrom(node_path_1.default.join(dir, e.name), segIndex)));
+            }
+            return results;
+        }
+        const entries = await node_fs_1.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+        const results = [];
+        for (const e of entries) {
+            if (!e.isDirectory())
+                continue;
+            if (!matchSegment(seg, e.name))
+                continue;
+            results.push(...(await expandFrom(node_path_1.default.join(dir, e.name), segIndex + 1)));
+        }
+        return results;
+    }
+    const dirs = await expandFrom(root, 0);
+    const pkgDirs = [];
+    for (const d of dirs) {
+        const pkgPath = node_path_1.default.join(d, 'package.json');
+        if (await exists(pkgPath)) {
+            pkgDirs.push(d);
+        }
+    }
+    return [...new Set(pkgDirs)];
+}
+async function findWorkspacePackageDirs(repoRoot, workspacePatterns) {
+    const dirs = [];
+    for (const pat of workspacePatterns) {
+        const expanded = await expandWorkspacePattern(repoRoot, pat);
+        dirs.push(...expanded);
+        dirs.push(...expanded);
+    }
+    const uniqueDirs = [...new Set(dirs)];
+    return uniqueDirs;
+}
+// ---------- .mono parsing ----------
+async function readMonoConfig() {
+    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);
+        return { path: configPath, config };
+    }
+    catch (err) {
+        return null;
+    }
+}
+function commandNameFromFile(filePath) {
+    return node_path_1.default.basename(filePath).replace(/\.json$/i, '');
+}
+async function readMonoCommands() {
+    if (!(await exists(MONO_DIR))) {
+        return [];
+    }
+    const entries = await listDir(MONO_DIR);
+    const jsonFiles = entries
+        .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');
+    const commands = [];
+    for (const file of jsonFiles) {
+        try {
+            const j = await readJson(file);
+            commands.push({
+                name: commandNameFromFile(file),
+                file,
+                json: j,
+            });
+        }
+        catch (err) {
+            console.error(`[readMonoCommands] Failed to load command file:`, file, err);
+            // skip invalid json
+        }
+    }
+    commands.sort((a, b) => a.name.localeCompare(b.name));
+    return commands;
+}
+function parseOptionsSchema(optionsObj) {
+    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.trim().length > 0;
+        const isBoolToggle = !hasType;
+        return {
+            key,
+            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,
+            allowed: Array.isArray(o.options) ? o.options : null,
+            allowAll: o.allowAll === true,
+        };
+    });
+    entries.sort((a, b) => a.key.localeCompare(b.key));
+    return entries;
+}
+function buildUsageExample(commandName, cmdJson, options) {
+    const arg = cmdJson?.argument;
+    const hasArg = isObject(arg);
+    const argToken = hasArg ? `<${commandName}-arg>` : '';
+    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);
+    for (const o of valueOpts.slice(0, 2)) {
+        const flag = `--${o.key}`;
+        const val = o.default !== undefined ? o.default : (o.allowed?.[0] ?? '<value>');
+        exampleParts.push(`${flag} ${val}`);
+    }
+    if (boolOpts.length) {
+        exampleParts.push(`--${boolOpts[0].key}`);
+    }
+    return exampleParts.join(' ');
+}
+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);
+    const packages = [];
+    for (const dir of pkgDirs) {
+        try {
+            const pkgPath = node_path_1.default.join(dir, 'package.json');
+            const pj = await readJson(pkgPath);
+            packages.push({
+                name: pj.name || toPosix(node_path_1.default.relative(REPO_ROOT, dir)) || node_path_1.default.basename(dir),
+                dir,
+                scripts: pj.scripts || {},
+            });
+        }
+        catch (err) {
+            console.error(`[main] Failed to load package.json for:`, dir, err);
+            // skip
+        }
+    }
+    const parts = [];
+    parts.push(`# ⚙️ Command Line Reference
+
+> Generated by \`scripts/generate-readme.mjs\`.
+> Update \`.mono/config.json\`, \`.mono/*.json\`, and workspace package scripts to change this output.
+
+`);
+    parts.push(formatMonoConfigSection(monoConfig));
+    parts.push('');
+    parts.push(formatMonoCommandsSection(monoCommands));
+    parts.push('');
+    const val = await (0, generate_docs_1.generateDocsIndex)({
+        docsDir: node_path_1.default.join(REPO_ROOT, 'docs'),
+        excludeFile: 'command-line.md',
+    });
+    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(`[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?.stack || String(err));
+    process.exitCode = 1;
+});

package/dist/project/build-readme.d.ts

@@ -0,0 +1,3 @@
+import './build-mono-readme';
+import './generate-readme';
+//# sourceMappingURL=build-readme.d.ts.map

package/dist/project/build-readme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-readme.d.ts","sourceRoot":"","sources":["../../src/project/build-readme.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,OAAO,mBAAmB,CAAC"}

package/dist/project/build-readme.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./build-mono-readme");
+require("./generate-readme");

package/dist/project/generate-docs.d.ts

@@ -0,0 +1,12 @@
+export interface GenerateDocsIndexOptions {
+    docsDir: string;
+    excludeFile?: string;
+}
+/**
+ * Generate a docs index from markdown files.
+ *
+ * @param options - Options for docs index generation
+ * @returns Markdown-formatted index
+ */
+export declare function generateDocsIndex({ docsDir, excludeFile, }: GenerateDocsIndexOptions): Promise<string>;
+//# sourceMappingURL=generate-docs.d.ts.map

package/dist/project/generate-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-docs.d.ts","sourceRoot":"","sources":["../../src/project/generate-docs.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,wBAAwB;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAKD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,EACvC,OAAO,EACP,WAAW,GACX,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgD5C"}