vouchington-tooling 0.0.21 → 0.1.0

package/dist/retrospective-transcript/shared.mjs

@@ -0,0 +1,213 @@
+export const emptyTokens = () => ({
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheCreation: 0,
+});
+export const emptyFacts = () => ({
+    userPrompts: 0,
+    assistantResponses: 0,
+    toolCalls: 0,
+    failedToolCalls: 0,
+    noMistakesInvocations: 0,
+    advisorCalls: 0,
+    pushCommandAttempts: 0,
+    compactions: 0,
+    tokens: emptyTokens(),
+    subagentToolCalls: 0,
+    subagentTokens: emptyTokens(),
+});
+export function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export const asNumber = (value) => typeof value === 'number' && Number.isFinite(value) ? value : 0;
+export function parseLines(lines) {
+    const records = [];
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const record = asRecord(JSON.parse(line));
+            if (record)
+                records.push(record);
+        }
+        catch {
+            // Keep valid records before a partially written final line.
+        }
+    }
+    return records;
+}
+export function hasMalformedInteriorRecord(lines) {
+    const nonblank = lines.filter((line) => line.trim());
+    const complete = lines.at(-1)?.trim() ? nonblank.slice(0, -1) : nonblank;
+    return complete.some((line) => {
+        try {
+            return !asRecord(JSON.parse(line));
+        }
+        catch {
+            return true;
+        }
+    });
+}
+function hereDocs(tokens) {
+    return tokens.flatMap((token, index) => {
+        if (token.startsWith('<<<'))
+            return [];
+        const match = token.match(/^<<(-?)(.*)$/);
+        const delimiter = match?.[2] || (match ? tokens[index + 1] : undefined);
+        return delimiter ? [{ delimiter, stripTabs: match?.[1] === '-' }] : [];
+    });
+}
+function segments(command) {
+    const result = [];
+    let segment = [];
+    let word = '';
+    let quote;
+    let escaped = false, comment = false;
+    const pending = [];
+    let hereDocLine = '';
+    const flush = () => {
+        if (word)
+            segment.push(word);
+        word = '';
+    };
+    const end = (newline = false) => {
+        flush();
+        if (newline)
+            pending.push(...hereDocs(segment));
+        if (segment.length)
+            result.push(segment);
+        segment = [];
+    };
+    for (let index = 0; index < command.length; index++) {
+        const char = command[index];
+        const next = command[index + 1] ?? '';
+        const canEscape = quote === '"' ? /[\\"$`\n]/.test(next) : quote === undefined && /[\\'";#&|\n]/.test(next);
+        if (pending.length) {
+            if (char === '\n') {
+                const current = pending[0];
+                const line = current.stripTabs ? hereDocLine.replace(/^\t+/, '') : hereDocLine;
+                if (line === current.delimiter)
+                    pending.shift();
+                hereDocLine = '';
+            }
+            else
+                hereDocLine += char;
+        }
+        else if (comment) {
+            if (char === '\n') {
+                comment = false;
+                end(true);
+            }
+        }
+        else if (quote === "'") {
+            if (char === quote)
+                quote = undefined;
+            else
+                word += char;
+        }
+        else if (escaped) {
+            if (char !== '\n')
+                word += char;
+            escaped = false;
+        }
+        else if (char === '\\' && next !== '' && canEscape)
+            escaped = true;
+        else if (char === '\\')
+            word += char;
+        else if (quote) {
+            if (char === quote)
+                quote = undefined;
+            else
+                word += char;
+        }
+        else if (char === '"' || char === "'")
+            quote = char;
+        else if (char === '#' && !word)
+            comment = true;
+        else if (char === ';' || char === '&' || char === '|' || char === '\n')
+            end(char === '\n');
+        else if (/\s/.test(char))
+            flush();
+        else
+            word += char;
+    }
+    if (!quote)
+        end();
+    return result;
+}
+function commandAfterAssignments(segment) {
+    const index = segment.findIndex((token) => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(token));
+    let tokens = index === -1 ? [] : segment.slice(index);
+    while (/(^|[\\/])env(?:\.exe)?$/i.test(tokens[0] ?? '')) {
+        let next = 1, options = true;
+        while (next < tokens.length) {
+            const token = tokens[next];
+            if (token === '--') {
+                options = false;
+                next++;
+            }
+            else if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(token))
+                next++;
+            else if (options &&
+                ['-u', '--unset', '-C', '--chdir', '-S', '--split-string'].includes(token))
+                next += 2;
+            else if (options && token.startsWith('-'))
+                next++;
+            else
+                break;
+        }
+        tokens = tokens.slice(next);
+    }
+    return tokens;
+}
+const NO_MISTAKES = /(^|[\\/])no-mistakes(?:\.(?:cmd|exe|bat))?$/i;
+function containsNoMistakesTarget(tokens) {
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token === '--')
+            continue;
+        if (token === '-c' || token === '--call')
+            return segments(tokens[index + 1] ?? '').some(isNoMistakes);
+        if (token === '--package' || token === '-p') {
+            index++;
+            continue;
+        }
+        if (token.startsWith('-'))
+            continue;
+        return NO_MISTAKES.test(token);
+    }
+    return false;
+}
+function isNoMistakes(segment) {
+    const tokens = commandAfterAssignments(segment);
+    const [command, second] = tokens;
+    if (NO_MISTAKES.test(command ?? ''))
+        return true;
+    if (!['npm', 'npx', 'pnpm', 'pnpx', 'yarn'].includes(command ?? ''))
+        return false;
+    const offset = second === 'run' || second === 'exec' || second === 'dlx' ? 2 : 1;
+    return containsNoMistakesTarget(tokens.slice(offset));
+}
+function isPush(segment) {
+    const tokens = commandAfterAssignments(segment);
+    if (!/(^|[\\/])git(?:\.exe)?$/i.test(tokens[0] ?? ''))
+        return false;
+    for (let index = 1; index < tokens.length; index++) {
+        if (['-C', '-c', '--git-dir', '--work-tree'].includes(tokens[index]))
+            index++;
+        else if (!tokens[index]?.startsWith('-'))
+            return tokens[index] === 'push';
+    }
+    return false;
+}
+export function applyCommand(command, facts) {
+    for (const segment of segments(command)) {
+        if (isNoMistakes(segment))
+            facts.noMistakesInvocations++;
+        if (isPush(segment))
+            facts.pushCommandAttempts++;
+    }
+}

package/dist/vitest-diagnostics/directory.d.mts

@@ -0,0 +1,12 @@
+export declare const HARD_MAX_DIAGNOSTIC_DIRECTORY_ENTRIES = 10000;
+interface DirectoryIdentity {
+    dev: number;
+    ino: number;
+}
+export interface DiagnosticReportDirectory {
+    filenames: string[];
+    identity: DirectoryIdentity;
+}
+export declare function isDiagnosticReportDirectoryCurrent(directory: string, identity: DirectoryIdentity): boolean;
+export declare function readDiagnosticReportDirectory(directory: string): DiagnosticReportDirectory | undefined;
+export {};

package/dist/vitest-diagnostics/directory.mjs

@@ -0,0 +1,44 @@
+import { lstatSync, opendirSync } from 'node:fs';
+export const HARD_MAX_DIAGNOSTIC_DIRECTORY_ENTRIES = 10_000;
+function directoryIdentity(directory) {
+    const stats = lstatSync(directory);
+    return stats.isDirectory() ? { dev: stats.dev, ino: stats.ino } : undefined;
+}
+export function isDiagnosticReportDirectoryCurrent(directory, identity) {
+    try {
+        const current = directoryIdentity(directory);
+        return current?.dev === identity.dev && current.ino === identity.ino;
+    }
+    catch {
+        return false;
+    }
+}
+export function readDiagnosticReportDirectory(directory) {
+    try {
+        const identity = directoryIdentity(directory);
+        if (identity === undefined)
+            return undefined;
+        const filenames = [];
+        const handle = opendirSync(directory);
+        try {
+            for (let scanned = 0;; scanned += 1) {
+                const entry = handle.readSync();
+                if (entry === null)
+                    break;
+                if (scanned >= HARD_MAX_DIAGNOSTIC_DIRECTORY_ENTRIES)
+                    return undefined;
+                if (entry.name.endsWith('.json'))
+                    filenames.push(entry.name);
+            }
+        }
+        finally {
+            handle.closeSync();
+        }
+        if (!isDiagnosticReportDirectoryCurrent(directory, identity))
+            return undefined;
+        return { filenames, identity };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/vitest-diagnostics/index.d.mts

@@ -0,0 +1,22 @@
+export { MAX_DIAGNOSTIC_REPORT_BYTES } from './read-file.mts';
+export declare const DEFAULT_MAX_DIAGNOSTIC_REPORTS = 100;
+export declare const DEFAULT_MAX_FORMATTED_DIAGNOSTIC_REPORTS = 20;
+export declare const HARD_MAX_DIAGNOSTIC_REPORTS = 100;
+export { HARD_MAX_DIAGNOSTIC_DIRECTORY_ENTRIES } from './directory.mts';
+export interface DiagnosticReportSummary {
+    file: string;
+    trigger: string;
+    event: string;
+    threadId: number | null;
+    heapUsedMB: string;
+    heapTotalMB: string;
+    heapLimitMB: string;
+    maxRssMB: string;
+    topNativeFrameModule: string | null;
+}
+export interface DiagnosticReportLimitOptions {
+    maxReports?: number;
+}
+export declare function summarizeDiagnosticReport(file: string, report: unknown): DiagnosticReportSummary;
+export declare function readDiagnosticReportSummaries(directory: string, options?: DiagnosticReportLimitOptions): DiagnosticReportSummary[];
+export declare function formatDiagnosticReportSummaries(summaries: readonly unknown[], options?: DiagnosticReportLimitOptions): string;

package/dist/vitest-diagnostics/index.mjs

@@ -0,0 +1,123 @@
+import { join, posix, win32 } from 'node:path';
+import { isDiagnosticReportDirectoryCurrent, readDiagnosticReportDirectory } from './directory.mjs';
+import { readBoundedRegularFile } from './read-file.mjs';
+export { MAX_DIAGNOSTIC_REPORT_BYTES } from './read-file.mjs';
+export const DEFAULT_MAX_DIAGNOSTIC_REPORTS = 100;
+export const DEFAULT_MAX_FORMATTED_DIAGNOSTIC_REPORTS = 20;
+export const HARD_MAX_DIAGNOSTIC_REPORTS = 100;
+export { HARD_MAX_DIAGNOSTIC_DIRECTORY_ENTRIES } from './directory.mjs';
+const TEXT_LIMIT = 200;
+const PATH_LIMIT = 240;
+function objectValue(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+function boundedText(value, fallback, limit) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value
+        .slice(0, limit * 4)
+        .replace(/[\p{Cc}\p{Cf}]/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return normalized.length === 0 ? fallback : normalized.slice(0, limit);
+}
+function formatMebibytes(value) {
+    const bytes = typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : 0;
+    return (bytes / 1024 / 1024).toFixed(1);
+}
+function threadId(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function nativeModulePath(value) {
+    const module = boundedText(value, '', PATH_LIMIT);
+    return posix.isAbsolute(module) || win32.isAbsolute(module) ? module : null;
+}
+function topNativeFrameModule(value) {
+    if (!Array.isArray(value))
+        return null;
+    const symbol = objectValue(value[0]).symbol;
+    if (typeof symbol !== 'string')
+        return null;
+    const tail = symbol.slice(-PATH_LIMIT * 2).trimEnd();
+    if (!tail.endsWith(']'))
+        return null;
+    const opening = tail.lastIndexOf('[');
+    if (opening < 0)
+        return null;
+    return nativeModulePath(tail.slice(opening + 1, -1));
+}
+function reportLimit(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isFinite(value))
+        return fallback;
+    return Math.min(Math.max(Math.floor(value), 0), HARD_MAX_DIAGNOSTIC_REPORTS);
+}
+export function summarizeDiagnosticReport(file, report) {
+    const root = objectValue(report);
+    const header = objectValue(root.header);
+    const heap = objectValue(root.javascriptHeap);
+    const resourceUsage = objectValue(root.resourceUsage);
+    return {
+        file: boundedText(file, 'unknown', PATH_LIMIT),
+        trigger: boundedText(header.trigger, 'unknown', TEXT_LIMIT),
+        event: boundedText(header.event, 'unknown', TEXT_LIMIT),
+        threadId: threadId(header.threadId),
+        heapUsedMB: formatMebibytes(heap.usedMemory),
+        heapTotalMB: formatMebibytes(heap.totalMemory),
+        heapLimitMB: formatMebibytes(heap.memoryLimit),
+        maxRssMB: formatMebibytes(resourceUsage.maxRss),
+        topNativeFrameModule: topNativeFrameModule(root.nativeStack),
+    };
+}
+export function readDiagnosticReportSummaries(directory, options = {}) {
+    const maxReports = reportLimit(options.maxReports, DEFAULT_MAX_DIAGNOSTIC_REPORTS);
+    if (maxReports === 0)
+        return [];
+    const reportsDirectory = readDiagnosticReportDirectory(directory);
+    if (reportsDirectory === undefined)
+        return [];
+    const filenames = reportsDirectory.filenames.sort();
+    const selected = filenames.slice(-maxReports);
+    const summaries = [];
+    for (const filename of selected) {
+        try {
+            if (!isDiagnosticReportDirectoryCurrent(directory, reportsDirectory.identity))
+                return [];
+            const contents = readBoundedRegularFile(join(directory, filename));
+            if (!isDiagnosticReportDirectoryCurrent(directory, reportsDirectory.identity))
+                return [];
+            if (contents === undefined)
+                continue;
+            const report = JSON.parse(contents);
+            summaries.push(summarizeDiagnosticReport(filename, report));
+        }
+        catch {
+            // Node can leave a partial report if the process exits while writing it.
+        }
+    }
+    return summaries;
+}
+export function formatDiagnosticReportSummaries(summaries, options = {}) {
+    const maxReports = reportLimit(options.maxReports, DEFAULT_MAX_FORMATTED_DIAGNOSTIC_REPORTS);
+    const lines = ['[vitest-diagnostics]', `reports provided: ${summaries.length}`];
+    if (summaries.length === 0)
+        lines.push('  (none recorded)');
+    for (const value of summaries.slice(0, maxReports)) {
+        const summary = objectValue(value);
+        lines.push(`  - file=${boundedText(summary.file, 'unknown', PATH_LIMIT)} ` +
+            `trigger=${boundedText(summary.trigger, 'unknown', TEXT_LIMIT)} ` +
+            `event=${boundedText(summary.event, 'unknown', TEXT_LIMIT)} ` +
+            `threadId=${threadId(summary.threadId) ?? 'unknown'} ` +
+            `heapUsedMB=${boundedText(summary.heapUsedMB, '0.0', TEXT_LIMIT)} ` +
+            `heapTotalMB=${boundedText(summary.heapTotalMB, '0.0', TEXT_LIMIT)} ` +
+            `heapLimitMB=${boundedText(summary.heapLimitMB, '0.0', TEXT_LIMIT)} ` +
+            `maxRssMB=${boundedText(summary.maxRssMB, '0.0', TEXT_LIMIT)} ` +
+            `topNativeFrameModule=${nativeModulePath(summary.topNativeFrameModule) ?? 'none'}`);
+    }
+    if (summaries.length > maxReports)
+        lines.push(`  ... ${summaries.length - maxReports} more`);
+    return `${lines.join('\n')}\n`;
+}

package/dist/vitest-diagnostics/read-file.d.mts

@@ -0,0 +1,2 @@
+export declare const MAX_DIAGNOSTIC_REPORT_BYTES: number;
+export declare function readBoundedRegularFile(path: string): string | undefined;

package/dist/vitest-diagnostics/read-file.mjs

@@ -0,0 +1,37 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync } from 'node:fs';
+export const MAX_DIAGNOSTIC_REPORT_BYTES = 5 * 1024 * 1024;
+export function readBoundedRegularFile(path) {
+    const entryStats = lstatSync(path);
+    if (!entryStats.isFile() || entryStats.isSymbolicLink())
+        return undefined;
+    const descriptor = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+    try {
+        const stats = fstatSync(descriptor);
+        const currentEntryStats = lstatSync(path);
+        if (!stats.isFile() ||
+            currentEntryStats.isSymbolicLink() ||
+            !currentEntryStats.isFile() ||
+            currentEntryStats.dev !== stats.dev ||
+            currentEntryStats.ino !== stats.ino ||
+            stats.size > MAX_DIAGNOSTIC_REPORT_BYTES)
+            return undefined;
+        const chunks = [];
+        let length = 0;
+        while (length <= MAX_DIAGNOSTIC_REPORT_BYTES) {
+            const remaining = MAX_DIAGNOSTIC_REPORT_BYTES + 1 - length;
+            const expected = length < stats.size ? stats.size - length : length === stats.size ? 1 : 65_536;
+            const bytes = Buffer.allocUnsafe(Math.min(expected, remaining, 65_536));
+            const read = readSync(descriptor, bytes, 0, bytes.length, null);
+            if (read === 0)
+                break;
+            chunks.push(bytes.subarray(0, read));
+            length += read;
+        }
+        return length > MAX_DIAGNOSTIC_REPORT_BYTES
+            ? undefined
+            : Buffer.concat(chunks, length).toString('utf8');
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.0.21",
+  "version": "0.1.0",
   "description": "Vouchington CLI and extractable tooling libraries.",
   "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
   "bugs": {
@@ -35,6 +35,11 @@
       "import": "./dist/runner-port-policy/index.mjs",
       "default": "./dist/runner-port-policy/index.mjs"
     },
+    "./retrospective-transcript": {
+      "types": "./dist/retrospective-transcript/index.d.mts",
+      "import": "./dist/retrospective-transcript/index.mjs",
+      "default": "./dist/retrospective-transcript/index.mjs"
+    },
     "./sql-ast": {
       "types": "./dist/sql-ast/index.d.mts",
       "import": "./dist/sql-ast/index.mjs",
@@ -90,6 +95,11 @@
       "import": "./dist/process-line-buffer/index.mjs",
       "default": "./dist/process-line-buffer/index.mjs"
     },
+    "./browser-session-runner": {
+      "types": "./dist/browser-session-runner/index.d.mts",
+      "import": "./dist/browser-session-runner/index.mjs",
+      "default": "./dist/browser-session-runner/index.mjs"
+    },
     "./pg-schema-snapshot": {
       "types": "./dist/pg-schema-snapshot/index.d.mts",
       "import": "./dist/pg-schema-snapshot/index.mjs",
@@ -195,6 +205,11 @@
       "import": "./dist/swift-resolved-pin-delta/index.mjs",
       "default": "./dist/swift-resolved-pin-delta/index.mjs"
     },
+    "./vitest-diagnostics": {
+      "types": "./dist/vitest-diagnostics/index.d.mts",
+      "import": "./dist/vitest-diagnostics/index.mjs",
+      "default": "./dist/vitest-diagnostics/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {