@emeryld/manager 1.5.1 → 1.5.2

package/dist/ts-trace/generate.js

@@ -0,0 +1,150 @@
+import { existsSync } from 'node:fs';
+import { mkdir, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { rootDir } from '../helper-cli/env.js';
+import { colors, logGlobal } from '../utils/log.js';
+import { run } from '../utils/run.js';
+import { TraceReportError } from './report.js';
+const PROJECT_CONFIG_CANDIDATES = [
+    'tsconfig.typecheck.json',
+    'tsconfig.base.json',
+    'tsconfig.json',
+];
+const TEMP_CONFIG_DIR = path.join(rootDir, '.manager-tmp', 'ts-trace');
+const TRACE_FILE_NAME = 'trace.json';
+const TYPES_FILE_NAME = 'types.json';
+export async function resolveTraceProfileTargetFromPath(rawPath) {
+    const trimmed = rawPath.trim();
+    if (!trimmed) {
+        throw new TraceReportError('Target path cannot be empty.', 2);
+    }
+    const absolutePath = path.isAbsolute(trimmed)
+        ? path.resolve(trimmed)
+        : path.resolve(rootDir, trimmed);
+    const stats = await stat(absolutePath).catch(() => undefined);
+    if (!stats) {
+        throw new TraceReportError(`Target path not found: ${absolutePath}`, 2);
+    }
+    if (!stats.isFile() && !stats.isDirectory()) {
+        throw new TraceReportError(`Target must be a file or directory: ${absolutePath}`, 2);
+    }
+    if (!isPathInWorkspace(absolutePath)) {
+        throw new TraceReportError(`Target must be inside this workspace: ${absolutePath}`, 2);
+    }
+    const kind = stats.isDirectory() ? 'directory' : 'file';
+    return {
+        absolutePath,
+        kind,
+        label: formatWorkspaceRelativePath(absolutePath),
+    };
+}
+export async function generateTypeScriptTraceForTarget(options) {
+    const projectPath = await resolveProjectConfigPath(options.projectPathSetting);
+    const traceName = buildTraceName(options.target.label);
+    const traceDir = path.join(tmpdir(), `ts-trace-${traceName}-${Date.now()}`);
+    const tempConfigPath = await writeScopedTraceConfig(options.target, projectPath);
+    try {
+        logGlobal(`Generating trace for ${options.target.label} using ${formatWorkspaceRelativePath(projectPath)}`, colors.cyan);
+        await run('pnpm', [
+            'tsc',
+            '-p',
+            tempConfigPath,
+            '--incremental',
+            'false',
+            '--generateTrace',
+            traceDir,
+            '--pretty',
+            'false',
+        ]);
+    }
+    catch (error) {
+        const hasArtifacts = await traceArtifactsExist(traceDir);
+        if (!hasArtifacts) {
+            throw new TraceReportError(`Failed to generate a trace for ${options.target.label}. ${error instanceof Error ? error.message : String(error)}`, 1);
+        }
+        logGlobal('TypeScript reported errors but emitted trace artifacts; continuing analysis.', colors.yellow);
+    }
+    finally {
+        await rm(tempConfigPath, { force: true }).catch(() => { });
+    }
+    const hasArtifacts = await traceArtifactsExist(traceDir);
+    if (!hasArtifacts) {
+        throw new TraceReportError(`Trace generation finished without ${TRACE_FILE_NAME} and ${TYPES_FILE_NAME}: ${traceDir}`, 1);
+    }
+    return { traceDir, projectPath };
+}
+export async function resolveProjectConfigPath(projectPathSetting) {
+    const configured = projectPathSetting?.trim();
+    if (configured && configured.toLowerCase() !== 'auto') {
+        const resolved = path.isAbsolute(configured)
+            ? path.resolve(configured)
+            : path.resolve(rootDir, configured);
+        const stats = await stat(resolved).catch(() => undefined);
+        if (!stats?.isFile()) {
+            throw new TraceReportError(`Configured TypeScript project not found: ${resolved}`, 2);
+        }
+        return resolved;
+    }
+    for (const candidate of PROJECT_CONFIG_CANDIDATES) {
+        const candidatePath = path.join(rootDir, candidate);
+        if (!existsSync(candidatePath))
+            continue;
+        return candidatePath;
+    }
+    throw new TraceReportError(`Could not find a TypeScript project config. Checked: ${PROJECT_CONFIG_CANDIDATES.join(', ')}`, 2);
+}
+async function writeScopedTraceConfig(target, projectPath) {
+    await mkdir(TEMP_CONFIG_DIR, { recursive: true });
+    const suffix = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const tempConfigPath = path.join(TEMP_CONFIG_DIR, `tsconfig.${suffix}.json`);
+    const extendsPath = toPosixPath(path.relative(path.dirname(tempConfigPath), projectPath));
+    const relativeTargetPath = toPosixPath(path.relative(path.dirname(tempConfigPath), target.absolutePath));
+    const includePattern = buildIncludePattern(relativeTargetPath, target.kind);
+    const payload = {
+        extends: extendsPath || './tsconfig.json',
+        include: [includePattern],
+        compilerOptions: {
+            noEmit: true,
+        },
+    };
+    await writeFile(tempConfigPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    return tempConfigPath;
+}
+function buildIncludePattern(relativePath, kind) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (!normalized || normalized === '.') {
+        return kind === 'directory' ? '**/*' : normalized;
+    }
+    return kind === 'directory' ? `${normalized}/**/*` : normalized;
+}
+function buildTraceName(label) {
+    const sanitized = label
+        .replace(/\\/g, '/')
+        .replace(/[^a-zA-Z0-9/_-]+/g, '-')
+        .replace(/\/+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase();
+    return sanitized.slice(0, 48) || 'scope';
+}
+async function traceArtifactsExist(traceDir) {
+    const tracePath = path.join(traceDir, TRACE_FILE_NAME);
+    const typesPath = path.join(traceDir, TYPES_FILE_NAME);
+    const [traceStats, typesStats] = await Promise.all([
+        stat(tracePath).catch(() => undefined),
+        stat(typesPath).catch(() => undefined),
+    ]);
+    return Boolean(traceStats?.isFile() && typesStats?.isFile());
+}
+function formatWorkspaceRelativePath(targetPath) {
+    const relative = path.relative(rootDir, targetPath).replace(/\\/g, '/');
+    return relative || '.';
+}
+function isPathInWorkspace(targetPath) {
+    const relative = path.relative(rootDir, targetPath);
+    return Boolean(relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative)));
+}
+function toPosixPath(value) {
+    return value.replace(/\\/g, '/');
+}

package/dist/ts-trace/index.js

@@ -0,0 +1,137 @@
+/**
+ * Self-check:
+ * 1) pnpm manager-cli
+ * 2) utilities -> typescript trace profiler -> profile file/folder
+ * 3) pick target path, wait for trace generation, review offenders
+ */
+import path from 'node:path';
+import { runHelperCli } from '../helper-cli.js';
+import { colors } from '../utils/log.js';
+import { parseTraceReportCliArgs, printTraceReportUsage } from './cli/options.js';
+import { promptTraceReportSettings } from './cli/prompts.js';
+import { loadTraceReportSettings } from './config.js';
+import { promptTraceDirectorySelection, promptTraceProfileTargetSelection, } from './picker.js';
+import { generateTypeScriptTraceForTarget, resolveTraceProfileTargetFromPath, } from './generate.js';
+import { TraceReportError, runTypeScriptTraceReport } from './report.js';
+export async function runTypeScriptTraceProfiler() {
+    console.log(colors.cyan('Loading defaults from .vscode/settings.json (manager.tsTraceProfiler)'));
+    let settings = await loadTraceReportSettings();
+    while (true) {
+        let lastAction;
+        const ran = await runHelperCli({
+            title: 'TypeScript trace profiler',
+            scripts: [
+                {
+                    name: 'Profile file/folder (auto trace)',
+                    emoji: '⏱️',
+                    description: traceSettingsSummary(settings),
+                    handler: async () => {
+                        try {
+                            const target = await promptTraceProfileTargetSelection();
+                            if (!target)
+                                return;
+                            const generated = await generateTypeScriptTraceForTarget({
+                                target,
+                                projectPathSetting: settings.projectPath,
+                            });
+                            console.log(colors.magenta(`Analyzing TypeScript trace for ${target.label}`));
+                            console.log(colors.dim(`Trace output: ${generated.traceDir}`));
+                            await runTypeScriptTraceReport(buildRunOptions(settings, generated.traceDir));
+                            lastAction = 'run';
+                        }
+                        catch (error) {
+                            logTraceError(error);
+                        }
+                    },
+                },
+                {
+                    name: 'Analyze existing trace',
+                    emoji: '🧾',
+                    description: 'Pick an existing trace.json/types.json folder and report offenders',
+                    handler: async () => {
+                        try {
+                            const selection = await promptTraceDirectorySelection();
+                            if (!selection)
+                                return;
+                            console.log(colors.magenta(`Analyzing TypeScript trace from ${selection.label}`));
+                            await runTypeScriptTraceReport(buildRunOptions(settings, selection.traceDir));
+                            lastAction = 'run';
+                        }
+                        catch (error) {
+                            logTraceError(error);
+                        }
+                    },
+                },
+                {
+                    name: 'Adjust settings',
+                    emoji: '⚙️',
+                    description: traceSettingsSummary(settings),
+                    handler: async () => {
+                        settings = await promptTraceReportSettings(settings);
+                        lastAction = 'configure';
+                    },
+                },
+            ],
+            argv: [],
+        });
+        if (!ran)
+            return;
+        if (lastAction === 'run')
+            return;
+    }
+}
+export async function runTypeScriptTraceReportCli(argv) {
+    const defaults = await loadTraceReportSettings();
+    const parsed = parseTraceReportCliArgs(argv, defaults);
+    if (parsed.help) {
+        printTraceReportUsage();
+        return;
+    }
+    if (!parsed.command)
+        return;
+    if (parsed.command.mode === 'existing') {
+        await runTypeScriptTraceReport(parsed.command.report);
+        return;
+    }
+    const target = await resolveTraceProfileTargetFromPath(parsed.command.targetPath);
+    const generated = await generateTypeScriptTraceForTarget({
+        target,
+        projectPathSetting: parsed.command.projectPath,
+    });
+    await runTypeScriptTraceReport({
+        traceDir: generated.traceDir,
+        ...parsed.command.report,
+    });
+}
+function buildRunOptions(settings, traceDir) {
+    return {
+        traceDir,
+        top: settings.top,
+        minMs: settings.minMs,
+        json: settings.includeJson || Boolean(settings.outPath),
+        filterRegex: settings.filterRegex || undefined,
+        eventNames: settings.eventNames,
+        baseDir: path.resolve(settings.baseDir || process.cwd()),
+        outPath: settings.outPath || undefined,
+    };
+}
+function traceSettingsSummary(settings) {
+    const events = settings.eventNames.length
+        ? settings.eventNames.join(',')
+        : 'all';
+    const filter = settings.filterRegex ? settings.filterRegex : 'none';
+    const jsonLabel = settings.includeJson || settings.outPath ? 'on' : 'off';
+    const project = settings.projectPath || 'auto';
+    return `top=${settings.top} minMs=${settings.minMs} events=${events} filter=${filter} json=${jsonLabel} project=${project}`;
+}
+function logTraceError(error) {
+    if (error instanceof TraceReportError) {
+        console.log(colors.red(error.message));
+        return;
+    }
+    if (error instanceof Error) {
+        console.log(colors.red(error.message));
+        return;
+    }
+    console.log(colors.red(String(error)));
+}

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 || '.';
+}