@mono-labs/cli 0.0.205 → 0.0.207

package/dist/cdk/index.js

@@ -1,4 +1,8 @@
-export function replaceTokens(str, env) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceTokens = replaceTokens;
+exports.setUpConfig = setUpConfig;
+function replaceTokens(str, env) {
     if (typeof str !== 'string')
         return str;
     return str.replace(/\$\{([^}]+)\}|\$([A-Z0-9_]+)/g, (m, k1, k2) => {
@@ -26,7 +30,7 @@ function filterEnvByPrefix(env, prefix) {
     }
     return filtered;
 }
-export function setUpConfig(config) {
+function setUpConfig(config) {
     const { extra = {}, ...other } = config.expo || {};
     const router = extra['router'] ?
         { origin: false, ...extra['router'] }

package/dist/expo.js

@@ -1,4 +1,8 @@
-export function replaceTokens(str, env) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceTokens = replaceTokens;
+exports.setUpConfig = setUpConfig;
+function replaceTokens(str, env) {
     if (typeof str !== 'string')
         return str;
     return str.replace(/\$\{([^}]+)\}|\$([A-Z0-9_]+)/g, (m, k1, k2) => {
@@ -26,7 +30,7 @@ function filterEnvByPrefix(env, prefix) {
     }
     return filtered;
 }
-export function setUpConfig(config) {
+function setUpConfig(config) {
     const { extra = {}, ...other } = config.expo || {};
     const router = extra['router'] ?
         { origin: false, ...extra['router'] }

package/dist/merge-env.js

@@ -1,14 +1,20 @@
-import fs from 'fs';
-import path from 'path';
-import dotenv from 'dotenv';
-export function loadMergedEnv() {
-    const ENV_PATH = path.resolve(process.cwd(), '.env');
-    const ENV_LOCAL_PATH = path.resolve(process.cwd(), '.env.local');
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMergedEnv = loadMergedEnv;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dotenv_1 = __importDefault(require("dotenv"));
+function loadMergedEnv() {
+    const ENV_PATH = path_1.default.resolve(process.cwd(), '.env');
+    const ENV_LOCAL_PATH = path_1.default.resolve(process.cwd(), '.env.local');
     // Load base .env
-    const base = fs.existsSync(ENV_PATH) ? dotenv.parse(fs.readFileSync(ENV_PATH)) : {};
+    const base = fs_1.default.existsSync(ENV_PATH) ? dotenv_1.default.parse(fs_1.default.readFileSync(ENV_PATH)) : {};
     // Load overrides .env.local
-    const local = fs.existsSync(ENV_LOCAL_PATH) ?
-        dotenv.parse(fs.readFileSync(ENV_LOCAL_PATH))
+    const local = fs_1.default.existsSync(ENV_LOCAL_PATH) ?
+        dotenv_1.default.parse(fs_1.default.readFileSync(ENV_LOCAL_PATH))
         : {};
     // Merge: local overrides base
     const merged = {

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

@@ -1,28 +1,30 @@
-// scripts/generate-readme.ts
+"use strict";
+// scripts/generate-readme.mjs
 // Node >= 18 recommended
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { generateDocsIndex } from './generate-docs.js';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = 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');
+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 = path.resolve(process.cwd(), path.dirname(filePath));
-    await fs.mkdir(dir, { recursive: true });
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
 }
 async function exists(p) {
     try {
-        await fs.access(p);
+        await node_fs_1.promises.access(p);
         return true;
     }
     catch {
@@ -30,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(path.sep).join('/');
+    return p.split(node_path_1.default.sep).join('/');
 }
 async function readJson(filePath) {
-    // 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);
+    return JSON.parse(await node_fs_1.promises.readFile(filePath, 'utf8'));
 }
 async function listDir(dir) {
-    // Always resolve dir relative to working directory
-    const absDir = path.resolve(process.cwd(), dir);
-    return fs.readdir(absDir, { withFileTypes: true });
+    return node_fs_1.promises.readdir(dir, { withFileTypes: true });
 }
 function normalizeWorkspacePatterns(workspacesField) {
     if (Array.isArray(workspacesField))
@@ -55,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 === '*')
@@ -74,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 = path.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 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;
-        }
-        const entries = await fs
-            .readdir(absDir, { withFileTypes: true })
+    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(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(path.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(path.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 = path.resolve(process.cwd(), path.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 path.basename(filePath).replace(/\.json$/i, '');
+    return node_path_1.default.basename(filePath).replace(/\.json$/i, '');
 }
 async function readMonoCommands() {
-    // Always resolve MONO_DIR relative to working directory
-    const monoDirAbs = path.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) => path.join(monoDirAbs, e.name))
-        .filter((p) => path.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',
@@ -188,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);
@@ -230,43 +171,35 @@ 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(path.join(dir, 'package.json'));
-            packages.push({
-                name: pkg.name ??
-                    toPosix(path.relative(REPO_ROOT, dir)) ??
-                    path.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 generateDocsIndex({
-        docsDir: path.join(REPO_ROOT, 'docs'),
+    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 fs.writeFile(OUTPUT_README, parts.join('\n'), 'utf8');
+    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}`);
 }
 main().catch((err) => {
-    console.error(err instanceof Error ? err.stack : err);
-    process.exit(1);
+    console.error(err);
+    process.exitCode = 1;
 });

package/dist/project/build-readme.js

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

package/dist/project/generate-docs.js

@@ -1,3 +1,4 @@
+"use strict";
 // scripts/generate-repo-help.mjs
 // Generates a developer-friendly workspace command reference.
 //
@@ -10,18 +11,23 @@
 // - Optimize for onboarding and day-to-day use
 // - Keep raw yarn workspace commands for reference
 // - Emphasize `yarn mono` as the primary interface
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDocsIndex = generateDocsIndex;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
 /**
  * Generate a docs index from markdown files.
  *
  * @param options - Options for docs index generation
  * @returns Markdown-formatted index
  */
-export async function generateDocsIndex({ docsDir, excludeFile, }) {
+async function generateDocsIndex({ docsDir, excludeFile, }) {
     // Always resolve docsDir relative to the working directory
-    const dirPath = path.resolve(process.cwd(), docsDir);
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const dirPath = node_path_1.default.resolve(process.cwd(), docsDir);
+    const entries = await node_fs_1.promises.readdir(dirPath, { withFileTypes: true });
     const links = [];
     for (const entry of entries) {
         if (!entry.isFile())
@@ -34,8 +40,8 @@ export async function generateDocsIndex({ docsDir, excludeFile, }) {
         // Optionally ignore a caller-specified file
         if (excludeFile && entry.name === excludeFile)
             continue;
-        const filePath = path.join(dirPath, entry.name);
-        const contents = await fs.readFile(filePath, 'utf8');
+        const filePath = node_path_1.default.join(dirPath, entry.name);
+        const contents = await node_fs_1.promises.readFile(filePath, 'utf8');
         // Find first markdown H1
         const match = contents.match(/^#\s+(.+)$/m);
         if (!match)