agentera 3.0.0-dev.23 → 3.0.0-dev.26

package/dist/cli/commands/migrate.js

@@ -1,677 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import YAML from "yaml";
-import { emitInvalidInput } from "../errors.js";
-import { emitStructured } from "../structured.js";
-import { resolveSourceRoot } from "../../core/sourceRoot.js";
-import { migrationModeFlags, migrationSelectorFlag, migrationFailure, stateMigrationContract, } from "../../state/migrationAuthority.js";
-import { applyLegacyMigration, inspectLegacyMigration, } from "../../state/legacyMigration.js";
-import { migrationEnrichmentContract } from "../../state/migrationEnrichment.js";
-function requestedFormat(argv, formats, formatFlag) {
-    let requested;
-    for (let index = 0; index < argv.length; index += 1) {
-        if (argv[index] === formatFlag) {
-            requested = argv[index + 1];
-        }
-        if (argv[index].startsWith(`${formatFlag}=`)) {
-            requested = argv[index].slice(formatFlag.length + 1);
-        }
-    }
-    if (!requested || (formats && !formats.includes(requested)))
-        return "text";
-    return requested;
-}
-function parseInteger(flag, value, pattern) {
-    if (pattern && !new RegExp(pattern).test(value)) {
-        return `argument ${flag}: invalid int value: '${value}'`;
-    }
-    const parsed = Number(value);
-    return Number.isSafeInteger(parsed) ? parsed : `argument ${flag}: invalid int value: '${value}'`;
-}
-function candidatePathError(candidate, contract, project = process.cwd()) {
-    if (candidate.includes("\0") ||
-        candidate.includes("\\") ||
-        path.isAbsolute(candidate) ||
-        path.win32.isAbsolute(candidate)) {
-        return "candidate path violates the project boundary: use a project-local relative path";
-    }
-    let decoded = candidate;
-    try {
-        decoded = decodeURIComponent(candidate);
-    }
-    catch {
-        return "candidate path contains invalid percent encoding";
-    }
-    const normalized = decoded.replaceAll("\\", "/");
-    const parts = normalized.split("/").filter((part) => part !== "" && part !== ".");
-    if (parts.some((part) => part === "..") ||
-        decoded.includes("://") ||
-        /^[A-Za-z][A-Za-z0-9+.-]*:/.test(decoded)) {
-        return "candidate path violates the project boundary: traversal and URI paths are forbidden";
-    }
-    const normalizedPath = parts.join("/");
-    if (contract.inventory.excludedRelativePaths.some((excluded) => normalizedPath === excluded || normalizedPath.startsWith(`${excluded}/`))) {
-        return "candidate path is excluded by the authority inventory policy";
-    }
-    const inScanRoot = contract.inventory.roots.some((root) => {
-        const rootParts = root.path === "." ? [] : root.path.split("/").filter(Boolean);
-        const relativeParts = parts.slice(rootParts.length);
-        return (rootParts.every((part, index) => parts[index] === part) &&
-            relativeParts.length > 0 &&
-            relativeParts.length <= root.maximumDepth);
-    });
-    if (!inScanRoot)
-        return "candidate path must remain within a declared project-local scan root";
-    if (!new RegExp(contract.candidatePattern).test(parts[parts.length - 1])) {
-        return "candidate path is unsupported by the authority candidate pattern";
-    }
-    let projectRoot;
-    try {
-        projectRoot = fs.realpathSync(project);
-    }
-    catch {
-        return "selected project must resolve to an existing project directory";
-    }
-    let current = projectRoot;
-    for (const part of parts) {
-        current = path.join(current, part);
-        try {
-            if (fs.lstatSync(current).isSymbolicLink()) {
-                return "candidate path violates the project boundary: symlink components are forbidden";
-            }
-        }
-        catch {
-            break;
-        }
-    }
-    return null;
-}
-class MigrationInventoryError extends Error {
-    failureClass;
-    constructor(message, failureClass) {
-        super(message);
-        this.failureClass = failureClass;
-        this.name = "MigrationInventoryError";
-    }
-}
-function normalizedRelativePath(value) {
-    return value.replaceAll("\\", "/").replace(/^\.\//, "");
-}
-function pathIsExcluded(relativePath, contract) {
-    return contract.inventory.excludedRelativePaths.some((excluded) => relativePath === excluded || relativePath.startsWith(`${excluded}/`));
-}
-function inventoryEntry(observation, project, contract) {
-    const artifactId = contract.fixedNames[observation.relativePath] ?? null;
-    const entry = {
-        candidate_id: observation.relativePath,
-        path: observation.relativePath,
-        artifact_id: artifactId,
-        entry_number: null,
-        classification: "unaddressable",
-        detail_availability: "candidate_metadata_only",
-        compatibility: "legacy",
-        source: "project_local",
-        addressable: false,
-        size_bytes: observation.sizeBytes,
-    };
-    const pathError = candidatePathError(observation.relativePath, contract, project);
-    if (observation.symbolicLink || pathError?.includes("boundary")) {
-        entry.classification = "project_boundary";
-        entry.compatibility = "blocked";
-        entry.rejection = observation.symbolicLink ? "symlink_escape" : "outside_project";
-    }
-    else if (!observation.regularFile || pathError) {
-        entry.classification = "unsupported";
-        entry.compatibility = "unsupported";
-        entry.rejection = observation.regularFile ? "unsupported_path" : "non_regular";
-    }
-    return entry;
-}
-function inventoryStatus(entries, omittedCount, contract) {
-    const preferred = omittedCount > 0
-        ? "degraded"
-        : entries.some((entry) => entry.rejection !== undefined)
-            ? "blocked"
-            : "complete";
-    return contract.resultStatuses.includes(preferred) ? preferred : contract.resultStatuses[0];
-}
-/** Inventory candidate metadata only; this function never reads bytes or mutates state. */
-export function inventoryCandidates(selectedProject, contract) {
-    let project;
-    try {
-        project = fs.realpathSync(selectedProject);
-        if (!fs.statSync(project).isDirectory())
-            throw new Error("not a directory");
-    }
-    catch {
-        throw new MigrationInventoryError("selected project must resolve to an existing project directory", "project_boundary");
-    }
-    const observations = [];
-    const seen = new Set();
-    const candidatePattern = new RegExp(contract.candidatePattern);
-    const collect = (rootPath, rootRelative, maximumDepth, depth) => {
-        let directoryEntries;
-        try {
-            directoryEntries = fs.readdirSync(rootPath, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const directoryEntry of directoryEntries) {
-            const relativePath = normalizedRelativePath(path.join(rootRelative, directoryEntry.name));
-            if (pathIsExcluded(relativePath, contract))
-                continue;
-            const absolutePath = path.join(project, relativePath);
-            if (directoryEntry.isDirectory()) {
-                if (depth + 1 < maximumDepth)
-                    collect(absolutePath, relativePath, maximumDepth, depth + 1);
-                continue;
-            }
-            if (!candidatePattern.test(directoryEntry.name) || seen.has(relativePath))
-                continue;
-            seen.add(relativePath);
-            let sizeBytes = 0;
-            try {
-                sizeBytes = fs.lstatSync(absolutePath).size;
-            }
-            catch {
-                sizeBytes = 0;
-            }
-            observations.push({
-                relativePath,
-                sizeBytes,
-                symbolicLink: directoryEntry.isSymbolicLink(),
-                regularFile: directoryEntry.isFile(),
-            });
-        }
-    };
-    for (const root of contract.inventory.roots) {
-        const rootRelative = normalizedRelativePath(root.path === "." ? "" : root.path);
-        const rootPath = path.resolve(project, rootRelative || ".");
-        try {
-            const rootStat = fs.lstatSync(rootPath);
-            if (rootStat.isSymbolicLink()) {
-                throw new MigrationInventoryError(`declared scan root '${root.path}' violates the project boundary: symlink roots are forbidden`, "project_boundary");
-            }
-            if (!rootStat.isDirectory())
-                continue;
-        }
-        catch (error) {
-            if (error instanceof MigrationInventoryError)
-                throw error;
-            continue;
-        }
-        collect(rootPath, rootRelative, root.maximumDepth, 0);
-    }
-    observations.sort((left, right) => left.relativePath < right.relativePath ? -1 : left.relativePath > right.relativePath ? 1 : 0);
-    const entries = [];
-    let omittedCount = 0;
-    let totalBytes = 0;
-    for (const [index, observation] of observations.entries()) {
-        if (index >= contract.inventory.maximumCandidateFiles) {
-            omittedCount += 1;
-            continue;
-        }
-        if (observation.sizeBytes > contract.inventory.maximumFileBytes) {
-            omittedCount += 1;
-            continue;
-        }
-        if (totalBytes + observation.sizeBytes > contract.inventory.maximumTotalBytes) {
-            omittedCount += 1;
-            continue;
-        }
-        totalBytes += observation.sizeBytes;
-        entries.push(inventoryEntry(observation, project, contract));
-    }
-    return {
-        project,
-        entries,
-        omittedCount,
-        status: inventoryStatus(entries, omittedCount, contract),
-    };
-}
-export function parseMigrateArgs(argv, contract = stateMigrationContract()) {
-    const selectorFlags = new Map(Object.keys(contract.selectors).map((name) => [migrationSelectorFlag(contract, name), name]));
-    const formatFlag = migrationSelectorFlag(contract, "format");
-    const previewFlags = migrationModeFlags(contract, "preview");
-    const applyFlags = migrationModeFlags(contract, "apply");
-    const dryRunFlag = previewFlags[0];
-    const applyFlag = applyFlags.find((flag) => !previewFlags.includes(flag)) ?? applyFlags[0];
-    const forceFlag = applyFlags.find((flag) => flag !== applyFlag);
-    const args = {
-        project: null,
-        artifact: null,
-        dryRun: false,
-        apply: false,
-        force: false,
-        format: contract.formats[0],
-        limit: contract.defaultLimit,
-    };
-    const seen = new Set();
-    for (let index = 0; index < argv.length; index += 1) {
-        const token = argv[index];
-        const flag = [...selectorFlags.keys()].find((candidate) => token === candidate || token.startsWith(`${candidate}=`));
-        if (flag) {
-            if (seen.has(flag))
-                return { error: `${flag} may only be supplied once` };
-            seen.add(flag);
-            const inline = token.startsWith(`${flag}=`);
-            const value = inline ? token.slice(flag.length + 1) : argv[++index];
-            if (value === undefined || value === "" || (!inline && value.startsWith("--"))) {
-                return { error: `argument ${flag}: expected a value` };
-            }
-            const selector = selectorFlags.get(flag);
-            if (selector === "format") {
-                if (!contract.formats.includes(value)) {
-                    return {
-                        error: `argument ${formatFlag}: invalid choice: '${value}' (choose from ${contract.formats.map((item) => `'${item}'`).join(", ")})`,
-                    };
-                }
-                args.format = value;
-            }
-            else if (selector === "project")
-                args.project = value;
-            else if (selector === "artifact")
-                args.artifact = value;
-            else if (selector === "path")
-                args.path = value;
-            else {
-                const pattern = selector === "number" ? contract.numberPattern : undefined;
-                const parsed = parseInteger(flag, value, pattern);
-                if (typeof parsed === "string")
-                    return { error: parsed };
-                if (selector === "number")
-                    args.number = parsed;
-                else if (selector === "limit")
-                    args.limit = parsed;
-            }
-        }
-        else if (token === dryRunFlag) {
-            if (args.dryRun)
-                return { error: `${dryRunFlag} may only be supplied once` };
-            args.dryRun = true;
-        }
-        else if (token === applyFlag) {
-            if (args.apply)
-                return { error: `${applyFlag} may only be supplied once` };
-            args.apply = true;
-        }
-        else if (token === forceFlag) {
-            if (args.force)
-                return { error: `${forceFlag} may only be supplied once` };
-            args.force = true;
-        }
-        else {
-            return { error: `unrecognized arguments: ${token}` };
-        }
-    }
-    return args;
-}
-export function validateMigrateArgs(args, contract) {
-    const limitFlag = migrationSelectorFlag(contract, "limit");
-    const dryRunFlag = migrationModeFlags(contract, "preview")[0];
-    const applyFlags = migrationModeFlags(contract, "apply");
-    const applyFlag = applyFlags.find((flag) => ![dryRunFlag].includes(flag)) ?? applyFlags[0];
-    const forceFlag = applyFlags.find((flag) => flag !== applyFlag);
-    const selectorValue = (selectorName) => {
-        if (selectorName === "project")
-            return args.project;
-        if (selectorName === "artifact")
-            return args.artifact;
-        if (selectorName === "number")
-            return args.number;
-        if (selectorName === "path")
-            return args.path;
-        if (selectorName === "limit")
-            return args.limit;
-        if (selectorName === "format")
-            return args.format;
-        return undefined;
-    };
-    const selectorFlag = (name) => migrationSelectorFlag(contract, name);
-    const activeModeFlags = new Set();
-    if (args.dryRun)
-        activeModeFlags.add(dryRunFlag);
-    if (args.apply)
-        activeModeFlags.add(applyFlag);
-    if (args.force && forceFlag)
-        activeModeFlags.add(forceFlag);
-    for (const combination of contract.invalidCombinations) {
-        if (!combination.flags.every((flag) => activeModeFlags.has(flag)))
-            continue;
-        if (combination.requires && !activeModeFlags.has(combination.requires))
-            return combination.message;
-        if (!combination.requires)
-            return combination.message;
-    }
-    const artifactValues = contract.selectorValidValues.artifact;
-    if (args.artifact && !artifactValues.includes(args.artifact)) {
-        return `unsupported artifact '${args.artifact}'`;
-    }
-    const numberRequires = contract.selectors.number.required_with;
-    if (args.number !== undefined && typeof numberRequires === "string") {
-        const requiredSelector = Object.keys(contract.selectors).find((name) => selectorFlag(name) === numberRequires);
-        if (!requiredSelector ||
-            selectorValue(requiredSelector) === null ||
-            selectorValue(requiredSelector) === undefined) {
-            return `argument ${selectorFlag("number")} requires ${numberRequires}`;
-        }
-    }
-    if (args.limit !== undefined &&
-        (args.limit < contract.minimumLimit || args.limit > contract.maximumLimit)) {
-        return `argument ${limitFlag} must be between ${contract.minimumLimit} and ${contract.maximumLimit}`;
-    }
-    if (args.path) {
-        const pathError = candidatePathError(args.path, contract, args.project ?? process.cwd());
-        if (pathError)
-            return pathError;
-    }
-    const requiredApplySelectors = contract.requiredSelectors.apply ?? [];
-    const missingApplySelectors = requiredApplySelectors.filter((required) => {
-        const selectorName = Object.keys(contract.selectors).find((name) => selectorFlag(name) === required);
-        return (!selectorName ||
-            selectorValue(selectorName) === null ||
-            selectorValue(selectorName) === undefined);
-    });
-    if (args.apply && missingApplySelectors.length > 0) {
-        return `${applyFlag} requires ${missingApplySelectors.join(" and ")} selector${missingApplySelectors.length === 1 ? "" : "s"}`;
-    }
-    return null;
-}
-function authorityFailure(contract, failureClass) {
-    const failure = migrationFailure(contract, failureClass);
-    return {
-        example: typeof failure.example === "string" ? failure.example : undefined,
-        recovery: typeof failure.recovery === "string" ? failure.recovery : undefined,
-    };
-}
-function failureClassForMessage(contract, message) {
-    const modeFailure = contract.invalidCombinations.find((combination) => combination.message === message);
-    if (modeFailure)
-        return modeFailure.failureClass;
-    if (message.includes("project boundary") || message.includes("selected project"))
-        return "project_boundary";
-    if (message.includes("unsupported"))
-        return "unsupported_candidate";
-    return "invalid_selector";
-}
-function invalid(message, format, contract, validValues, failureClass = "invalid_selector") {
-    const failure = contract ? authorityFailure(contract, failureClass) : {};
-    return {
-        format,
-        body: {
-            class: message.startsWith("unsupported artifact") ? "invalid_choice" : "invalid_request",
-            message,
-            ...(contract
-                ? { syntax: contract.command, example: authorityFailure(contract, failureClass).example }
-                : {}),
-            ...(validValues ? { valid_values: validValues } : {}),
-            ...(failure.recovery ? { recovery: failure.recovery } : {}),
-        },
-    };
-}
-export function projectedEntries(entries, args, contract) {
-    const allowedFields = new Set(contract.resultEntryFields);
-    const normalized = entries
-        .map((entry) => {
-        const projected = Object.fromEntries(Object.entries(entry).filter(([field]) => allowedFields.has(field)));
-        for (const field of ["path", "candidate_id"]) {
-            if (typeof projected[field] === "string") {
-                projected[field] = normalizedRelativePath(projected[field]);
-            }
-        }
-        return projected;
-    })
-        .sort((left, right) => {
-        const leftPath = String(left.path ?? "").replaceAll("\\", "/");
-        const rightPath = String(right.path ?? "").replaceAll("\\", "/");
-        return leftPath < rightPath ? -1 : leftPath > rightPath ? 1 : 0;
-    });
-    const limit = args.limit ?? contract.defaultLimit;
-    return {
-        entries: normalized.slice(0, limit),
-        omittedCount: Math.max(0, normalized.length - limit),
-    };
-}
-export function resultCounts(entries, omittedCount, contract) {
-    const matches = (entry, predicates) => predicates.every((predicate) => {
-        if ("equals" in predicate)
-            return entry[predicate.field] === predicate.equals;
-        return entry[predicate.field] !== predicate.notEquals;
-    });
-    const counts = {};
-    for (const field of contract.resultCountFields) {
-        const rule = contract.resultCountRules[field];
-        const sourceEntries = rule.source === "visible_entries" ? entries : [];
-        if (rule.operation === "value" && rule.source === "omitted_count") {
-            counts[field] = omittedCount;
-        }
-        else if (rule.operation === "count" &&
-            rule.source === "all_candidates" &&
-            rule.predicates.length === 0) {
-            counts[field] = entries.length + omittedCount;
-        }
-        else if (rule.operation === "count" && rule.source === "visible_entries") {
-            counts[field] = sourceEntries.filter((entry) => matches(entry, rule.predicates)).length;
-        }
-        else if (rule.operation === "distinct" && rule.source === "visible_entries" && rule.field) {
-            counts[field] = new Set(sourceEntries
-                .filter((entry) => matches(entry, rule.predicates))
-                .map((entry) => entry[rule.field])
-                .filter((value) => typeof value === "string" || typeof value === "number")).size;
-        }
-        else {
-            counts[field] = null;
-        }
-    }
-    return counts;
-}
-function omissionValues(contract, omittedCount, outputBounded = false) {
-    const sourceValues = {
-        has_omissions: omittedCount > 0,
-        omitted_count: omittedCount,
-        omission_reason: omittedCount > 0
-            ? outputBounded
-                ? contract.omission.outputBoundedReason
-                : contract.omission.boundedReason
-            : contract.omission.completeReason,
-        retrieval: {
-            command: contract.omission.retrieval,
-            retry: outputBounded ? contract.omission.outputRetry : contract.omission.retry,
-        },
-    };
-    return Object.fromEntries(contract.omission.fields.map((field) => {
-        const source = contract.omission.fieldSources[field];
-        if (!(source in sourceValues)) {
-            throw new Error(`state migration omission source '${source}' is unavailable`);
-        }
-        return [field, sourceValues[source]];
-    }));
-}
-function textResponse(response) {
-    const diagnostics = response.diagnostics;
-    const valueText = (value) => value !== null && typeof value === "object" ? JSON.stringify(value) : String(value);
-    return ([
-        ...Object.entries(response)
-            .filter(([field]) => field !== "diagnostics")
-            .map(([field, value]) => `${field}: ${valueText(value)}`),
-        `diagnostic: ${diagnostics[0]?.message ?? "none"}`,
-        `authority: ${response.source_contract.authority}`,
-        "",
-    ].join("\n"));
-}
-function serializedResponseBytes(response, format) {
-    const serialized = format === "text"
-        ? textResponse(response)
-        : format === "yaml"
-            ? YAML.stringify(response, { sortMapEntries: false })
-            : JSON.stringify(response, null, 2) + "\n";
-    return Buffer.byteLength(serialized, "utf8");
-}
-function boundedDiagnostics(diagnostics, entries, contract) {
-    if (!Array.isArray(diagnostics))
-        return [];
-    const retainedIds = new Set(entries.map((entry) => String(entry.candidate_id ?? "")));
-    const retained = [];
-    const omitted = new Map();
-    for (const value of diagnostics) {
-        if (value === null || typeof value !== "object" || Array.isArray(value))
-            continue;
-        const diagnostic = value;
-        const candidateId = diagnostic.candidate_id;
-        if (candidateId === undefined || retainedIds.has(String(candidateId))) {
-            retained.push(diagnostic);
-            continue;
-        }
-        const failureClass = String(diagnostic.class ?? "unsupported_candidate");
-        omitted.set(failureClass, (omitted.get(failureClass) ?? 0) + 1);
-    }
-    for (const [failureClass, count] of [...omitted.entries()].sort(([left], [right]) => left.localeCompare(right))) {
-        retained.push({
-            class: failureClass,
-            message: `${count} candidate diagnostic(s) were omitted by the serialized output budget`,
-            provenance: {
-                failure_class: failureClass,
-                reason: contract.omission.outputBoundedReason,
-                omitted_count: count,
-            },
-        });
-    }
-    return retained;
-}
-function boundMigrationResponse(response, format, contract) {
-    if (serializedResponseBytes(response, format) <= contract.outputMaxUtf8Bytes)
-        return response;
-    const entries = Array.isArray(response.entries)
-        ? response.entries
-        : [];
-    const initialOmitted = Number(response.omitted_count ?? 0);
-    for (let retainedCount = entries.length; retainedCount >= 0; retainedCount -= 1) {
-        const retained = entries.slice(0, retainedCount);
-        const omittedCount = initialOmitted + entries.length - retainedCount;
-        const bounded = {
-            ...response,
-            entries: retained,
-            diagnostics: boundedDiagnostics(response.diagnostics, retained, contract),
-            counts: resultCounts(retained, omittedCount, contract),
-            ...omissionValues(contract, omittedCount, true),
-        };
-        if (serializedResponseBytes(bounded, format) <= contract.outputMaxUtf8Bytes)
-            return bounded;
-    }
-    throw new Error(`migration output requires more than the authority ${contract.outputMaxUtf8Bytes}-byte ${format} budget after required omission metadata`);
-}
-export function deferredResponse(args, contract, entries = [], inventory, options = {}, sourceRoot = resolveSourceRoot()) {
-    const mode = args.apply ? "apply" : args.dryRun ? "preview" : "inventory";
-    const projected = projectedEntries(entries, args, contract);
-    const omittedCount = (inventory?.omittedCount ?? 0) + projected.omittedCount;
-    const omission = omissionValues(contract, omittedCount);
-    const values = {
-        schemaVersion: contract.resultSchemaVersion,
-        command: contract.command,
-        status: options.status ?? inventory?.status ?? contract.resultStatuses[0],
-        mode,
-        project: inventory?.project ?? args.project ?? process.cwd(),
-        read_only: !args.apply,
-        mutation_intent: args.apply,
-        mutation_performed: options.mutationPerformed ?? false,
-        remote_contact: false,
-        inventory_performed: inventory !== undefined,
-        entries: projected.entries,
-        counts: resultCounts(projected.entries, omittedCount, contract),
-        ...omission,
-        diagnostics: options.diagnostics ?? [
-            {
-                class: "implementation_deferred",
-                message: `${String(contract.migration.implementation_boundary)} No state was changed.`,
-            },
-        ],
-        source_contract: {
-            authority: contract.authorityPath,
-            schema_version: contract.schemaVersion,
-            execution: "authority_and_dispatch_only",
-            result: {
-                required_fields: contract.resultRequiredFields,
-                entry_fields: contract.resultEntryFields,
-                count_fields: contract.resultCountFields,
-                count_rules: contract.resultCountRules,
-                omission: contract.omission,
-                max_utf8_bytes: contract.outputMaxUtf8Bytes,
-            },
-            inventory: contract.inventory,
-            git_required: false,
-            remote_contact: "forbidden",
-            optional_git_enrichment: migrationEnrichmentContract(sourceRoot),
-        },
-    };
-    const response = Object.fromEntries(contract.resultRequiredFields.map((field) => [field, values[field] ?? null]));
-    if (options.operations !== undefined)
-        response.operations = options.operations;
-    return boundMigrationResponse(response, args.format, contract);
-}
-export function renderText(response, out) {
-    out(textResponse(response));
-}
-export function runMigrate(argv, io, sourceRootOverride) {
-    let format = "text";
-    const sourceRoot = sourceRootOverride ?? resolveSourceRoot();
-    let contract;
-    try {
-        contract = stateMigrationContract(sourceRoot);
-    }
-    catch (error) {
-        return emitInvalidInput(io, invalid(`Local migration authority could not be loaded: ${error.message}`, format));
-    }
-    format = requestedFormat(argv, contract.formats, migrationSelectorFlag(contract, "format"));
-    const parsed = parseMigrateArgs(argv, contract);
-    if ("error" in parsed) {
-        const validValues = parsed.error.includes("invalid choice")
-            ? contract.selectorValidValues.format
-            : undefined;
-        return emitInvalidInput(io, invalid(parsed.error, format, contract, validValues, "invalid_selector"));
-    }
-    const validation = validateMigrateArgs(parsed, contract);
-    if (validation) {
-        const validValues = validation.startsWith("unsupported artifact")
-            ? contract.selectorValidValues.artifact
-            : undefined;
-        return emitInvalidInput(io, invalid(validation, format, contract, validValues, failureClassForMessage(contract, validation)));
-    }
-    let inventory;
-    try {
-        inventory = inventoryCandidates(parsed.project ?? process.cwd(), contract);
-    }
-    catch (error) {
-        const inventoryError = error;
-        return emitInvalidInput(io, invalid(inventoryError.message, format, contract, undefined, inventoryError.failureClass ?? "project_boundary"));
-    }
-    let inspection;
-    try {
-        inspection = inspectLegacyMigration(inventory, contract, sourceRoot, parsed);
-    }
-    catch (error) {
-        return emitInvalidInput(io, invalid(`local migration inventory failed: ${error.message}`, format, contract, undefined, "corrupt_candidate"));
-    }
-    let applyResult;
-    if (parsed.apply) {
-        applyResult = applyLegacyMigration(inspection, {
-            artifact: parsed.artifact,
-            number: parsed.number,
-            path: parsed.path,
-        }, { sourceRoot });
-    }
-    const diagnostics = [...inspection.diagnostics, ...(applyResult?.diagnostics ?? [])].slice(0, parsed.limit ?? contract.defaultLimit);
-    const response = deferredResponse(parsed, contract, inspection.entries, { ...inventory, status: applyResult?.status ?? inspection.status }, {
-        status: applyResult?.status ?? inspection.status,
-        diagnostics,
-        operations: applyResult?.operations ?? inspection.operations,
-        mutationPerformed: applyResult?.mutationPerformed ?? false,
-    }, sourceRoot);
-    const out = io.out ?? ((text) => process.stdout.write(text));
-    if (format === "text")
-        renderText(response, out);
-    else
-        emitStructured(response, format, out);
-    return 1;
-}
-//# sourceMappingURL=migrate.js.map