@emeryld/manager 1.5.0 → 1.5.2

package/dist/ts-trace/picker.js

@@ -0,0 +1,373 @@
+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 { IGNORED_DIRECTORIES, SOURCE_EXTENSIONS, } from '../format-checker/scan/constants.js';
+import { rootDir } from '../helper-cli/env.js';
+import { promptForScript } from '../helper-cli/prompts.js';
+import { normalizeScripts } from '../helper-cli/scripts.js';
+import { runHelperCli } from '../helper-cli.js';
+import { askLine } from '../prompts.js';
+import { colors } from '../utils/log.js';
+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) {
+        let selected;
+        const ran = await runHelperCli({
+            title: 'TypeScript trace profiler target',
+            scripts: [
+                {
+                    name: 'Pick folder from workspace',
+                    emoji: '📁',
+                    description: 'Profile all TypeScript work under a selected folder',
+                    handler: async () => {
+                        selected = await pickProfileDirectoryFromWorkspace();
+                    },
+                },
+                {
+                    name: 'Pick file from workspace',
+                    emoji: '📄',
+                    description: 'Profile a single TypeScript file',
+                    handler: async () => {
+                        selected = await pickProfileFileFromWorkspace();
+                    },
+                },
+                {
+                    name: 'Enter file/folder path',
+                    emoji: '⌨️',
+                    description: 'Manual path entry relative to the workspace',
+                    handler: async () => {
+                        selected = await pickProfilePathManually();
+                    },
+                },
+            ],
+            argv: [],
+        });
+        if (!ran)
+            return undefined;
+        if (selected)
+            return selected;
+    }
+}
+export async function promptTraceDirectorySelection() {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        let selected;
+        const ran = await runHelperCli({
+            title: 'TypeScript trace input (pick a folder or file)',
+            scripts: [
+                {
+                    name: 'Pick folder from workspace',
+                    emoji: '📁',
+                    description: 'Choose a directory and auto-detect trace.json/types.json',
+                    handler: async () => {
+                        selected = await pickTraceFolderFromWorkspace();
+                    },
+                },
+                {
+                    name: `Pick folder from ${tmpdir()}`,
+                    emoji: '🧊',
+                    description: 'Quick pick for /tmp/ts-trace-* directories',
+                    handler: async () => {
+                        selected = await pickTraceFolderFromTmp();
+                    },
+                },
+                {
+                    name: 'Pick trace.json file from workspace',
+                    emoji: '📄',
+                    description: 'Choose a file; its parent directory is used as traceDir',
+                    handler: async () => {
+                        selected = await pickTraceFileFromWorkspace();
+                    },
+                },
+                {
+                    name: 'Enter file or folder path',
+                    emoji: '⌨️',
+                    description: 'Manual path entry for any location',
+                    handler: async () => {
+                        selected = await pickTracePathManually();
+                    },
+                },
+            ],
+            argv: [],
+        });
+        if (!ran)
+            return undefined;
+        if (selected)
+            return selected;
+    }
+}
+async function pickProfileDirectoryFromWorkspace() {
+    const selection = await promptDirectorySelection({
+        title: 'Select a directory to profile',
+    });
+    if (!selection)
+        return undefined;
+    return {
+        absolutePath: selection.absolutePath,
+        label: describeDirectorySelection(selection),
+        kind: 'directory',
+    };
+}
+async function pickProfileFileFromWorkspace() {
+    const baseSelection = await promptDirectorySelection({
+        title: 'Select a directory to search for source files',
+    });
+    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),
+        kind: 'file',
+    };
+}
+async function pickProfilePathManually() {
+    const rawPath = await askLine(colors.cyan('Enter workspace-relative file/folder path to profile: '));
+    const trimmed = rawPath.trim();
+    if (!trimmed)
+        return undefined;
+    const absolutePath = path.isAbsolute(trimmed)
+        ? path.resolve(trimmed)
+        : path.resolve(rootDir, trimmed);
+    let stats;
+    try {
+        stats = await stat(absolutePath);
+    }
+    catch {
+        console.log(colors.yellow(`Path not found: ${absolutePath}`));
+        return undefined;
+    }
+    if (!stats.isFile() && !stats.isDirectory()) {
+        console.log(colors.yellow('Target must be a file or a folder.'));
+        return undefined;
+    }
+    return {
+        absolutePath,
+        label: relToRoot(absolutePath),
+        kind: stats.isDirectory() ? 'directory' : 'file',
+    };
+}
+async function pickTraceFolderFromWorkspace() {
+    const selection = await promptDirectorySelection({
+        title: 'Select a directory containing a TypeScript trace',
+    });
+    if (!selection)
+        return undefined;
+    return resolveTraceDirectoryFromInput(selection.absolutePath);
+}
+async function pickTraceFolderFromTmp() {
+    const tmp = tmpdir();
+    let entries;
+    try {
+        entries = await readdir(tmp, { withFileTypes: true });
+    }
+    catch {
+        console.log(colors.yellow(`Unable to read temporary directory: ${tmp}`));
+        return undefined;
+    }
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('ts-trace-'))
+            continue;
+        const absolutePath = path.join(tmp, entry.name);
+        const hasArtifacts = await directoryHasTraceArtifacts(absolutePath);
+        if (!hasArtifacts)
+            continue;
+        candidates.push({
+            absolutePath,
+            relativePath: absolutePath.replace(/\\/g, '/'),
+        });
+    }
+    if (!candidates.length) {
+        console.log(colors.yellow(`No ts-trace-* folders with trace artifacts found in ${tmp}.`));
+        return undefined;
+    }
+    const chosen = await promptPathCandidate(candidates, `Pick a trace folder from ${tmp}`, tmp, '📦');
+    if (!chosen)
+        return undefined;
+    return {
+        traceDir: chosen.absolutePath,
+        label: chosen.relativePath,
+    };
+}
+async function pickTraceFileFromWorkspace() {
+    const baseSelection = await promptDirectorySelection({
+        title: 'Select a directory to search for trace.json files',
+    });
+    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);
+}
+async function pickTracePathManually() {
+    const rawPath = await askLine(colors.cyan('Enter path to trace directory or trace.json/types.json file: '));
+    const trimmed = rawPath.trim();
+    if (!trimmed)
+        return undefined;
+    const absolutePath = path.isAbsolute(trimmed)
+        ? trimmed
+        : path.resolve(rootDir, trimmed);
+    return resolveTraceDirectoryFromInput(absolutePath);
+}
+async function resolveTraceDirectoryFromInput(inputPath) {
+    let targetPath = inputPath;
+    let stats;
+    try {
+        stats = await stat(targetPath);
+    }
+    catch {
+        console.log(colors.yellow(`Path not found: ${targetPath}`));
+        return undefined;
+    }
+    if (stats.isFile()) {
+        const fileName = path.basename(targetPath).toLowerCase();
+        if (fileName !== TRACE_FILE_NAME && fileName !== TYPES_FILE_NAME) {
+            console.log(colors.yellow('Selected file must be trace.json or types.json. Pick one of those files or a folder.'));
+            return undefined;
+        }
+        targetPath = path.dirname(targetPath);
+    }
+    if (!(await isDirectory(targetPath))) {
+        console.log(colors.yellow(`Not a directory: ${targetPath}`));
+        return undefined;
+    }
+    if (await directoryHasTraceArtifacts(targetPath)) {
+        return {
+            traceDir: targetPath,
+            label: relToRoot(targetPath),
+        };
+    }
+    const nestedCandidates = await collectTraceDirectories(targetPath, TRACE_SCAN_MAX_DEPTH, TRACE_SCAN_MAX_RESULTS);
+    if (!nestedCandidates.length) {
+        console.log(colors.yellow(`No folders containing ${TRACE_FILE_NAME} and ${TYPES_FILE_NAME} were found.`));
+        return undefined;
+    }
+    const chosen = await promptPathCandidate(nestedCandidates, 'Select a trace directory', targetPath, '📦');
+    if (!chosen)
+        return undefined;
+    return {
+        traceDir: chosen.absolutePath,
+        label: chosen.relativePath,
+    };
+}
+async function promptPathCandidate(candidates, title, basePath, emoji) {
+    const entries = normalizeScripts(candidates.map((candidate) => ({
+        name: candidate.relativePath,
+        emoji,
+        description: candidate.absolutePath,
+        script: candidate.absolutePath,
+    })));
+    const chosen = await promptForScript(entries, title);
+    if (!chosen || !chosen.script)
+        return undefined;
+    const absolutePath = chosen.script;
+    return {
+        absolutePath,
+        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) => {
+        if (output.length >= maxResults)
+            return;
+        if (!(await isDirectory(absolutePath)))
+            return;
+        const hasArtifacts = await directoryHasTraceArtifacts(absolutePath);
+        if (!hasArtifacts)
+            return;
+        output.push({ absolutePath, relativePath });
+    }, 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;
+    let entries;
+    try {
+        entries = await readdir(currentPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isSymbolicLink())
+            continue;
+        if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name))
+            continue;
+        const absolutePath = path.join(currentPath, entry.name);
+        const relativePath = path.relative(basePath, absolutePath).replace(/\\/g, '/') || '.';
+        await onEntry(absolutePath, relativePath);
+        if (entry.isDirectory()) {
+            await walk(absolutePath, basePath, depth + 1, onEntry, maxDepth);
+        }
+    }
+}
+async function directoryHasTraceArtifacts(directory) {
+    const tracePath = path.join(directory, TRACE_FILE_NAME);
+    const typesPath = path.join(directory, TYPES_FILE_NAME);
+    const [traceStats, typesStats] = await Promise.all([
+        stat(tracePath).catch(() => undefined),
+        stat(typesPath).catch(() => undefined),
+    ]);
+    return Boolean(traceStats?.isFile() && typesStats?.isFile());
+}
+async function isDirectory(targetPath) {
+    try {
+        const stats = await stat(targetPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function relToRoot(targetPath) {
+    const relative = path.relative(rootDir, targetPath).replace(/\\/g, '/');
+    return relative || '.';
+}