@emeryld/manager 1.5.2 → 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/ts-trace/picker.js

@@ -1,7 +1,7 @@
 import { tmpdir } from 'node:os';
 import { readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { describeDirectorySelection, promptDirectorySelection, } from '../directory-picker.js';
+import { describeDirectorySelection, promptDirectorySelection, promptWorkspaceFileSelection, } from '../directory-picker.js';
 import { IGNORED_DIRECTORIES, SOURCE_EXTENSIONS, } from '../format-checker/scan/constants.js';
 import { rootDir } from '../helper-cli/env.js';
 import { promptForScript } from '../helper-cli/prompts.js';
@@ -13,8 +13,6 @@ const TRACE_FILE_NAME = 'trace.json';
 const TYPES_FILE_NAME = 'types.json';
 const TRACE_SCAN_MAX_DEPTH = 4;
 const TRACE_SCAN_MAX_RESULTS = 300;
-const PROFILE_SCAN_MAX_DEPTH = 8;
-const PROFILE_SCAN_MAX_RESULTS = 600;
 export async function promptTraceProfileTargetSelection() {
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -25,7 +23,7 @@ export async function promptTraceProfileTargetSelection() {
                 {
                     name: 'Pick folder from workspace',
                     emoji: '📁',
-                    description: 'Profile all TypeScript work under a selected folder',
+                    description: 'Profile all TypeScript work under any workspace folder',
                     handler: async () => {
                         selected = await pickProfileDirectoryFromWorkspace();
                     },
@@ -33,7 +31,7 @@ export async function promptTraceProfileTargetSelection() {
                 {
                     name: 'Pick file from workspace',
                     emoji: '📄',
-                    description: 'Profile a single TypeScript file',
+                    description: 'Profile a single file from anywhere in the workspace',
                     handler: async () => {
                         selected = await pickProfileFileFromWorkspace();
                     },
@@ -116,22 +114,15 @@ async function pickProfileDirectoryFromWorkspace() {
     };
 }
 async function pickProfileFileFromWorkspace() {
-    const baseSelection = await promptDirectorySelection({
-        title: 'Select a directory to search for source files',
+    const chosen = await promptWorkspaceFileSelection({
+        title: 'Pick file to profile',
+        includeFile: (entry) => SOURCE_EXTENSIONS.has(path.extname(entry.name).toLowerCase()),
     });
-    if (!baseSelection)
-        return undefined;
-    const files = await collectProfileFiles(baseSelection.absolutePath, PROFILE_SCAN_MAX_DEPTH, PROFILE_SCAN_MAX_RESULTS);
-    if (!files.length) {
-        console.log(colors.yellow(`No TypeScript/JavaScript source files found under ${baseSelection.relativePath || '.'}.`));
-        return undefined;
-    }
-    const chosen = await promptPathCandidate(files, 'Pick file to profile', baseSelection.absolutePath, '📄');
     if (!chosen)
         return undefined;
     return {
         absolutePath: chosen.absolutePath,
-        label: relToRoot(chosen.absolutePath),
+        label: chosen.relativePath,
         kind: 'file',
     };
 }
@@ -207,17 +198,10 @@ async function pickTraceFolderFromTmp() {
     };
 }
 async function pickTraceFileFromWorkspace() {
-    const baseSelection = await promptDirectorySelection({
-        title: 'Select a directory to search for trace.json files',
+    const chosen = await promptWorkspaceFileSelection({
+        title: 'Pick trace.json file',
+        includeFile: (entry) => entry.name.toLowerCase() === TRACE_FILE_NAME,
     });
-    if (!baseSelection)
-        return undefined;
-    const files = await collectNamedFiles(baseSelection.absolutePath, TRACE_FILE_NAME, TRACE_SCAN_MAX_DEPTH, TRACE_SCAN_MAX_RESULTS);
-    if (!files.length) {
-        console.log(colors.yellow('No trace.json files found in that selection.'));
-        return undefined;
-    }
-    const chosen = await promptPathCandidate(files, 'Pick trace.json file', baseSelection.absolutePath, '📦');
     if (!chosen)
         return undefined;
     return resolveTraceDirectoryFromInput(chosen.absolutePath);
@@ -289,17 +273,6 @@ async function promptPathCandidate(candidates, title, basePath, emoji) {
         relativePath: path.relative(basePath, absolutePath).replace(/\\/g, '/') || '.',
     };
 }
-async function collectNamedFiles(rootPath, filename, maxDepth, maxResults) {
-    const output = [];
-    await walk(rootPath, rootPath, 0, async (absolutePath, relativePath) => {
-        if (path.basename(absolutePath).toLowerCase() !== filename)
-            return;
-        if (output.length >= maxResults)
-            return;
-        output.push({ absolutePath, relativePath });
-    }, maxDepth);
-    return output;
-}
 async function collectTraceDirectories(rootPath, maxDepth, maxResults) {
     const output = [];
     await walk(rootPath, rootPath, 0, async (absolutePath, relativePath) => {
@@ -314,18 +287,6 @@ async function collectTraceDirectories(rootPath, maxDepth, maxResults) {
     }, maxDepth);
     return output;
 }
-async function collectProfileFiles(rootPath, maxDepth, maxResults) {
-    const output = [];
-    await walk(rootPath, rootPath, 0, async (absolutePath, relativePath) => {
-        if (output.length >= maxResults)
-            return;
-        const extension = path.extname(absolutePath).toLowerCase();
-        if (!SOURCE_EXTENSIONS.has(extension))
-            return;
-        output.push({ absolutePath, relativePath });
-    }, maxDepth);
-    return output;
-}
 async function walk(currentPath, basePath, depth, onEntry, maxDepth) {
     if (depth > maxDepth)
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",