@contentful/experience-design-system-cli 2.26.1-dev-build-a852362.0 → 2.26.1-dev-build-f03f014.0

package/dist/src/runs/staleness.js

@@ -1,140 +0,0 @@
-import { readFile, stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { sha256Hex } from './fingerprint.js';
-const UNKNOWN = {
-    stale: false,
-    staleComponents: [],
-    staleTokens: false,
-    savedComponentsEdited: false,
-    savedTokensEdited: false,
-    missingSourceFiles: [],
-};
-/**
- * Re-stat the source files and re-hash the saved artifacts captured by a
- * run record's fingerprints, and report what (if anything) drifted.
- *
- * Returns `stale: false` when the run is missing a source fingerprint
- * entirely (v2 records pre-dating runs.json v3 — treat as UNKNOWN, not
- * stale, so existing runs keep replaying).
- */
-export async function checkRunStaleness(run) {
-    if (!run.sourceFingerprint)
-        return { ...UNKNOWN };
-    const result = {
-        stale: false,
-        staleComponents: [],
-        staleTokens: false,
-        savedComponentsEdited: false,
-        savedTokensEdited: false,
-        missingSourceFiles: [],
-    };
-    // ── Per-file source check ────────────────────────────────────────────
-    for (const [absPath, entry] of Object.entries(run.sourceFingerprint.files)) {
-        try {
-            const st = await stat(absPath);
-            if (st.mtime.toISOString() !== entry.mtime) {
-                result.staleComponents.push(entry.componentName ?? absPath);
-                result.stale = true;
-            }
-        }
-        catch {
-            result.missingSourceFiles.push(absPath);
-            result.stale = true;
-        }
-    }
-    // ── Raw tokens (single file: re-stat AND re-hash) ────────────────────
-    if (run.sourceFingerprint.rawTokensPath) {
-        const absPath = run.sourceFingerprint.rawTokensPath;
-        try {
-            const [st, buf] = await Promise.all([stat(absPath), readFile(absPath)]);
-            const mtime = st.mtime.toISOString();
-            const hash = sha256Hex(buf);
-            const mtimeChanged = run.sourceFingerprint.rawTokensMtime !== null && mtime !== run.sourceFingerprint.rawTokensMtime;
-            const hashChanged = run.sourceFingerprint.rawTokensContentHash !== null && hash !== run.sourceFingerprint.rawTokensContentHash;
-            if (mtimeChanged || hashChanged) {
-                result.staleTokens = true;
-                result.stale = true;
-            }
-        }
-        catch {
-            result.staleTokens = true;
-            result.stale = true;
-        }
-    }
-    // ── Saved-file check (read & hash components.json / tokens.json) ─────
-    if (run.savedFingerprint) {
-        if (run.savedFingerprint.componentsJsonHash !== null) {
-            const compPath = join(run.savePath, 'components.json');
-            try {
-                const buf = await readFile(compPath);
-                if (sha256Hex(buf) !== run.savedFingerprint.componentsJsonHash) {
-                    result.savedComponentsEdited = true;
-                    result.stale = true;
-                }
-            }
-            catch {
-                result.savedComponentsEdited = true;
-                result.stale = true;
-            }
-        }
-        if (run.savedFingerprint.tokensJsonHash !== null) {
-            const tokensPath = run.tokensPath ?? join(run.savePath, 'tokens.json');
-            try {
-                const buf = await readFile(tokensPath);
-                if (sha256Hex(buf) !== run.savedFingerprint.tokensJsonHash) {
-                    result.savedTokensEdited = true;
-                    result.stale = true;
-                }
-            }
-            catch {
-                result.savedTokensEdited = true;
-                result.stale = true;
-            }
-        }
-    }
-    return result;
-}
-/**
- * Render a short human-readable summary of a Staleness result, e.g.
- * `src: 3, tokens, saved`. Returns the empty string when not stale.
- */
-export function shortStalenessSummary(s) {
-    if (!s.stale)
-        return '';
-    const parts = [];
-    const srcCount = s.staleComponents.length + s.missingSourceFiles.length;
-    if (srcCount > 0)
-        parts.push(`src: ${srcCount}`);
-    if (s.staleTokens)
-        parts.push('tokens');
-    if (s.savedComponentsEdited || s.savedTokensEdited)
-        parts.push('saved');
-    return parts.join(', ');
-}
-/**
- * Render a multi-line detail block for staleness output (used by `runs <id>`
- * detail view and replay refusals). Caps long lists at 5 entries.
- */
-export function formatStalenessDetail(s) {
-    if (!s.stale)
-        return ['Status: FRESH'];
-    const lines = ['Status: STALE'];
-    const cap = 5;
-    if (s.staleComponents.length > 0) {
-        const head = s.staleComponents.slice(0, cap).join(', ');
-        const more = s.staleComponents.length > cap ? ` and ${s.staleComponents.length - cap} more` : '';
-        lines.push(`  Source changed: ${head}${more}`);
-    }
-    if (s.missingSourceFiles.length > 0) {
-        const head = s.missingSourceFiles.slice(0, cap).join(', ');
-        const more = s.missingSourceFiles.length > cap ? ` and ${s.missingSourceFiles.length - cap} more` : '';
-        lines.push(`  Source missing: ${head}${more}`);
-    }
-    if (s.staleTokens)
-        lines.push('  Raw tokens drifted');
-    if (s.savedComponentsEdited)
-        lines.push('  Saved components.json edited');
-    if (s.savedTokensEdited)
-        lines.push('  Saved tokens.json edited');
-    return lines;
-}

package/dist/src/runs/store.js

@@ -1,136 +0,0 @@
-import { readFile, writeFile, mkdir, rename } from 'node:fs/promises';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { randomBytes } from 'node:crypto';
-export const RUNS_FILE_VERSION = 3;
-export const RUNS_FILE_CAP = 200;
-/** Versions this CLI can read. v1 / v2 files are auto-migrated in memory;
- *  new writes always use the latest version. */
-export const READABLE_VERSIONS = new Set([1, 2, 3]);
-const RUNS_DIR = join(homedir(), '.config', 'experiences');
-const RUNS_PATH = join(RUNS_DIR, 'runs.json');
-export function runsFilePath() {
-    return RUNS_PATH;
-}
-// Crockford-base32 ULID (26 chars: 10 timestamp + 16 random).
-const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
-function encodeBase32(bytes, length) {
-    let out = '';
-    let bits = 0;
-    let value = 0;
-    for (const b of bytes) {
-        value = (value << 8) | b;
-        bits += 8;
-        while (bits >= 5) {
-            bits -= 5;
-            out += CROCKFORD[(value >> bits) & 0x1f];
-        }
-    }
-    if (bits > 0)
-        out += CROCKFORD[(value << (5 - bits)) & 0x1f];
-    return out.slice(0, length);
-}
-export function generateUlid(now = Date.now()) {
-    // 48-bit timestamp -> 10 chars
-    const tsBytes = new Uint8Array(6);
-    let n = now;
-    for (let i = 5; i >= 0; i--) {
-        tsBytes[i] = n & 0xff;
-        n = Math.floor(n / 256);
-    }
-    const ts = encodeBase32(tsBytes, 10);
-    const rand = encodeBase32(randomBytes(10), 16);
-    return (ts + rand).toUpperCase();
-}
-function migrateRecord(rec) {
-    return {
-        ...rec,
-        tokensPath: rec.tokensPath ?? null,
-        tokenSessionId: rec.tokenSessionId ?? null,
-        sourceFingerprint: rec.sourceFingerprint ?? null,
-        savedFingerprint: rec.savedFingerprint ?? null,
-    };
-}
-async function readFileMaybe() {
-    try {
-        const raw = await readFile(RUNS_PATH, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (!READABLE_VERSIONS.has(parsed.version)) {
-            throw new Error(`runs.json version mismatch: file is v${parsed.version}, this CLI expects v${RUNS_FILE_VERSION} (also reads: ${[...READABLE_VERSIONS].join(', ')}). Back up and remove the file to start fresh.`);
-        }
-        // Always migrate to current schema in memory; new writes will persist v2.
-        const runs = parsed.runs.map(migrateRecord);
-        return { version: RUNS_FILE_VERSION, runs };
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === 'ENOENT')
-            return null;
-        throw err;
-    }
-}
-async function writeAtomic(file) {
-    await mkdir(RUNS_DIR, { recursive: true });
-    const body = JSON.stringify(file, null, 2) + '\n';
-    const tmp = `${RUNS_PATH}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile(tmp, body, { mode: 0o600 });
-    await rename(tmp, RUNS_PATH);
-}
-export async function appendRun(input) {
-    const existing = await readFileMaybe();
-    const record = {
-        ...input,
-        id: input.id ?? generateUlid(),
-        createdAt: input.createdAt ?? new Date().toISOString(),
-        sourceFingerprint: input.sourceFingerprint ?? null,
-        savedFingerprint: input.savedFingerprint ?? null,
-    };
-    const runs = existing ? [record, ...existing.runs] : [record];
-    if (runs.length > RUNS_FILE_CAP) {
-        const dropped = runs.length - RUNS_FILE_CAP;
-        runs.length = RUNS_FILE_CAP;
-        console.warn(`runs.json reached cap of ${RUNS_FILE_CAP}; dropped ${dropped} oldest entr${dropped === 1 ? 'y' : 'ies'}.`);
-    }
-    await writeAtomic({ version: RUNS_FILE_VERSION, runs });
-    return record;
-}
-export async function listRuns(opts = {}) {
-    const file = await readFileMaybe();
-    if (!file)
-        return [];
-    let runs = file.runs;
-    if (opts.projectPath)
-        runs = runs.filter((r) => r.projectPath === opts.projectPath);
-    if (opts.before)
-        runs = runs.filter((r) => r.createdAt < opts.before);
-    if (opts.after)
-        runs = runs.filter((r) => r.createdAt > opts.after);
-    if (typeof opts.limit === 'number')
-        runs = runs.slice(0, opts.limit);
-    return runs;
-}
-export async function getRun(id) {
-    const file = await readFileMaybe();
-    const found = file?.runs.find((r) => r.id === id);
-    if (!found)
-        throw new Error(`Run ${id} not found in ${RUNS_PATH}`);
-    return found;
-}
-export async function updateRun(id, patch) {
-    const file = (await readFileMaybe()) ?? { version: RUNS_FILE_VERSION, runs: [] };
-    const idx = file.runs.findIndex((r) => r.id === id);
-    if (idx < 0)
-        throw new Error(`Run ${id} not found in ${RUNS_PATH}`);
-    const updated = { ...file.runs[idx], ...patch, id };
-    file.runs[idx] = updated;
-    await writeAtomic(file);
-    return updated;
-}
-export async function findRunBySavePath(savePath) {
-    const file = await readFileMaybe();
-    return file?.runs.find((r) => r.savePath === savePath) ?? null;
-}
-export async function findAllRunsBySavePath(savePath) {
-    const file = await readFileMaybe();
-    return file?.runs.filter((r) => r.savePath === savePath) ?? [];
-}

package/dist/src/session/cache-keys.js

@@ -1,44 +0,0 @@
-/**
- * Hash helpers for the fine-grained LLM cache.
- *
- * Three layers of cache (extract, select, generate) all need stable content
- * hashes for cache-key derivation. Keep these primitives in one place so the
- * algorithm and encoding never drift between callers.
- *
- * All hashes are sha256 hex (64 chars). No npm deps — uses node:crypto.
- */
-import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { resolveSkillPath } from '@contentful/experience-design-system-generation';
-/** sha256 hex of a string. Stable across runs. */
-export function hashContent(content) {
-    return createHash('sha256').update(content).digest('hex');
-}
-/** sha256 hex of a file's UTF-8 content. */
-export async function hashFile(filePath) {
-    const content = await readFile(filePath, 'utf8');
-    return hashContent(content);
-}
-/**
- * Hash the prompt content for a skill — either the bundled skill file shipped
- * with the CLI, or a custom override path. Used to key the select_cache and
- * generation_cache so cache entries invalidate when the prompt itself changes
- * (including bundled-skill updates across CLI versions).
- *
- * Also folds in the resolved agent and model: a cache hit must not stand in
- * for an agent run that was never made with the currently requested
- * agent/model, or `--agent`/`--model` overrides would appear to be ignored
- * whenever a prior cache entry already exists for the same input/prompt.
- *
- * @param skill — which skill (matches resolveSkillPath in prompt-builder)
- * @param agent — resolved agent name for this run
- * @param model — resolved model for this run (undefined resolves to the agent's default)
- * @param skillPathOverride — optional absolute/relative path to a custom prompt
- */
-export async function hashPromptForSkill(skill, agent, model, skillPathOverride) {
-    const promptHash = skillPathOverride
-        ? await hashFile(resolve(skillPathOverride))
-        : await hashFile(resolveSkillPath(skill));
-    return hashContent(`${promptHash}|${agent}|${model ?? ''}`);
-}

package/dist/src/session/command.js

@@ -1,261 +0,0 @@
-import { openPipelineDb, getPipelineDbPath } from './db.js';
-import { getStats, formatStatsText } from './stats.js';
-import { runMigrationIfNeeded } from './migration.js';
-function parseDuration(str) {
-    const m = /^(\d+)([dwmy])$/.exec(str);
-    if (!m)
-        return null;
-    const n = parseInt(m[1], 10);
-    const unit = m[2];
-    const days = unit === 'd' ? n : unit === 'w' ? n * 7 : unit === 'm' ? n * 30 : n * 365;
-    return days * 24 * 60 * 60 * 1000;
-}
-function formatDate(iso) {
-    return iso.replace('T', ' ').slice(0, 16);
-}
-export function registerSessionCommand(program) {
-    const session = program.command('session').description('Manage pipeline sessions');
-    // session list
-    session
-        .command('list')
-        .description('List all pipeline sessions')
-        .option('--status <status>', 'Filter by status: in-progress, complete, failed, interrupted')
-        .option('--all', 'Include interrupted sessions (hidden by default)')
-        .option('--limit <n>', 'Max rows to return', '20')
-        .option('--json', 'Force JSON output')
-        .action((opts) => {
-        const dbPath = getPipelineDbPath();
-        const db = openPipelineDb(dbPath);
-        runMigrationIfNeeded(db);
-        const limit = parseInt(opts.limit, 10) || 20;
-        const rows = db
-            .prepare(`SELECT s.id, s.name, s.updated_at,
-                  COUNT(st.id) AS step_count,
-                  (SELECT command FROM steps WHERE session_id = s.id ORDER BY started_at DESC, id DESC LIMIT 1) AS last_step,
-                  (SELECT status  FROM steps WHERE session_id = s.id ORDER BY started_at DESC, id DESC LIMIT 1) AS last_status
-           FROM sessions s
-           LEFT JOIN steps st ON st.session_id = s.id
-           GROUP BY s.id
-           ORDER BY s.updated_at DESC
-           LIMIT ?`)
-            .all(limit);
-        let filtered = rows;
-        if (opts.status) {
-            const filterStatus = opts.status === 'in-progress' ? 'pending' : opts.status;
-            filtered = rows.filter((r) => r.last_status === filterStatus || (!r.last_status && opts.status === 'in-progress'));
-        }
-        else if (!opts.all) {
-            // Hide interrupted sessions by default — they're typically migration artifacts
-            filtered = rows.filter((r) => r.last_status !== 'interrupted');
-        }
-        db.close();
-        if (opts.json) {
-            process.stdout.write(JSON.stringify(filtered.map((r) => ({
-                id: r.id,
-                name: r.name,
-                status: r.last_status ?? null,
-                stepCount: r.step_count,
-                lastStep: r.last_step,
-                updatedAt: r.updated_at,
-            })), null, 2) + '\n');
-            return;
-        }
-        if (filtered.length === 0) {
-            process.stdout.write('No sessions found.\n');
-            return;
-        }
-        const header = 'ID                    Name                Steps  Status       Last Step             Updated';
-        process.stdout.write(header + '\n');
-        process.stdout.write('─'.repeat(header.length) + '\n');
-        for (const r of filtered) {
-            const id = r.id.padEnd(22);
-            const name = (r.name ?? '(none)').slice(0, 18).padEnd(20);
-            const steps = String(r.step_count).padStart(5);
-            const status = (r.last_status ?? '—').padEnd(13);
-            const lastStep = (r.last_step ?? '—').padEnd(22);
-            const updated = formatDate(r.updated_at);
-            process.stdout.write(`${id}${name}${steps}  ${status}${lastStep}${updated}\n`);
-        }
-    });
-    // session show
-    session
-        .command('show <id>')
-        .description('Show all steps for a session')
-        .option('--json', 'Force JSON output')
-        .action((id, opts) => {
-        const dbPath = getPipelineDbPath();
-        const db = openPipelineDb(dbPath);
-        runMigrationIfNeeded(db);
-        const sess = db.prepare('SELECT id, name, created_at, updated_at FROM sessions WHERE id = ?').get(id);
-        if (!sess) {
-            db.close();
-            process.stderr.write(`Error: session '${id}' not found.\n`);
-            process.exit(1);
-        }
-        const steps = db
-            .prepare(`SELECT id, command, status, started_at, completed_at, inputs, outputs, error
-           FROM steps WHERE session_id = ? ORDER BY started_at ASC, id ASC`)
-            .all(id);
-        db.close();
-        if (opts.json) {
-            process.stdout.write(JSON.stringify({
-                id: sess.id,
-                name: sess.name,
-                createdAt: sess.created_at,
-                updatedAt: sess.updated_at,
-                steps: steps.map((s, i) => ({
-                    number: i + 1,
-                    command: s.command,
-                    status: s.status,
-                    startedAt: s.started_at,
-                    completedAt: s.completed_at,
-                    inputs: JSON.parse(s.inputs),
-                    outputs: JSON.parse(s.outputs),
-                    error: s.error,
-                })),
-            }, null, 2) + '\n');
-            return;
-        }
-        process.stdout.write(`Session: ${sess.id}\n`);
-        process.stdout.write(`Name:    ${sess.name ?? '(none)'}\n`);
-        process.stdout.write(`Created: ${formatDate(sess.created_at)}\n`);
-        process.stdout.write(`Updated: ${formatDate(sess.updated_at)}\n`);
-        process.stdout.write(`\nSteps\n${'─'.repeat(60)}\n`);
-        for (const [i, s] of steps.entries()) {
-            const num = String(i + 1).padStart(3);
-            const cmd = s.command.padEnd(20);
-            const stat = s.status.padEnd(12);
-            const timing = s.completed_at
-                ? `${s.started_at.slice(11, 16)} → ${s.completed_at.slice(11, 16)}`
-                : `${s.started_at.slice(11, 16)} → …`;
-            let inputs = {};
-            let outputs = {};
-            try {
-                inputs = JSON.parse(s.inputs);
-                outputs = JSON.parse(s.outputs);
-            }
-            catch {
-                // ignore
-            }
-            const inputStr = Object.values(inputs).join(', ');
-            const outputStr = Object.values(outputs).join(', ');
-            const paths = [inputStr, outputStr].filter(Boolean).join(' → ');
-            process.stdout.write(`${num}  ${cmd}${stat}${timing}  ${paths}\n`);
-            if (s.error) {
-                process.stdout.write(`     Error: ${s.error}\n`);
-            }
-        }
-    });
-    // session stats
-    session
-        .command('stats')
-        .description('Show aggregate storage and record counts')
-        .option('--json', 'Force JSON output')
-        .action((opts) => {
-        const dbPath = getPipelineDbPath();
-        const db = openPipelineDb(dbPath);
-        runMigrationIfNeeded(db);
-        const stats = getStats(db, dbPath);
-        db.close();
-        if (opts.json) {
-            process.stdout.write(JSON.stringify(stats, null, 2) + '\n');
-            return;
-        }
-        process.stdout.write(formatStatsText(stats) + '\n');
-    });
-    // session prune
-    session
-        .command('prune')
-        .description('Delete sessions matching criteria')
-        .option('--id <id>', 'Delete a specific session by ID')
-        .option('--older-than <duration>', 'Delete sessions older than this age (e.g. 30d, 2w, 1y)')
-        .option('--status <status>', 'Delete sessions by last step status: complete, failed, interrupted')
-        .option('--yes', 'Skip confirmation prompt')
-        .option('--dry-run', 'Print what would be deleted without deleting')
-        .action(async (opts) => {
-        if (!opts.id && !opts.olderThan && !opts.status) {
-            process.stderr.write('Error: at least one of --id, --older-than, or --status is required\n');
-            process.exit(1);
-        }
-        const dbPath = getPipelineDbPath();
-        const db = openPipelineDb(dbPath);
-        runMigrationIfNeeded(db);
-        // Build the list of sessions to delete
-        let candidates;
-        if (opts.id) {
-            const sess = db.prepare('SELECT id, updated_at FROM sessions WHERE id = ?').get(opts.id);
-            if (!sess) {
-                db.close();
-                process.stderr.write(`Error: session '${opts.id}' not found.\n`);
-                process.exit(1);
-            }
-            candidates = [sess];
-        }
-        else {
-            candidates = db.prepare('SELECT id, updated_at FROM sessions ORDER BY updated_at DESC').all();
-        }
-        if (opts.olderThan) {
-            const ms = parseDuration(opts.olderThan);
-            if (!ms) {
-                db.close();
-                process.stderr.write(`Error: invalid duration '${opts.olderThan}'. Use e.g. 30d, 2w, 1y.\n`);
-                process.exit(1);
-            }
-            const cutoff = new Date(Date.now() - ms).toISOString();
-            candidates = candidates.filter((c) => c.updated_at < cutoff);
-        }
-        if (opts.status) {
-            const filterStatus = opts.status === 'in-progress' ? 'pending' : opts.status;
-            candidates = candidates.filter((c) => {
-                const lastStep = db
-                    .prepare('SELECT status FROM steps WHERE session_id = ? ORDER BY started_at DESC, id DESC LIMIT 1')
-                    .get(c.id);
-                return lastStep?.status === filterStatus;
-            });
-        }
-        if (candidates.length === 0) {
-            db.close();
-            process.stdout.write('No sessions match the specified criteria.\n');
-            return;
-        }
-        if (opts.dryRun) {
-            db.close();
-            process.stdout.write(`Would delete ${candidates.length} session(s):\n\n`);
-            for (const c of candidates) {
-                process.stdout.write(`  ${c.id.padEnd(22)}last updated ${c.updated_at.slice(0, 10)}\n`);
-            }
-            return;
-        }
-        if (!opts.yes && process.stdout.isTTY) {
-            process.stdout.write(`This will delete ${candidates.length} session(s) matching your criteria.\n\n`);
-            for (const c of candidates) {
-                process.stdout.write(`  ${c.id.padEnd(22)}last updated ${c.updated_at.slice(0, 10)}\n`);
-            }
-            process.stdout.write('\nDelete these sessions? (y/N) ');
-            const answer = await new Promise((resolve) => {
-                process.stdin.setEncoding('utf8');
-                process.stdin.once('data', (chunk) => resolve(String(chunk).trim().toLowerCase()));
-            });
-            if (answer !== 'y') {
-                db.close();
-                process.stdout.write('Cancelled.\n');
-                return;
-            }
-        }
-        db.exec('BEGIN');
-        try {
-            for (const c of candidates) {
-                db.prepare('DELETE FROM sessions WHERE id = ?').run(c.id);
-            }
-            db.exec('COMMIT');
-        }
-        catch (e) {
-            db.exec('ROLLBACK');
-            db.close();
-            process.stderr.write(`Error: failed to delete sessions: ${e instanceof Error ? e.message : String(e)}\n`);
-            process.exit(1);
-        }
-        db.close();
-        process.stdout.write(`Deleted ${candidates.length} session(s).\n`);
-    });
-}