@emeryld/manager 1.5.1 → 1.5.3

package/dist/directory-picker.js

@@ -1,9 +1,9 @@
 import path from 'node:path';
 import { readdir, readFile } from 'node:fs/promises';
 import { IGNORED_DIRECTORIES } from './format-checker/scan/constants.js';
-import { normalizeScripts } from './helper-cli/scripts.js';
-import { promptForScript } from './helper-cli/prompts.js';
 import { rootDir } from './helper-cli/env.js';
+import { promptForScript } from './helper-cli/prompts.js';
+import { normalizeScripts } from './helper-cli/scripts.js';
 import { loadPackages } from './packages.js';
 const ROOT_ENTRY = {
     label: 'Workspace root',
@@ -11,21 +11,53 @@ const ROOT_ENTRY = {
     description: 'Root directory',
     color: 'brightBlue',
 };
+const ACTION_SCRIPT_PREFIX = '__explorer_action__';
 export async function promptDirectorySelection(options = {}) {
-    const candidates = await buildDirectoryCandidates(options.includeWorkspaceRoot ?? true);
-    const entries = normalizeScripts(candidates.map((candidate) => ({
-        name: candidate.label,
-        emoji: '📁',
-        color: candidate.color,
-        description: candidate.description ?? candidate.relativePath,
-        script: candidate.relativePath,
-    })));
-    const selection = await promptForScript(entries, options.title ?? 'Select a directory');
+    const packageMap = await buildPackageMap();
+    const selection = await promptWorkspaceExplorer({
+        title: options.title ?? 'Select a directory',
+        mode: 'directory',
+        rootPath: rootDir,
+        includeRootSelection: options.includeWorkspaceRoot ?? true,
+        includeFile: () => true,
+        describeDirectory: (entry) => describeDirectory(entry, packageMap),
+        describeFile: (entry) => ({
+            label: entry.name,
+            description: entry.relativePath,
+        }),
+    });
     if (!selection)
         return undefined;
-    const relativePath = selection.script ?? '.';
-    const absolutePath = path.resolve(rootDir, relativePath);
-    return { label: selection.displayName, relativePath, absolutePath };
+    return {
+        label: selection.label,
+        relativePath: selection.relativePath,
+        absolutePath: selection.absolutePath,
+    };
+}
+export async function promptWorkspaceFileSelection(options = {}) {
+    const rootPath = resolveRootPath(options.rootPath);
+    const selection = await promptWorkspaceExplorer({
+        title: options.title ?? 'Select a file',
+        mode: 'file',
+        rootPath,
+        includeRootSelection: false,
+        includeFile: options.includeFile ?? (() => true),
+        describeDirectory: (entry) => ({
+            label: `${entry.name}/`,
+            description: entry.relativePath,
+        }),
+        describeFile: (entry) => ({
+            label: entry.name,
+            description: entry.relativePath,
+        }),
+    });
+    if (!selection || selection.kind !== 'file')
+        return undefined;
+    return {
+        label: selection.label,
+        relativePath: selection.relativePath,
+        absolutePath: selection.absolutePath,
+    };
 }
 export function describeDirectorySelection(selection) {
     const normalized = selection.relativePath
@@ -36,83 +68,243 @@ export function describeDirectorySelection(selection) {
     }
     return `${selection.label} (${normalized})`;
 }
-async function buildDirectoryCandidates(includeRoot) {
-    const directories = await collectDirectories();
-    const packages = await loadPackageMetadata();
-    const packageMap = new Map(packages.map((pkg) => [pkg.relativeDir, pkg]));
-    const candidates = [];
-    const filtered = directories.filter((entry) => includeRoot || entry.relativePath !== '.');
-    for (const entry of filtered) {
-        const pkg = packageMap.get(entry.relativePath);
-        if (pkg) {
-            candidates.push({
-                label: pkg.name ?? pkg.dirName,
-                relativePath: entry.relativePath,
-                description: pkg.relativeDir,
-                color: pkg.color,
-            });
+async function promptWorkspaceExplorer(options) {
+    const ignorePatterns = await collectIgnorePatterns(options.rootPath);
+    let currentPath = options.rootPath;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const entries = await readExplorerEntries(currentPath, options, ignorePatterns);
+        const { menuEntries, actionMap } = buildExplorerMenuEntries(options, currentPath, entries);
+        const selectedEntry = await promptForScript(menuEntries, `${options.title} (${formatCurrentLocation(options.rootPath, currentPath)})`);
+        if (!selectedEntry?.script) {
+            const parentPath = getParentPath(currentPath, options.rootPath);
+            if (parentPath) {
+                currentPath = parentPath;
+                continue;
+            }
+            return undefined;
+        }
+        const action = actionMap.get(selectedEntry.script);
+        if (!action) {
             continue;
         }
-        if (entry.relativePath === '.') {
-            candidates.push({
-                label: ROOT_ENTRY.label,
-                relativePath: ROOT_ENTRY.relativePath,
-                description: ROOT_ENTRY.description,
-                color: ROOT_ENTRY.color,
+        if (action.type === 'select-current-directory') {
+            return buildCurrentDirectorySelection(options, currentPath);
+        }
+        if (action.type === 'open-directory') {
+            currentPath = action.entry.absolutePath;
+            continue;
+        }
+        if (action.type === 'select-file') {
+            if (options.mode === 'file') {
+                return toExplorerSelection(action.entry);
+            }
+            continue;
+        }
+        // noop placeholder
+    }
+}
+function buildExplorerMenuEntries(options, currentPath, entries) {
+    const actionMap = new Map();
+    const scripts = [];
+    let actionIndex = 0;
+    const addAction = (action, entry) => {
+        const scriptId = `${ACTION_SCRIPT_PREFIX}${actionIndex++}`;
+        actionMap.set(scriptId, action);
+        scripts.push({
+            ...entry,
+            script: scriptId,
+        });
+    };
+    if (options.mode === 'directory' && canSelectCurrentDirectory(options, currentPath)) {
+        const currentSelection = buildCurrentDirectorySelection(options, currentPath);
+        addAction({ type: 'select-current-directory' }, {
+            name: currentSelection.relativePath === '.'
+                ? ROOT_ENTRY.label
+                : 'Select this directory',
+            emoji: '✅',
+            description: currentSelection.relativePath === '.'
+                ? ROOT_ENTRY.description
+                : currentSelection.relativePath,
+            color: currentSelection.relativePath === '.' ? ROOT_ENTRY.color : undefined,
+        });
+    }
+    for (const entry of entries) {
+        if (entry.kind === 'directory') {
+            addAction({ type: 'open-directory', entry }, {
+                name: entry.label,
+                emoji: '📁',
+                description: entry.description,
+                color: entry.color,
             });
             continue;
         }
-        candidates.push({
-            label: path.basename(entry.relativePath) || ROOT_ENTRY.label,
-            relativePath: entry.relativePath,
-            description: entry.relativePath,
+        addAction({ type: 'select-file', entry }, {
+            name: entry.label,
+            emoji: '📄',
+            description: entry.description,
+            color: entry.color,
         });
     }
-    if (candidates.length === 0 && includeRoot) {
-        candidates.push(ROOT_ENTRY);
+    if (scripts.length === 0) {
+        addAction({ type: 'noop' }, {
+            name: 'No entries at this level',
+            emoji: '🫥',
+            description: 'Go deeper into another folder or press 0 to go back.',
+        });
     }
-    return candidates;
+    return {
+        menuEntries: normalizeScripts(scripts),
+        actionMap,
+    };
 }
-async function collectDirectories() {
-    const patterns = await collectIgnorePatterns();
-    const directories = [];
-    async function walk(current) {
-        const relativeRaw = path.relative(rootDir, current);
-        const relativePath = normalizeRelativePath(relativeRaw);
-        if (current !== rootDir && shouldIgnore(relativePath, patterns)) {
-            return;
-        }
-        directories.push({ absolutePath: current, relativePath });
-        let entries;
-        try {
-            entries = await readdir(current, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.isSymbolicLink())
-                continue;
-            await walk(path.join(current, entry.name));
+async function readExplorerEntries(currentPath, options, ignorePatterns) {
+    let filesystemEntries;
+    try {
+        filesystemEntries = await readdir(currentPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const filesystemEntry of filesystemEntries) {
+        if (filesystemEntry.isSymbolicLink())
+            continue;
+        const absolutePath = path.join(currentPath, filesystemEntry.name);
+        const relativePath = normalizeRelativePath(path.relative(options.rootPath, absolutePath));
+        if (shouldIgnore(relativePath, ignorePatterns))
+            continue;
+        const candidate = {
+            name: filesystemEntry.name,
+            absolutePath,
+            relativePath,
+        };
+        if (filesystemEntry.isDirectory()) {
+            const presentation = options.describeDirectory(candidate);
+            entries.push({
+                ...candidate,
+                kind: 'directory',
+                label: presentation.label,
+                description: presentation.description ?? candidate.relativePath,
+                color: presentation.color,
+            });
+            continue;
         }
+        if (!filesystemEntry.isFile())
+            continue;
+        if (!options.includeFile(candidate))
+            continue;
+        const presentation = options.describeFile(candidate);
+        entries.push({
+            ...candidate,
+            kind: 'file',
+            label: presentation.label,
+            description: presentation.description ?? candidate.relativePath,
+            color: presentation.color,
+        });
     }
-    await walk(rootDir);
-    directories.sort((a, b) => {
-        if (a.relativePath === '.')
-            return -1;
-        if (b.relativePath === '.')
-            return 1;
-        return a.relativePath.localeCompare(b.relativePath);
+    entries.sort((left, right) => {
+        if (left.kind !== right.kind)
+            return left.kind === 'directory' ? -1 : 1;
+        return left.label.localeCompare(right.label, undefined, {
+            sensitivity: 'base',
+            numeric: true,
+        });
     });
-    return directories;
+    return entries;
+}
+function toExplorerSelection(entry) {
+    return {
+        kind: entry.kind,
+        label: entry.label,
+        relativePath: entry.relativePath,
+        absolutePath: entry.absolutePath,
+    };
 }
-async function collectIgnorePatterns() {
+function formatCurrentLocation(rootPath, currentPath) {
+    const relativePath = normalizeRelativePath(path.relative(rootPath, currentPath));
+    return relativePath === '.'
+        ? `${ROOT_ENTRY.label} (${ROOT_ENTRY.relativePath})`
+        : relativePath;
+}
+function canSelectCurrentDirectory(options, currentPath) {
+    if (options.mode !== 'directory')
+        return false;
+    if (options.includeRootSelection)
+        return true;
+    const relativePath = normalizeRelativePath(path.relative(options.rootPath, currentPath));
+    return relativePath !== '.';
+}
+function buildCurrentDirectorySelection(options, currentPath) {
+    const relativePath = normalizeRelativePath(path.relative(options.rootPath, currentPath));
+    const candidate = {
+        name: path.basename(currentPath),
+        absolutePath: currentPath,
+        relativePath,
+    };
+    const presentation = relativePath === '.'
+        ? {
+            label: ROOT_ENTRY.label,
+            description: ROOT_ENTRY.description,
+            color: ROOT_ENTRY.color,
+        }
+        : options.describeDirectory(candidate);
+    return {
+        kind: 'directory',
+        label: presentation.label,
+        relativePath,
+        absolutePath: currentPath,
+    };
+}
+function getParentPath(currentPath, rootPath) {
+    const relativePath = normalizeRelativePath(path.relative(rootPath, currentPath));
+    if (relativePath === '.')
+        return undefined;
+    const parent = path.dirname(currentPath);
+    if (!isWithinRoot(parent, rootPath))
+        return undefined;
+    return parent;
+}
+function isWithinRoot(targetPath, rootPath) {
+    const relative = path.relative(rootPath, targetPath);
+    return (relative === '' ||
+        relative === '.' ||
+        (!relative.startsWith('..') && !path.isAbsolute(relative)));
+}
+function describeDirectory(entry, packageMap) {
+    if (entry.relativePath === '.') {
+        return {
+            label: ROOT_ENTRY.label,
+            description: ROOT_ENTRY.description,
+            color: ROOT_ENTRY.color,
+        };
+    }
+    const pkg = packageMap.get(entry.relativePath);
+    if (pkg) {
+        return {
+            label: pkg.name ?? pkg.dirName,
+            description: pkg.relativeDir,
+            color: pkg.color,
+        };
+    }
+    return {
+        label: entry.name,
+        description: entry.relativePath,
+    };
+}
+function resolveRootPath(rootPath) {
+    const basePath = rootPath ?? rootDir;
+    if (path.isAbsolute(basePath))
+        return path.resolve(basePath);
+    return path.resolve(rootDir, basePath);
+}
+async function collectIgnorePatterns(rootPath) {
     const patterns = new Set();
     for (const entry of IGNORED_DIRECTORIES) {
         patterns.add(normalizeRelativePath(entry));
     }
     try {
-        const contents = await readFile(path.join(rootDir, '.gitignore'), 'utf-8');
+        const contents = await readFile(path.join(rootPath, '.gitignore'), 'utf-8');
         for (const rawLine of contents.split(/\r?\n/)) {
             const trimmed = rawLine.trim();
             if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!'))
@@ -125,6 +317,14 @@ async function collectIgnorePatterns() {
     }
     return Array.from(patterns).filter(Boolean);
 }
+async function buildPackageMap() {
+    const packages = await loadPackageMetadata();
+    const packageMap = new Map();
+    for (const pkg of packages) {
+        packageMap.set(normalizeRelativePath(pkg.relativeDir), pkg);
+    }
+    return packageMap;
+}
 function normalizeRelativePath(value) {
     const normalized = value.replace(/\\/g, '/').replace(/^\/+/, '');
     const trimmed = normalized.replace(/\/+$/, '');

package/dist/publish.js

@@ -13,6 +13,7 @@ import { publishCliState } from './prompts.js';
 import { createRrrPackage, runCreatePackageCli, } from './create-package/index.js';
 import { runRobot } from './robot/index.js';
 import { runDocsFeature } from './docs/index.js';
+import { runTypeScriptTraceProfiler, runTypeScriptTraceReportCli, } from './ts-trace/index.js';
 import { colors, logGlobal } from './utils/log.js';
 import { run } from './utils/run.js';
 const MANAGER_PACKAGE = '@emeryld/manager';
@@ -187,7 +188,7 @@ async function runPackageSelectionLoop(packages, helperArgs) {
                 {
                     name: 'utils',
                     emoji: '🛠️',
-                    description: 'Docs, format checker, robot metadata, and package scaffolding',
+                    description: 'Docs, format checker, TypeScript trace profiler, robot metadata, and package scaffolding',
                     handler: async () => {
                         // eslint-disable-next-line no-constant-condition
                         while (true) {
@@ -210,6 +211,14 @@ async function runPackageSelectionLoop(packages, helperArgs) {
                                             await runFormatChecker();
                                         },
                                     },
+                                    {
+                                        name: 'typescript trace profiler',
+                                        emoji: '⏱️',
+                                        description: 'Analyze TypeScript generateTrace output and rank slow files, spans, and type relations',
+                                        handler: async () => {
+                                            await runTypeScriptTraceProfiler();
+                                        },
+                                    },
                                     {
                                         name: 'robot metadata',
                                         emoji: '🤖',
@@ -258,6 +267,15 @@ async function main() {
         await runFormatCheckerScanCli(cliArgs.slice(1));
         return;
     }
+    if (cliArgs[0] === 'ts-trace') {
+        if (cliArgs.length === 1) {
+            await runTypeScriptTraceProfiler();
+        }
+        else {
+            await runTypeScriptTraceReportCli(cliArgs.slice(1));
+        }
+        return;
+    }
     const parsed = parseCliArgs(cliArgs);
     const packages = await loadPackages();
     // If user provided non-interactive flags, run headless path
@@ -294,5 +312,11 @@ async function main() {
 }
 main().catch((error) => {
     console.error(error);
-    process.exit(1);
+    const exitCode = typeof error === 'object' &&
+        error !== null &&
+        'exitCode' in error &&
+        typeof error.exitCode === 'number'
+        ? error.exitCode
+        : 1;
+    process.exit(exitCode);
 });

package/dist/ts-trace/cli/options.js

@@ -0,0 +1,196 @@
+import path from 'node:path';
+import { colors } from '../../utils/log.js';
+export function parseTraceReportCliArgs(argv, defaults) {
+    let traceDir;
+    let targetPath;
+    let projectPath = defaults.projectPath;
+    let top = defaults.top;
+    let minMs = defaults.minMs;
+    let json = defaults.includeJson;
+    let filterRegex = defaults.filterRegex;
+    let eventNames = [...defaults.eventNames];
+    let didProvideEventFlag = false;
+    let baseDir = defaults.baseDir;
+    let outPath = defaults.outPath;
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === '--help' || token === '-h') {
+            return { help: true };
+        }
+        if (token === '--json') {
+            json = true;
+            continue;
+        }
+        if (token === '--traceDir' || token === '--trace-dir') {
+            const raw = argv[++i];
+            if (!raw)
+                throw new Error('Flag "--traceDir" expects a directory path.');
+            traceDir = raw;
+            continue;
+        }
+        if (token === '--target') {
+            const raw = argv[++i];
+            if (!raw)
+                throw new Error('Flag "--target" expects a file or folder path.');
+            targetPath = raw;
+            continue;
+        }
+        if (token === '--project') {
+            const raw = argv[++i];
+            if (!raw)
+                throw new Error('Flag "--project" expects a tsconfig path.');
+            projectPath = raw;
+            continue;
+        }
+        if (token === '--top') {
+            const raw = argv[++i];
+            const parsed = parsePositiveInteger(raw);
+            if (parsed === undefined) {
+                throw new Error('Flag "--top" expects a positive integer.');
+            }
+            top = parsed;
+            continue;
+        }
+        if (token === '--minMs' || token === '--min-ms') {
+            const raw = argv[++i];
+            const parsed = parseNonNegativeNumber(raw);
+            if (parsed === undefined) {
+                throw new Error('Flag "--minMs" expects a non-negative number.');
+            }
+            minMs = parsed;
+            continue;
+        }
+        if (token === '--filter') {
+            const raw = argv[++i];
+            if (raw === undefined) {
+                throw new Error('Flag "--filter" expects a regex string.');
+            }
+            ensureRegex(raw);
+            filterRegex = raw;
+            continue;
+        }
+        if (token === '--event') {
+            const raw = argv[++i];
+            if (!raw)
+                throw new Error('Flag "--event" expects an event name.');
+            if (!didProvideEventFlag) {
+                eventNames = [];
+            }
+            didProvideEventFlag = true;
+            eventNames.push(raw);
+            continue;
+        }
+        if (token === '--baseDir' || token === '--base-dir') {
+            const raw = argv[++i];
+            if (!raw)
+                throw new Error('Flag "--baseDir" expects a path.');
+            baseDir = raw;
+            continue;
+        }
+        if (token === '--out') {
+            const raw = argv[++i];
+            if (!raw)
+                throw new Error('Flag "--out" expects a file path.');
+            outPath = raw;
+            json = true;
+            continue;
+        }
+        throw new Error(`Unknown option "${token}". Use "pnpm manager-cli ts-trace --help".`);
+    }
+    if (traceDir && targetPath) {
+        throw new Error('Use either --traceDir (existing trace) or --target (generate trace), not both.');
+    }
+    const reportBase = {
+        top,
+        minMs,
+        json,
+        filterRegex,
+        eventNames: normalizeEventNames(eventNames),
+        baseDir: path.resolve(baseDir || process.cwd()),
+        outPath: outPath ? path.resolve(outPath) : undefined,
+    };
+    if (traceDir) {
+        return {
+            help: false,
+            command: {
+                mode: 'existing',
+                report: {
+                    traceDir: path.resolve(traceDir),
+                    ...reportBase,
+                },
+            },
+        };
+    }
+    if (targetPath) {
+        return {
+            help: false,
+            command: {
+                mode: 'generate',
+                targetPath: path.resolve(targetPath),
+                projectPath: projectPath ? path.resolve(projectPath) : undefined,
+                report: reportBase,
+            },
+        };
+    }
+    throw new Error('Provide one of: --target <file|folder> (generate trace) or --traceDir <path> (analyze existing).');
+}
+export function printTraceReportUsage() {
+    console.log(colors.bold('Usage: pnpm manager-cli ts-trace [flags]'));
+    console.log(colors.dim('Profile TypeScript checker speed by target path, or analyze an existing --generateTrace directory.'));
+    console.log('');
+    console.log(`${colors.cyan('--target <path>')}\tProfile a file/folder (auto-generates trace then reports offenders).`);
+    console.log(`${colors.cyan('--project <tsconfig>')}\tOptional project config for generation (default: auto-detect).`);
+    console.log(`${colors.cyan('--traceDir <path>')}\tAnalyze an already-generated trace directory with trace.json/types.json.`);
+    console.log(`${colors.cyan('--top <n>')}\tShow top results per table. Defaults to workspace settings or 20.`);
+    console.log(`${colors.cyan('--json')}\tPrint machine-readable JSON in addition to tables.`);
+    console.log(`${colors.cyan('--filter <regex>')}\tFilter events by matching file path.`);
+    console.log(`${colors.cyan('--event <name>')}\tInclude only specified event names (repeatable).`);
+    console.log(`${colors.cyan('--minMs <n>')}\tIgnore events shorter than n ms (default 1).`);
+    console.log(`${colors.cyan('--baseDir <path>')}\tBase directory for relative display paths.`);
+    console.log(`${colors.cyan('--out <path>')}\tWrite JSON report to file (implies --json).`);
+    console.log('');
+    console.log(colors.dim('Example (auto profile): pnpm manager-cli ts-trace --target src/format-checker --top 30'));
+    console.log(colors.dim('Example (existing trace): pnpm manager-cli ts-trace --traceDir /tmp/ts-trace-foo --json --out /tmp/ts-report.json'));
+    console.log(colors.dim('Large traces: set NODE_OPTIONS="--max-old-space-size=4096" before running if needed.'));
+}
+function parsePositiveInteger(raw) {
+    if (!raw)
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return undefined;
+    const floored = Math.floor(parsed);
+    if (floored <= 0)
+        return undefined;
+    return floored;
+}
+function parseNonNegativeNumber(raw) {
+    if (!raw)
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return undefined;
+    if (parsed < 0)
+        return undefined;
+    return parsed;
+}
+function normalizeEventNames(eventNames) {
+    const seen = new Set();
+    const normalized = [];
+    for (const value of eventNames) {
+        const trimmed = value.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        normalized.push(trimmed);
+    }
+    return normalized;
+}
+function ensureRegex(raw) {
+    try {
+        new RegExp(raw);
+    }
+    catch (error) {
+        throw new Error(`Flag "--filter" received an invalid regex: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}