@mono-labs/cli 0.0.203 → 0.0.205

package/dist/project/generate-readme.js

@@ -0,0 +1,311 @@
+// scripts/generate-repo-help.mjs
+// Generates a developer-friendly workspace command reference.
+//
+// Output: docs/workspaces.md
+//
+// Run (from repo root):
+//   node ./scripts/generate-repo-help.mjs
+//
+// Philosophy:
+// - 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';
+import { generateDocsIndex } from './generate-docs.js';
+// ----------------- config -----------------
+// Always use the working directory as the root for all file actions
+const REPO_ROOT = path.resolve(process.cwd());
+const ROOT_PKG_JSON = path.join(REPO_ROOT, 'package.json');
+const OUTPUT_PATH = path.join(REPO_ROOT, 'docs', 'workspaces.md');
+// ----------------- helpers -----------------
+async function exists(p) {
+    // Always resolve path relative to working directory
+    const absPath = path.resolve(process.cwd(), p);
+    try {
+        await fs.access(absPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function toPosix(p) {
+    return p.split(path.sep).join('/');
+}
+function mdEscapeInline(s) {
+    return String(s ?? '').replaceAll('`', '\`');
+}
+function slugifyForGithubAnchor(title) {
+    return String(title ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-');
+}
+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);
+}
+function normalizeWorkspacePatterns(workspacesField) {
+    if (Array.isArray(workspacesField))
+        return workspacesField;
+    if (isObject(workspacesField) &&
+        Array.isArray(workspacesField.packages))
+        return workspacesField.packages;
+    return [];
+}
+// ----------------- glob expansion -----------------
+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) {
+        // Always resolve dir relative to working directory
+        const absDir = path.resolve(process.cwd(), dir);
+        if (segIndex >= segs.length)
+            return [absDir];
+        const seg = segs[segIndex];
+        if (seg === '**') {
+            const results = [];
+            results.push(...(await expandFrom(absDir, segIndex + 1)));
+            const entries = await fs
+                .readdir(absDir, { withFileTypes: true })
+                .catch(() => []);
+            for (const e of entries) {
+                if (e.isDirectory()) {
+                    results.push(...(await expandFrom(path.join(absDir, e.name), segIndex)));
+                }
+            }
+            return results;
+        }
+        const entries = await fs
+            .readdir(absDir, { withFileTypes: true })
+            .catch(() => []);
+        const results = [];
+        for (const e of entries) {
+            if (e.isDirectory() && matchSegment(seg, e.name)) {
+                results.push(...(await expandFrom(path.join(absDir, e.name), segIndex + 1)));
+            }
+        }
+        return results;
+    }
+    return [...new Set(await expandFrom(root, 0))];
+}
+async function findWorkspaceRoots(repoRoot, workspacePatterns) {
+    const roots = [];
+    for (const pat of workspacePatterns) {
+        const expandedDirs = await expandWorkspacePattern(repoRoot, pat);
+        roots.push(...expandedDirs);
+    }
+    return [...new Set(roots)];
+}
+// ----------------- package discovery -----------------
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.next',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    '.turbo',
+]);
+async function findPackageJsonFilesRecursive(startDir) {
+    const found = [];
+    async function walk(dir) {
+        // Always resolve dir relative to working directory
+        const absDir = path.resolve(process.cwd(), dir);
+        const entries = await fs
+            .readdir(absDir, { withFileTypes: true })
+            .catch(() => []);
+        for (const e of entries) {
+            const full = path.join(absDir, e.name);
+            if (e.isDirectory()) {
+                if (!SKIP_DIRS.has(e.name))
+                    await walk(full);
+            }
+            else if (e.isFile() && e.name === 'package.json') {
+                found.push(full);
+            }
+        }
+    }
+    await walk(startDir);
+    return found;
+}
+async function collectPackagesFromWorkspaceRoots(workspaceRoots) {
+    const pkgJsonFiles = [];
+    for (const root of workspaceRoots) {
+        if (await exists(root)) {
+            pkgJsonFiles.push(...(await findPackageJsonFilesRecursive(root)));
+        }
+    }
+    const packages = [];
+    for (const file of [...new Set(pkgJsonFiles)]) {
+        if (path.resolve(file) === path.resolve(ROOT_PKG_JSON))
+            continue;
+        try {
+            const pj = await readJson(file);
+            const dir = path.dirname(file);
+            packages.push({
+                name: pj.name || toPosix(path.relative(REPO_ROOT, dir)),
+                dir,
+                scripts: isObject(pj.scripts) ? pj.scripts : {},
+            });
+        }
+        catch { }
+    }
+    const seen = new Set();
+    return packages
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .filter((p) => (seen.has(p.name) ? false : seen.add(p.name)));
+}
+// ----------------- classification -----------------
+function classifyPackage(pkg) {
+    const p = toPosix(pkg.dir);
+    if (p.startsWith('apps/'))
+        return 'Apps';
+    if (p.startsWith('packages/'))
+        return 'Libraries';
+    return 'Other';
+}
+// ----------------- markdown generation -----------------
+function formatQuickStart(pkgMgr) {
+    return [
+        '# 🗂️ Workspace Overview',
+        '',
+        'This document explains how to run and discover commands in this monorepo.',
+        '',
+        '---',
+        '',
+        '## 🚀 Quick Start',
+        '',
+        'Most developers only need the following:',
+        '',
+        '```bash',
+        `${pkgMgr} dev`,
+        `${pkgMgr} serve`,
+        `${pkgMgr} mobile`,
+        `${pkgMgr} help`,
+        '```',
+        '',
+        'Use `yarn mono` whenever possible. It handles environment setup,',
+        'workspace routing, and service coordination automatically.',
+        '',
+        '---',
+        '',
+    ];
+}
+function formatReferenceIntro() {
+    return [
+        '## 📖 Reference',
+        '',
+        'This section lists all workspace packages and their available scripts.',
+        '',
+        'Use this when:',
+        '- Debugging',
+        '- Working on internal libraries',
+        '- Running CI or low-level tooling',
+        '',
+    ];
+}
+function formatIndex(packages) {
+    const groups = {};
+    for (const p of packages) {
+        const g = classifyPackage(p);
+        groups[g] ||= [];
+        groups[g].push(p);
+    }
+    const lines = ['## Workspace Index', ''];
+    for (const group of Object.keys(groups)) {
+        lines.push(`### ${group}`);
+        lines.push('');
+        for (const p of groups[group]) {
+            lines.push(`- [\`${mdEscapeInline(p.name)}\`](#${slugifyForGithubAnchor(p.name)})`);
+        }
+        lines.push('');
+    }
+    return lines;
+}
+function formatPackages(packages) {
+    const lines = [];
+    for (const p of packages) {
+        lines.push(`### ${p.name}`);
+        lines.push('');
+        lines.push(`_Location: \`${toPosix(path.relative(REPO_ROOT, p.dir))}\`_`);
+        lines.push('');
+        const scripts = Object.keys(p.scripts).sort();
+        if (!scripts.length) {
+            lines.push('_No scripts defined._');
+            lines.push('');
+            continue;
+        }
+        lines.push('| Script | Recommended |');
+        lines.push('|------|-------------|');
+        for (const s of scripts) {
+            lines.push(`| \`${s}\` | \`yarn mono ${p.name} ${s}\` |`);
+        }
+        lines.push('');
+        lines.push('<details>');
+        lines.push('<summary>Raw yarn workspace commands</summary>');
+        lines.push('');
+        for (const s of scripts) {
+            lines.push(`- \`yarn workspace ${p.name} ${s}\``);
+        }
+        lines.push('</details>');
+        lines.push('');
+    }
+    return lines;
+}
+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 });
+}
+// ----------------- main -----------------
+async function main() {
+    // Always resolve all paths relative to working directory
+    if (!(await exists(ROOT_PKG_JSON))) {
+        throw new Error('Root package.json not found');
+    }
+    const rootPkg = await readJson(ROOT_PKG_JSON);
+    const workspacePatterns = normalizeWorkspacePatterns(rootPkg.workspaces);
+    const pkgMgr = `${(rootPkg.packageManager || 'yarn').split('@')[0]} mono`;
+    const workspaceRoots = await findWorkspaceRoots(REPO_ROOT, workspacePatterns);
+    const fallbackRoots = ['packages', 'apps'].map((p) => path.join(REPO_ROOT, p));
+    const roots = workspaceRoots.length ? workspaceRoots : fallbackRoots;
+    const packages = await collectPackagesFromWorkspaceRoots(roots);
+    const lines = [];
+    lines.push(...formatQuickStart(pkgMgr));
+    lines.push(...formatReferenceIntro());
+    lines.push(...formatIndex(packages));
+    lines.push('## Packages');
+    lines.push('');
+    lines.push(...formatPackages(packages));
+    const val = await generateDocsIndex({
+        docsDir: path.join(REPO_ROOT, 'docs'),
+        excludeFile: 'workspaces.md',
+    });
+    val.split('\n').forEach((line) => lines.push(line));
+    await ensureParentDir(OUTPUT_PATH);
+    await fs.writeFile(OUTPUT_PATH, lines.join('\n'), 'utf8');
+    console.log(`✅ Generated ${OUTPUT_PATH}`);
+    console.log(`📦 Packages found: ${packages.length}`);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import './build-mono-readme';
+import './generate-readme';

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

@@ -0,0 +1,11 @@
+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>;

package/dist/types/project/generate-readme.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/project/index.d.ts

@@ -25,6 +25,8 @@ type DefaultDeployConfig = {
     defaultKeyPair?: string;
     regions: string[];
     ec2User: string;
+    defaultVpcId?: string;
+    defaultVpcSecurityGroupId?: string;
 };
 type ConfigTypeMap = {
     app: DefaultAppConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mono-labs/cli",
-    "version": "0.0.203",
+    "version": "0.0.205",
     "description": "A CLI tool for building and deploying projects",
     "type": "module",
     "main": "dist/index.js",