@contentful/experience-design-system-cli 2.2.1

package/dist/src/session/command.js

@@ -0,0 +1,261 @@
+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`);
+    });
+}

package/dist/src/session/db.d.ts

@@ -0,0 +1,111 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { RawComponentDefinition } from '../types.js';
+import type { CDFComponentEntry, DTCGTokenEntry, DTCGTokenGroup } from '@contentful/experience-design-system-types';
+import type { ToolCall, TokenToolCall } from '../generate/agent-runner.js';
+import type { ComponentTypeSummary } from '@contentful/experience-design-system-types';
+export type StepStatus = 'pending' | 'complete' | 'failed' | 'interrupted';
+export type CommandName = 'analyze extract' | 'analyze select' | 'generate components' | 'generate tokens' | 'generate edit' | 'apply preview' | 'apply select' | 'apply push' | 'print components' | 'print tokens' | 'import';
+export interface SessionRow {
+    id: string;
+    name: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface StepRow {
+    id: number;
+    session_id: string;
+    command: string;
+    status: StepStatus;
+    started_at: string;
+    completed_at: string | null;
+    inputs: string;
+    outputs: string;
+    error: string | null;
+    updated_at: string;
+}
+export declare function getPipelineDbPath(): string;
+export declare function openPipelineDb(dbPath?: string): DatabaseSync;
+export interface ApplyToolCallsResult {
+    classified: number;
+    excluded: number;
+    slots: number;
+    warnings: string[];
+}
+export declare function applyToolCalls(db: DatabaseSync, sessionId: string, componentId: string, componentName: string, calls: ToolCall[], incomingWarnings: string[]): ApplyToolCallsResult;
+export interface MatchHints {
+    command: CommandName;
+    inputPath?: string;
+    outDir?: string;
+}
+export interface SessionResolution {
+    sessionId: string;
+    isNew: boolean;
+    isResumed: boolean;
+}
+export declare function getOrCreateSession(db: DatabaseSync, sessionFlag: string | undefined, sessionName: string | undefined, hints: MatchHints): SessionResolution;
+export declare function createStep(db: DatabaseSync, sessionId: string, command: CommandName, inputs: Record<string, string>): number;
+export declare function updateStep(db: DatabaseSync, stepId: number, status: 'complete' | 'failed', outputs: Record<string, string>, error?: string): void;
+export declare function storeRawComponents(db: DatabaseSync, sessionId: string, components: RawComponentDefinition[], options?: {
+    status?: string;
+    preserveCDF?: boolean;
+}): void;
+export type RawComponentWithId = RawComponentDefinition & {
+    component_id: string;
+};
+export declare function loadRawComponents(db: DatabaseSync, sessionId: string, allowedNames?: Set<string>): RawComponentWithId[];
+export declare function storeCDFComponents(db: DatabaseSync, sessionId: string, components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): void;
+export declare function loadCDFComponents(db: DatabaseSync, sessionId: string): Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>;
+export declare function storeDTCGTokens(db: DatabaseSync, sessionId: string, groups: DTCGTokenGroup[], tokens: DTCGTokenEntry[]): void;
+export interface ApplyTokenToolCallsResult {
+    tokens: number;
+    groups: number;
+    warnings: string[];
+}
+export declare function applyTokenToolCalls(db: DatabaseSync, sessionId: string, calls: TokenToolCall[], incomingWarnings: string[]): ApplyTokenToolCallsResult;
+export declare function loadDTCGTokens(db: DatabaseSync, sessionId: string): {
+    groups: DTCGTokenGroup[];
+    tokens: DTCGTokenEntry[];
+};
+export declare function findLatestSessionForCommand(db: DatabaseSync, command: CommandName): string | null;
+export declare function seedCDFFromPriorSession(db: DatabaseSync, targetSessionId: string): number;
+export declare function seedCDFFromPreviewResponse(db: DatabaseSync, sessionId: string, removedItems: ComponentTypeSummary[]): number;
+/**
+ * Seeds server-side metadata for changed components:
+ * 1. Fills in defaults the server has but we don't (prevents accidental removal)
+ * 2. Seeds cdf_type/cdf_category for props that exist on server but lack CDF locally
+ *    (e.g. props with non-standard source types the generation step couldn't classify)
+ */
+export declare function seedDefaultsFromChangedItems(db: DatabaseSync, sessionId: string, changedItems: Array<{
+    current: ComponentTypeSummary;
+    proposed: Record<string, unknown>;
+}>): number;
+/**
+ * Ensures all props on generated components have a cdf_type.
+ * Uses the pre-classification `category` column when available.
+ * Falls back to cdf_type: 'string', cdf_category: 'content' for props
+ * with no pre-classification (safe default — content is the most common category).
+ */
+export declare function backfillUnclassifiedProps(db: DatabaseSync, sessionId: string): number;
+export interface CacheEntry {
+    inputHash: string;
+    entityType: 'component' | 'token_set';
+    entityId: string;
+    sourceSessionId: string;
+    humanEdited: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function computeComponentInputHash(component: RawComponentWithId): string;
+export declare function computeTokenInputHash(rawTokenContent: string): string;
+export declare function lookupCache(db: DatabaseSync, inputHash: string, entityType: 'component' | 'token_set', entityId: string): CacheEntry | null;
+export declare function lookupCacheByEntity(db: DatabaseSync, entityType: 'component' | 'token_set', entityId: string): CacheEntry | null;
+export declare function storeCache(db: DatabaseSync, inputHash: string, entityType: 'component' | 'token_set', entityId: string, sourceSessionId: string, humanEdited: boolean): void;
+export declare function markCacheHumanEdited(db: DatabaseSync, entityType: 'component' | 'token_set', entityId: string): void;
+export declare function copyComponentFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string, componentId: string): void;
+export declare function copyTokensFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string): void;