@ductape/cli 0.2.23 → 0.3.0

package/dist/commands/migration-products.d.ts

@@ -0,0 +1,23 @@
+export declare function initializeProductMap(opts: {
+    analysis: string;
+    definition: string;
+    output: string;
+}): {
+    path: string;
+};
+export declare function validateProductMap(file: string): {
+    artifact: string;
+    ready: boolean;
+    blockers: string[];
+};
+export declare function runMigrationProductsInit(opts: {
+    analysis: string;
+    definition: string;
+    output: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationProductsValidate(opts: {
+    file: string;
+    strict?: boolean;
+    json?: boolean;
+}): void;

package/dist/commands/migration-products.js

@@ -0,0 +1,88 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { printJson } from '../lib/output.js';
+import { readMigrationJson, writeMigrationJson } from '../lib/migration-artifact.js';
+function read(file) {
+    return readMigrationJson(file);
+}
+export function initializeProductMap(opts) {
+    const analysisPath = path.resolve(opts.analysis);
+    const definition = read(opts.definition);
+    if (!Array.isArray(definition.mappings) || !Array.isArray(definition.assets) ||
+        !Array.isArray(definition.promotions)) {
+        throw new Error('Definition requires mappings, assets, and promotions arrays.');
+    }
+    const artifact = {
+        version: 1,
+        artifact_kind: 'ductape_service_product_map',
+        analysis: analysisPath,
+        ...definition,
+    };
+    const output = path.resolve(opts.output);
+    if (fs.existsSync(output))
+        throw new Error(`Service-to-product map already exists: ${output}`);
+    fs.mkdirSync(path.dirname(output), { recursive: true });
+    writeMigrationJson(output, artifact, { createOnly: true });
+    return { path: output };
+}
+export function validateProductMap(file) {
+    const resolved = path.resolve(file);
+    const artifact = read(resolved);
+    if (artifact.artifact_kind !== 'ductape_service_product_map')
+        throw new Error('Invalid service-to-product map.');
+    const analysis = read(artifact.analysis);
+    const blockers = [];
+    const assignment = new Map();
+    for (const mapping of artifact.mappings) {
+        if (!mapping.service || !mapping.product_tag || !mapping.environments.length || !mapping.evidence) {
+            blockers.push(`mapping ${mapping.service || '<unknown>'}: service, product, environments, and evidence are required`);
+        }
+        for (const manifest of mapping.manifests) {
+            assignment.set(manifest, [...(assignment.get(manifest) ?? []), mapping.service]);
+        }
+    }
+    for (const unit of analysis.workspace_units ?? []) {
+        const owners = assignment.get(unit.manifest) ?? [];
+        if (owners.length === 0)
+            blockers.push(`workspace unit is unmapped: ${unit.manifest}`);
+        if (owners.length > 1)
+            blockers.push(`workspace unit has multiple service owners: ${unit.manifest}`);
+    }
+    for (const manifest of assignment.keys()) {
+        if (!(analysis.workspace_units ?? []).some((unit) => unit.manifest === manifest)) {
+            blockers.push(`mapping references unknown workspace unit: ${manifest}`);
+        }
+    }
+    for (const asset of artifact.assets) {
+        if (!asset.kind || !asset.tag || !asset.product_tag || !asset.inventory_evidence) {
+            blockers.push(`asset ${asset.tag || '<unknown>'}: identity and inventory evidence are required`);
+        }
+        for (const environment of asset.required_environments) {
+            if (!asset.configured_environments.includes(environment)) {
+                blockers.push(`asset ${asset.kind}:${asset.tag} missing environment configuration: ${environment}`);
+            }
+        }
+    }
+    for (const promotion of artifact.promotions) {
+        if (!promotion.product_tag || !promotion.from || !promotion.to ||
+            !promotion.entry_conditions.length || !promotion.validation.length || !promotion.rollback.length) {
+            blockers.push(`promotion ${promotion.from || '?'} -> ${promotion.to || '?'} is incomplete`);
+        }
+    }
+    const mappedProducts = new Set(artifact.mappings.map((mapping) => mapping.product_tag));
+    for (const product of mappedProducts) {
+        if (!artifact.promotions.some((promotion) => promotion.product_tag === product)) {
+            blockers.push(`product has no promotion plan: ${product}`);
+        }
+    }
+    return { artifact: resolved, ready: blockers.length === 0, blockers };
+}
+export function runMigrationProductsInit(opts) {
+    printJson(initializeProductMap(opts), Boolean(opts.json));
+}
+export function runMigrationProductsValidate(opts) {
+    const result = validateProductMap(opts.file);
+    printJson(result, Boolean(opts.json));
+    if (opts.strict && !result.ready)
+        throw new Error('Service-to-product mapping is not ready.');
+}

package/dist/commands/migration-review.d.ts

@@ -0,0 +1,248 @@
+type ReviewStatus = 'pending' | 'reviewed' | 'excluded';
+type ParityStatus = 'pending' | 'verified' | 'not_applicable';
+type ReferenceKind = 'import' | 'caller' | 'callee' | 'implements' | 'event' | 'test' | 'config' | 'schema';
+interface ParityEvidence {
+    status: ParityStatus;
+    evidence: string[];
+    reason?: string;
+}
+interface ReviewEntry {
+    file: string;
+    status: ReviewStatus;
+    safety: 'names_only' | 'normal';
+    baseline_checksum: string | null;
+    reviewed_checksum: string | null;
+    purpose: string;
+    dependencies: string[];
+    follow_up_files: string[];
+    references: Array<{
+        kind: ReferenceKind;
+        target: string;
+        external: boolean;
+        evidence: string;
+    }>;
+    interfaces: string[];
+    findings: Array<{
+        kind: string;
+        evidence: string;
+        location: {
+            start_line: number;
+            end_line: number;
+        };
+        symbol: {
+            kind: 'module' | 'class' | 'interface' | 'function' | 'method' | 'field' | 'route' | 'event' | 'schema' | 'other';
+            name: string;
+            qualified_name?: string;
+        };
+        classification: 'observed' | 'inferred' | 'proposed' | 'confirmed';
+        confidence: 'low' | 'medium' | 'high';
+        requires_followup: string[];
+    }>;
+    exclusion_reason?: string;
+    exclusion?: {
+        classification: 'generated' | 'vendor' | 'build' | 'snapshot' | 'other';
+        reason: string;
+        owner?: string;
+        generator?: string;
+        regeneration_test?: string;
+    };
+    interface_parity: ParityEvidence;
+    functional_parity: ParityEvidence;
+    operational_parity: ParityEvidence;
+}
+interface ReviewLedger {
+    version: 1;
+    artifact_kind: 'ai_migration_review_ledger';
+    source: string;
+    created_at: string;
+    revision: number;
+    events: Array<{
+        revision: number;
+        timestamp: string;
+        actor: string;
+        tool: '@ductape/cli';
+        tool_version: string;
+        operation: string;
+        state_hash: string;
+        previous_hash: string | null;
+        hash: string;
+    }>;
+    entries: ReviewEntry[];
+}
+interface LedgerSignature {
+    version: 1;
+    artifact_kind: 'ductape_review_ledger_signature';
+    ledger: string;
+    ledger_checksum: string;
+    key_id: string;
+    algorithm: 'Ed25519';
+    signed_at: string;
+    signature: string;
+}
+export declare function initializeReviewLedger(analysisPath: string, ledgerPath?: string): {
+    ledger: ReviewLedger;
+    path: string;
+};
+export declare function validateReviewLedger(ledgerPath: string): {
+    ledger: string;
+    source: string;
+    ready: boolean;
+    coverage: {
+        total: number;
+        reviewed: number;
+        excluded: number;
+        pending: number;
+        percent: number;
+    };
+    blockers: {
+        pending: string[];
+        stale: string[];
+        invalid_exclusions: string[];
+        invalid_generated_exclusions: string[];
+        missing_follow_ups: {
+            file: string;
+            follow_up: string;
+        }[];
+        uncovered_references: {
+            file: string;
+            kind: ReferenceKind;
+            target: string;
+        }[];
+        missing_finding_provenance: {
+            file: string;
+            finding: number;
+        }[];
+        missing_symbol_provenance: {
+            file: string;
+            finding: number;
+        }[];
+        probable_moves: {
+            from: string;
+            candidates: string[];
+        }[];
+        invalidated_dependents: string[];
+        audit_errors: string[];
+        missing_context: string[];
+        incomplete_parity: {
+            file: string;
+            concern: string;
+        }[];
+    };
+};
+export declare function snapshotReviewedFile(ledgerPath: string, file: string): ReviewEntry;
+export declare function recordReviewContext(ledgerPath: string, file: string, dataPath: string): ReviewEntry;
+export declare function addFollowUpFile(ledgerPath: string, fromFile: string, followUpFile: string): ReviewEntry;
+export declare function excludeReviewFile(ledgerPath: string, file: string, exclusion: NonNullable<ReviewEntry['exclusion']>): ReviewEntry;
+export declare function setParityEvidence(ledgerPath: string, file: string, concern: 'interface' | 'functional' | 'operational', status: Exclude<ParityStatus, 'pending'>, evidence?: string, reason?: string): ReviewEntry;
+export declare function reopenReviewFile(ledgerPath: string, file: string): ReviewEntry;
+export declare function moveReviewedFile(ledgerPath: string, from: string, to: string): ReviewEntry;
+export declare function signReviewLedger(opts: {
+    ledger: string;
+    privateKey: string;
+    keyId: string;
+    output?: string;
+}): {
+    path: string;
+    signature: LedgerSignature;
+};
+export declare function verifyReviewLedgerSignature(opts: {
+    ledger: string;
+    signature: string;
+    publicKey: string;
+}): {
+    ledger: string;
+    key_id: string;
+    valid: boolean;
+};
+export declare function mergeReviewLedgers(opts: {
+    base: string;
+    current: string;
+    incoming: string;
+    output: string;
+}): {
+    merged: boolean;
+    conflicts: string[];
+    output: null;
+} | {
+    merged: boolean;
+    conflicts: never[];
+    output: string;
+};
+export declare function runMigrationReviewInit(opts: {
+    analysis: string;
+    output?: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewValidate(opts: {
+    ledger: string;
+    strict?: boolean;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewSnapshot(opts: {
+    ledger: string;
+    file: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewRecord(opts: {
+    ledger: string;
+    file: string;
+    data: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewFollowUp(opts: {
+    ledger: string;
+    file: string;
+    followUp: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewExclude(opts: {
+    ledger: string;
+    file: string;
+    classification: NonNullable<ReviewEntry['exclusion']>['classification'];
+    reason: string;
+    owner?: string;
+    generator?: string;
+    regenerationTest?: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewParity(opts: {
+    ledger: string;
+    file: string;
+    concern: 'interface' | 'functional' | 'operational';
+    status: 'verified' | 'not_applicable';
+    evidence?: string;
+    reason?: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewReopen(opts: {
+    ledger: string;
+    file: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewMove(opts: {
+    ledger: string;
+    from: string;
+    to: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewSign(opts: {
+    ledger: string;
+    privateKey: string;
+    keyId: string;
+    output?: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewVerifySignature(opts: {
+    ledger: string;
+    signature: string;
+    publicKey: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationReviewMerge(opts: {
+    base: string;
+    current: string;
+    incoming: string;
+    output: string;
+    json?: boolean;
+}): void;
+export {};