@emeryld/manager 1.5.0 → 1.5.2

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

@@ -0,0 +1,154 @@
+export const SETTING_DESCRIPTORS = [
+    {
+        key: 'top',
+        label: 'Top results',
+        unit: 'entries',
+        type: 'number',
+    },
+    {
+        key: 'minMs',
+        label: 'Minimum span duration',
+        unit: 'milliseconds',
+        type: 'number',
+        allowZero: true,
+    },
+    {
+        key: 'filterRegex',
+        label: 'Path filter regex',
+        unit: 'blank = include all',
+        type: 'text',
+    },
+    {
+        key: 'eventNames',
+        label: 'Event names',
+        unit: 'comma-separated, blank = all',
+        type: 'list',
+    },
+    {
+        key: 'includeJson',
+        label: 'Print JSON in terminal',
+        type: 'boolean',
+    },
+    {
+        key: 'outPath',
+        label: 'JSON output path',
+        unit: 'blank = no file output',
+        type: 'text',
+    },
+    {
+        key: 'baseDir',
+        label: 'Display base directory',
+        type: 'text',
+    },
+    {
+        key: 'projectPath',
+        label: 'TypeScript project config',
+        unit: 'blank = auto-detect',
+        type: 'text',
+    },
+];
+export function formatValue(value, descriptor) {
+    if (descriptor.type === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (descriptor.type === 'list') {
+        const list = value;
+        return list.length ? list.join(', ') : 'all events';
+    }
+    if (descriptor.type === 'text') {
+        const text = `${value}`.trim();
+        return text || '(none)';
+    }
+    return `${value}`;
+}
+export function parseInteractiveValue(descriptor, buffer) {
+    const trimmed = buffer.trim();
+    if (trimmed === '') {
+        if (descriptor.type === 'list')
+            return { value: [] };
+        if (descriptor.type === 'text')
+            return { value: '' };
+        return { value: undefined };
+    }
+    if (descriptor.type === 'number') {
+        const parsed = parseNumericValue(trimmed);
+        if (parsed === undefined) {
+            const rangeLabel = descriptor.allowZero ? 'non-negative' : 'positive';
+            return { error: `${descriptor.label} requires a ${rangeLabel} number.` };
+        }
+        if (!descriptor.allowZero && parsed <= 0) {
+            return { error: `${descriptor.label} requires a positive number.` };
+        }
+        if (descriptor.allowZero && parsed < 0) {
+            return { error: `${descriptor.label} must be non-negative.` };
+        }
+        if (descriptor.key === 'top') {
+            return { value: Math.floor(parsed) };
+        }
+        return { value: parsed };
+    }
+    if (descriptor.type === 'boolean') {
+        const parsed = parseBooleanInput(trimmed);
+        if (parsed.error)
+            return { error: parsed.error };
+        return { value: parsed.value };
+    }
+    if (descriptor.type === 'list') {
+        const events = parseStringList(trimmed);
+        return {
+            value: events,
+        };
+    }
+    if (descriptor.key === 'filterRegex') {
+        try {
+            // Validate early so mistakes are caught inside the settings page.
+            new RegExp(trimmed);
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Invalid regex pattern.',
+            };
+        }
+    }
+    return { value: trimmed };
+}
+export function validateTraceSettings(settings) {
+    if (!Number.isFinite(settings.top) || settings.top <= 0) {
+        return 'Top results must be a positive number.';
+    }
+    if (!Number.isFinite(settings.minMs) || settings.minMs < 0) {
+        return 'Minimum span duration must be non-negative.';
+    }
+    if (settings.filterRegex) {
+        try {
+            new RegExp(settings.filterRegex);
+        }
+        catch (error) {
+            return `Path filter regex is invalid: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    if (!settings.baseDir.trim()) {
+        return 'Display base directory cannot be empty.';
+    }
+    return undefined;
+}
+export function parseNumericValue(raw) {
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return undefined;
+    return parsed;
+}
+export function parseBooleanInput(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (['yes', 'y', 'true', '1'].includes(normalized))
+        return { value: true };
+    if (['no', 'n', 'false', '0'].includes(normalized))
+        return { value: false };
+    return { error: 'Provide "true" or "false".' };
+}
+export function parseStringList(raw) {
+    return raw
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}

package/dist/ts-trace/config.js

@@ -0,0 +1,100 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { rootDir } from '../helper-cli/env.js';
+const SETTINGS_SECTION = 'manager.tsTraceProfiler';
+const workspaceSettingsPath = path.join(rootDir, '.vscode', 'settings.json');
+export const DEFAULT_TRACE_REPORT_SETTINGS = {
+    top: 20,
+    minMs: 1,
+    filterRegex: '',
+    eventNames: [],
+    includeJson: false,
+    outPath: '',
+    baseDir: rootDir,
+    projectPath: '',
+};
+export async function loadTraceReportSettings() {
+    if (!existsSync(workspaceSettingsPath)) {
+        return DEFAULT_TRACE_REPORT_SETTINGS;
+    }
+    try {
+        const raw = await readFile(workspaceSettingsPath, 'utf8');
+        const json = JSON.parse(raw);
+        const section = json[SETTINGS_SECTION];
+        if (!section || typeof section !== 'object') {
+            return DEFAULT_TRACE_REPORT_SETTINGS;
+        }
+        const record = section;
+        return {
+            top: coercePositiveInteger(record.top, DEFAULT_TRACE_REPORT_SETTINGS.top),
+            minMs: coerceNonNegativeNumber(record.minMs, DEFAULT_TRACE_REPORT_SETTINGS.minMs),
+            filterRegex: coerceString(record.filterRegex, DEFAULT_TRACE_REPORT_SETTINGS.filterRegex),
+            eventNames: coerceStringArray(record.eventNames, DEFAULT_TRACE_REPORT_SETTINGS.eventNames),
+            includeJson: coerceBoolean(record.includeJson, DEFAULT_TRACE_REPORT_SETTINGS.includeJson),
+            outPath: coerceString(record.outPath, DEFAULT_TRACE_REPORT_SETTINGS.outPath),
+            baseDir: coerceBaseDir(record.baseDir, DEFAULT_TRACE_REPORT_SETTINGS.baseDir),
+            projectPath: coerceString(record.projectPath, DEFAULT_TRACE_REPORT_SETTINGS.projectPath),
+        };
+    }
+    catch {
+        return DEFAULT_TRACE_REPORT_SETTINGS;
+    }
+}
+function coercePositiveInteger(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    const floored = Math.floor(parsed);
+    if (floored <= 0)
+        return fallback;
+    return floored;
+}
+function coerceNonNegativeNumber(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    if (parsed < 0)
+        return fallback;
+    return parsed;
+}
+function coerceString(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    return value.trim();
+}
+function coerceStringArray(value, fallback) {
+    if (Array.isArray(value)) {
+        const parsed = value
+            .map((item) => (typeof item === 'string' ? item.trim() : ''))
+            .filter(Boolean);
+        return parsed;
+    }
+    if (typeof value === 'string') {
+        return value
+            .split(',')
+            .map((item) => item.trim())
+            .filter(Boolean);
+    }
+    return fallback;
+}
+function coerceBoolean(value, fallback) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true')
+            return true;
+        if (normalized === 'false')
+            return false;
+    }
+    return fallback;
+}
+function coerceBaseDir(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return fallback;
+    return path.isAbsolute(trimmed) ? trimmed : path.resolve(rootDir, trimmed);
+}

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)));
+}