ushman-characterize 0.4.0

package/dist/capture.js

@@ -0,0 +1,620 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { createViteCaptureServerHost } from "./capture-server.js";
+import { DEFAULT_CAPTURE_SETTLE_FRAMES, DEFAULT_CAPTURE_VIEWPORT, DEFAULT_MAX_UNIQUE_RECORDS_PER_STATE, DEFAULT_PER_FUNCTION_SHAPE_CAP, DEFAULT_TRACE_BYTES_LIMIT, } from "./constants.js";
+import { toTraceDeduplicationPayload } from "./dedupe-contract.js";
+import { parseTraceRecord, stampTraceRecord } from "./format-contract.js";
+import { instrumentBundleSource } from "./instrument.js";
+import { recordCharacterizeValidatorResult, writeCharacterizeReport } from "./ledger.js";
+import { createPuppeteerHarness, safeEvaluate, } from "./puppeteer-harness.js";
+import { StateDagDocumentSchema } from "./schema-types.js";
+import { parseJsonLines, toJsonLines } from "./shared.js";
+import { collectStateDagActions } from "./state-dag.js";
+import { sleep } from "./time.js";
+import { ensureWorkspaceTraceHarness, workspaceHarnessPaths } from "./trace-format.js";
+import { buildStableHash } from "./trace-serializer.js";
+import { buildTracerRuntimeSource } from "./tracer-runtime.js";
+import { assertV4Workspace, pathExists, readVersionedDocument, resolveDeterminismSeed, resolveStateDagFile, resolveWorkspacePaths, } from "./workspace-paths.js";
+const INITIAL_PORT = 0;
+const createTraceState = (state) => ({
+    dedupeLimitReached: false,
+    droppedUniqueCalls: 0,
+    functionNames: new Set(),
+    mergedExistingRecords: 0,
+    rawCalls: 0,
+    recordBytesByKey: new Map(),
+    recordsByKey: new Map(),
+    skippedExistingRecords: 0,
+    state,
+    traceBytes: 0,
+    uniqueCalls: 0,
+});
+class CaptureCapacityError extends Error {
+    phase;
+    state;
+    constructor({ message, phase, state, }) {
+        super(message);
+        this.phase = phase;
+        this.state = state;
+    }
+}
+const buildRecordKey = (record) => buildStableHash(JSON.stringify(toTraceDeduplicationPayload(record)));
+const countRecordBytes = (record) => Buffer.byteLength(JSON.stringify({
+    ...record,
+    args: record.args,
+    expected: record.expected,
+    sideEffects: record.sideEffects,
+    thisArg: record.thisArg,
+    threw: record.threw,
+})) + 1;
+const toStateSummary = (state) => ({
+    dedupeLimitReached: state.dedupeLimitReached,
+    droppedUniqueCalls: state.droppedUniqueCalls,
+    functionCount: state.functionNames.size,
+    mergedExistingRecords: state.mergedExistingRecords,
+    rawCalls: state.rawCalls,
+    skippedExistingRecords: state.skippedExistingRecords,
+    state: state.state,
+    traceBytes: state.traceBytes,
+    uniqueCalls: state.recordsByKey.size,
+});
+const updateRecord = ({ record, state, }) => {
+    const key = buildRecordKey(record);
+    const previous = state.recordsByKey.get(key);
+    const nextBytes = countRecordBytes(record);
+    const previousBytes = state.recordBytesByKey.get(key) ?? 0;
+    state.traceBytes += nextBytes - previousBytes;
+    state.recordBytesByKey.set(key, nextBytes);
+    state.recordsByKey.set(key, previous ? { ...previous, count: record.count } : record);
+    state.functionNames.add(record.functionName);
+};
+const readExistingTraceRecords = async ({ harnessPaths, stateId, }) => {
+    const traceFile = path.join(harnessPaths.tracesDir, `${stateId}.jsonl`);
+    if (!(await pathExists(traceFile))) {
+        return [];
+    }
+    return parseJsonLines(await Bun.file(traceFile).text()).map((record, index) => parseTraceRecord({
+        context: `Trace record ${stateId}.jsonl:${index + 1}`,
+        value: record,
+    }));
+};
+const loadExistingStateRecords = async ({ harnessPaths, maxUniqueRecordsPerState, state, stateId, }) => {
+    for (const record of await readExistingTraceRecords({ harnessPaths, stateId })) {
+        const key = buildRecordKey(record);
+        if (state.recordsByKey.has(key)) {
+            state.skippedExistingRecords += 1;
+            updateRecord({
+                record,
+                state,
+            });
+            continue;
+        }
+        if (state.recordsByKey.size >= maxUniqueRecordsPerState) {
+            state.dedupeLimitReached = true;
+            throw new CaptureCapacityError({
+                message: `State ${stateId} already contains more than ${maxUniqueRecordsPerState} unique trace records. Increase maxUniqueRecordsPerState or prune the existing trace file before re-running capture.`,
+                phase: 'existing-traces',
+                state: stateId,
+            });
+        }
+        updateRecord({
+            record,
+            state,
+        });
+        state.mergedExistingRecords += 1;
+    }
+    state.uniqueCalls = state.recordsByKey.size;
+};
+const mergeDrainPayload = async ({ disableTracer, maxUniqueRecordsPerState = Number.MAX_SAFE_INTEGER, maxTraceBytes, payload, state, }) => {
+    state.rawCalls = payload.stats.rawCalls;
+    state.droppedUniqueCalls = payload.stats.droppedUniqueCalls;
+    for (const [index, drainedRecord] of payload.records.entries()) {
+        const record = {
+            ...drainedRecord,
+            state: state.state,
+        };
+        const key = buildRecordKey(record);
+        if (!state.recordsByKey.has(key) && state.recordsByKey.size >= maxUniqueRecordsPerState) {
+            state.dedupeLimitReached = true;
+            state.droppedUniqueCalls += payload.records.length - index;
+            await disableTracer();
+            break;
+        }
+        const nextBytes = countRecordBytes(record);
+        const previousBytes = state.recordBytesByKey.get(key) ?? 0;
+        const projectedBytes = state.traceBytes - previousBytes + nextBytes;
+        if (projectedBytes > maxTraceBytes) {
+            state.traceBytes = Math.max(state.traceBytes, maxTraceBytes);
+            state.droppedUniqueCalls += payload.records.length - index;
+            await disableTracer();
+            break;
+        }
+        updateRecord({
+            record,
+            state,
+        });
+    }
+    state.uniqueCalls = state.recordsByKey.size;
+};
+const executeStateActions = async ({ dag, onAfterAction, pageHandle, stateId, }) => {
+    for (const action of collectStateDagActions(dag, stateId)) {
+        if (action.type === 'wait') {
+            await sleep(action.ms);
+            await onAfterAction();
+            continue;
+        }
+        await pageHandle.page.click(action.selector);
+        if (action.waitMs) {
+            await sleep(action.waitMs);
+        }
+        await onAfterAction();
+    }
+};
+const resolveServedBundlePath = ({ bundlePath, workspaceRoot, }) => {
+    const { root, v4 } = resolveWorkspacePaths(workspaceRoot);
+    const resolvedBundlePath = path.resolve(bundlePath);
+    const candidates = [v4.candidatePublic, root];
+    for (const baseDir of candidates) {
+        const relative = path.relative(path.resolve(baseDir), resolvedBundlePath);
+        if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
+            return `/${relative.split(path.sep).join('/')}`;
+        }
+    }
+    throw new Error(`Bundle path ${bundlePath} must live under ${v4.candidatePublic} or ${root}. Re-run with a workspace-relative bundle path such as public/assets/index.js.`);
+};
+const loadStateDag = async (workspaceRoot) => {
+    const stateDagFile = await resolveStateDagFile(workspaceRoot);
+    const dag = await readVersionedDocument(stateDagFile, StateDagDocumentSchema);
+    if (!dag) {
+        throw new Error(`Missing state DAG at ${stateDagFile}.`);
+    }
+    return dag;
+};
+const maybeInstallInterception = async ({ bundleRequestPath, instrumentedSource, page, }) => {
+    if (!bundleRequestPath || !instrumentedSource) {
+        return async () => undefined;
+    }
+    const requestHandler = (request) => {
+        const url = new URL(request.url());
+        if (url.pathname === bundleRequestPath) {
+            void request.respond({
+                body: instrumentedSource,
+                contentType: 'application/javascript; charset=utf-8',
+                status: 200,
+            });
+            return;
+        }
+        void request.continue();
+    };
+    await page.setRequestInterception(true);
+    page.on('request', requestHandler);
+    return async () => {
+        try {
+            page.off?.('request', requestHandler);
+            await page.setRequestInterception(false);
+        }
+        catch {
+            // page may already be closing
+        }
+    };
+};
+const drainTracer = async (page) => safeEvaluate(page, 'characterize:drain', () => {
+    const tracer = globalThis.__USHMAN_TRACER__;
+    return tracer?.drain?.() ?? { records: [], stats: { droppedUniqueCalls: 0, rawCalls: 0, uniqueCalls: 0 } };
+});
+const disableTracer = async (page) => {
+    await safeEvaluate(page, 'characterize:disable-tracer', () => {
+        const tracer = globalThis.__USHMAN_TRACER__;
+        tracer?.disable?.();
+    });
+};
+const loadDefaultSceneInspectorDriver = async () => {
+    try {
+        const specifier = '@ushman/threejs-tools/inspector';
+        const imported = (await import(__rewriteRelativeImportExtension(specifier)));
+        const captureSceneTree = imported.captureSceneGraph;
+        const installPreboot = imported.installSceneHeavyPreboot;
+        if (typeof captureSceneTree !== 'function') {
+            return null;
+        }
+        return {
+            captureSceneTree: captureSceneTree,
+            installPreboot: typeof installPreboot === 'function'
+                ? installPreboot
+                : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const resolveSceneInspectorDriver = async ({ requested, sceneOnly, }) => {
+    if (requested) {
+        return requested;
+    }
+    if (!sceneOnly) {
+        return null;
+    }
+    const loaded = await loadDefaultSceneInspectorDriver();
+    if (loaded) {
+        return loaded;
+    }
+    throw new Error('scene-only capture requires a SceneInspectorDriver. Install @ushman/threejs-tools and expose its inspector entrypoint, or pass sceneInspectorDriver programmatically.');
+};
+const captureSceneOnly = async ({ driver, harnessPaths, page, stateId, }) => {
+    const sceneCapture = await driver.captureSceneTree(page);
+    await Bun.write(path.join(harnessPaths.sceneFixturesDir, `${stateId}.json`), `${JSON.stringify(sceneCapture, null, 2)}\n`);
+};
+const captureState = async ({ bundleRequestPath, captureSideEffects, driver, harnessPaths, instrumentedSource, maxUniqueRecordsPerState, maxTraceBytes, perFunctionCap, pageHandle, sceneOnly, serverUrl, stateId, dag, }) => {
+    const state = createTraceState(stateId);
+    await loadExistingStateRecords({
+        harnessPaths,
+        maxUniqueRecordsPerState,
+        state,
+        stateId,
+    });
+    const mergeLatestDrain = async () => {
+        const payload = await drainTracer(pageHandle.page);
+        await mergeDrainPayload({
+            disableTracer: async () => disableTracer(pageHandle.page),
+            maxTraceBytes,
+            maxUniqueRecordsPerState,
+            payload,
+            state,
+        });
+    };
+    await driver?.installPreboot?.(pageHandle.page);
+    await pageHandle.page.evaluateOnNewDocument(buildTracerRuntimeSource({
+        captureSideEffects,
+        perFunctionShapeCap: perFunctionCap,
+    }));
+    const restoreInterception = await maybeInstallInterception({
+        bundleRequestPath,
+        instrumentedSource,
+        page: pageHandle.page,
+    });
+    try {
+        await pageHandle.goto(serverUrl);
+        if (sceneOnly && driver) {
+            await executeStateActions({
+                dag,
+                onAfterAction: async () => { },
+                pageHandle,
+                stateId,
+            });
+            for (let index = 0; index < DEFAULT_CAPTURE_SETTLE_FRAMES; index += 1) {
+                await pageHandle.tickFrame();
+            }
+            await captureSceneOnly({
+                driver,
+                harnessPaths,
+                page: pageHandle.page,
+                stateId,
+            });
+            return state;
+        }
+        await executeStateActions({
+            dag,
+            onAfterAction: mergeLatestDrain,
+            pageHandle,
+            stateId,
+        });
+        for (let index = 0; index < DEFAULT_CAPTURE_SETTLE_FRAMES; index += 1) {
+            await pageHandle.tickFrame();
+            await mergeLatestDrain();
+        }
+    }
+    finally {
+        await restoreInterception();
+    }
+    return state;
+};
+const validateCaptureOptions = async ({ bundlePath, mode, sceneOnly, workspaceRoot, }) => {
+    await assertV4Workspace(workspaceRoot);
+    if (mode !== 'dev' && mode !== 'preview') {
+        throw new Error(`Unsupported capture mode "${mode}". Use "preview" or "dev".`);
+    }
+    if (!sceneOnly && !bundlePath) {
+        throw new Error('capture requires --bundle=<path> unless --scene-only is set.');
+    }
+};
+const buildInstrumentedSource = async ({ bundlePath, sceneOnly, }) => {
+    if (!bundlePath || sceneOnly) {
+        return null;
+    }
+    return instrumentBundleSource({
+        source: await Bun.file(bundlePath).text(),
+        sourceMapMode: 'inline',
+        sourcePath: bundlePath,
+    }).code;
+};
+const prepareCaptureRun = async ({ bundlePath, mode, sceneInspectorDriver, sceneOnly, serverHost, states, workspaceRoot, }) => {
+    const dag = await loadStateDag(workspaceRoot);
+    const stateIds = states && states.length > 0 ? [...states] : Object.keys(dag.states);
+    const bundleRequestPath = bundlePath ? resolveServedBundlePath({ bundlePath, workspaceRoot }) : null;
+    const driver = await resolveSceneInspectorDriver({
+        requested: sceneInspectorDriver,
+        sceneOnly,
+    });
+    const harnessPaths = await ensureWorkspaceTraceHarness(workspaceRoot);
+    await mkdir(harnessPaths.tracesDir, { recursive: true });
+    await mkdir(harnessPaths.sceneFixturesDir, { recursive: true });
+    return {
+        bundleRequestPath,
+        dag,
+        driver,
+        harnessPaths,
+        instrumentedSource: await buildInstrumentedSource({
+            bundlePath,
+            sceneOnly,
+        }),
+        seed: await resolveDeterminismSeed(workspaceRoot),
+        serverFactory: serverHost ?? createViteCaptureServerHost({ mode }),
+        stateIds,
+    };
+};
+const writeCapturedStateFile = async ({ harnessPaths, records, stateId, }) => {
+    const traceFile = path.join(harnessPaths.tracesDir, `${stateId}.jsonl`);
+    await Bun.write(traceFile, `${toJsonLines(records.map((record) => stampTraceRecord(record)))}\n`);
+    return traceFile;
+};
+const toWorkspaceRelativePath = ({ filePath, workspaceRoot, }) => path.relative(path.resolve(workspaceRoot), path.resolve(filePath)).split(path.sep).join('/');
+const captureRequestedStates = async ({ bundleRequestPath, captureSideEffects, dag, driver, harness, harnessPaths, instrumentedSource, maxUniqueRecordsPerState, maxTraceBytes, perFunctionCap, sceneOnly, seed, serverUrl, stateIds, workspaceRoot, }) => {
+    const attemptedStates = [];
+    const summaries = [];
+    const failures = [];
+    const affectedFiles = [];
+    for (const stateId of stateIds) {
+        attemptedStates.push(stateId);
+        const pageHandle = (await harness.launch({
+            deterministicPreboot: true,
+            replaceDateConstructor: true,
+            seed,
+            viewport: DEFAULT_CAPTURE_VIEWPORT,
+        }));
+        try {
+            const stateCapture = await captureState({
+                bundleRequestPath,
+                captureSideEffects,
+                dag,
+                driver,
+                harnessPaths,
+                instrumentedSource,
+                maxTraceBytes,
+                maxUniqueRecordsPerState,
+                pageHandle,
+                perFunctionCap,
+                sceneOnly,
+                serverUrl,
+                stateId,
+            });
+            if (sceneOnly) {
+                affectedFiles.push(toWorkspaceRelativePath({
+                    filePath: path.join(harnessPaths.sceneFixturesDir, `${stateId}.json`),
+                    workspaceRoot,
+                }));
+                summaries.push({
+                    dedupeLimitReached: false,
+                    droppedUniqueCalls: 0,
+                    functionCount: 0,
+                    mergedExistingRecords: 0,
+                    rawCalls: 0,
+                    skippedExistingRecords: 0,
+                    state: stateId,
+                    traceBytes: 0,
+                    uniqueCalls: 0,
+                });
+                continue;
+            }
+            const records = [...stateCapture.recordsByKey.values()].sort((left, right) => left.functionName.localeCompare(right.functionName));
+            const traceFile = await writeCapturedStateFile({
+                harnessPaths,
+                records,
+                stateId,
+            });
+            affectedFiles.push(toWorkspaceRelativePath({
+                filePath: traceFile,
+                workspaceRoot,
+            }));
+            summaries.push(toStateSummary(stateCapture));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failures.push({
+                error: message,
+                phase: error instanceof CaptureCapacityError ? error.phase : 'capture',
+                state: stateId,
+                successfulStatesBeforeFailure: summaries.map((summary) => summary.state),
+            });
+        }
+        finally {
+            await pageHandle.close();
+        }
+    }
+    return {
+        affectedFiles,
+        failures,
+        result: {
+            attemptedStates,
+            completedStates: summaries.map((summary) => summary.state),
+            failures,
+            requestedStates: stateIds,
+            skippedStates: stateIds.filter((stateId) => !attemptedStates.includes(stateId)),
+            states: summaries,
+            status: failures.length > 0 ? 'partial' : 'success',
+            traceDir: harnessPaths.tracesDir,
+        },
+    };
+};
+const recordSuccessfulCapture = async ({ affectedFiles, failures, mode, result, sceneOnly, stateIds, workspaceRoot, }) => {
+    const reportPath = await writeCharacterizeReport({
+        payload: {
+            affectedFiles,
+            failures,
+            mode,
+            result,
+            sceneOnly,
+            states: stateIds,
+        },
+        prefix: 'capture',
+        workspaceRoot,
+    });
+    await recordCharacterizeValidatorResult({
+        affectedFiles,
+        metrics: {
+            failures,
+            mode,
+            sceneOnly,
+            stateCount: result.states.length,
+            states: result.states,
+        },
+        resultPath: reportPath,
+        summary: failures.length > 0
+            ? `capture partially succeeded: wrote ${affectedFiles.length} characterize artifact(s), ${failures.length} state(s) failed`
+            : `capture wrote ${affectedFiles.length} characterize artifact(s) across ${result.states.length} state(s)`,
+        verdict: failures.length > 0 ? 'yellow' : 'green',
+        workspaceRoot,
+    });
+};
+const recordFailedCapture = async ({ error, mode, requestedStates, sceneOnly, workspaceRoot, }) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const structuredFailure = error instanceof CaptureCapacityError
+        ? {
+            phase: error.phase,
+            state: error.state,
+        }
+        : null;
+    const reportPath = await writeCharacterizeReport({
+        payload: {
+            error: message,
+            mode,
+            sceneOnly,
+            states: requestedStates,
+            structuredFailure,
+        },
+        prefix: 'capture-failed',
+        workspaceRoot,
+    }).catch((reportError) => {
+        console.error(`Failed to write characterize failure report: ${reportError instanceof Error ? reportError.message : String(reportError)}`);
+        return null;
+    });
+    if (!reportPath) {
+        return;
+    }
+    await recordCharacterizeValidatorResult({
+        metrics: {
+            error: message,
+            mode,
+            requestedStates,
+            sceneOnly,
+            structuredFailure,
+        },
+        resultPath: reportPath,
+        summary: `capture failed: ${message}`,
+        verdict: 'red',
+        workspaceRoot,
+    }).catch((ledgerError) => {
+        console.error(`Failed to record characterize failure verdict: ${ledgerError instanceof Error ? ledgerError.message : String(ledgerError)}`);
+    });
+};
+const logCleanupFailure = (label, error) => {
+    console.error(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+};
+/**
+ * Capture instrumented call traces for the requested workspace states.
+ */
+export const captureCharacterization = async ({ bundlePath = null, captureSideEffects = false, harnessFactory = createPuppeteerHarness, maxTraceBytes = DEFAULT_TRACE_BYTES_LIMIT, mode = 'preview', maxUniqueRecordsPerState = DEFAULT_MAX_UNIQUE_RECORDS_PER_STATE, perFunctionCap = DEFAULT_PER_FUNCTION_SHAPE_CAP, sceneInspectorDriver, sceneOnly = false, serverHost, states, workspaceRoot, }) => {
+    await validateCaptureOptions({
+        bundlePath,
+        mode,
+        sceneOnly,
+        workspaceRoot,
+    });
+    const prepared = await prepareCaptureRun({
+        bundlePath,
+        mode,
+        sceneInspectorDriver,
+        sceneOnly,
+        serverHost,
+        states,
+        workspaceRoot,
+    });
+    let server = null;
+    let harness = null;
+    try {
+        server = await prepared.serverFactory.serve(workspaceRoot, INITIAL_PORT);
+        harness = harnessFactory({ headless: true });
+        const captured = await captureRequestedStates({
+            bundleRequestPath: prepared.bundleRequestPath,
+            captureSideEffects,
+            dag: prepared.dag,
+            driver: prepared.driver,
+            harness,
+            harnessPaths: prepared.harnessPaths,
+            instrumentedSource: prepared.instrumentedSource,
+            maxTraceBytes,
+            maxUniqueRecordsPerState,
+            perFunctionCap,
+            sceneOnly,
+            seed: prepared.seed,
+            serverUrl: server.url,
+            stateIds: prepared.stateIds,
+            workspaceRoot,
+        });
+        if (captured.result.states.length === 0 && captured.failures.length > 0) {
+            throw new Error(captured.failures.map((failure) => `${failure.state}: ${failure.error}`).join('\n'));
+        }
+        await recordSuccessfulCapture({
+            affectedFiles: captured.affectedFiles,
+            failures: captured.failures,
+            mode,
+            result: captured.result,
+            sceneOnly,
+            stateIds: prepared.stateIds,
+            workspaceRoot,
+        });
+        return captured.result;
+    }
+    catch (error) {
+        await recordFailedCapture({
+            error,
+            mode,
+            requestedStates: prepared.stateIds,
+            sceneOnly,
+            workspaceRoot,
+        });
+        throw error;
+    }
+    finally {
+        const [harnessClose, serverClose] = await Promise.allSettled([harness?.close(), server?.close()]);
+        if (harnessClose.status === 'rejected') {
+            logCleanupFailure('Failed to close characterize harness', harnessClose.reason);
+        }
+        if (serverClose.status === 'rejected') {
+            logCleanupFailure('Failed to close characterize server', serverClose.reason);
+        }
+    }
+};
+export const readCapturedTraceState = async ({ stateId, workspaceRoot, }) => {
+    const filePath = path.join(workspaceHarnessPaths(workspaceRoot).tracesDir, `${stateId}.jsonl`);
+    if (!(await pathExists(filePath))) {
+        return [];
+    }
+    return parseJsonLines(await Bun.file(filePath).text()).map((record, index) => parseTraceRecord({
+        context: `Trace record ${stateId}.jsonl:${index + 1}`,
+        value: record,
+    }));
+};
+export const __testOnly = {
+    buildRecordKey,
+    mergeDrainPayload,
+    resolveServedBundlePath,
+};

package/dist/cli/logger.d.ts

@@ -0,0 +1,7 @@
+export type Logger = {
+    info: (message: string, extra?: Record<string, unknown>) => void;
+    warn: (message: string, extra?: Record<string, unknown>) => void;
+    error: (message: string, extra?: Record<string, unknown>) => void;
+};
+export declare const createConsoleLogger: () => Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/cli/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/cli/logger.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,MAAM,GAAG;IACjB,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACjE,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACjE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CACrE,CAAC;AAYF,eAAO,MAAM,mBAAmB,QAAO,MAIrC,CAAC"}

package/dist/cli/logger.js

@@ -0,0 +1,14 @@
+import { createConsola } from 'consola';
+const log = createConsola({ formatOptions: { colors: true, date: false } });
+const format = (extra) => {
+    if (!extra || Object.keys(extra).length === 0) {
+        return '';
+    }
+    const parts = Object.entries(extra).map(([key, value]) => `${key}=${JSON.stringify(value)}`);
+    return ` (${parts.join(' ')})`;
+};
+export const createConsoleLogger = () => ({
+    error: (message, extra) => log.error(`${message}${format(extra)}`),
+    info: (message, extra) => log.info(`${message}${format(extra)}`),
+    warn: (message, extra) => log.warn(`${message}${format(extra)}`),
+});

package/dist/cli/parse-flags.d.ts

@@ -0,0 +1,8 @@
+export declare const parseKeyValueFlags: (args: readonly string[], options?: {
+    readonly booleanFlags?: readonly string[];
+    readonly stringFlags?: readonly string[];
+}) => {
+    flags: Map<string, string | boolean>;
+    positionals: string[];
+};
+//# sourceMappingURL=parse-flags.d.ts.map

package/dist/cli/parse-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-flags.d.ts","sourceRoot":"","sources":["../../src/cli/parse-flags.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,GAC3B,MAAM,SAAS,MAAM,EAAE,EACvB,UAAS;IACL,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;;;CAkET,CAAC"}