poe-code 3.0.4 → 3.0.6

package/dist/services/service-manifest.js

@@ -1,717 +0,0 @@
-import path from "node:path";
-import { createBackup } from "../utils/backup.js";
-import { renderTemplate } from "../utils/templates.js";
-import { deepMergeJson, isJsonObject, pruneJsonByShape } from "../utils/json.js";
-import { parseTomlDocument, serializeTomlDocument, mergeTomlTables } from "../utils/toml.js";
-export function ensureDirectory(config) {
-    const targetDirectory = config.targetDirectory ?? config.path;
-    if (!targetDirectory) {
-        throw new Error("ensureDirectory requires a path or targetDirectory.");
-    }
-    return {
-        kind: "ensureDirectory",
-        targetDirectory,
-        label: config.label
-    };
-}
-export function createBackupMutation(config) {
-    return {
-        kind: "createBackup",
-        target: normalizeTargetLocation(config),
-        timestamp: config.timestamp,
-        label: config.label
-    };
-}
-export function writeTemplateMutation(config) {
-    return {
-        kind: "writeTemplate",
-        target: normalizeTargetLocation(config),
-        templateId: config.templateId,
-        context: config.context,
-        label: config.label
-    };
-}
-export function chmodMutation(config) {
-    return {
-        kind: "chmod",
-        target: normalizeTargetLocation(config),
-        mode: config.mode,
-        label: config.label
-    };
-}
-export function jsonMergeMutation(config) {
-    return {
-        kind: "transformFile",
-        target: normalizeTargetLocation(config),
-        label: config.label,
-        async transform({ content, context }) {
-            const targetPath = resolveTargetPath(config, context);
-            const current = await parseJsonWithRecovery({
-                content,
-                fs: context.fs,
-                targetPath
-            });
-            const desired = resolveValue(config.value, context);
-            const merged = deepMergeJson(current, desired);
-            const serialized = serializeJson(merged);
-            return {
-                content: serialized,
-                changed: serialized !== content
-            };
-        }
-    };
-}
-export function jsonPruneMutation(config) {
-    return {
-        kind: "transformFile",
-        target: normalizeTargetLocation(config),
-        label: config.label,
-        async transform({ content, context }) {
-            if (content == null) {
-                return { content: null, changed: false };
-            }
-            const targetPath = resolveTargetPath(config, context);
-            const current = await parseJsonWithRecovery({
-                content,
-                fs: context.fs,
-                targetPath
-            });
-            const shape = resolveValue(config.shape, context);
-            const { changed, result } = pruneJsonByShape(current, shape);
-            if (!changed) {
-                return { content, changed: false };
-            }
-            if (Object.keys(result).length === 0) {
-                return { content: null, changed: true };
-            }
-            const serialized = serializeJson(result);
-            return {
-                content: serialized,
-                changed: serialized !== content
-            };
-        }
-    };
-}
-export function tomlMergeMutation(config) {
-    return {
-        kind: "transformFile",
-        target: normalizeTargetLocation(config),
-        label: config.label,
-        async transform({ content, context }) {
-            const targetPath = resolveTargetPath(config, context);
-            const current = await parseTomlWithRecovery({
-                content,
-                fs: context.fs,
-                targetPath
-            });
-            const desired = resolveValue(config.value, context);
-            const mergeOptions = config.pruneByPrefix
-                ? { pruneByPrefix: config.pruneByPrefix }
-                : {};
-            const merged = mergeTomlTables(current, desired, mergeOptions);
-            const serialized = serializeTomlDocument(merged);
-            const previous = content ?? "";
-            return {
-                content: serialized,
-                changed: serialized !== previous
-            };
-        }
-    };
-}
-export function tomlPruneMutation(config) {
-    return {
-        kind: "transformFile",
-        target: normalizeTargetLocation(config),
-        label: config.label,
-        async transform({ content, context }) {
-            if (content == null) {
-                return { content: null, changed: false };
-            }
-            let document;
-            try {
-                document = parseTomlDocument(content);
-            }
-            catch {
-                return { content, changed: false };
-            }
-            const outcome = config.prune(document, context);
-            if (!outcome.changed) {
-                return { content, changed: false };
-            }
-            if (!outcome.result || Object.keys(outcome.result).length === 0) {
-                return { content: null, changed: true };
-            }
-            const serialized = serializeTomlDocument(outcome.result);
-            return {
-                content: serialized,
-                changed: serialized !== content
-            };
-        }
-    };
-}
-export function tomlTemplateMergeMutation(config) {
-    return {
-        kind: "transformFile",
-        target: normalizeTargetLocation(config),
-        label: config.label,
-        async transform({ content, context }) {
-            const targetPath = resolveTargetPath(config, context);
-            const current = await parseTomlWithRecovery({
-                content,
-                fs: context.fs,
-                targetPath
-            });
-            const templateContext = config.context
-                ? resolveValue(config.context, context)
-                : undefined;
-            const rendered = await renderTemplate(config.templateId, templateContext ?? {});
-            const templateDocument = parseTomlDocument(rendered);
-            const merged = mergeTomlTables(current, templateDocument);
-            const serialized = serializeTomlDocument(merged);
-            const previous = content ?? "";
-            return {
-                content: serialized,
-                changed: serialized !== previous
-            };
-        }
-    };
-}
-export function removePatternMutation(config) {
-    return {
-        kind: "transformFile",
-        target: { target: config.target },
-        label: config.label,
-        transform({ content, context }) {
-            if (content == null) {
-                return { content: null, changed: false };
-            }
-            let next;
-            if (typeof config.replacement === "function") {
-                const replacementFn = config.replacement;
-                const replacer = (match, ..._args) => replacementFn(match, context);
-                next = content.replace(config.pattern, replacer);
-            }
-            else {
-                next = content.replace(config.pattern, config.replacement ?? "");
-            }
-            return {
-                content: next,
-                changed: next !== content
-            };
-        }
-    };
-}
-export function removeFileMutation(config) {
-    return {
-        kind: "removeFile",
-        target: normalizeTargetLocation(config),
-        whenEmpty: config.whenEmpty,
-        whenContentMatches: config.whenContentMatches,
-        label: config.label
-    };
-}
-export function createServiceManifest(definition) {
-    const configureMutations = definition.configure;
-    const unconfigureMutations = definition.unconfigure;
-    return {
-        id: definition.id,
-        summary: definition.summary,
-        configureMutations,
-        unconfigureMutations,
-        async configure(context, runOptions) {
-            await runMutations(configureMutations, context, {
-                trackChanges: false,
-                observers: runOptions?.observers,
-                manifestId: definition.id
-            });
-        },
-        async unconfigure(context, runOptions) {
-            if (!unconfigureMutations) {
-                return false;
-            }
-            return runMutations(unconfigureMutations, context, {
-                trackChanges: true,
-                observers: runOptions?.observers,
-                manifestId: definition.id
-            });
-        }
-    };
-}
-async function runMutations(mutations, context, options) {
-    let touched = false;
-    for (const mutation of mutations) {
-        const changed = await applyMutation(mutation, context, options.manifestId, options.observers);
-        if (options.trackChanges && changed) {
-            touched = true;
-        }
-    }
-    return touched;
-}
-async function applyMutation(mutation, context, manifestId, observers) {
-    switch (mutation.kind) {
-        case "ensureDirectory": {
-            validateHomeRelativePath(mutation.targetDirectory, context);
-            const targetPath = resolvePath({ targetDirectory: mutation.targetDirectory }, context);
-            const details = createMutationDetails(mutation, manifestId, targetPath, context);
-            observers?.onStart?.(details);
-            try {
-                const existed = await pathExists(context.fs, targetPath);
-                await context.fs.mkdir(targetPath, { recursive: true });
-                observers?.onComplete?.(details, {
-                    changed: !existed,
-                    effect: "mkdir",
-                    detail: existed ? "noop" : "create"
-                });
-                flushCommandDryRun(context);
-                return !existed;
-            }
-            catch (error) {
-                observers?.onError?.(details, error);
-                throw error;
-            }
-        }
-        case "createBackup": {
-            validateHomeRelativePath(mutation.target, context);
-            const targetPath = resolvePath(mutation.target, context);
-            const timestamp = mutation.timestamp
-                ? resolveValue(mutation.timestamp, mutationContext(context))
-                : undefined;
-            const details = createMutationDetails(mutation, manifestId, targetPath, context);
-            observers?.onStart?.(details);
-            try {
-                const backupPath = await createBackup(context.fs, targetPath, timestamp);
-                observers?.onComplete?.(details, {
-                    changed: backupPath != null,
-                    effect: backupPath ? "copy" : "none",
-                    detail: backupPath ? "backup" : "noop"
-                });
-                flushCommandDryRun(context);
-            }
-            catch (error) {
-                observers?.onError?.(details, error);
-                throw error;
-            }
-            return false;
-        }
-        case "writeTemplate": {
-            validateHomeRelativePath(mutation.target, context);
-            const targetPath = resolvePath(mutation.target, context);
-            const renderContext = mutation.context
-                ? resolveValue(mutation.context, mutationContext(context))
-                : undefined;
-            const rendered = await renderTemplate(mutation.templateId, renderContext ?? {});
-            const details = createMutationDetails(mutation, manifestId, targetPath, context);
-            observers?.onStart?.(details);
-            try {
-                const existed = await pathExists(context.fs, targetPath);
-                await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
-                observers?.onComplete?.(details, {
-                    changed: true,
-                    effect: "write",
-                    detail: existed ? "update" : "create"
-                });
-                flushCommandDryRun(context);
-            }
-            catch (error) {
-                observers?.onError?.(details, error);
-                throw error;
-            }
-            return true;
-        }
-        case "chmod": {
-            validateHomeRelativePath(mutation.target, context);
-            const targetPath = resolvePath(mutation.target, context);
-            const details = createMutationDetails(mutation, manifestId, targetPath, context);
-            observers?.onStart?.(details);
-            try {
-                if (typeof context.fs.chmod !== "function") {
-                    observers?.onComplete?.(details, {
-                        changed: false,
-                        effect: "none",
-                        detail: "noop"
-                    });
-                    flushCommandDryRun(context);
-                    return false;
-                }
-                const stat = await context.fs.stat(targetPath);
-                const currentMode = typeof stat.mode === "number" ? stat.mode & 0o777 : null;
-                if (currentMode === mutation.mode) {
-                    observers?.onComplete?.(details, {
-                        changed: false,
-                        effect: "none",
-                        detail: "noop"
-                    });
-                    flushCommandDryRun(context);
-                    return false;
-                }
-                await context.fs.chmod(targetPath, mutation.mode);
-                observers?.onComplete?.(details, {
-                    changed: true,
-                    effect: "chmod",
-                    detail: "update"
-                });
-                flushCommandDryRun(context);
-                return true;
-            }
-            catch (error) {
-                if (isNotFound(error)) {
-                    observers?.onComplete?.(details, {
-                        changed: false,
-                        effect: "none",
-                        detail: "noop"
-                    });
-                    flushCommandDryRun(context);
-                    return false;
-                }
-                observers?.onError?.(details, error);
-                throw error;
-            }
-        }
-        case "removeFile": {
-            validateHomeRelativePath(mutation.target, context);
-            const targetPath = resolvePath(mutation.target, context);
-            const details = createMutationDetails(mutation, manifestId, targetPath, context);
-            observers?.onStart?.(details);
-            try {
-                const raw = await context.fs.readFile(targetPath, "utf8");
-                const trimmed = raw.trim();
-                if (mutation.whenContentMatches &&
-                    !mutation.whenContentMatches.test(trimmed)) {
-                    observers?.onComplete?.(details, {
-                        changed: false,
-                        effect: "none",
-                        detail: "noop"
-                    });
-                    flushCommandDryRun(context);
-                    return false;
-                }
-                if (mutation.whenEmpty && trimmed.length > 0) {
-                    observers?.onComplete?.(details, {
-                        changed: false,
-                        effect: "none",
-                        detail: "noop"
-                    });
-                    flushCommandDryRun(context);
-                    return false;
-                }
-                await context.fs.unlink(targetPath);
-                observers?.onComplete?.(details, {
-                    changed: true,
-                    effect: "delete",
-                    detail: "delete"
-                });
-                flushCommandDryRun(context);
-                return true;
-            }
-            catch (error) {
-                if (isNotFound(error)) {
-                    observers?.onComplete?.(details, {
-                        changed: false,
-                        effect: "none",
-                        detail: "noop"
-                    });
-                    flushCommandDryRun(context);
-                    return false;
-                }
-                observers?.onError?.(details, error);
-                throw error;
-            }
-        }
-        case "transformFile": {
-            validateHomeRelativePath(mutation.target, context);
-            const targetPath = resolvePath(mutation.target, context);
-            const current = await readFileIfExists(context.fs, targetPath);
-            const details = createMutationDetails(mutation, manifestId, targetPath, context);
-            observers?.onStart?.(details);
-            try {
-                const result = await mutation.transform({
-                    content: current,
-                    context: mutationContext(context)
-                });
-                const transformOutcome = await persistTransformResult({
-                    fs: context.fs,
-                    targetPath,
-                    previousContent: current,
-                    result
-                });
-                observers?.onComplete?.(details, transformOutcome);
-                flushCommandDryRun(context);
-                return transformOutcome.changed;
-            }
-            catch (error) {
-                observers?.onError?.(details, error);
-                throw error;
-            }
-        }
-        default: {
-            const neverMutation = mutation;
-            throw new Error(`Unsupported mutation kind: ${neverMutation.kind}`);
-        }
-    }
-}
-function validateHomeRelativePath(resolver, context) {
-    const raw = resolveRawPathResolver(resolver, context);
-    if (typeof raw !== "string" || raw.length === 0) {
-        return;
-    }
-    if (raw.startsWith("~")) {
-        return;
-    }
-    throw new Error(`Service manifest targets must live under home (~): received "${raw}".`);
-}
-function resolveRawPathResolver(resolver, context) {
-    const location = normalizeResolverToLocation(resolver);
-    if ("target" in location && location.target !== undefined) {
-        return resolveValue(location.target, mutationContext(context));
-    }
-    return resolveValue(location.targetDirectory, mutationContext(context));
-}
-function mutationContext(context) {
-    return {
-        fs: context.fs,
-        options: context.options,
-        env: context.env
-    };
-}
-function createMutationDetails(mutation, manifestId, targetPath, context) {
-    const customLabel = mutation.label != null
-        ? resolveValue(mutation.label, mutationContext(context))
-        : undefined;
-    const label = customLabel ?? describeMutationOperation(mutation.kind, targetPath);
-    return {
-        manifestId,
-        kind: mutation.kind,
-        label,
-        targetPath
-    };
-}
-function describeMutationOperation(kind, targetPath) {
-    const displayPath = targetPath ?? "target";
-    switch (kind) {
-        case "ensureDirectory":
-            return `Create ${displayPath}`;
-        case "createBackup":
-            return `Backup ${displayPath}`;
-        case "writeTemplate":
-            return `Write ${displayPath}`;
-        case "chmod":
-            return `Set permissions on ${displayPath}`;
-        case "removeFile":
-            return `Remove ${displayPath}`;
-        case "transformFile":
-            return `Update ${displayPath}`;
-        default:
-            return "Operation";
-    }
-}
-function resolveValue(resolver, context) {
-    if (typeof resolver === "function") {
-        return resolver(context);
-    }
-    return resolver;
-}
-function resolvePath(resolver, context) {
-    const location = normalizeResolverToLocation(resolver);
-    if ("target" in location && location.target !== undefined) {
-        const raw = resolveValue(location.target, mutationContext(context));
-        const expanded = expandHomeShortcut(raw, context.env);
-        if (!context.pathMapper) {
-            return expanded;
-        }
-        const rawDirectory = path.dirname(expanded);
-        const mappedDirectory = context.pathMapper.mapTargetDirectory({
-            targetDirectory: rawDirectory,
-            env: context.env
-        });
-        const rawFile = path.basename(expanded);
-        return rawFile.length === 0 ? mappedDirectory : path.join(mappedDirectory, rawFile);
-    }
-    const rawDirectory = resolveValue(location.targetDirectory, mutationContext(context));
-    const expandedDirectory = expandHomeShortcut(rawDirectory, context.env);
-    const mappedDirectory = context.pathMapper
-        ? context.pathMapper.mapTargetDirectory({
-            targetDirectory: expandedDirectory,
-            env: context.env
-        })
-        : expandedDirectory;
-    if (location.targetFile === undefined) {
-        return mappedDirectory;
-    }
-    const rawFile = resolveValue(location.targetFile, mutationContext(context));
-    return rawFile.length === 0 ? mappedDirectory : path.join(mappedDirectory, rawFile);
-}
-function normalizeResolverToLocation(resolver) {
-    if (typeof resolver === "object" && resolver != null) {
-        if ("target" in resolver || "targetDirectory" in resolver) {
-            return resolver;
-        }
-    }
-    return {
-        target: resolver
-    };
-}
-function normalizeTargetLocation(config) {
-    if (config.target) {
-        return { target: config.target };
-    }
-    if (config.targetDirectory) {
-        return {
-            targetDirectory: config.targetDirectory,
-            targetFile: config.targetFile
-        };
-    }
-    throw new Error("Missing target for service manifest mutation.");
-}
-function resolveTargetPath(config, context) {
-    if (config.target) {
-        return expandHomeShortcut(resolveValue(config.target, context), context.env);
-    }
-    if (!config.targetDirectory) {
-        throw new Error("Missing targetDirectory.");
-    }
-    const directory = expandHomeShortcut(resolveValue(config.targetDirectory, context), context.env);
-    if (!config.targetFile) {
-        return directory;
-    }
-    const file = resolveValue(config.targetFile, context);
-    return file.length === 0 ? directory : path.join(directory, file);
-}
-function flushCommandDryRun(context) {
-    context.command.flushDryRun({ emitIfEmpty: false });
-}
-function expandHomeShortcut(targetPath, env) {
-    if (!targetPath?.startsWith("~")) {
-        return targetPath;
-    }
-    if (targetPath.startsWith("~./")) {
-        targetPath = `~/.${targetPath.slice(3)}`;
-    }
-    const homeDir = env?.homeDir ?? process.env.HOME ?? process.env.USERPROFILE;
-    if (!homeDir) {
-        return targetPath;
-    }
-    let remainder = targetPath.slice(1);
-    if (remainder.startsWith("/")) {
-        remainder = remainder.slice(1);
-    }
-    else if (remainder.startsWith("\\")) {
-        remainder = remainder.slice(1);
-    }
-    else if (remainder.startsWith(".")) {
-        remainder = remainder.slice(1);
-        if (remainder.startsWith("/")) {
-            remainder = remainder.slice(1);
-        }
-        else if (remainder.startsWith("\\")) {
-            remainder = remainder.slice(1);
-        }
-    }
-    return remainder.length === 0 ? homeDir : path.join(homeDir, remainder);
-}
-function parseJson(content) {
-    if (content == null) {
-        return {};
-    }
-    const parsed = JSON.parse(content);
-    if (!isJsonObject(parsed)) {
-        throw new Error("Expected JSON object for manifest-managed file.");
-    }
-    return parsed;
-}
-async function parseJsonWithRecovery(input) {
-    try {
-        return parseJson(input.content);
-    }
-    catch {
-        await backupInvalidJsonDocument(input);
-        return {};
-    }
-}
-async function parseTomlWithRecovery(input) {
-    if (input.content == null) {
-        return {};
-    }
-    try {
-        return parseTomlDocument(input.content);
-    }
-    catch {
-        await backupInvalidTomlDocument(input);
-        return {};
-    }
-}
-async function backupInvalidJsonDocument(input) {
-    if (input.content == null) {
-        return;
-    }
-    const backupPath = createInvalidDocumentBackupPath(input.targetPath);
-    await input.fs.writeFile(backupPath, input.content, { encoding: "utf8" });
-}
-async function backupInvalidTomlDocument(input) {
-    if (input.content == null) {
-        return;
-    }
-    const backupPath = createInvalidDocumentBackupPath(input.targetPath);
-    await input.fs.writeFile(backupPath, input.content, { encoding: "utf8" });
-}
-function createInvalidDocumentBackupPath(targetPath) {
-    return `${targetPath}.invalid-${createTimestamp()}.json`;
-}
-function createTimestamp() {
-    return new Date()
-        .toISOString()
-        .replaceAll(":", "-")
-        .replaceAll(".", "-");
-}
-function serializeJson(value) {
-    return `${JSON.stringify(value, null, 2)}\n`;
-}
-async function persistTransformResult(input) {
-    if (!input.result.changed) {
-        return { changed: false, effect: "none", detail: "noop" };
-    }
-    if (input.result.content == null) {
-        if (input.previousContent == null) {
-            return { changed: false, effect: "none", detail: "noop" };
-        }
-        await input.fs.unlink(input.targetPath);
-        return { changed: true, effect: "delete", detail: "delete" };
-    }
-    await input.fs.writeFile(input.targetPath, input.result.content, {
-        encoding: "utf8"
-    });
-    return {
-        changed: true,
-        effect: "write",
-        detail: input.previousContent == null ? "create" : "update"
-    };
-}
-async function readFileIfExists(fs, target) {
-    try {
-        return await fs.readFile(target, "utf8");
-    }
-    catch (error) {
-        if (isNotFound(error)) {
-            return null;
-        }
-        throw error;
-    }
-}
-async function pathExists(fs, target) {
-    try {
-        await fs.stat(target);
-        return true;
-    }
-    catch (error) {
-        if (isNotFound(error)) {
-            return false;
-        }
-        throw error;
-    }
-}
-function isNotFound(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === "ENOENT");
-}
-//# sourceMappingURL=service-manifest.js.map