@aiwg/cli 2026.9.0 → 2026.9.2

package/dist/src/dataset/adapter-types.d.ts

@@ -0,0 +1,179 @@
+import type { Digest, PrivacyClassification, SchemaBinding } from './types.js';
+export declare const DATASET_ADAPTER_CONTRACT_VERSION: "aiwg.dataset.adapter/v1";
+export type DatasetAdapterContractVersion = typeof DATASET_ADAPTER_CONTRACT_VERSION;
+export type AdapterOperation = 'describe' | 'configure' | 'check' | 'discover' | 'preview' | 'read';
+export type AdapterDiagnosticCode = 'ADAPTER_INVALID_CONFIGURATION' | 'ADAPTER_AUTHORIZATION_UNAVAILABLE' | 'ADAPTER_OFFLINE_PROHIBITED' | 'ADAPTER_SOURCE_UNAVAILABLE' | 'ADAPTER_RESOURCE_LIMIT' | 'ADAPTER_SCHEMA_DRIFT' | 'ADAPTER_CHECKPOINT_INCOMPATIBLE' | 'ADAPTER_CANCELLED' | 'ADAPTER_PATH_ESCAPE' | 'ADAPTER_UNSAFE_SYMLINK' | 'ADAPTER_SPECIAL_FILE' | 'ADAPTER_NETWORK_PROHIBITED' | 'ADAPTER_REDIRECT_PROHIBITED' | 'ADAPTER_SECRET_REJECTED' | 'ADAPTER_INTERNAL_ERROR';
+export interface AdapterDiagnostic {
+    code: AdapterDiagnosticCode;
+    severity: 'info' | 'warning' | 'error';
+    message: string;
+    operation: AdapterOperation;
+    path?: string;
+    retryable: boolean;
+}
+export interface AdapterSchemaDeclaration extends SchemaBinding {
+    digest: Digest;
+    dialect: 'https://json-schema.org/draft/2020-12/schema';
+    schema: Record<string, unknown>;
+}
+export interface AdapterManifest {
+    contractVersion: DatasetAdapterContractVersion;
+    kind: 'AdapterManifest';
+    id: string;
+    version: string;
+    packageDigest: Digest;
+    datasetContractRange: string;
+    sourceKinds: string[];
+    schemas: {
+        config: AdapterSchemaDeclaration;
+        discoveredRecord: AdapterSchemaDeclaration;
+        checkpoint: AdapterSchemaDeclaration;
+    };
+    capabilities: Array<'discovery' | 'preview' | 'streaming-read' | 'checkpoint' | 'tombstone'>;
+    limits: AdapterLimits;
+    maturity: 'experimental' | 'qualified' | 'stable';
+    publisher: {
+        id: string;
+        url?: string;
+    };
+    trust: {
+        state: 'builtin' | 'verified' | 'untrusted';
+        signature?: string;
+    };
+    permissions: {
+        locality: 'local' | 'remote';
+        network: 'none' | 'https-allowlisted';
+        credentials: 'none' | 'locator-only';
+    };
+    incremental: {
+        ordering: string;
+        sameCursorTieHandling: string;
+        lateArrivals: string;
+        tombstones: string;
+        checkpointCompatibility: string;
+    };
+}
+export interface CredentialLocator {
+    kind: 'opaque' | 'environment' | 'keychain' | 'vault';
+    locator: string;
+}
+export interface AdapterLimits {
+    maxRecords: number;
+    maxBytes: number;
+    maxRecordBytes: number;
+    timeoutMs: number;
+    maxRedirects: number;
+    maxDepth: number;
+}
+export interface AdapterPolicy {
+    offline: boolean;
+    allowedRoot?: string;
+    allowedHosts?: string[];
+    allowPrivateNetwork?: boolean;
+}
+export interface AdapterRequest<TConfig extends Record<string, unknown> = Record<string, unknown>> {
+    contractVersion: DatasetAdapterContractVersion;
+    requestId: string;
+    config: TConfig;
+    policy: AdapterPolicy;
+    limits: AdapterLimits;
+    signal?: AbortSignal;
+}
+export interface AdapterCheckpoint {
+    contractVersion: DatasetAdapterContractVersion;
+    kind: 'AdapterCheckpoint';
+    adapter: {
+        id: string;
+        version: string;
+    };
+    sourceIdentity: string;
+    cursor: string;
+    tieBreaker?: string;
+    schema: SchemaBinding;
+    createdAt: string;
+}
+export interface AdapterConfigurationResult<TConfig extends Record<string, unknown> = Record<string, unknown>> {
+    ok: boolean;
+    config?: TConfig;
+    configDigest?: Digest;
+    diagnostics: AdapterDiagnostic[];
+}
+export interface AdapterDiscovery {
+    sourceIdentity: string;
+    proposedSchema: Record<string, unknown>;
+    schemaBasis: 'declared' | 'observed' | 'inferred';
+    estimates: {
+        records?: number;
+        bytes?: number;
+    };
+    privacySignals: PrivacyClassification[];
+    licenseSignals: string[];
+    cursorSupport: boolean;
+    checkpointSupport: boolean;
+    identityStability: 'stable' | 'source-unstable';
+    identityLimitation?: string;
+    limitations: string[];
+}
+export interface AdapterResult<T> {
+    ok: boolean;
+    value?: T;
+    diagnostics: AdapterDiagnostic[];
+}
+export interface AdapterRecord {
+    logicalId: string;
+    ordinal: number;
+    value: unknown;
+    sourceLocator: string;
+    contentDigest: Digest;
+    tombstone?: boolean;
+}
+export type AdapterReadEvent = {
+    kind: 'record';
+    record: AdapterRecord;
+} | {
+    kind: 'checkpoint';
+    checkpoint: AdapterCheckpoint;
+} | {
+    kind: 'diagnostic';
+    diagnostic: AdapterDiagnostic;
+};
+export interface DatasetSourceAdapter<TConfig extends Record<string, unknown> = Record<string, unknown>> {
+    describe(): AdapterManifest;
+    configure(config: unknown): Promise<AdapterConfigurationResult<TConfig>>;
+    check(request: AdapterRequest<TConfig>): Promise<AdapterResult<{
+        sourceIdentity: string;
+    }>>;
+    discover(request: AdapterRequest<TConfig>): Promise<AdapterResult<AdapterDiscovery>>;
+    preview(request: AdapterRequest<TConfig> & {
+        count: number;
+    }): Promise<AdapterResult<AdapterRecord[]>>;
+    read(request: AdapterRequest<TConfig> & {
+        checkpoint?: AdapterCheckpoint;
+    }): AsyncIterable<AdapterReadEvent>;
+}
+export interface AdapterQualificationCell {
+    name: string;
+    source: 'fixture' | 'real-source';
+    passed: boolean;
+    evidence: string[];
+}
+export interface AdapterQualificationReport {
+    contractVersion: DatasetAdapterContractVersion;
+    kind: 'AdapterQualificationReport';
+    adapter: {
+        id: string;
+        version: string;
+        packageDigest: Digest;
+    };
+    schemas: {
+        config: SchemaBinding;
+        record: SchemaBinding;
+        checkpoint: SchemaBinding;
+    };
+    fixtureRevision: string;
+    cells: AdapterQualificationCell[];
+    qualifiedAt: string;
+    qualified: boolean;
+    stableEligible: boolean;
+}
+//# sourceMappingURL=adapter-types.d.ts.map

package/dist/src/dataset/adapter-types.js

@@ -0,0 +1,2 @@
+export const DATASET_ADAPTER_CONTRACT_VERSION = 'aiwg.dataset.adapter/v1';
+//# sourceMappingURL=adapter-types.js.map

package/dist/src/dataset/adapters.d.ts

@@ -0,0 +1,104 @@
+import type { AdapterCheckpoint, AdapterConfigurationResult, AdapterDiscovery, AdapterManifest, AdapterReadEvent, AdapterRecord, AdapterRequest, AdapterResult, DatasetSourceAdapter } from './adapter-types.js';
+type FileConfig = {
+    path: string;
+    encoding?: 'utf8';
+};
+type DirectoryConfig = FileConfig & {
+    recursive?: boolean;
+};
+type HttpConfig = {
+    url: string;
+    headers?: Record<string, string | {
+        kind: 'opaque' | 'environment' | 'keychain' | 'vault';
+        locator: string;
+    }>;
+};
+declare abstract class LocalAdapter<T extends FileConfig> implements DatasetSourceAdapter<T> {
+    abstract describe(): AdapterManifest;
+    protected abstract valid(value: Record<string, unknown>): value is T;
+    protected abstract discoverPath(config: T, request: AdapterRequest<T>): Promise<AdapterDiscovery>;
+    protected abstract records(config: T, request: AdapterRequest<T> & {
+        checkpoint?: AdapterCheckpoint;
+    }): AsyncIterable<AdapterRecord>;
+    configure(config: unknown): Promise<AdapterConfigurationResult<T>>;
+    check(request: AdapterRequest<T>): Promise<AdapterResult<{
+        sourceIdentity: string;
+    }>>;
+    discover(request: AdapterRequest<T>): Promise<AdapterResult<AdapterDiscovery>>;
+    preview(request: AdapterRequest<T> & {
+        count: number;
+    }): Promise<AdapterResult<AdapterRecord[]>>;
+    read(request: AdapterRequest<T> & {
+        checkpoint?: AdapterCheckpoint;
+    }): AsyncIterable<AdapterReadEvent>;
+}
+export declare class FileAdapter extends LocalAdapter<FileConfig> {
+    #private;
+    describe(): AdapterManifest;
+    protected valid(value: Record<string, unknown>): value is FileConfig;
+    protected discoverPath(config: FileConfig, request: AdapterRequest<FileConfig>): Promise<AdapterDiscovery>;
+    protected records(config: FileConfig, request: AdapterRequest<FileConfig> & {
+        checkpoint?: AdapterCheckpoint;
+    }): AsyncIterable<AdapterRecord>;
+}
+declare abstract class LineAdapter<T extends FileConfig> extends LocalAdapter<T> {
+    protected lineDiscovery(kind: string, config: T, request: AdapterRequest<T>, schema: Record<string, unknown>): Promise<AdapterDiscovery>;
+    protected lines(config: T, request: AdapterRequest<T> & {
+        checkpoint?: AdapterCheckpoint;
+    }, parse: (line: string, ordinal: number) => unknown): AsyncIterable<AdapterRecord>;
+}
+export declare class JsonlAdapter extends LineAdapter<FileConfig> {
+    #private;
+    describe(): AdapterManifest;
+    protected valid(value: Record<string, unknown>): value is FileConfig;
+    protected discoverPath(config: FileConfig, request: AdapterRequest<FileConfig>): Promise<AdapterDiscovery>;
+    protected records(config: FileConfig, request: AdapterRequest<FileConfig> & {
+        checkpoint?: AdapterCheckpoint;
+    }): AsyncIterable<AdapterRecord>;
+}
+export declare class CsvAdapter extends LineAdapter<FileConfig> {
+    #private;
+    describe(): AdapterManifest;
+    protected valid(value: Record<string, unknown>): value is FileConfig;
+    protected discoverPath(config: FileConfig, request: AdapterRequest<FileConfig>): Promise<AdapterDiscovery>;
+    protected records(config: FileConfig, request: AdapterRequest<FileConfig> & {
+        checkpoint?: AdapterCheckpoint;
+    }): AsyncIterable<AdapterRecord>;
+}
+export declare class DirectoryAdapter extends LocalAdapter<DirectoryConfig> {
+    #private;
+    describe(): AdapterManifest;
+    protected valid(value: Record<string, unknown>): value is DirectoryConfig;
+    protected discoverPath(config: DirectoryConfig, request: AdapterRequest<DirectoryConfig>): Promise<AdapterDiscovery>;
+    protected records(config: DirectoryConfig, request: AdapterRequest<DirectoryConfig> & {
+        checkpoint?: AdapterCheckpoint;
+    }): AsyncIterable<AdapterRecord>;
+}
+type FetchLike = typeof fetch;
+type HostResolver = (hostname: string) => Promise<Array<{
+    address: string;
+}>>;
+export declare class HttpAdapter implements DatasetSourceAdapter<HttpConfig> {
+    #private;
+    private readonly fetchImpl;
+    private readonly resolveHost;
+    constructor(fetchImpl?: FetchLike, resolveHost?: HostResolver);
+    describe(): AdapterManifest;
+    configure(config: unknown): Promise<AdapterConfigurationResult<HttpConfig>>;
+    check(request: AdapterRequest<HttpConfig>): Promise<AdapterResult<{
+        sourceIdentity: string;
+    }>>;
+    discover(request: AdapterRequest<HttpConfig>): Promise<AdapterResult<AdapterDiscovery>>;
+    preview(request: AdapterRequest<HttpConfig> & {
+        count: number;
+    }): Promise<AdapterResult<AdapterRecord[]>>;
+    read(request: AdapterRequest<HttpConfig> & {
+        checkpoint?: AdapterCheckpoint;
+    }): AsyncIterable<AdapterReadEvent>;
+}
+export declare function createBuiltinAdapterRegistry(): {
+    adapters: (FileAdapter | JsonlAdapter | CsvAdapter | DirectoryAdapter | HttpAdapter)[];
+    manifests: AdapterManifest[];
+};
+export {};
+//# sourceMappingURL=adapters.d.ts.map