@mono-labs/cli 0.0.206 → 0.0.207

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

@@ -1,5 +1,5 @@
 "use strict";
-// scripts/generate-readme.ts
+// scripts/generate-readme.mjs
 // Node >= 18 recommended
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -9,21 +9,18 @@ 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                                 */
+/* Constants                                                                  */
 /* -------------------------------------------------------------------------- */
-// 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                                    */
+/* 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));
-    await node_fs_1.promises.mkdir(dir, { recursive: true });
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
 }
 async function exists(p) {
     try {
@@ -35,21 +32,16 @@ async function exists(p) {
     }
 }
 function isObject(v) {
-    return v !== null && typeof v === 'object' && !Array.isArray(v);
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
 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);
+    return JSON.parse(await node_fs_1.promises.readFile(filePath, 'utf8'));
 }
 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 });
+    return node_fs_1.promises.readdir(dir, { withFileTypes: true });
 }
 function normalizeWorkspacePatterns(workspacesField) {
     if (Array.isArray(workspacesField))
@@ -60,18 +52,18 @@ function normalizeWorkspacePatterns(workspacesField) {
     }
     return [];
 }
-function mdEscapeInline(value) {
-    return String(value ?? '').replaceAll('`', '\\`');
+function mdEscapeInline(s) {
+    return s.replaceAll('`', '\\`');
 }
 function indentLines(s, spaces = 2) {
     const pad = ' '.repeat(spaces);
     return s
         .split('\n')
-        .map((line) => pad + line)
+        .map((l) => pad + l)
         .join('\n');
 }
 /* -------------------------------------------------------------------------- */
-/*                      Workspace glob pattern expansion                       */
+/* Workspace globbing                                                         */
 /* -------------------------------------------------------------------------- */
 function matchSegment(patternSeg, name) {
     if (patternSeg === '*')
@@ -79,113 +71,78 @@ function matchSegment(patternSeg, name) {
     if (!patternSeg.includes('*'))
         return patternSeg === name;
     const escaped = patternSeg.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-    const regex = new RegExp(`^${escaped.replaceAll('*', '.*')}$`);
-    return regex.test(name);
+    return new RegExp(`^${escaped.replaceAll('*', '.*')}$`).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];
-        if (seg === '**') {
-            const results = [];
-            results.push(...(await expandFrom(absDir, index + 1)));
-            const entries = await node_fs_1.promises
-                .readdir(absDir, { withFileTypes: true })
-                .catch(() => []);
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                results.push(...(await expandFrom(node_path_1.default.join(absDir, entry.name), index)));
-            }
-            return results;
-        }
+    const segs = toPosix(pattern).split('/').filter(Boolean);
+    async function expandFrom(dir, idx) {
+        if (idx >= segs.length)
+            return [dir];
         const entries = await node_fs_1.promises
-            .readdir(absDir, { withFileTypes: true })
+            .readdir(dir, { withFileTypes: true })
             .catch(() => []);
-        const results = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (!matchSegment(seg, entry.name))
-                continue;
-            results.push(...(await expandFrom(node_path_1.default.join(absDir, entry.name), index + 1)));
+        const seg = segs[idx];
+        if (seg === '**') {
+            const nested = await Promise.all(entries
+                .filter((e) => e.isDirectory())
+                .map((e) => expandFrom(node_path_1.default.join(dir, e.name), idx)));
+            return [...(await expandFrom(dir, idx + 1)), ...nested.flat()];
         }
-        return results;
+        const nested = await Promise.all(entries
+            .filter((e) => e.isDirectory() && matchSegment(seg, e.name))
+            .map((e) => expandFrom(node_path_1.default.join(dir, e.name), idx + 1)));
+        return nested.flat();
     }
     const dirs = await expandFrom(root, 0);
-    const pkgDirs = [];
-    for (const d of dirs) {
-        if (await exists(node_path_1.default.join(d, 'package.json'))) {
-            pkgDirs.push(d);
-        }
-    }
-    return Array.from(new Set(pkgDirs));
+    const pkgDirs = (await Promise.all(dirs.map(async (d) => (await exists(node_path_1.default.join(d, 'package.json'))) ? d : null))).filter(Boolean);
+    return [...new Set(pkgDirs)];
 }
-async function findWorkspacePackageDirs(repoRoot, patterns) {
-    const dirs = [];
-    for (const pat of patterns) {
-        dirs.push(...(await expandWorkspacePattern(repoRoot, pat)));
-    }
-    return Array.from(new Set(dirs));
+async function findWorkspacePackageDirs(repoRoot, workspacePatterns) {
+    const resolved = await Promise.all(workspacePatterns.map((p) => expandWorkspacePattern(repoRoot, p)));
+    return [...new Set(resolved.flat())];
 }
 /* -------------------------------------------------------------------------- */
-/*                             .mono configuration                             */
+/* Mono config + commands                                                     */
 /* -------------------------------------------------------------------------- */
 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'));
+    const configPath = node_path_1.default.join(MONO_DIR, 'config.json');
     if (!(await exists(configPath)))
         return null;
-    try {
-        const config = await readJson(configPath);
-        return { path: configPath, config };
-    }
-    catch {
-        return null;
-    }
+    return {
+        path: configPath,
+        config: await readJson(configPath),
+    };
 }
 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)))
+    if (!(await exists(MONO_DIR)))
         return [];
-    const entries = await listDir(monoDirAbs);
-    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');
-    const commands = [];
-    for (const file of jsonFiles) {
-        try {
-            const json = await readJson(file);
-            commands.push({
-                name: commandNameFromFile(file),
-                file,
-                json,
-            });
-        }
-        catch {
-            /* ignore invalid JSON */
-        }
-    }
+    const entries = await listDir(MONO_DIR);
+    const commands = await Promise.all(entries
+        .filter((e) => e.isFile() && e.name.endsWith('.json') && e.name !== 'config.json')
+        .map(async (e) => {
+        const file = node_path_1.default.join(MONO_DIR, e.name);
+        const json = await readJson(file);
+        return {
+            name: commandNameFromFile(file),
+            file,
+            json,
+        };
+    }));
     return commands.sort((a, b) => a.name.localeCompare(b.name));
 }
 /* -------------------------------------------------------------------------- */
-/*                          Options schema parsing                             */
+/* Options parsing                                                           */
 /* -------------------------------------------------------------------------- */
 function parseOptionsSchema(optionsObj) {
     if (!isObject(optionsObj))
         return [];
-    const entries = Object.entries(optionsObj).map(([key, raw]) => {
+    return 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';
         return {
             key,
             kind: hasType ? 'value' : 'boolean',
@@ -193,41 +150,20 @@ function parseOptionsSchema(optionsObj) {
             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,
+            allowed: Array.isArray(o.options) ?
+                o.options.filter((x) => typeof x === 'string')
+                : null,
             allowAll: o.allowAll === true,
         };
-    });
-    return entries.sort((a, b) => a.key.localeCompare(b.key));
+    })
+        .sort((a, b) => a.key.localeCompare(b.key));
 }
 /* -------------------------------------------------------------------------- */
-/*                                 Formatting                                 */
-/* -------------------------------------------------------------------------- */
-function buildUsageExample(commandName, cmdJson, options) {
-    const arg = cmdJson.argument;
-    const hasArg = isObject(arg);
-    const parts = [`yarn mono ${commandName}`];
-    if (hasArg)
-        parts.push(`<${commandName}-arg>`);
-    const valueOpts = options.filter((o) => o.kind === 'value');
-    const boolOpts = options.filter((o) => o.kind === 'boolean');
-    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}`);
-    }
-    if (boolOpts[0]) {
-        parts.push(`--${boolOpts[0].key}`);
-    }
-    return parts.join(' ');
-}
-/* -------------------------------------------------------------------------- */
-/*                                    Main                                    */
+/* 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}`);
+        throw new Error(`Missing: ${ROOT_PKG_JSON}`);
     }
     await ensureParentDir(OUTPUT_PATH);
     const rootPkg = await readJson(ROOT_PKG_JSON);
@@ -235,36 +171,28 @@ async function main() {
     const monoConfig = await readMonoConfig();
     const monoCommands = await readMonoCommands();
     const pkgDirs = await findWorkspacePackageDirs(REPO_ROOT, workspacePatterns);
-    const packages = [];
-    for (const dir of pkgDirs) {
-        try {
-            const pkg = await readJson(node_path_1.default.join(dir, 'package.json'));
-            packages.push({
-                name: pkg.name ??
-                    toPosix(node_path_1.default.relative(REPO_ROOT, dir)) ??
-                    node_path_1.default.basename(dir),
-                dir,
-                scripts: pkg.scripts ?? {},
-            });
-        }
-        catch {
-            /* ignore */
-        }
-    }
+    const packages = await Promise.all(pkgDirs.map(async (dir) => {
+        const pj = await readJson(node_path_1.default.join(dir, 'package.json'));
+        return {
+            name: pj.name ||
+                toPosix(node_path_1.default.relative(REPO_ROOT, dir)) ||
+                node_path_1.default.basename(dir),
+            dir,
+            scripts: pj.scripts ?? {},
+        };
+    }));
     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)({
         docsDir: node_path_1.default.join(REPO_ROOT, 'docs'),
         excludeFile: 'command-line.md',
     });
     parts.push(docsIndex);
-    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'}`);
@@ -272,6 +200,6 @@ async function main() {
     console.log(`- workspace packages: ${packages.length}`);
 }
 main().catch((err) => {
-    console.error(err instanceof Error ? err.stack : err);
-    process.exit(1);
+    console.error(err);
+    process.exitCode = 1;
 });

package/package.json

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

package/src/project/build-mono-readme.ts

@@ -1,31 +1,15 @@
-// scripts/generate-readme.ts
+// scripts/generate-readme.mjs
 // Node >= 18 recommended
 
-import { promises as fs } from 'node:fs';
-import { Dirent } from 'node:fs';
+import { promises as fs, Dirent } from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
 import { generateDocsIndex } from './generate-docs.js';
 
 /* -------------------------------------------------------------------------- */
-/*                               Path helpers                                 */
-/* -------------------------------------------------------------------------- */
-
-// Always use the working directory as the root for all file actions
-const REPO_ROOT = path.resolve(process.cwd());
-const MONO_DIR = path.join(REPO_ROOT, '.mono');
-const ROOT_PKG_JSON = path.join(REPO_ROOT, 'package.json');
-const OUTPUT_PATH = path.join(REPO_ROOT, 'docs');
-const OUTPUT_README = path.join(OUTPUT_PATH, 'command-line.md');
-
-/* -------------------------------------------------------------------------- */
-/*                                   Types                                    */
+/* Types                                                                      */
 /* -------------------------------------------------------------------------- */
 
-type JsonObject = Record<string, unknown>;
-
-interface MonoConfig {
+type MonoConfig = {
 	path: string;
 	config: {
 		envMap?: string[];
@@ -35,21 +19,33 @@ interface MonoConfig {
 			preactions?: string[];
 		};
 	};
-}
+};
 
-interface MonoCommand {
+type MonoCommand = {
 	name: string;
 	file: string;
-	json: JsonObject;
-}
+	json: {
+		description?: string;
+		argument?: {
+			type?: string;
+			description?: string;
+			default?: unknown;
+			required?: boolean;
+		};
+		options?: Record<string, unknown>;
+		environments?: Record<string, Record<string, string>>;
+		preactions?: string[];
+		actions?: string[];
+	};
+};
 
-interface PackageInfo {
+type PackageInfo = {
 	name: string;
 	dir: string;
 	scripts: Record<string, string>;
-}
+};
 
-interface OptionSchema {
+type OptionSchema = {
 	key: string;
 	kind: 'boolean' | 'value';
 	type: string;
@@ -58,16 +54,24 @@ interface OptionSchema {
 	default: unknown;
 	allowed: string[] | null;
 	allowAll: boolean;
-}
+};
 
 /* -------------------------------------------------------------------------- */
-/*                                   Utils                                    */
+/* Constants                                                                  */
+/* -------------------------------------------------------------------------- */
+
+const REPO_ROOT = path.resolve(process.cwd());
+const MONO_DIR = path.join(REPO_ROOT, '.mono');
+const ROOT_PKG_JSON = path.join(REPO_ROOT, 'package.json');
+const OUTPUT_PATH = path.join(REPO_ROOT, 'docs');
+const OUTPUT_README = path.join(OUTPUT_PATH, 'command-line.md');
+
+/* -------------------------------------------------------------------------- */
+/* Utils                                                                      */
 /* -------------------------------------------------------------------------- */
 
 async function ensureParentDir(filePath: string): Promise<void> {
-	// Always resolve parent dir relative to working directory
-	const dir = path.resolve(process.cwd(), path.dirname(filePath));
-	await fs.mkdir(dir, { recursive: true });
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
 }
 
 async function exists(p: string): Promise<boolean> {
@@ -79,25 +83,20 @@ async function exists(p: string): Promise<boolean> {
 	}
 }
 
-function isObject(v: unknown): v is JsonObject {
-	return v !== null && typeof v === 'object' && !Array.isArray(v);
+function isObject(v: unknown): v is Record<string, unknown> {
+	return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
 
 function toPosix(p: string): string {
 	return p.split(path.sep).join('/');
 }
 
-async function readJson<T = unknown>(filePath: string): Promise<T> {
-	// Always resolve filePath relative to working directory
-	const absPath = path.resolve(process.cwd(), filePath);
-	const raw = await fs.readFile(absPath, 'utf8');
-	return JSON.parse(raw) as T;
+async function readJson<T>(filePath: string): Promise<T> {
+	return JSON.parse(await fs.readFile(filePath, 'utf8')) as T;
 }
 
 async function listDir(dir: string): Promise<Dirent[]> {
-	// Always resolve dir relative to working directory
-	const absDir = path.resolve(process.cwd(), dir);
-	return fs.readdir(absDir, { withFileTypes: true });
+	return fs.readdir(dir, { withFileTypes: true });
 }
 
 function normalizeWorkspacePatterns(workspacesField: unknown): string[] {
@@ -111,121 +110,97 @@ function normalizeWorkspacePatterns(workspacesField: unknown): string[] {
 	return [];
 }
 
-function mdEscapeInline(value: unknown): string {
-	return String(value ?? '').replaceAll('`', '\\`');
+function mdEscapeInline(s: string): string {
+	return s.replaceAll('`', '\\`');
 }
 
 function indentLines(s: string, spaces = 2): string {
 	const pad = ' '.repeat(spaces);
 	return s
 		.split('\n')
-		.map((line) => pad + line)
+		.map((l) => pad + l)
 		.join('\n');
 }
 
 /* -------------------------------------------------------------------------- */
-/*                      Workspace glob pattern expansion                       */
+/* Workspace globbing                                                         */
 /* -------------------------------------------------------------------------- */
 
 function matchSegment(patternSeg: string, name: string): boolean {
 	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);
+	return new RegExp(`^${escaped.replaceAll('*', '.*')}$`).test(name);
 }
 
 async function expandWorkspacePattern(
 	root: string,
 	pattern: string
 ): Promise<string[]> {
-	const segments = toPosix(pattern).split('/').filter(Boolean);
-
-	async function expandFrom(dir: string, index: number): Promise<string[]> {
-		// Always resolve dir relative to working directory
-		const absDir = path.resolve(process.cwd(), dir);
-		if (index >= segments.length) return [absDir];
+	const segs = toPosix(pattern).split('/').filter(Boolean);
 
-		const seg = segments[index];
-
-		if (seg === '**') {
-			const results: string[] = [];
-			results.push(...(await expandFrom(absDir, index + 1)));
-
-			const entries = await fs
-				.readdir(absDir, { withFileTypes: true })
-				.catch(() => []);
-
-			for (const entry of entries) {
-				if (!entry.isDirectory()) continue;
-				results.push(
-					...(await expandFrom(path.join(absDir, entry.name), index))
-				);
-			}
-			return results;
-		}
+	async function expandFrom(dir: string, idx: number): Promise<string[]> {
+		if (idx >= segs.length) return [dir];
 
 		const entries = await fs
-			.readdir(absDir, { withFileTypes: true })
+			.readdir(dir, { withFileTypes: true })
 			.catch(() => []);
 
-		const results: string[] = [];
-		for (const entry of entries) {
-			if (!entry.isDirectory()) continue;
-			if (!matchSegment(seg, entry.name)) continue;
+		const seg = segs[idx];
 
-			results.push(
-				...(await expandFrom(path.join(absDir, entry.name), index + 1))
+		if (seg === '**') {
+			const nested = await Promise.all(
+				entries
+					.filter((e) => e.isDirectory())
+					.map((e) => expandFrom(path.join(dir, e.name), idx))
 			);
+
+			return [...(await expandFrom(dir, idx + 1)), ...nested.flat()];
 		}
 
-		return results;
+		const nested = await Promise.all(
+			entries
+				.filter((e) => e.isDirectory() && matchSegment(seg, e.name))
+				.map((e) => expandFrom(path.join(dir, e.name), idx + 1))
+		);
+
+		return nested.flat();
 	}
 
 	const dirs = await expandFrom(root, 0);
-	const pkgDirs: string[] = [];
 
-	for (const d of dirs) {
-		if (await exists(path.join(d, 'package.json'))) {
-			pkgDirs.push(d);
-		}
-	}
+	const pkgDirs = (
+		await Promise.all(
+			dirs.map(async (d) =>
+				(await exists(path.join(d, 'package.json'))) ? d : null
+			)
+		)
+	).filter(Boolean) as string[];
 
-	return Array.from(new Set(pkgDirs));
+	return [...new Set(pkgDirs)];
 }
 
 async function findWorkspacePackageDirs(
 	repoRoot: string,
-	patterns: string[]
+	workspacePatterns: string[]
 ): Promise<string[]> {
-	const dirs: string[] = [];
-
-	for (const pat of patterns) {
-		dirs.push(...(await expandWorkspacePattern(repoRoot, pat)));
-	}
-
-	return Array.from(new Set(dirs));
+	const resolved = await Promise.all(
+		workspacePatterns.map((p) => expandWorkspacePattern(repoRoot, p))
+	);
+	return [...new Set(resolved.flat())];
 }
 
 /* -------------------------------------------------------------------------- */
-/*                             .mono configuration                             */
+/* Mono config + commands                                                     */
 /* -------------------------------------------------------------------------- */
 
 async function readMonoConfig(): Promise<MonoConfig | null> {
-	// Always resolve configPath relative to working directory
-	const configPath = path.resolve(
-		process.cwd(),
-		path.join(MONO_DIR, 'config.json')
-	);
+	const configPath = path.join(MONO_DIR, 'config.json');
 	if (!(await exists(configPath))) return null;
-
-	try {
-		const config = await readJson<MonoConfig['config']>(configPath);
-		return { path: configPath, config };
-	} catch {
-		return null;
-	}
+	return {
+		path: configPath,
+		config: await readJson<MonoConfig['config']>(configPath),
+	};
 }
 
 function commandNameFromFile(filePath: string): string {
@@ -233,150 +208,100 @@ function commandNameFromFile(filePath: string): string {
 }
 
 async function readMonoCommands(): Promise<MonoCommand[]> {
-	// Always resolve MONO_DIR relative to working directory
-	const monoDirAbs = path.resolve(process.cwd(), MONO_DIR);
-	if (!(await exists(monoDirAbs))) return [];
-
-	const entries = await listDir(monoDirAbs);
-
-	const jsonFiles = entries
-		.filter((e) => e.isFile() && e.name.endsWith('.json'))
-		.map((e) => path.join(monoDirAbs, e.name))
-		.filter((p) => path.basename(p) !== 'config.json');
-
-	const commands: MonoCommand[] = [];
-
-	for (const file of jsonFiles) {
-		try {
-			const json = await readJson<JsonObject>(file);
-			commands.push({
-				name: commandNameFromFile(file),
-				file,
-				json,
-			});
-		} catch {
-			/* ignore invalid JSON */
-		}
-	}
+	if (!(await exists(MONO_DIR))) return [];
+
+	const entries = await listDir(MONO_DIR);
+
+	const commands = await Promise.all(
+		entries
+			.filter(
+				(e) =>
+					e.isFile() && e.name.endsWith('.json') && e.name !== 'config.json'
+			)
+			.map(async (e) => {
+				const file = path.join(MONO_DIR, e.name);
+				const json = await readJson<MonoCommand['json']>(file);
+				return {
+					name: commandNameFromFile(file),
+					file,
+					json,
+				};
+			})
+	);
 
 	return commands.sort((a, b) => a.name.localeCompare(b.name));
 }
 
 /* -------------------------------------------------------------------------- */
-/*                          Options schema parsing                             */
+/* Options parsing                                                           */
 /* -------------------------------------------------------------------------- */
 
 function parseOptionsSchema(optionsObj: unknown): OptionSchema[] {
 	if (!isObject(optionsObj)) return [];
 
-	const entries: OptionSchema[] = Object.entries(optionsObj).map(
-		([key, raw]) => {
+	return 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';
 
 			return {
 				key,
-				kind: hasType ? 'value' : 'boolean',
+				kind: hasType ? ('value' as const) : ('boolean' as const),
 				type: hasType ? (o.type as string) : '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 as string[]) : null,
+				allowed:
+					Array.isArray(o.options) ?
+						o.options.filter((x): x is string => typeof x === 'string')
+					:	null,
 				allowAll: o.allowAll === true,
 			};
-		}
-	);
-
-	return entries.sort((a, b) => a.key.localeCompare(b.key));
+		})
+		.sort((a, b) => a.key.localeCompare(b.key));
 }
 
 /* -------------------------------------------------------------------------- */
-/*                                 Formatting                                 */
-/* -------------------------------------------------------------------------- */
-
-function buildUsageExample(
-	commandName: string,
-	cmdJson: JsonObject,
-	options: OptionSchema[]
-): string {
-	const arg = cmdJson.argument;
-	const hasArg = isObject(arg);
-
-	const parts: string[] = [`yarn mono ${commandName}`];
-
-	if (hasArg) parts.push(`<${commandName}-arg>`);
-
-	const valueOpts = options.filter((o) => o.kind === 'value');
-	const boolOpts = options.filter((o) => o.kind === 'boolean');
-
-	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}`);
-	}
-
-	if (boolOpts[0]) {
-		parts.push(`--${boolOpts[0].key}`);
-	}
-
-	return parts.join(' ');
-}
-
-/* -------------------------------------------------------------------------- */
-/*                                    Main                                    */
+/* Main                                                                      */
 /* -------------------------------------------------------------------------- */
 
 async function main(): Promise<void> {
-	// Always resolve all paths relative to working directory
 	if (!(await exists(ROOT_PKG_JSON))) {
-		throw new Error(`Missing ${ROOT_PKG_JSON}`);
+		throw new Error(`Missing: ${ROOT_PKG_JSON}`);
 	}
 
 	await ensureParentDir(OUTPUT_PATH);
 
-	const rootPkg = await readJson<{ workspaces?: unknown }>(ROOT_PKG_JSON);
+	const rootPkg = await readJson<any>(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: PackageInfo[] = [];
-
-	for (const dir of pkgDirs) {
-		try {
-			const pkg = await readJson<{
-				name?: string;
-				scripts?: Record<string, string>;
-			}>(path.join(dir, 'package.json'));
-
-			packages.push({
+	const packages: PackageInfo[] = await Promise.all(
+		pkgDirs.map(async (dir) => {
+			const pj = await readJson<any>(path.join(dir, 'package.json'));
+			return {
 				name:
-					pkg.name ??
-					toPosix(path.relative(REPO_ROOT, dir)) ??
+					pj.name ||
+					toPosix(path.relative(REPO_ROOT, dir)) ||
 					path.basename(dir),
 				dir,
-				scripts: pkg.scripts ?? {},
-			});
-		} catch {
-			/* ignore */
-		}
-	}
+				scripts: pj.scripts ?? {},
+			};
+		})
+	);
 
 	const parts: string[] = [];
 
 	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 generateDocsIndex({
 		docsDir: path.join(REPO_ROOT, 'docs'),
 		excludeFile: 'command-line.md',
@@ -384,7 +309,6 @@ async function main(): Promise<void> {
 
 	parts.push(docsIndex);
 
-	await ensureParentDir(OUTPUT_README);
 	await fs.writeFile(OUTPUT_README, parts.join('\n'), 'utf8');
 
 	console.log(`Generated: ${OUTPUT_README}`);
@@ -394,6 +318,6 @@ async function main(): Promise<void> {
 }
 
 main().catch((err) => {
-	console.error(err instanceof Error ? err.stack : err);
-	process.exit(1);
+	console.error(err);
+	process.exitCode = 1;
 });