@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/dsl/mutate-dsl.js

@@ -0,0 +1,746 @@
+"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.MUTATE_DSL_AGENT_DX_FIELD = void 0;
+exports.compileMutateDsl = compileMutateDsl;
+exports.compileMutateDslWithDiagnostics = compileMutateDslWithDiagnostics;
+const path = __importStar(require("node:path"));
+const errors_1 = require("../shared/errors");
+exports.MUTATE_DSL_AGENT_DX_FIELD = "__aibMutateDslAgentDx";
+function compileMutateDsl(source) {
+    return compileMutateDslWithDiagnostics(source).payload;
+}
+function compileMutateDslWithDiagnostics(source) {
+    const defaults = {
+        sourceFile: null,
+        base: null,
+        scope: null,
+        files: null,
+        expectEmpty: false
+    };
+    const operations = [];
+    const diagnostics = [];
+    let activeFileMove = null;
+    let activeFileMoveBase = null;
+    const flushActiveFileMove = () => {
+        if (!activeFileMove) {
+            return;
+        }
+        if (!activeFileMoveBase) {
+            throw new errors_1.CliError("MUTATE_BASE_REQUIRED", "moveToDir expects @base before the row.");
+        }
+        appendFileMoveOperations(operations, activeFileMoveBase, activeFileMove);
+        activeFileMove = null;
+        activeFileMoveBase = null;
+    };
+    const lines = source.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const lineNumber = index + 1;
+        const rawLine = lines[index] ?? "";
+        const trimmed = stripComment(rawLine).trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (rawLine.match(/^\s+/) && activeFileMove && !trimmed.startsWith("@")) {
+            activeFileMove.files.push(...stripUnknownOptions("mutate file moveToDir", tokenize(trimmed, lineNumber), diagnostics, lineNumber).tokens);
+            continue;
+        }
+        flushActiveFileMove();
+        if (trimmed.startsWith("@")) {
+            applyDirective(defaults, trimmed, lineNumber, diagnostics);
+            continue;
+        }
+        if (trimmed.startsWith("renameFile ")) {
+            requireBase(defaults, lineNumber, "renameFile");
+            appendFileRenameOperations(operations, defaults.base, trimmed, lineNumber, diagnostics);
+            continue;
+        }
+        if (trimmed.startsWith("moveToDir ")) {
+            requireBase(defaults, lineNumber, "moveToDir");
+            activeFileMove = parseMoveToDirLine(trimmed, lineNumber, diagnostics);
+            activeFileMoveBase = defaults.base;
+            continue;
+        }
+        if (trimmed.startsWith("rename ")) {
+            requireSource(defaults, lineNumber, "rename");
+            operations.push({
+                family: "semantic",
+                request: {
+                    op: "rename",
+                    sourceFile: defaults.sourceFile,
+                    renames: Object.fromEntries(parseRenamePairs(trimmed.slice("rename".length).trim(), lineNumber, diagnostics, "mutate semantic rename").map((pair) => [pair.source, pair.target]))
+                }
+            });
+            continue;
+        }
+        if (trimmed.startsWith("move ")) {
+            requireSource(defaults, lineNumber, "move");
+            const move = parseMoveLine(trimmed, lineNumber, diagnostics);
+            operations.push({
+                family: "semantic",
+                request: {
+                    op: "move",
+                    sourceFile: defaults.sourceFile,
+                    targetFile: move.targetFile,
+                    entities: move.entities
+                }
+            });
+            continue;
+        }
+        if (trimmed.startsWith("module ")) {
+            requireSource(defaults, lineNumber, "module");
+            operations.push({
+                family: "modulePlan",
+                sourceFile: defaults.sourceFile,
+                expectEmpty: defaults.expectEmpty,
+                row: parseModuleLine(trimmed, lineNumber, diagnostics)
+            });
+            continue;
+        }
+        if (trimmed.startsWith("imports.normalize")) {
+            operations.push({
+                family: "importsNormalize",
+                request: parseImportsNormalizeLine(trimmed, lineNumber, defaults)
+            });
+            continue;
+        }
+        if (trimmed.startsWith("imports.useBarrel ") || trimmed.startsWith("imports.useDirect ")) {
+            operations.push({
+                family: "importsRebase",
+                request: parseImportsRebaseLine(trimmed, lineNumber, defaults)
+            });
+            continue;
+        }
+        if (trimmed.startsWith("object.pack ") || trimmed.startsWith("object.unpack ")) {
+            const operation = trimmed.startsWith("object.unpack ") ? "unpack" : "pack";
+            requireSource(defaults, lineNumber, `object.${operation}`);
+            operations.push({
+                family: "exportsObject",
+                request: parseObjectPackLine(defaults.sourceFile, trimmed, lineNumber, operation)
+            });
+            continue;
+        }
+        if (/^exports\.star\.(?:expand|collapse)(?:\s|$)/.test(trimmed)) {
+            const operation = trimmed.startsWith("exports.star.collapse") ? "collapse" : "expand";
+            requireSource(defaults, lineNumber, `exports.star.${operation}`);
+            operations.push({
+                family: "exportsStar",
+                request: parseExportsStarLine(defaults.sourceFile, trimmed, lineNumber, operation)
+            });
+            continue;
+        }
+        if (trimmed.startsWith("remove ") || trimmed === "remove") {
+            requireDeclarationTarget(defaults, lineNumber, "remove");
+            operations.push({
+                family: "declaration",
+                request: buildDeclarationRequest(defaults, "remove", trimmed.slice("remove".length).trim(), lineNumber)
+            });
+            continue;
+        }
+        if (trimmed.startsWith("addMissing ") || trimmed === "addMissing") {
+            requireDeclarationTarget(defaults, lineNumber, "addMissing");
+            operations.push({
+                family: "declaration",
+                request: buildDeclarationRequest(defaults, "addMissing", trimmed.slice("addMissing".length).trim(), lineNumber)
+            });
+            continue;
+        }
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `Invalid mutate DSL at line ${lineNumber}: ${trimmed}`, {
+            line: lineNumber,
+            expected: "@source, @base, @scope, @files, rename, move, moveToDir, renameFile, module, imports.normalize, imports.useBarrel, imports.useDirect, object.pack, object.unpack, exports.star.expand, exports.star.collapse, remove, or addMissing"
+        });
+    }
+    flushActiveFileMove();
+    if (operations.length === 0) {
+        throw new errors_1.CliError("MUTATE_ROWS_REQUIRED", "mutate DSL expects at least one operation.");
+    }
+    return {
+        payload: {
+            segments: buildSegments(operations),
+            ...(diagnostics.length > 0 ? { [exports.MUTATE_DSL_AGENT_DX_FIELD]: diagnostics } : {})
+        },
+        diagnostics
+    };
+}
+function applyDirective(defaults, trimmed, lineNumber, diagnostics) {
+    if (trimmed.startsWith("@source ")) {
+        const tokens = tokenize(trimmed.slice("@source".length).trim(), lineNumber);
+        const [sourceFile, ...flags] = tokens;
+        if (!sourceFile) {
+            throw new errors_1.CliError("INVALID_MUTATE_DSL", `@source expects a path at line ${lineNumber}.`, { line: lineNumber });
+        }
+        defaults.sourceFile = sourceFile;
+        const stripped = stripUnknownOptions("mutate module", flags, diagnostics, lineNumber, new Set(["+expectEmpty"]));
+        defaults.expectEmpty = stripped.tokens.includes("+expectEmpty");
+        return;
+    }
+    if (trimmed.startsWith("@base ")) {
+        const base = trimmed.slice("@base".length).trim();
+        if (!base) {
+            throw new errors_1.CliError("INVALID_MUTATE_DSL", `@base expects a path at line ${lineNumber}.`, { line: lineNumber });
+        }
+        defaults.base = base;
+        return;
+    }
+    if (trimmed.startsWith("@scope ")) {
+        const scope = trimmed.slice("@scope".length).trim();
+        if (!scope) {
+            throw new errors_1.CliError("INVALID_MUTATE_DSL", `@scope expects a path at line ${lineNumber}.`, { line: lineNumber });
+        }
+        defaults.scope = scope;
+        defaults.files = null;
+        return;
+    }
+    if (trimmed.startsWith("@files ")) {
+        const files = tokenize(trimmed.slice("@files".length).trim(), lineNumber);
+        if (files.length === 0) {
+            throw new errors_1.CliError("INVALID_MUTATE_DSL", `@files expects at least one file at line ${lineNumber}.`, { line: lineNumber });
+        }
+        defaults.files = files;
+        defaults.scope = null;
+        return;
+    }
+    throw new errors_1.CliError("INVALID_MUTATE_DSL", `Unknown mutate directive at line ${lineNumber}: ${trimmed}`, { line: lineNumber });
+}
+function appendFileMoveOperations(operations, base, move) {
+    if (move.files.length === 0) {
+        throw new errors_1.CliError("MUTATE_FILE_MOVE_FILES_REQUIRED", "moveToDir expects at least one file.");
+    }
+    for (const file of move.files) {
+        const sourceFile = resolveDslPath(base, file);
+        const targetDir = resolveDslPath(base, move.targetDir);
+        operations.push({
+            family: "file",
+            operation: {
+                kind: "fileMoveToDir",
+                sourceFile,
+                targetDir,
+                targetFile: path.normalize(path.join(targetDir, path.basename(sourceFile)))
+            }
+        });
+    }
+}
+function appendFileRenameOperations(operations, base, line, lineNumber, diagnostics) {
+    for (const pair of parseRenamePairs(line.slice("renameFile".length).trim(), lineNumber, diagnostics, "mutate file rename")) {
+        const sourceFile = resolveDslPath(base, pair.source);
+        const targetFile = resolveRenameTarget(base, sourceFile, pair.target);
+        operations.push({
+            family: "file",
+            operation: {
+                kind: "fileRename",
+                sourceFile,
+                targetDir: path.dirname(targetFile),
+                targetFile
+            }
+        });
+    }
+}
+function buildSegments(operations) {
+    const segments = [];
+    for (const operation of operations) {
+        const previous = segments[segments.length - 1];
+        if (operation.family === "semantic") {
+            if (previous?.kind === "semantic") {
+                previous.requests.push(operation.request);
+            }
+            else {
+                segments.push({ kind: "semantic", requests: [operation.request] });
+            }
+            continue;
+        }
+        if (operation.family === "file") {
+            if (previous?.kind === "file") {
+                previous.operations.push(operation.operation);
+            }
+            else {
+                segments.push({ kind: "file", operations: [operation.operation] });
+            }
+            continue;
+        }
+        if (operation.family === "importsNormalize") {
+            segments.push({ kind: "imports.normalize", request: operation.request });
+            continue;
+        }
+        if (operation.family === "importsRebase") {
+            segments.push({ kind: "imports.rebase", request: operation.request });
+            continue;
+        }
+        if (operation.family === "exportsObject") {
+            if (previous?.kind === "exports.object" && previous.sourceFile === operation.request.sourceFile) {
+                previous.packs.push(...readObjectArray(operation.request.packs));
+            }
+            else {
+                segments.push({ kind: "exports.object", sourceFile: String(operation.request.sourceFile ?? ""), packs: readObjectArray(operation.request.packs) });
+            }
+            continue;
+        }
+        if (operation.family === "exportsStar") {
+            segments.push({ kind: "exports.star", ...operation.request });
+            continue;
+        }
+        if (operation.family === "declaration") {
+            segments.push({ kind: "declaration", request: operation.request });
+            continue;
+        }
+        if (previous?.kind === "modulePlan" && previous.sourceFile === operation.sourceFile && previous.expectEmpty === operation.expectEmpty) {
+            previous.modules.push(operation.row);
+        }
+        else {
+            segments.push({
+                kind: "modulePlan",
+                sourceFile: operation.sourceFile,
+                expectEmpty: operation.expectEmpty,
+                modules: [operation.row]
+            });
+        }
+        continue;
+    }
+    return segments;
+}
+function parseExportsStarLine(sourceFile, line, lineNumber, operation) {
+    const label = `exports.star.${operation}`;
+    const body = line.slice(label.length).trim();
+    const selectors = [];
+    let namespaceShape = "retain";
+    for (const token of tokenize(body, lineNumber)) {
+        const separator = token.indexOf("=");
+        if (separator < 0) {
+            throw new errors_1.CliError("INVALID_MUTATE_DSL", `${label} expects key=value options at line ${lineNumber}.`, { line: lineNumber, token });
+        }
+        const key = token.slice(0, separator);
+        const value = token.slice(separator + 1);
+        if (key === "from") {
+            selectors.push(...value.split(",").map((item) => item.trim()).filter(Boolean));
+            continue;
+        }
+        if (operation === "expand" && key === "namespaceShape" && (value === "allow" || value === "retain")) {
+            namespaceShape = value;
+            continue;
+        }
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `Unknown ${label} option at line ${lineNumber}: ${token}`, { line: lineNumber, option: key });
+    }
+    return {
+        operation,
+        sourceFile,
+        selectors,
+        ...(operation === "expand" ? { namespaceShape } : {})
+    };
+}
+function parseObjectPackLine(sourceFile, line, lineNumber, operation) {
+    const label = `object.${operation}`;
+    const body = line.slice(label.length).trim();
+    const colonIndex = body.indexOf(":");
+    if (colonIndex < 0) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `${label} expects ':' at line ${lineNumber}.`, { line: lineNumber });
+    }
+    const objectName = body.slice(0, colonIndex).trim();
+    const tokens = tokenize(body.slice(colonIndex + 1).trim(), lineNumber);
+    if (!/^[A-Za-z_$][\w$]*$/.test(objectName)) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `${label} expects a valid object name at line ${lineNumber}.`, { line: lineNumber });
+    }
+    const selectors = [];
+    const pack = {
+        operation,
+        objectName,
+        selectors,
+        exportMode: "replace",
+        usageMode: "property"
+    };
+    for (const token of tokens) {
+        const separator = token.indexOf("=");
+        if (separator < 0) {
+            selectors.push(token);
+            continue;
+        }
+        const key = token.slice(0, separator);
+        const value = token.slice(separator + 1);
+        if (key === "export") {
+            pack.exportMode = value;
+            continue;
+        }
+        if (key === "usage") {
+            pack.usageMode = value;
+            continue;
+        }
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `${key}= is not supported for ${label} at line ${lineNumber}.`, { line: lineNumber });
+    }
+    if (selectors.length === 0) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `${label} expects at least one selector at line ${lineNumber}.`, { line: lineNumber });
+    }
+    return {
+        sourceFile,
+        packs: [pack]
+    };
+}
+function parseImportsNormalizeLine(line, lineNumber, defaults) {
+    const tokens = tokenize(line.slice("imports.normalize".length).trim(), lineNumber);
+    const request = {};
+    if (defaults.scope) {
+        request.scope = defaults.scope;
+    }
+    for (const token of tokens) {
+        if (token === "+overrideConfig") {
+            request.overrideConfig = true;
+            continue;
+        }
+        const separator = token.indexOf("=");
+        if (separator < 0) {
+            if (request.scope !== undefined) {
+                throw new errors_1.CliError("INVALID_MUTATE_DSL", `imports.normalize accepts one positional scope at line ${lineNumber}.`, { line: lineNumber });
+            }
+            request.scope = token;
+            continue;
+        }
+        const key = token.slice(0, separator);
+        const value = token.slice(separator + 1);
+        if (key === "scope" || key === "to" || key === "mode" || key === "preferAlias") {
+            request[key === "to" ? "to" : key] = value;
+            continue;
+        }
+        if (key === "exclude" || key === "excludes" || key === "pathExclude") {
+            request.exclude = parseListValue(value);
+            continue;
+        }
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `imports.normalize does not support ${key}= at line ${lineNumber}.`, { line: lineNumber });
+    }
+    if (typeof request.scope !== "string" || request.scope.trim() === "") {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `imports.normalize expects scope=... or positional scope at line ${lineNumber}.`, { line: lineNumber });
+    }
+    return request;
+}
+function parseImportsRebaseLine(line, lineNumber, defaults) {
+    const operation = line.startsWith("imports.useBarrel") ? "imports.useBarrel" : "imports.useDirect";
+    const tokens = tokenize(line.slice(operation.length).trim(), lineNumber);
+    const request = { operation };
+    if (defaults.scope) {
+        request.scope = defaults.scope;
+    }
+    if (defaults.files) {
+        request.files = defaults.files;
+    }
+    const positionals = [];
+    const pathExclude = [];
+    const symbols = [];
+    for (const token of tokens) {
+        const separator = token.indexOf("=");
+        if (separator < 0) {
+            positionals.push(token);
+            continue;
+        }
+        const key = token.slice(0, separator);
+        const value = token.slice(separator + 1);
+        if (key === "scope") {
+            request.scope = value;
+            continue;
+        }
+        if (key === "barrel" || key === "target" || key === "path") {
+            request.barrel = value;
+            continue;
+        }
+        if (key === "pathExclude" || key === "exclude" || key === "excludes") {
+            pathExclude.push(...parseListValue(value));
+            continue;
+        }
+        if (key === "symbols" || key === "symbol") {
+            symbols.push(...parseListValue(value));
+            continue;
+        }
+        if (key === "details") {
+            request.details = value === "true" || value === "1" || value === "all";
+            continue;
+        }
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `${operation} does not support ${key}= at line ${lineNumber}.`, { line: lineNumber });
+    }
+    if (positionals.length > 1) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `${operation} accepts one barrel path at line ${lineNumber}.`, { line: lineNumber });
+    }
+    if (request.barrel === undefined && positionals[0] !== undefined) {
+        request.barrel = positionals[0];
+    }
+    if (typeof request.barrel !== "string" || request.barrel.trim() === "") {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `${operation} expects a barrel file or directory at line ${lineNumber}.`, { line: lineNumber });
+    }
+    if (!request.scope && !request.files) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `${operation} expects @scope or @files before line ${lineNumber}.`, { line: lineNumber });
+    }
+    if (pathExclude.length > 0) {
+        request.pathExclude = pathExclude;
+    }
+    if (symbols.length > 0) {
+        request.symbols = symbols;
+    }
+    return request;
+}
+function buildDeclarationRequest(defaults, operation, body, lineNumber) {
+    const parsed = parseDeclarationOperationBody(body, lineNumber);
+    const request = {
+        operation,
+        selectors: parsed.selectors,
+        ...(parsed.exclude.length > 0 ? { exclude: parsed.exclude } : {}),
+        ...(parsed.prefer.length > 0 ? { prefer: parsed.prefer } : {}),
+        ...(parsed.details ? { details: true } : {})
+    };
+    if (defaults.scope) {
+        request.scope = defaults.scope;
+    }
+    if (defaults.files) {
+        request.files = defaults.files;
+    }
+    if (operation === "remove" && request.selectors.length === 0) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `remove expects at least one selector at line ${lineNumber}.`, { line: lineNumber });
+    }
+    return request;
+}
+function parseDeclarationOperationBody(body, lineNumber) {
+    const selectors = [];
+    const exclude = [];
+    const prefer = [];
+    let details = false;
+    for (const token of body ? tokenize(body, lineNumber) : []) {
+        const separator = token.indexOf("=");
+        if (separator < 0) {
+            selectors.push(token);
+            continue;
+        }
+        const key = token.slice(0, separator);
+        const value = token.slice(separator + 1);
+        if (key === "exclude" || key === "excludes") {
+            exclude.push(...parseListValue(value));
+            continue;
+        }
+        if (key === "prefer") {
+            prefer.push(...parseListValue(value));
+            continue;
+        }
+        if (key === "details") {
+            details = value === "true" || value === "1" || value === "all";
+            continue;
+        }
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `${key}= is not supported for declaration ${lineNumber}.`, { line: lineNumber });
+    }
+    return { selectors, exclude, prefer, details };
+}
+function requireDeclarationTarget(defaults, lineNumber, op) {
+    if (!defaults.scope && (!defaults.files || defaults.files.length === 0)) {
+        throw new errors_1.CliError("MUTATE_DECLARATION_TARGET_REQUIRED", `${op} expects @scope or @files before line ${lineNumber}.`, { line: lineNumber });
+    }
+}
+function parseListValue(value) {
+    const trimmed = value.trim();
+    const withoutBrackets = trimmed.startsWith("[") && trimmed.endsWith("]")
+        ? trimmed.slice(1, -1)
+        : trimmed;
+    return withoutBrackets.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function parseMoveToDirLine(line, lineNumber, diagnostics) {
+    const body = line.slice("moveToDir".length).trim();
+    const colonIndex = body.indexOf(":");
+    if (colonIndex < 0) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `moveToDir expects ':' at line ${lineNumber}.`, { line: lineNumber });
+    }
+    const targetDir = body.slice(0, colonIndex).trim();
+    const rest = body.slice(colonIndex + 1).trim();
+    if (!targetDir) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `moveToDir expects a target directory at line ${lineNumber}.`, { line: lineNumber });
+    }
+    return {
+        targetDir,
+        files: rest ? stripUnknownOptions("mutate file moveToDir", tokenize(rest, lineNumber), diagnostics, lineNumber).tokens : []
+    };
+}
+function parseMoveLine(line, lineNumber, diagnostics) {
+    const body = line.slice("move".length).trim();
+    const colonIndex = body.indexOf(":");
+    if (colonIndex < 0) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `move expects ':' at line ${lineNumber}.`, { line: lineNumber });
+    }
+    const targetFile = body.slice(0, colonIndex).trim();
+    const entities = stripUnknownOptions("mutate semantic move", tokenize(body.slice(colonIndex + 1).trim(), lineNumber), diagnostics, lineNumber).tokens;
+    if (!targetFile || entities.length === 0) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `move expects target file and entities at line ${lineNumber}.`, { line: lineNumber });
+    }
+    return { targetFile, entities };
+}
+function parseModuleLine(line, lineNumber, diagnostics) {
+    const body = line.slice("module".length).trim();
+    const colonIndex = body.indexOf(":");
+    if (colonIndex < 0) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `module expects ':' at line ${lineNumber}.`, { line: lineNumber });
+    }
+    const targetFile = body.slice(0, colonIndex).trim();
+    const symbols = stripUnknownOptions("mutate module", tokenize(body.slice(colonIndex + 1).trim(), lineNumber), diagnostics, lineNumber).tokens;
+    if (!targetFile || symbols.length === 0) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `module expects target file and symbols at line ${lineNumber}.`, { line: lineNumber });
+    }
+    return { targetFile, symbols };
+}
+function parseRenamePairs(body, lineNumber, diagnostics, command = "mutate semantic rename") {
+    if (!body) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `rename expects at least one pair at line ${lineNumber}.`, { line: lineNumber });
+    }
+    const tokens = diagnostics
+        ? stripUnknownOptions(command, tokenize(body, lineNumber), diagnostics, lineNumber).tokens
+        : tokenize(body, lineNumber);
+    const pairs = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        const inlineArrow = token.indexOf("->");
+        if (inlineArrow >= 0) {
+            const source = token.slice(0, inlineArrow).trim();
+            const target = token.slice(inlineArrow + 2).trim();
+            if (!source || !target) {
+                throw invalidRenamePair(lineNumber);
+            }
+            pairs.push({ source, target });
+            continue;
+        }
+        if (tokens[index + 1] !== "->" || !tokens[index + 2]) {
+            throw invalidRenamePair(lineNumber);
+        }
+        pairs.push({ source: token, target: tokens[index + 2] });
+        index += 2;
+    }
+    return pairs;
+}
+function stripUnknownOptions(command, tokens, diagnostics, lineNumber, knownOptions = new Set()) {
+    const kept = [];
+    const unknownOptions = [];
+    for (const token of tokens) {
+        if (knownOptions.has(token)) {
+            kept.push(token);
+            continue;
+        }
+        if (isOptionLikeToken(token)) {
+            unknownOptions.push(token);
+            continue;
+        }
+        kept.push(token);
+    }
+    if (unknownOptions.length > 0) {
+        diagnostics.push({
+            kind: "unknownOption",
+            command,
+            options: uniqueStrings(unknownOptions),
+            line: lineNumber
+        });
+    }
+    return { tokens: kept };
+}
+function isOptionLikeToken(token) {
+    return token.startsWith("+") ||
+        token.startsWith("--") ||
+        /^-[A-Za-z][\w.-]*$/.test(token) ||
+        /^[A-Za-z][\w.-]*=/.test(token);
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function readObjectArray(value) {
+    return Array.isArray(value) ? value.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)) : [];
+}
+function invalidRenamePair(lineNumber) {
+    return new errors_1.CliError("INVALID_MUTATE_DSL", `rename expects <old>-><new> at line ${lineNumber}.`, { line: lineNumber });
+}
+function requireSource(defaults, lineNumber, op) {
+    if (!defaults.sourceFile) {
+        throw new errors_1.CliError("MUTATE_SOURCE_REQUIRED", `${op} expects @source before line ${lineNumber}.`, { line: lineNumber });
+    }
+}
+function requireBase(defaults, lineNumber, op) {
+    if (!defaults.base) {
+        throw new errors_1.CliError("MUTATE_BASE_REQUIRED", `${op} expects @base before line ${lineNumber}.`, { line: lineNumber });
+    }
+}
+function resolveDslPath(base, filePath) {
+    return path.normalize(path.isAbsolute(filePath) ? filePath : path.join(base, filePath));
+}
+function resolveRenameTarget(base, sourceFile, target) {
+    if (path.isAbsolute(target)) {
+        return path.normalize(target);
+    }
+    if (target.includes("/") || target.includes("\\")) {
+        return path.normalize(path.join(base, target));
+    }
+    return path.normalize(path.join(path.dirname(sourceFile), target));
+}
+function stripComment(line) {
+    const index = line.indexOf("#");
+    return index >= 0 ? line.slice(0, index) : line;
+}
+function tokenize(input, lineNumber) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        if (char === "-" && input[index + 1] === ">") {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            tokens.push("->");
+            index += 1;
+            continue;
+        }
+        current += char;
+    }
+    if (quote) {
+        throw new errors_1.CliError("INVALID_MUTATE_DSL", `Unterminated quote at line ${lineNumber}.`, { line: lineNumber });
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}