@sanity/ailf 2.8.0 → 3.0.0

package/dist/artifact-capture/filesystem-collector.js

@@ -1,237 +0,0 @@
-/**
- * FilesystemArtifactCollector — writes captured artifacts to a local directory.
- *
- * Accumulates artifact entries in memory during pipeline execution.
- * On flush(), creates a structured directory with one subdirectory per
- * step, writes all artifacts, and generates a manifest.json.
- *
- * Design principles:
- * - capture() and captureFile() are synchronous (no I/O during step execution)
- * - flush() does all I/O at pipeline end
- * - Failures in capture/captureFile are swallowed (P5: non-blocking)
- */
-import { execFileSync } from "node:child_process";
-import { copyFileSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import path from "node:path";
-import { redactArtifactData } from "./redact-artifact.js";
-// ---------------------------------------------------------------------------
-// Timestamp-prefixed capture ID (same shape as report-store.ts IDs)
-// ---------------------------------------------------------------------------
-function generateCaptureId() {
-    const now = Date.now();
-    const uuid = crypto.randomUUID();
-    const hex = now.toString(16).padStart(12, "0");
-    return (hex.slice(0, 8) +
-        "-" +
-        hex.slice(8, 12) +
-        "-7" +
-        uuid.slice(15, 18) +
-        "-" +
-        uuid.slice(19, 23) +
-        "-" +
-        uuid.slice(24));
-}
-function formatTimestamp(date) {
-    const y = date.getFullYear();
-    const m = String(date.getMonth() + 1).padStart(2, "0");
-    const d = String(date.getDate()).padStart(2, "0");
-    const h = String(date.getHours()).padStart(2, "0");
-    const min = String(date.getMinutes()).padStart(2, "0");
-    const s = String(date.getSeconds()).padStart(2, "0");
-    return `${y}${m}${d}-${h}${min}${s}`;
-}
-function detectFormat(entry) {
-    if (entry.filePath) {
-        const ext = path.extname(entry.filePath).toLowerCase();
-        if (ext === ".json")
-            return "json";
-        if (ext === ".md")
-            return "markdown";
-        if (ext === ".yaml" || ext === ".yml")
-            return "text";
-        return "text";
-    }
-    // In-memory data — if it's an object/array, it's JSON
-    if (typeof entry.data === "object" && entry.data !== null)
-        return "json";
-    return "text";
-}
-function fileExtension(format) {
-    switch (format) {
-        case "json":
-            return ".json";
-        case "markdown":
-            return ".md";
-        default:
-            return ".txt";
-    }
-}
-// ---------------------------------------------------------------------------
-// Collector
-// ---------------------------------------------------------------------------
-export class FilesystemArtifactCollector {
-    enabled = true;
-    extrasEnabled;
-    entries = [];
-    captureId;
-    outputDir;
-    startedAt;
-    options;
-    constructor(options) {
-        this.options = options;
-        this.extrasEnabled = options.extras;
-        this.captureId = generateCaptureId();
-        this.startedAt = new Date().toISOString();
-        // Use the last 4 hex chars (from the random UUID portion) — the first
-        // chars are timestamp-derived and change too slowly to disambiguate.
-        const shortId = this.captureId.replace(/-/g, "").slice(-4);
-        const timestamp = formatTimestamp(new Date());
-        this.outputDir = path.join(options.captureDir, `${options.mode}-${timestamp}-${shortId}`);
-    }
-    capture(step, type, data, meta) {
-        try {
-            this.entries.push({
-                step,
-                type,
-                data,
-                meta,
-                capturedAt: new Date().toISOString(),
-            });
-        }
-        catch {
-            // P5: non-blocking — swallow capture errors
-        }
-    }
-    captureFile(step, type, filePath, meta) {
-        try {
-            this.entries.push({
-                step,
-                type,
-                filePath,
-                meta,
-                capturedAt: new Date().toISOString(),
-            });
-        }
-        catch {
-            // P5: non-blocking — swallow capture errors
-        }
-    }
-    async flush() {
-        const manifestEntries = [];
-        let totalBytes = 0;
-        // Create the root output directory
-        mkdirSync(this.outputDir, { recursive: true });
-        for (const entry of this.entries) {
-            try {
-                const format = detectFormat(entry);
-                const ext = entry.filePath
-                    ? path.extname(entry.filePath)
-                    : fileExtension(format);
-                const relativePath = path.join(entry.step, `${entry.type}${ext}`);
-                const absolutePath = path.join(this.outputDir, relativePath);
-                // Ensure step subdirectory exists
-                mkdirSync(path.dirname(absolutePath), { recursive: true });
-                // Write the artifact — JSON artifacts are redacted before persistence
-                let bytes;
-                if (entry.filePath && format === "json") {
-                    // JSON file on disk: read → parse → redact → write
-                    const raw = readFileSync(entry.filePath, "utf-8");
-                    try {
-                        const parsed = JSON.parse(raw);
-                        const redacted = redactArtifactData(parsed);
-                        const content = JSON.stringify(redacted, null, 2);
-                        writeFileSync(absolutePath, content, "utf-8");
-                        bytes = Buffer.byteLength(content, "utf-8");
-                    }
-                    catch {
-                        // Unparseable JSON — copy as-is (comparator will scan it later)
-                        copyFileSync(entry.filePath, absolutePath);
-                        bytes = statSync(absolutePath).size;
-                    }
-                }
-                else if (entry.filePath) {
-                    // Non-JSON file: copy as-is
-                    copyFileSync(entry.filePath, absolutePath);
-                    bytes = statSync(absolutePath).size;
-                }
-                else {
-                    let content;
-                    if (format === "json") {
-                        try {
-                            content = JSON.stringify(redactArtifactData(entry.data), null, 2);
-                        }
-                        catch {
-                            // Fallback: serialize unredacted (e.g., circular references)
-                            content = JSON.stringify(entry.data, null, 2);
-                        }
-                    }
-                    else {
-                        content = String(entry.data ?? "");
-                    }
-                    writeFileSync(absolutePath, content, "utf-8");
-                    bytes = Buffer.byteLength(content, "utf-8");
-                }
-                totalBytes += bytes;
-                manifestEntries.push({
-                    step: entry.step,
-                    type: entry.type,
-                    path: relativePath,
-                    capturedAt: entry.capturedAt,
-                    bytes,
-                    format,
-                    ...(entry.meta ? { meta: entry.meta } : {}),
-                });
-            }
-            catch {
-                // P5: skip individual artifact failures, continue with the rest
-            }
-        }
-        // Write manifest
-        const manifest = {
-            version: 1,
-            captureId: this.captureId,
-            startedAt: this.startedAt,
-            completedAt: new Date().toISOString(),
-            pipeline: {
-                mode: this.options.mode,
-                ...(this.options.pipeline?.variant
-                    ? { variant: this.options.pipeline.variant }
-                    : {}),
-                ...(this.options.pipeline?.source
-                    ? { source: this.options.pipeline.source }
-                    : {}),
-                ...(this.options.pipeline?.areas
-                    ? { areas: this.options.pipeline.areas }
-                    : {}),
-            },
-            artifacts: manifestEntries,
-        };
-        const manifestContent = JSON.stringify(manifest, null, 2);
-        writeFileSync(path.join(this.outputDir, "manifest.json"), manifestContent, "utf-8");
-        // Compress to tar.gz if configured
-        if (this.options.compress) {
-            try {
-                const archivePath = `${this.outputDir}.tar.gz`;
-                const parentDir = path.dirname(this.outputDir);
-                const dirName = path.basename(this.outputDir);
-                execFileSync("tar", ["-czf", archivePath, "-C", parentDir, dirName]);
-                rmSync(this.outputDir, { recursive: true });
-                return {
-                    artifactCount: manifestEntries.length,
-                    destination: archivePath,
-                    totalBytes,
-                    compressed: true,
-                };
-            }
-            catch {
-                // Non-blocking: compression failed, keep the raw directory
-            }
-        }
-        return {
-            artifactCount: manifestEntries.length,
-            destination: this.outputDir,
-            totalBytes,
-            compressed: false,
-        };
-    }
-}

package/dist/artifact-capture/gcs-collector.d.ts

@@ -1,55 +0,0 @@
-/**
- * GcsArtifactCollector — decorator that uploads capture artifacts to GCS.
- *
- * Wraps the FilesystemArtifactCollector: local flush first (preserving
- * the existing manifest + redaction logic), then upload to a GCS bucket.
- *
- * Design principles:
- * - P5: Non-blocking — GCS upload failure should not block the pipeline.
- *   Local artifacts are always preserved.
- * - Decorator pattern — delegates capture() and captureFile() to the inner
- *   collector unchanged. Only flush() adds the GCS upload step.
- * - Lazy client — GCS Storage client is created on first flush(), not at
- *   construction (same pattern as BigQuerySink).
- *
- * @see docs/decisions/D0030-external-artifact-store.md
- * @see docs/work-items/W0035-gcs-artifact-output.json
- */
-import type { ArtifactCollector, CaptureFlushResult } from "../_vendor/ailf-core/index.d.ts";
-export interface GcsCollectorOptions {
-    /** GCS bucket name (e.g., "ailf-artifacts") */
-    bucket: string;
-    /** Object prefix in the bucket (e.g., "captures/") */
-    prefix?: string;
-    /** Path to service account credentials JSON (optional — falls back to ADC) */
-    credentials?: string;
-}
-export interface GcsFlushResult extends CaptureFlushResult {
-    /** GCS upload status */
-    gcs: {
-        status: "uploaded";
-        bucket: string;
-        path: string;
-    } | {
-        status: "skipped";
-        reason: string;
-    } | {
-        status: "failed";
-        error: string;
-    };
-}
-export declare class GcsArtifactCollector implements ArtifactCollector {
-    get enabled(): boolean;
-    get extrasEnabled(): boolean;
-    private client;
-    private readonly inner;
-    private readonly options;
-    constructor(inner: ArtifactCollector, options: GcsCollectorOptions);
-    capture(step: string, type: string, data: unknown, meta?: Record<string, unknown>): void;
-    captureFile(step: string, type: string, filePath: string, meta?: Record<string, unknown>): void;
-    flush(): Promise<GcsFlushResult>;
-    /** Lazily create the GCS Storage client. */
-    private getClient;
-    /** Upload the flushed artifact (tar.gz or directory) to GCS. */
-    private uploadToGcs;
-}

package/dist/artifact-capture/gcs-collector.js

@@ -1,117 +0,0 @@
-/**
- * GcsArtifactCollector — decorator that uploads capture artifacts to GCS.
- *
- * Wraps the FilesystemArtifactCollector: local flush first (preserving
- * the existing manifest + redaction logic), then upload to a GCS bucket.
- *
- * Design principles:
- * - P5: Non-blocking — GCS upload failure should not block the pipeline.
- *   Local artifacts are always preserved.
- * - Decorator pattern — delegates capture() and captureFile() to the inner
- *   collector unchanged. Only flush() adds the GCS upload step.
- * - Lazy client — GCS Storage client is created on first flush(), not at
- *   construction (same pattern as BigQuerySink).
- *
- * @see docs/decisions/D0030-external-artifact-store.md
- * @see docs/work-items/W0035-gcs-artifact-output.json
- */
-import { readFileSync } from "node:fs";
-import { Storage } from "@google-cloud/storage";
-// ---------------------------------------------------------------------------
-// Collector
-// ---------------------------------------------------------------------------
-export class GcsArtifactCollector {
-    get enabled() {
-        return this.inner.enabled;
-    }
-    get extrasEnabled() {
-        return this.inner.extrasEnabled;
-    }
-    client = null;
-    inner;
-    options;
-    constructor(inner, options) {
-        this.inner = inner;
-        this.options = options;
-    }
-    capture(step, type, data, meta) {
-        this.inner.capture(step, type, data, meta);
-    }
-    captureFile(step, type, filePath, meta) {
-        this.inner.captureFile(step, type, filePath, meta);
-    }
-    async flush() {
-        // Step 1: Flush to local filesystem first (always succeeds or throws)
-        const localResult = await this.inner.flush();
-        // Step 2: Upload to GCS (non-blocking — P5)
-        if (localResult.artifactCount === 0) {
-            return {
-                ...localResult,
-                gcs: { status: "skipped", reason: "No artifacts to upload" },
-            };
-        }
-        try {
-            const gcsPath = await this.uploadToGcs(localResult);
-            return {
-                ...localResult,
-                gcs: {
-                    status: "uploaded",
-                    bucket: this.options.bucket,
-                    path: gcsPath,
-                },
-            };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.warn(`  ⚠️  GCS upload failed (non-blocking): ${message}`);
-            return {
-                ...localResult,
-                gcs: { status: "failed", error: message },
-            };
-        }
-    }
-    // -----------------------------------------------------------------------
-    // Private helpers
-    // -----------------------------------------------------------------------
-    /** Lazily create the GCS Storage client. */
-    getClient() {
-        if (this.client)
-            return this.client;
-        this.client = this.options.credentials
-            ? new Storage({ keyFilename: this.options.credentials })
-            : new Storage();
-        return this.client;
-    }
-    /** Upload the flushed artifact (tar.gz or directory) to GCS. */
-    async uploadToGcs(result) {
-        const storage = this.getClient();
-        const bucket = storage.bucket(this.options.bucket);
-        const prefix = this.options.prefix ?? "captures/";
-        if (result.compressed) {
-            // Upload the tar.gz directly
-            const fileName = result.destination.split("/").pop() ?? "capture.tar.gz";
-            const gcsPath = `${prefix}${fileName}`;
-            const fileContent = readFileSync(result.destination);
-            await bucket.file(gcsPath).save(fileContent, {
-                contentType: "application/gzip",
-                metadata: {
-                    artifactCount: String(result.artifactCount),
-                    totalBytes: String(result.totalBytes),
-                },
-            });
-            return gcsPath;
-        }
-        // Uncompressed: upload the manifest.json as the representative file.
-        // The full directory could be uploaded file-by-file, but for the
-        // capture use case (forensic archive), the compressed bundle is the
-        // expected path. Upload just the manifest as a reference.
-        const manifestPath = `${result.destination}/manifest.json`;
-        const dirName = result.destination.split("/").pop() ?? "capture";
-        const gcsPath = `${prefix}${dirName}/manifest.json`;
-        const manifestContent = readFileSync(manifestPath, "utf-8");
-        await bucket.file(gcsPath).save(manifestContent, {
-            contentType: "application/json",
-        });
-        return gcsPath;
-    }
-}

package/dist/commands/capture-compare.d.ts

@@ -1,15 +0,0 @@
-/**
- * capture compare — compare two pipeline capture directories.
- *
- * Reads manifest.json from both captures, runs compareCaptures(),
- * and prints a human-readable table or JSON diff report.
- *
- * Supports both raw directories and .tar.gz archives.
- *
- * Exit codes:
- *   0 — captures are equivalent
- *   1 — differences found
- *   2 — error (missing files, invalid manifest, etc.)
- */
-import { Command } from "commander";
-export declare function createCaptureCompareCommand(): Command;

package/dist/commands/capture-compare.js

@@ -1,253 +0,0 @@
-/**
- * capture compare — compare two pipeline capture directories.
- *
- * Reads manifest.json from both captures, runs compareCaptures(),
- * and prints a human-readable table or JSON diff report.
- *
- * Supports both raw directories and .tar.gz archives.
- *
- * Exit codes:
- *   0 — captures are equivalent
- *   1 — differences found
- *   2 — error (missing files, invalid manifest, etc.)
- */
-import { execFileSync } from "node:child_process";
-import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { Command, Option } from "commander";
-import { compareCaptures } from "../artifact-capture/comparator.js";
-// ---------------------------------------------------------------------------
-// Command factory
-// ---------------------------------------------------------------------------
-export function createCaptureCompareCommand() {
-    return new Command("compare")
-        .description("Compare two pipeline capture directories")
-        .argument("<baseline>", "Path to baseline capture (directory or .tar.gz)")
-        .argument("<experiment>", "Path to experiment capture (directory or .tar.gz)")
-        .addOption(new Option("-m, --mode <mode>", "Comparison mode")
-        .choices(["inventory", "structural", "strict"])
-        .default("inventory"))
-        .option("-f, --format <fmt>", "Output format: table or json", "table")
-        .option("-o, --output <path>", "Write JSON report to file")
-        .option("--score-threshold <n>", "Aggregate score regression threshold (points)", parseFloat, 5)
-        .option("--task-threshold <n>", "Per-task score regression threshold (points)", parseFloat, 10)
-        .option("--timing-threshold <n>", "Step timing multiplier threshold", parseFloat, 2)
-        .option("--json-depth <n>", "JSON structural diff depth", parseInt, 3)
-        .action(async (baselinePath, experimentPath, opts) => {
-        const cleanups = [];
-        try {
-            const baseline = resolveCapturePath(resolve(baselinePath), cleanups);
-            const experiment = resolveCapturePath(resolve(experimentPath), cleanups);
-            console.log("");
-            console.log("  ailf capture compare");
-            console.log("  " + "─".repeat(40));
-            console.log("");
-            console.log(`  Baseline:   ${baselinePath}`);
-            console.log(`  Experiment: ${experimentPath}`);
-            console.log(`  Mode:       ${opts.mode}`);
-            console.log("");
-            const report = compareCaptures(baseline, experiment, {
-                mode: opts.mode,
-                scoreThresholds: {
-                    aggregate: opts.scoreThreshold,
-                    perTask: opts.taskThreshold,
-                },
-                timingThresholds: { multiplier: opts.timingThreshold },
-                jsonDiffDepth: opts.jsonDepth,
-            });
-            if (opts.format === "json") {
-                const json = JSON.stringify(report, null, 2);
-                if (opts.output) {
-                    writeFileSync(opts.output, json, "utf-8");
-                    console.log(`  Report written to ${opts.output}`);
-                }
-                else {
-                    console.log(json);
-                }
-            }
-            else {
-                printTableReport(report);
-                if (opts.output) {
-                    const json = JSON.stringify(report, null, 2);
-                    writeFileSync(opts.output, json, "utf-8");
-                    console.log(`  Report also written to ${opts.output}`);
-                }
-            }
-            process.exitCode = report.equivalent ? 0 : 1;
-        }
-        catch (err) {
-            console.error(`  Error: ${err instanceof Error ? err.message : String(err)}`);
-            process.exitCode = 2;
-        }
-        finally {
-            for (const cleanup of cleanups) {
-                try {
-                    cleanup();
-                }
-                catch {
-                    // Best-effort cleanup
-                }
-            }
-        }
-    });
-}
-// ---------------------------------------------------------------------------
-// Path resolution (handles tar.gz, subdirectories, raw dirs)
-// ---------------------------------------------------------------------------
-function resolveCapturePath(inputPath, cleanups) {
-    if (!existsSync(inputPath)) {
-        throw new Error(`Path does not exist: ${inputPath}`);
-    }
-    if (inputPath.endsWith(".tar.gz")) {
-        const tempDir = mkdtempSync(join(tmpdir(), "ailf-capture-cmp-"));
-        cleanups.push(() => rmSync(tempDir, { recursive: true, force: true }));
-        execFileSync("tar", ["-xzf", inputPath, "-C", tempDir]);
-        return findManifestDir(tempDir);
-    }
-    return findManifestDir(inputPath);
-}
-/**
- * Find the directory containing manifest.json.
- *
- * Handles two cases:
- * 1. Path IS the capture dir (contains manifest.json directly)
- * 2. Path is the parent captures/ dir (contains a single timestamped subdir)
- */
-function findManifestDir(dir) {
-    if (existsSync(join(dir, "manifest.json")))
-        return dir;
-    // Look one level down for a capture subdirectory
-    const entries = readdirSync(dir).filter((e) => !e.startsWith(".") && !e.endsWith(".tar.gz"));
-    for (const entry of entries) {
-        const sub = join(dir, entry);
-        if (existsSync(join(sub, "manifest.json")))
-            return sub;
-    }
-    throw new Error(`No manifest.json found in ${dir} or its subdirectories. ` +
-        `Is this a valid capture directory?`);
-}
-// ---------------------------------------------------------------------------
-// Table formatting
-// ---------------------------------------------------------------------------
-function printTableReport(report) {
-    // Inventory
-    console.log("  Inventory");
-    console.log("  " + "─".repeat(40));
-    console.log(`  Common:    ${report.inventory.common.length} artifact(s)`);
-    if (report.inventory.added.length > 0) {
-        console.log(`  Added:     ${report.inventory.added.length}  (${report.inventory.added.join(", ")})`);
-    }
-    else {
-        console.log("  Added:     0");
-    }
-    if (report.inventory.removed.length > 0) {
-        console.log(`  Removed:   ${report.inventory.removed.length}  (${report.inventory.removed.join(", ")})`);
-    }
-    else {
-        console.log("  Removed:   0");
-    }
-    console.log("");
-    // Content diff preview (structural/strict modes)
-    if (report.content && report.content.length > 0) {
-        console.log("  Content Changes");
-        console.log("  " + "─".repeat(40));
-        for (const diff of report.content.slice(0, 10)) {
-            printContentDiff(diff);
-        }
-        if (report.content.length > 10) {
-            console.log(`  ... and ${report.content.length - 10} more changed artifact(s)`);
-        }
-        console.log("");
-    }
-    // Scores
-    if (report.scores) {
-        console.log("  Scores");
-        console.log("  " + "─".repeat(40));
-        const { baselineMean, currentMean, delta } = report.scores;
-        const icon = delta > 0 ? "+" : delta < 0 ? "" : " ";
-        console.log(`  Aggregate: ${baselineMean.toFixed(1)} -> ${currentMean.toFixed(1)}  (${icon}${delta.toFixed(1)})`);
-        if (report.scores.breaches.length > 0) {
-            console.log(`  Breaches:  ${report.scores.breaches.length}`);
-            for (const b of report.scores.breaches) {
-                console.log(`    - ${b}`);
-            }
-        }
-        else {
-            console.log("  Breaches:  none");
-        }
-        console.log("");
-    }
-    // Timing
-    if (report.timing) {
-        console.log("  Timing");
-        console.log("  " + "─".repeat(40));
-        const { totalDeltaMs } = report.timing;
-        const sign = totalDeltaMs >= 0 ? "+" : "";
-        console.log(`  Total delta: ${sign}${totalDeltaMs}ms`);
-        if (report.timing.breaches.length > 0) {
-            console.log(`  Breaches:    ${report.timing.breaches.length}`);
-            for (const b of report.timing.breaches) {
-                console.log(`    - ${b}`);
-            }
-        }
-        else {
-            console.log("  Breaches:    none");
-        }
-        console.log("");
-    }
-    // Security
-    console.log("  Security");
-    console.log("  " + "─".repeat(40));
-    if (report.security.leaksFound) {
-        console.log(`  Leaks:     ${report.security.violations.length} finding(s)`);
-        for (const v of report.security.violations.slice(0, 5)) {
-            console.log(`    - ${v.file}: ${v.detail}`);
-        }
-        if (report.security.violations.length > 5) {
-            console.log(`    ... and ${report.security.violations.length - 5} more`);
-        }
-    }
-    else {
-        console.log("  Leaks:     none");
-    }
-    console.log("");
-    // Result
-    if (report.equivalent) {
-        console.log("  Result: EQUIVALENT");
-    }
-    else {
-        console.log(`  Result: DIFFERENCES FOUND`);
-        console.log(`  ${report.summary}`);
-    }
-    console.log("");
-}
-/**
- * Print up to 3 changed key paths for a content diff.
- */
-function printContentDiff(diff) {
-    console.log(`  ${diff.artifactKey} (${diff.format})`);
-    if (Array.isArray(diff.changes)) {
-        // JSON diff — show up to 3 changed paths
-        const jsonChanges = diff.changes;
-        for (const change of jsonChanges.slice(0, 3)) {
-            if (change.baseline === undefined) {
-                console.log(`    + ${change.path} (added)`);
-            }
-            else if (change.experiment === undefined) {
-                console.log(`    - ${change.path} (removed)`);
-            }
-            else {
-                console.log(`    ~ ${change.path} (changed)`);
-            }
-        }
-        if (jsonChanges.length > 3) {
-            console.log(`    ... ${jsonChanges.length - 3} more change(s)`);
-        }
-    }
-    else {
-        // Text/markdown diff
-        const { addedLines, removedLines } = diff.changes;
-        console.log(`    +${addedLines} / -${removedLines} lines`);
-    }
-}

package/dist/commands/capture-list.d.ts

@@ -1,12 +0,0 @@
-/**
- * capture list — list pipeline captures in a directory.
- *
- * Scans a capture directory for subdirectories containing manifest.json,
- * reads each manifest, and prints a summary table sorted by date.
- *
- * Usage:
- *   ailf capture list                          # default: .ailf/results/captures/
- *   ailf capture list ./my-captures            # custom directory
- */
-import { Command } from "commander";
-export declare function createCaptureListCommand(): Command;