@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/commands/mutate-object-output.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildObjectPackMutateDetails = buildObjectPackMutateDetails;
+exports.objectOperationFromString = objectOperationFromString;
+exports.formatObjectPackAggregateFailureText = formatObjectPackAggregateFailureText;
+function buildObjectPackMutateDetails(response, helpers) {
+    const { collectFilesTouched, collectFilesWritten, compactObject, isObject, readNumber, readObjectArray, readString } = helpers;
+    return compactObject({
+        kind: "exports.object",
+        operation: readString(response.operation),
+        sourceFile: readString(response.sourceFile),
+        objectCount: readNumber(response.objectCount),
+        memberCount: readNumber(response.memberCount),
+        requestedObjectCount: readNumber(response.requestedObjectCount),
+        requestedMemberCount: readNumber(response.requestedMemberCount),
+        retainedCount: readNumber(response.retainedCount),
+        partial: response.partial === true,
+        importerCount: readNumber(response.importerCount),
+        referenceCount: readNumber(response.referenceCount),
+        objects: readObjectArray(response.objects),
+        importers: readObjectArray(response.importers),
+        unsupported: readObjectArray(response.unsupported),
+        retained: readObjectArray(response.retained),
+        notRun: readObjectArray(response.notRun),
+        code: readString(response.code),
+        semanticFingerprint: readString(response.semanticFingerprint),
+        ...(typeof response.applyAvailable === "boolean" ? { applyAvailable: response.applyAvailable } : {}),
+        ...(isObject(response.recovery) ? { recovery: response.recovery } : {}),
+        ...(isObject(response.cache) ? { cache: response.cache } : {}),
+        recoveryRequired: response.recoveryRequired === true,
+        filesTouched: collectFilesTouched(response),
+        filesWritten: collectFilesWritten(response),
+        view: readString(response.view)
+    });
+}
+function objectOperationFromString(value) {
+    if (!value) {
+        return null;
+    }
+    if (value.includes(".unpack.") || value === "unpack") {
+        return "unpack";
+    }
+    if (value.includes(".pack.") || value === "pack") {
+        return "pack";
+    }
+    return null;
+}
+function formatObjectPackAggregateFailureText(cwd, operation, response, aggregate, helpers) {
+    const { formatPathForMutateOutput, isObject, readObjectArray, readString, readStringArray } = helpers;
+    if (response.ok !== false) {
+        return null;
+    }
+    const operations = isObject(aggregate.operations) ? aggregate.operations : {};
+    const objectPacks = readObjectArray(operations.objectPacks);
+    if (objectPacks.length === 0) {
+        return null;
+    }
+    const unsupported = objectPacks.flatMap((pack) => readObjectArray(pack.unsupported));
+    if (unsupported.length === 0) {
+        return null;
+    }
+    const lines = [`${operation ?? "mutate.preview"} failed`];
+    const objectOperation = objectOperationFromString(readString(objectPacks[0]?.operation)) ?? "pack";
+    const label = `object.${objectOperation}`;
+    lines.push(`failed: ${unsupported.length} unsupported ${label} ${unsupported.length === 1 ? "issue" : "issues"}`);
+    const sourceFile = readString(objectPacks[0]?.sourceFile);
+    if (sourceFile) {
+        lines.push(`source: ${formatPathForMutateOutput(cwd, sourceFile)}`);
+    }
+    lines.push("unsupported:");
+    for (const item of unsupported.slice(0, 12)) {
+        const selector = readString(item.selector) ?? readString(item.objectName) ?? label;
+        const message = readString(item.message) ?? readString(item.code) ?? "unsupported";
+        const file = readString(item.file);
+        lines.push(`${selector}: ${message}${file ? ` (${formatPathForMutateOutput(cwd, file)})` : ""}`);
+    }
+    if (unsupported.length > 12) {
+        lines.push(`+${unsupported.length - 12} more unsupported issues`);
+    }
+    const files = readStringArray(aggregate.filesTouched);
+    if (files.length > 0) {
+        lines.push("files:");
+        lines.push(...files.slice(0, 10).map((file) => formatPathForMutateOutput(cwd, file)));
+        if (files.length > 10) {
+            lines.push(`+${files.length - 10} more files`);
+        }
+    }
+    const next = readString(response.next) ?? `Fix unsupported ${label} selectors/usages and rerun mutate preview.`;
+    lines.push(`next: ${next.replace("failed group", `${label} issues`)}`);
+    return lines.join("\n");
+}

package/dist/commands/mutate-output-values.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueStrings = uniqueStrings;
+exports.compactObject = compactObject;
+exports.readString = readString;
+exports.readNumber = readNumber;
+exports.readStringArray = readStringArray;
+exports.readObjectArray = readObjectArray;
+exports.isObject = isObject;
+exports.readSummary = readSummary;
+exports.readNestedManualExtractionEntities = readNestedManualExtractionEntities;
+exports.isSemanticManualExtractionRow = isSemanticManualExtractionRow;
+exports.readEntityFromRowId = readEntityFromRowId;
+exports.formatCompactList = formatCompactList;
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function compactObject(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        if (Array.isArray(value) && value.length === 0) {
+            return false;
+        }
+        if (isObject(value) && Object.keys(value).length === 0) {
+            return false;
+        }
+        return true;
+    }));
+}
+function readString(value) {
+    return typeof value === "string" ? value : null;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function readObjectArray(value) {
+    return Array.isArray(value) ? value.filter(isObject) : [];
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readSummary(response) {
+    if (!response) {
+        return "not run";
+    }
+    if (typeof response.summary === "string") {
+        return response.summary;
+    }
+    if (typeof response.operation === "string") {
+        return response.operation;
+    }
+    return response.ok === false ? "failed" : "ok";
+}
+function readNestedManualExtractionEntities(row) {
+    const manual = readObjectArray(row.manualExtractionRequired)
+        .map((item) => readString(item.entity))
+        .filter((entity) => Boolean(entity));
+    if (manual.length > 0) {
+        return manual;
+    }
+    const provider = readObjectArray(row.providerLimitations)
+        .map((item) => readString(item.entity))
+        .filter((entity) => Boolean(entity));
+    if (provider.length > 0) {
+        return provider;
+    }
+    const code = readString(row.code);
+    const entity = readString(row.entity);
+    return code === "TS_MOVE_TO_FILE_UNSUPPORTED_BY_ENGINE" && entity ? [entity] : [];
+}
+function isSemanticManualExtractionRow(row) {
+    if (row.outcome === "manualExtractionRequired" || row.status === "manualExtractionRequired") {
+        return true;
+    }
+    const code = readString(isObject(row.response) ? row.response.code : null);
+    const error = readString(row.error) ?? readString(isObject(row.response) ? row.response.error : null) ?? "";
+    return code === "TS_MOVE_TO_FILE_UNSUPPORTED_BY_ENGINE" ||
+        (code === "TS_MOVE_TO_FILE_REFACTOR_FAILED" && /Changes overlap/i.test(error));
+}
+function readEntityFromRowId(id) {
+    if (!id) {
+        return null;
+    }
+    const separator = id.lastIndexOf(":");
+    return separator >= 0 ? id.slice(separator + 1) : null;
+}
+function formatCompactList(values, limit) {
+    if (values.length <= limit) {
+        return values.join(", ");
+    }
+    return `${values.slice(0, limit).join(", ")}, +${values.length - limit} more`;
+}

package/dist/commands/mutate-preview-cache.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMutatePreviewId = buildMutatePreviewId;
+exports.buildMutatePreviewHash = buildMutatePreviewHash;
+exports.readMutatePreviewRecord = readMutatePreviewRecord;
+exports.writeMutatePreviewRecord = writeMutatePreviewRecord;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("../shared/errors");
+const workspace_cache_1 = require("./workspace-cache");
+function buildMutatePreviewId(normalizedPayload) {
+    return `mutate_${sha256(stableStringify(normalizedPayload)).slice(0, 10)}`;
+}
+function buildMutatePreviewHash(normalizedPayload, segments) {
+    return `sha256:${sha256(stableStringify({ normalizedPayload, segments: segments.map((segment) => ({ kind: segment.kind, childId: segment.childId })) }))}`;
+}
+function readMutatePreviewRecord(cwd, previewId) {
+    const filePath = mutatePreviewRecordPath(cwd, previewId);
+    if (!fs.existsSync(filePath)) {
+        throw new errors_1.CliError("MUTATE_PREVIEW_NOT_FOUND", `Mutate preview not found: ${previewId}`, {
+            previewId,
+            expectedPath: filePath
+        });
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+function writeMutatePreviewRecord(cwd, record) {
+    const filePath = mutatePreviewRecordPath(cwd, record.previewId);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(record, null, 2)}\n`);
+}
+function mutatePreviewRecordPath(cwd, previewId) {
+    return (0, workspace_cache_1.workspaceCachePath)(cwd, "mutate-previews", `${sanitizeId(previewId)}.json`);
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+        .join(",")}}`;
+}
+function sanitizeId(value) {
+    return value.replace(/[^a-z0-9_-]+/gi, "-");
+}

package/dist/commands/mutate-response-replay.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMutateResponseForReplay = formatMutateResponseForReplay;
+exports.formatMutatePreviewAggregateText = formatMutatePreviewAggregateText;
+exports.formatMutateAgentText = formatMutateAgentText;
+const agent_text_1 = require("../shared/agent-text");
+const mutate_execution_status_1 = require("./mutate-execution-status");
+const mutate_aggregate_output_1 = require("./mutate-aggregate-output");
+const mutate_output_values_1 = require("./mutate-output-values");
+const exports_star_command_1 = require("./exports-star-command");
+const exports_star_collapse_command_1 = require("./exports-star-collapse-command");
+function formatMutateResponseForReplay(cwd, response) {
+    if (response.operation === "execution.status") {
+        return formatExecutionStatusResponseForReplay(response);
+    }
+    const importRebaseError = formatImportRebaseErrorForReplay(response);
+    if (importRebaseError) {
+        return importRebaseError;
+    }
+    const exportsStarText = (0, exports_star_command_1.formatExportsStarResponseForReplay)(response);
+    if (exportsStarText) {
+        return exportsStarText;
+    }
+    const collapseText = formatExportsStarCollapseResponseForReplay(response);
+    if (collapseText) {
+        return collapseText;
+    }
+    return (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, response) ?? formatMutateAgentText(response);
+}
+function formatExportsStarCollapseResponseForReplay(response) {
+    if (response.operation !== "mutate.preview" && response.operation !== "mutate.apply" && response.operation !== "mutate.execute")
+        return null;
+    if ((response.operation === "mutate.apply" || response.operation === "mutate.execute") && response.exportsStarOperation === "collapse") {
+        return (0, exports_star_collapse_command_1.formatExportsStarCollapseWriteText)(response.operation === "mutate.apply" ? "apply" : "execute", response);
+    }
+    const aggregate = (0, mutate_output_values_1.isObject)(response.aggregate) ? response.aggregate : {};
+    const operations = (0, mutate_output_values_1.isObject)(aggregate.operations) ? aggregate.operations : {};
+    const collapses = (0, mutate_output_values_1.readObjectArray)(operations.exportStarCollapses);
+    return collapses.length ? (0, exports_star_collapse_command_1.formatExportsStarCollapseBatchText)(collapses, response.operation === "mutate.preview" ? "preview" : response.operation === "mutate.apply" ? "apply" : "execute") : null;
+}
+function formatImportRebaseErrorForReplay(response) {
+    const code = (0, mutate_output_values_1.readString)(response.code);
+    if (code !== "IMPORT_REBASE_BARREL_AMBIGUOUS") {
+        return null;
+    }
+    const details = (0, mutate_output_values_1.isObject)(response.details) ? response.details : {};
+    const candidates = (0, mutate_output_values_1.readStringArray)(details.candidates);
+    return [
+        (0, mutate_output_values_1.readString)(response.error) ?? "Barrel directory is ambiguous.",
+        ...(candidates.length > 0
+            ? ["", "Choose an explicit barrel file:", ...candidates]
+            : []),
+        "",
+        "Pass the exact barrel file path."
+    ].join("\n");
+}
+function formatExecutionStatusResponseForReplay(response) {
+    const groups = (0, mutate_output_values_1.readObjectArray)(response.groups);
+    const completedRows = groups.reduce((sum, group) => sum + ((0, mutate_output_values_1.readNumber)(group.completedRows) ?? 0), 0);
+    const rowCount = groups.reduce((sum, group) => sum + ((0, mutate_output_values_1.readNumber)(group.rowCount) ?? 0), 0);
+    const completedGroups = groups.filter((group) => group.status === "completed").length;
+    const failedGroups = groups.filter((group) => group.status === "failed").length;
+    const notRunGroups = groups.filter((group) => group.status === "notRun").length;
+    const status = {
+        executionId: (0, mutate_output_values_1.readString)(response.executionId) ?? "",
+        status: (0, mutate_output_values_1.readString)(response.status) ?? "running",
+        phase: (0, mutate_output_values_1.readString)(response.phase) ?? "semantic",
+        rowCount,
+        groupCount: groups.length,
+        completedRows,
+        failedRows: groups.reduce((sum, group) => sum + ((0, mutate_output_values_1.readNumber)(group.failedRows) ?? 0), 0),
+        notRunRows: groups
+            .filter((group) => group.status === "notRun")
+            .reduce((sum, group) => sum + ((0, mutate_output_values_1.readNumber)(group.rowCount) ?? 0), 0),
+        completedGroups,
+        failedGroups,
+        notRunGroups,
+        filesWritten: (0, mutate_output_values_1.readStringArray)(response.filesWritten),
+        filesTouched: (0, mutate_output_values_1.readStringArray)(response.filesTouched),
+        groups,
+        updatedAt: (0, mutate_output_values_1.readString)(response.updatedAt) ?? new Date(0).toISOString(),
+        ...((0, mutate_output_values_1.readString)(response.error) ? { error: (0, mutate_output_values_1.readString)(response.error) } : {})
+    };
+    const estimatedRemainingMs = (0, mutate_output_values_1.readNumber)(response.estimatedRemainingMs);
+    if (estimatedRemainingMs !== null) {
+        return [
+            status.executionId ? `execution.status ${status.executionId}` : "execution.status",
+            (0, mutate_execution_status_1.buildMutateExecutionSummary)(status),
+            status.status === "running" ? (0, mutate_execution_status_1.formatMutatePhaseLine)(status) : null,
+            estimatedRemainingMs > 0
+                ? `estimated remaining: ${(0, mutate_execution_status_1.formatDuration)(Math.max(estimatedRemainingMs, 5_000))}`
+                : "estimated remaining: check status again soon"
+        ].filter((line) => Boolean(line)).join("\n");
+    }
+    return (0, mutate_execution_status_1.formatMutateExecutionStatusText)(status);
+}
+function formatMutatePreviewAggregateText(cwd, response) {
+    return (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, response);
+}
+function formatMutateAgentText(response) {
+    const lines = [];
+    const operation = String(response.operation ?? "mutate");
+    const id = typeof response.previewId === "string" ? ` ${response.previewId}` : "";
+    lines.push(`${operation}${id}`);
+    if (typeof response.summary === "string") {
+        lines.push(response.summary);
+    }
+    const segments = Array.isArray(response.segments) ? response.segments.filter(mutate_output_values_1.isObject) : [];
+    if (segments.length > 0) {
+        lines.push("segments:");
+        for (const segment of segments) {
+            const status = readSegmentDisplayStatus(segment);
+            const child = typeof segment.childId === "string" ? ` ${segment.childId}` : "";
+            const summary = typeof segment.summary === "string" ? ` - ${segment.summary}` : "";
+            lines.push(`${segment.index}. ${segment.kind}${child}: ${status}${summary}`);
+        }
+    }
+    appendMutateFailureDetail(lines, response);
+    if (typeof response.next === "string") {
+        lines.push(`next: ${response.next.replace("failed segment", "failed group")}`);
+    }
+    return lines.join("\n");
+}
+function appendMutateFailureDetail(lines, response) {
+    if (response.ok !== false || !(0, mutate_output_values_1.isObject)(response.response)) {
+        return;
+    }
+    const nestedText = (0, agent_text_1.readAgentText)(response.response);
+    lines.push("failed:");
+    if (nestedText) {
+        for (const line of nestedText.split("\n").slice(0, 16)) {
+            lines.push(line);
+        }
+        return;
+    }
+    const code = (0, mutate_output_values_1.readString)(response.response.code);
+    const error = (0, mutate_output_values_1.readString)(response.response.error);
+    if (code) {
+        lines.push(`code: ${code}`);
+    }
+    if (error) {
+        lines.push(error);
+    }
+}
+function readSegmentDisplayStatus(segment) {
+    if (segment.status === "notRun") {
+        return "not run";
+    }
+    if (segment.status === "failed" || segment.ok === false) {
+        return "failed";
+    }
+    return "ok";
+}