@mono-labs/cli 0.0.244 → 0.0.248

package/dist/src/loadFromRoot.js

@@ -1,115 +0,0 @@
-"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/src/merge-env.js

@@ -1,25 +0,0 @@
-"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 node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const dotenv_1 = __importDefault(require("dotenv"));
-function loadMergedEnv() {
-    const ENV_PATH = node_path_1.default.resolve(process.cwd(), '.env');
-    const ENV_LOCAL_PATH = node_path_1.default.resolve(process.cwd(), '.env.local');
-    const base = node_fs_1.default.existsSync(ENV_PATH) ? dotenv_1.default.parse(node_fs_1.default.readFileSync(ENV_PATH)) : {};
-    const local = node_fs_1.default.existsSync(ENV_LOCAL_PATH) ? dotenv_1.default.parse(node_fs_1.default.readFileSync(ENV_LOCAL_PATH)) : {};
-    const merged = {
-        ...base,
-        ...local,
-    };
-    for (const [key, value] of Object.entries(merged)) {
-        if (process.env[key] === undefined) {
-            process.env[key] = value;
-        }
-    }
-    return process.env;
-}

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

@@ -1,456 +0,0 @@
-"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) {
-    // New structure supports:
-    // - optionKey: { type: "string", default, options: [], allowAll, shortcut, description }
-    // - boolean toggle: { shortcut, description } (no type)
-    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; // in your examples, booleans omit `type`
-        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>` : '';
-    // choose a representative value option to show
-    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);
-    // include at most 2 value options and 1 boolean in the example for readability
-    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/src/project/build-readme.js

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

package/dist/src/project/generate-docs.js

@@ -1,73 +0,0 @@
-"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');
-}