@mono-labs/project 0.0.248

package/dist/project/generate-docs.js

@@ -0,0 +1,73 @@
+"use strict";
+// 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
+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"));
+function createSpacer() {
+    return '\n\n';
+}
+/**
+ * Generate a docs index from markdown files.
+ *
+ * @param options - Options for docs index generation
+ * @returns Markdown-formatted index
+ */
+async function generateDocsIndex({ docsDir, excludeFile, }) {
+    // Always resolve docsDir relative to the working directory
+    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())
+            continue;
+        if (!entry.name.endsWith('.md'))
+            continue;
+        // Always ignore docs/readme.md (case-insensitive)
+        if (entry.name.toLowerCase() === 'readme.md')
+            continue;
+        // Optionally ignore a caller-specified file
+        if (excludeFile && entry.name === excludeFile)
+            continue;
+        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)
+            continue;
+        const rawTitle = match[1].trim();
+        const relativeLink = `./${entry.name}`;
+        /**
+         * Detect leading non-alphanumeric characters (emoji / symbols).
+         * This matches one or more Unicode characters that are NOT letters or numbers.
+         */
+        const leadingSymbolMatch = rawTitle.match(/^([^\p{L}\p{N}]+)\s*(.+)$/u);
+        if (leadingSymbolMatch) {
+            const [, symbol, title] = leadingSymbolMatch;
+            links.push(`- ${symbol.trim()} [${title.trim()}](${relativeLink})`);
+        }
+        else {
+            links.push(`- [${rawTitle.trim()}](${relativeLink})`);
+        }
+    }
+    // Sort alphabetically by rendered text (stable output)
+    links.sort((a, b) => a.localeCompare(b));
+    // Append Back to Readme
+    links.push('');
+    links.push('🏠 ← [Back to README](../README.md)');
+    return ['', '---', '', ...links].join('\n');
+}

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

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

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

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

package/dist/project/generate-readme.js

@@ -0,0 +1,309 @@
+"use strict";
+// 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
+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_1 = require("./generate-docs");
+// ----------------- config -----------------
+// Always use the working directory as the root for all file actions
+const REPO_ROOT = node_path_1.default.resolve(process.cwd());
+const ROOT_PKG_JSON = node_path_1.default.join(REPO_ROOT, 'package.json');
+const OUTPUT_PATH = node_path_1.default.join(REPO_ROOT, 'docs', 'workspaces.md');
+// ----------------- helpers -----------------
+async function exists(p) {
+    // Always resolve path relative to working directory
+    const absPath = node_path_1.default.resolve(process.cwd(), p);
+    try {
+        await node_fs_1.promises.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(node_path_1.default.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 = node_path_1.default.resolve(process.cwd(), filePath);
+    const raw = await node_fs_1.promises.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 = node_path_1.default.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 node_fs_1.promises.readdir(absDir, { withFileTypes: true }).catch(() => []);
+            for (const e of entries) {
+                if (e.isDirectory()) {
+                    results.push(...(await expandFrom(node_path_1.default.join(absDir, e.name), segIndex)));
+                }
+            }
+            return results;
+        }
+        const entries = await node_fs_1.promises.readdir(absDir, { withFileTypes: true }).catch(() => []);
+        const results = [];
+        for (const e of entries) {
+            if (e.isDirectory() && matchSegment(seg, e.name)) {
+                results.push(...(await expandFrom(node_path_1.default.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 = node_path_1.default.resolve(process.cwd(), dir);
+        const entries = await node_fs_1.promises.readdir(absDir, { withFileTypes: true }).catch(() => []);
+        for (const e of entries) {
+            const full = node_path_1.default.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 (node_path_1.default.resolve(file) === node_path_1.default.resolve(ROOT_PKG_JSON))
+            continue;
+        try {
+            const pj = await readJson(file);
+            const dir = node_path_1.default.dirname(file);
+            packages.push({
+                name: pj.name || toPosix(node_path_1.default.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(node_path_1.default.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 = node_path_1.default.resolve(process.cwd(), node_path_1.default.dirname(filePath));
+    await node_fs_1.promises.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) => node_path_1.default.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 (0, generate_docs_1.generateDocsIndex)({
+        docsDir: node_path_1.default.join(REPO_ROOT, 'docs'),
+        excludeFile: 'workspaces.md',
+    });
+    val.split('\n').forEach((line) => lines.push(line));
+    await ensureParentDir(OUTPUT_PATH);
+    await node_fs_1.promises.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/project/index.d.ts

@@ -0,0 +1,41 @@
+type WorkspaceDetectResult = {
+    cwd: string;
+    workspaceRoot: string | null;
+    isWorkspaceRoot: boolean;
+    configDir: string;
+    configPath: string;
+};
+type DefaultAppConfig = {
+    appleAppId?: string;
+    androidAppId?: string;
+    appName?: string;
+    easProjectId?: string;
+    appScheme?: string;
+};
+type DefaultDeployConfig = {
+    baseDomain?: string;
+    webSubdomain?: string;
+    apiSubdomain?: string;
+    defaultKeyPair?: string;
+    regions: string[];
+    ec2User: string;
+    warehouseRegion: string;
+    dbInstanceType: string;
+    appInstanceType: string;
+};
+type ConfigTypeMap = {
+    app: DefaultAppConfig;
+    deployment: DefaultDeployConfig;
+};
+/**
+ * If TType is a known key, use the mapped type.
+ * Otherwise use TCustom (default = unknown).
+ */
+type ResolveConfig<TType extends string, TCustom = unknown> = TType extends keyof ConfigTypeMap ? ConfigTypeMap[TType] : TCustom;
+export declare function loadAppConfig<TCustom = unknown, TType extends string = 'app'>(configType?: TType, startDir?: string): {
+    config: ResolveConfig<TType, TCustom>;
+    meta: WorkspaceDetectResult;
+};
+export declare const loadProjectConfig: typeof loadAppConfig;
+export { loadMergedEnv } from './merge-env';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/project/index.ts"],"names":[],"mappings":"AAOA,KAAK,qBAAqB,GAAG;IAC3B,GAAG,EAAE,MAAM,CAAA;IACX,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,eAAe,EAAE,OAAO,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,KAAK,gBAAgB,GAAG;IACtB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,KAAK,mBAAmB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;IACvB,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAUD,KAAK,aAAa,GAAG;IACnB,GAAG,EAAE,gBAAgB,CAAA;IACrB,UAAU,EAAE,mBAAmB,CAAA;CAChC,CAAA;AAED;;;GAGG;AACH,KAAK,aAAa,CAAC,KAAK,SAAS,MAAM,EAAE,OAAO,GAAG,OAAO,IAAI,KAAK,SAAS,MAAM,aAAa,GAC3F,aAAa,CAAC,KAAK,CAAC,GACpB,OAAO,CAAA;AAgFX,wBAAgB,aAAa,CAAC,OAAO,GAAG,OAAO,EAAE,KAAK,SAAS,MAAM,GAAG,KAAK,EAC3E,UAAU,GAAE,KAAsB,EAClC,QAAQ,GAAE,MAAsB,GAC/B;IAAE,MAAM,EAAE,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,EAAE,qBAAqB,CAAA;CAAE,CA6CxE;AAED,eAAO,MAAM,iBAAiB,sBAAgB,CAAA;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA"}

package/dist/project/index.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMergedEnv = exports.loadProjectConfig = void 0;
+exports.loadAppConfig = loadAppConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const requiredSystemDefaults = {
+    ec2User: 'ec2-user',
+    regions: ['us-east-1'],
+    warehouseRegion: 'us-east-1',
+    dbInstanceType: 't3.micro',
+    appInstanceType: 't3.large',
+};
+/* ──────────────────────────────────────────────────────────
+ * Environment helpers
+ * ────────────────────────────────────────────────────────── */
+function isLambdaRuntime() {
+    return !!process.env.AWS_LAMBDA_FUNCTION_NAME;
+}
+/* ──────────────────────────────────────────────────────────
+ * Workspace detection (CLI / local dev only)
+ * ────────────────────────────────────────────────────────── */
+function detectWorkspaceAndConfigPath(startDir, configFileName) {
+    const cwd = node_path_1.default.resolve(startDir);
+    const isWorkspaceRootDir = (dir) => {
+        const pkgPath = node_path_1.default.join(dir, 'package.json');
+        if (node_fs_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, 'utf8'));
+                if (pkg?.workspaces)
+                    return true;
+            }
+            catch {
+                // ignore
+            }
+        }
+        const markers = ['pnpm-workspace.yaml', 'lerna.json', 'turbo.json', 'nx.json', '.git'];
+        return markers.some((m) => node_fs_1.default.existsSync(node_path_1.default.join(dir, m)));
+    };
+    let dir = cwd;
+    while (true) {
+        if (isWorkspaceRootDir(dir)) {
+            return {
+                cwd,
+                workspaceRoot: dir,
+                isWorkspaceRoot: dir === cwd,
+                configDir: dir,
+                configPath: node_path_1.default.join(dir, configFileName),
+            };
+        }
+        const parent = node_path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return {
+        cwd,
+        workspaceRoot: null,
+        isWorkspaceRoot: false,
+        configDir: cwd,
+        configPath: node_path_1.default.join(cwd, configFileName),
+    };
+}
+/* ──────────────────────────────────────────────────────────
+ * Bundled config loader (Lambda runtime)
+ * ────────────────────────────────────────────────────────── */
+function loadConfigFromBundle(fileName) {
+    const bundledPath = node_path_1.default.join(__dirname, fileName);
+    if (node_fs_1.default.existsSync(bundledPath)) {
+        return JSON.parse(node_fs_1.default.readFileSync(bundledPath, 'utf8'));
+    }
+    return null;
+}
+/* ──────────────────────────────────────────────────────────
+ * Public API
+ * ────────────────────────────────────────────────────────── */
+function loadAppConfig(configType = 'app', startDir = process.cwd()) {
+    const fileName = `mono.${configType}.json`;
+    // 1. Lambda runtime: load bundled config if present
+    if (isLambdaRuntime()) {
+        const bundled = loadConfigFromBundle(fileName);
+        if (bundled) {
+            return {
+                config: bundled,
+                meta: {
+                    cwd: __dirname,
+                    workspaceRoot: null,
+                    isWorkspaceRoot: false,
+                    configDir: __dirname,
+                    configPath: node_path_1.default.join(__dirname, fileName),
+                },
+            };
+        }
+    }
+    // 2. CLI / local dev: workspace discovery
+    const meta = detectWorkspaceAndConfigPath(startDir, fileName);
+    if (!node_fs_1.default.existsSync(meta.configPath)) {
+        const where = meta.workspaceRoot ? `workspace root: ${meta.workspaceRoot}` : `cwd: ${meta.cwd}`;
+        throw new Error(`Could not find ${fileName} at ${meta.configPath} (detected from ${where}).`);
+    }
+    const raw = node_fs_1.default.readFileSync(meta.configPath, 'utf8');
+    const config = JSON.parse(raw);
+    // Apply required system defaults
+    if (typeof config === 'object' && config !== null) {
+        for (const key of Object.keys(requiredSystemDefaults)) {
+            // @ts-ignore: index signature
+            if (config[key] === undefined || config[key] === null) {
+                // @ts-ignore: index signature
+                config[key] = requiredSystemDefaults[key];
+            }
+        }
+    }
+    return { config, meta };
+}
+exports.loadProjectConfig = loadAppConfig;
+var merge_env_1 = require("./merge-env");
+Object.defineProperty(exports, "loadMergedEnv", { enumerable: true, get: function () { return merge_env_1.loadMergedEnv; } });

package/dist/project/merge-env.d.ts

@@ -0,0 +1,2 @@
+export declare function loadMergedEnv(): NodeJS.ProcessEnv;
+//# sourceMappingURL=merge-env.d.ts.map

package/dist/project/merge-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-env.d.ts","sourceRoot":"","sources":["../../src/project/merge-env.ts"],"names":[],"mappings":"AAIA,wBAAgB,aAAa,IAAI,MAAM,CAAC,UAAU,CA2BjD"}

package/dist/project/merge-env.js

@@ -0,0 +1,31 @@
+"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_1.default.existsSync(ENV_PATH) ? dotenv_1.default.parse(fs_1.default.readFileSync(ENV_PATH)) : {};
+    // Load overrides .env.local
+    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 = {
+        ...base,
+        ...local,
+    };
+    // Inject into process.env (do NOT overwrite existing real env vars)
+    for (const [key, value] of Object.entries(merged)) {
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+    }
+    return process.env;
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@mono-labs/project",
+  "version": "0.0.248",
+  "type": "commonjs",
+  "description": "Project configuration utilities for mono-labs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./project": {
+      "types": "./dist/project/index.d.ts",
+      "require": "./dist/project/index.js",
+      "default": "./dist/project/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "deploy": "tsc && npm publish --access public --registry https://registry.npmjs.org/",
+    "release:patch": "npm version patch -m \"chore: release %s\" && npm publish --access public",
+    "release:minor": "npm version minor -m \"chore: release %s\" && npm publish --access public",
+    "release:major": "npm version major -m \"chore: release %s\" && npm publish --access public"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "dotenv": "^17.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+// @mono-labs/project barrel export
+
+export {
+  findProjectRoot,
+  getRootDirectory,
+  getRootJson,
+  resolveMonoDirectory,
+  getMonoFiles,
+  getMonoConfig,
+} from './loadFromRoot'
+
+export type {
+  MonoWorkspaceConfig,
+  MonoProjectConfig,
+  MonoFiles,
+  MonoConfig,
+} from './loadFromRoot'
+
+export { loadAppConfig, loadProjectConfig, loadMergedEnv } from './project/index'