@sanity/ailf 2.9.0 → 3.0.0

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

@@ -1,262 +0,0 @@
-/**
- * FilesystemArtifactCollector — DEPRECATED legacy capture path.
- *
- * W0050 Slice 5: the unified artifact writer (`ctx.artifactWriter.emit()`)
- * owns artifact production starting this release. This class is retained
- * for one release cycle so producer steps that haven't migrated yet still
- * have a surface to call against; W0052 deletes the class + port.
- *
- * Behavioral changes vs. pre-W0050:
- *
- * - **No tarball.** The `compress` option is ignored; flush() always writes
- *   a loose directory tree. The legacy `.tar.gz` artifact archive is no
- *   longer produced (D0033 AC8 — "no new capture tarballs").
- * - **First-call deprecation warning.** The first invocation of capture()
- *   or captureFile() on any instance emits a one-time-per-process warning
- *   pointing callers at `ctx.artifactWriter.emit()`.
- *
- * Everything else (in-memory accumulation, redaction, loose-file output at
- * flush time) is unchanged — existing tests continue to pass. This is the
- * **minimum** pass-through posture. Full delegation to
- * `LocalFilesystemArtifactWriter` is W0052 scope, at which point the port
- * and this class are both deleted.
- *
- * 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)
- *
- * @deprecated Use `ctx.artifactWriter.emit()` instead; removal scheduled for W0052.
- */
-import { copyFileSync, mkdirSync, readFileSync, 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
-// ---------------------------------------------------------------------------
-/**
- * Module-level flag so the W0050 deprecation warning fires exactly once
- * per process even when multiple collectors are constructed.
- */
-let warnedLegacyCollector = false;
-function warnLegacyCollectorOnce() {
-    if (warnedLegacyCollector)
-        return;
-    warnedLegacyCollector = true;
-    console.warn("FilesystemArtifactCollector is deprecated (W0050). Producers should migrate to ctx.artifactWriter.emit(); this class will be removed in W0052.");
-}
-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) {
-        warnLegacyCollectorOnce();
-        try {
-            this.entries.push({
-                step,
-                type,
-                data,
-                meta,
-                capturedAt: new Date().toISOString(),
-            });
-        }
-        catch {
-            // P5: non-blocking — swallow capture errors
-        }
-    }
-    captureFile(step, type, filePath, meta) {
-        warnLegacyCollectorOnce();
-        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");
-        // W0050 Slice 5 — compression disabled unconditionally. The legacy
-        // .tar.gz archive is no longer produced (D0033 AC8 "no new capture
-        // tarballs"); callers that asked for it get the loose directory plus
-        // a one-time warning.
-        if (this.options.compress) {
-            warnTarballSuppressedOnce();
-        }
-        return {
-            artifactCount: manifestEntries.length,
-            destination: this.outputDir,
-            totalBytes,
-            compressed: false,
-        };
-    }
-}
-let warnedTarballSuppressed = false;
-function warnTarballSuppressedOnce() {
-    if (warnedTarballSuppressed)
-        return;
-    warnedTarballSuppressed = true;
-    console.warn("capture.compress is deprecated (W0050); tarball output is no longer produced. The loose directory at <captureDir>/<run>-<ts>-<id>/ contains the same files.");
-}

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;