@use-the-fork/spindle 0.0.0-stage → 0.0.2

package/build/Support/Repository.js

@@ -0,0 +1,139 @@
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+export class Repository {
+    items = {};
+    get(key, defaultValue) {
+        const result = this.lookup(this.segments(key), key);
+        if (result.found)
+            return result.value;
+        return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+    }
+    set(key, value) {
+        const segments = this.segments(key);
+        let parent = this.items;
+        for (let index = 0; index < segments.length - 1; index++) {
+            const segment = segments[index];
+            if (!Object.hasOwn(parent, segment)) {
+                const branch = {};
+                let nested = branch;
+                for (const remaining of segments.slice(index + 1, -1)) {
+                    const child = {};
+                    this.write(nested, remaining, child);
+                    nested = child;
+                }
+                this.write(nested, segments[segments.length - 1], value);
+                this.write(parent, segment, branch);
+                return;
+            }
+            parent = this.container(parent[segment], key, segments.slice(0, index + 1));
+        }
+        this.write(parent, segments[segments.length - 1], value);
+    }
+    has(key) {
+        return this.lookup(this.segments(key), key).found;
+    }
+    delete(key) {
+        const segments = this.segments(key);
+        let parent = this.items;
+        for (let index = 0; index < segments.length - 1; index++) {
+            const segment = segments[index];
+            if (!Object.hasOwn(parent, segment))
+                return false;
+            parent = this.container(parent[segment], key, segments.slice(0, index + 1));
+        }
+        const last = segments[segments.length - 1];
+        if (!Object.hasOwn(parent, last))
+            return false;
+        return delete parent[last];
+    }
+    string(key, defaultValue) {
+        return this.typed(key, (value) => typeof value === "string", "a string", defaultValue, arguments.length > 1);
+    }
+    integer(key, defaultValue) {
+        return this.typed(key, (value) => typeof value === "number" && Number.isSafeInteger(value), "a safe integer", defaultValue, arguments.length > 1);
+    }
+    float(key, defaultValue) {
+        return this.typed(key, (value) => typeof value === "number" && Number.isFinite(value), "a finite number", defaultValue, arguments.length > 1);
+    }
+    boolean(key, defaultValue) {
+        return this.typed(key, (value) => typeof value === "boolean", "a boolean", defaultValue, arguments.length > 1);
+    }
+    array(key, defaultValue) {
+        return this.typed(key, (value) => Array.isArray(value), "an array", defaultValue, arguments.length > 1);
+    }
+    push(key, value) {
+        const items = this.array(key, () => {
+            const items = [];
+            this.set(key, items);
+            return items;
+        });
+        items.push(value);
+    }
+    prepend(key, value) {
+        const items = this.array(key, () => {
+            const items = [];
+            this.set(key, items);
+            return items;
+        });
+        items.unshift(value);
+    }
+    typed(key, validate, expected, defaultValue, hasDefault) {
+        const result = this.lookup(this.segments(key), key);
+        if (!result.found && !hasDefault) {
+            throw new Error(`Repository key "${key}" is missing; expected ${expected}.`);
+        }
+        const value = result.found
+            ? result.value
+            : typeof defaultValue === "function"
+                ? defaultValue()
+                : defaultValue;
+        if (!validate(value)) {
+            throw new TypeError(`Repository key "${key}" must contain ${expected}.`);
+        }
+        return value;
+    }
+    segments(key) {
+        if (typeof key !== "string")
+            throw new TypeError("Repository keys must be strings.");
+        const segments = key.split(".");
+        if (segments.some((segment) => segment.length === 0)) {
+            throw new Error(`Invalid repository key "${key}": empty path segments are not allowed.`);
+        }
+        const forbidden = segments.find((segment) => segment === "__proto__" || segment === "prototype" || segment === "constructor");
+        if (forbidden !== undefined) {
+            throw new Error(`Invalid repository key "${key}": forbidden path segment "${forbidden}".`);
+        }
+        return segments;
+    }
+    lookup(segments, key) {
+        let parent = this.items;
+        for (let index = 0; index < segments.length; index++) {
+            const segment = segments[index];
+            if (!Object.hasOwn(parent, segment))
+                return { found: false };
+            const value = parent[segment];
+            if (index === segments.length - 1)
+                return { found: true, value };
+            parent = this.container(value, key, segments.slice(0, index + 1));
+        }
+        return { found: false };
+    }
+    container(value, key, traversed) {
+        if (!isPlainObject(value)) {
+            throw new TypeError(`Cannot traverse repository key "${key}": "${traversed.join(".")}" is not a plain object.`);
+        }
+        return value;
+    }
+    write(parent, key, value) {
+        Object.defineProperty(parent, key, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+    }
+}

package/build/Support/Stacks.js

@@ -0,0 +1,10 @@
+export class Stacks {
+    static supported = ["php-laravel", "python", "typescript"];
+    static validate(stacks) {
+        for (const stack of stacks) {
+            if (!Stacks.supported.includes(stack)) {
+                throw new Error(`Invalid stack '${stack}'. Supported stacks: ${Stacks.supported.join(", ")}.`);
+            }
+        }
+    }
+}

package/build/TemplateRendering/Computed/ComputedContextService.js

@@ -0,0 +1,13 @@
+import { Service } from "../../Foundation/Service.js";
+import { computedVariableProviders } from "./ComputedVariableProviders.js";
+import { resolveRenderContext } from "./ResolveRenderContext.js";
+export class ComputedContextService extends Service {
+    resolvedContext;
+    resolve(resolveBaseContext, registry = computedVariableProviders) {
+        this.resolvedContext ??= (async () => {
+            const inputs = await resolveBaseContext();
+            return inputs === undefined ? undefined : resolveRenderContext(this.app, inputs, registry);
+        })();
+        return this.resolvedContext;
+    }
+}

package/build/TemplateRendering/Computed/ComputedVariableProvider.js

@@ -0,0 +1,6 @@
+export class ComputedVariableProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+}

package/build/TemplateRendering/Computed/ComputedVariableProviders.js

@@ -0,0 +1,6 @@
+import { InternalSkillDescriptionProvider } from "./Providers/InternalSkillDescriptionProvider.js";
+import { SpindlePackageManagerProvider } from "./Providers/SpindlePackageManagerProvider.js";
+export const computedVariableProviders = {
+    internal_skill_description: InternalSkillDescriptionProvider,
+    spindle_package_manager: SpindlePackageManagerProvider,
+};

package/build/TemplateRendering/Computed/Providers/InternalSkillDescriptionProvider.js

@@ -0,0 +1,6 @@
+import { ComputedVariableProvider } from "../ComputedVariableProvider.js";
+export class InternalSkillDescriptionProvider extends ComputedVariableProvider {
+    render() {
+        return "This is an internal skill do not load it unless explicitly required by the user or another skill.";
+    }
+}

package/build/TemplateRendering/Computed/Providers/SpindlePackageManagerProvider.js

@@ -0,0 +1,11 @@
+import { LoadProjectConfiguration } from "../../../Foundation/Bootstrap/LoadProjectConfiguration.js";
+import { ComputedVariableProvider } from "../ComputedVariableProvider.js";
+export class SpindlePackageManagerProvider extends ComputedVariableProvider {
+    render() {
+        const { config } = LoadProjectConfiguration.requireCurrent(this.app);
+        if (config.spindle_package_manager === undefined) {
+            throw new Error('Missing "spindle_package_manager" in project Config; run `spindle init` before rendering Blueprints.');
+        }
+        return config.spindle_package_manager;
+    }
+}

package/build/TemplateRendering/Computed/ResolveRenderContext.js

@@ -0,0 +1,18 @@
+import { computedVariableProviders } from "./ComputedVariableProviders.js";
+export function resolveRenderContext(app, inputs, registry = computedVariableProviders) {
+    const stacks = [...(inputs.stacks ?? [])];
+    const variables = { ...inputs.variables };
+    const computed = {};
+    for (const [name, Provider] of Object.entries(registry)) {
+        try {
+            const value = new Provider(app).render();
+            if (value !== undefined)
+                computed[name] = value;
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`Computed Variable '${name}' failed: ${detail}`, { cause: error });
+        }
+    }
+    return { stacks, variables, computed };
+}

package/build/TemplateRendering/Rendering/RenderText.js

@@ -0,0 +1,43 @@
+import nunjucks from "nunjucks";
+const environment = new nunjucks.Environment(null, {
+    autoescape: false,
+    throwOnUndefined: true,
+});
+function missingComputedOutput(source, error) {
+    if (!(error instanceof Error))
+        return undefined;
+    const location = /\[Line (\d+), Column (\d+)\]/.exec(error.message);
+    if (!location)
+        return undefined;
+    const line = Number(location[1]);
+    const column = Number(location[2]);
+    let lineStart = 0;
+    for (let currentLine = 1; currentLine < line; currentLine += 1) {
+        const newline = source.indexOf("\n", lineStart);
+        if (newline < 0)
+            return undefined;
+        lineStart = newline + 1;
+    }
+    const offset = lineStart + column - 1;
+    const opening = source.lastIndexOf("{{", offset);
+    const closing = source.indexOf("}}", offset);
+    if (opening < 0 || closing < 0)
+        return undefined;
+    const expression = source.slice(opening + 2, closing);
+    return /^\s*computed(?:\.([A-Za-z_][A-Za-z0-9_]*)|\[\s*(?:"([^"]*)"|'([^']*)')\s*\])/
+        .exec(expression)
+        ?.slice(1)
+        .find((name) => name !== undefined);
+}
+export function renderText(source, context) {
+    try {
+        return environment.renderString(source, context);
+    }
+    catch (error) {
+        const name = missingComputedOutput(source, error);
+        if (name !== undefined) {
+            throw new Error(`Unknown computed output 'computed.${name}'.`, { cause: error });
+        }
+        throw error;
+    }
+}

package/build/TemplateRendering/TemplateRenderingServiceProvider.js

@@ -0,0 +1,8 @@
+import { ServiceProvider } from "../Foundation/ServiceProvider.js";
+import { ComputedContextService } from "./Computed/ComputedContextService.js";
+export class TemplateRenderingServiceProvider extends ServiceProvider {
+    register() {
+        this.app.bind(ComputedContextService);
+    }
+    async boot() { }
+}

package/build/Tooling/Commands/ToolingAddCommand.js

@@ -0,0 +1,29 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { toolGroup } from "./groups.js";
+import { ToolingService } from "../Services/ToolingService.js";
+export class ToolingAddCommand extends Command {
+    static register(program, createApp) {
+        toolGroup(program)
+            .command("add")
+            .description("Register a project tooling command and regenerate docs/agents/tooling.md.")
+            .requiredOption("--key <key>", "Stable lowercase kebab-case key", CommandOptions.once("--key"))
+            .requiredOption("--section <section>", "Tooling documentation section", CommandOptions.once("--section"))
+            .requiredOption("--command <command>", "Verified command text", CommandOptions.once("--command"))
+            .option("--description <description>", "Optional command description", CommandOptions.once("--description"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(ToolingAddCommand);
+            console.log(JSON.stringify(await command.run({
+                key: options.key,
+                section: options.section,
+                command: options.command,
+                ...(options.description === undefined ? {} : { description: options.description }),
+            }), null, 2));
+        });
+    }
+    async run(input) {
+        this.assertApplicationBooted();
+        return (await this.app.make(ToolingService)).addTooling(input);
+    }
+}

package/build/Tooling/Commands/ToolingListCommand.js

@@ -0,0 +1,19 @@
+import { Command } from "../../Commands/Command.js";
+import { toolGroup } from "./groups.js";
+import { ToolingService } from "../Services/ToolingService.js";
+export class ToolingListCommand extends Command {
+    static register(program, createApp) {
+        toolGroup(program)
+            .command("list")
+            .description("List registered tooling commands and their keys.")
+            .allowExcessArguments(false)
+            .action(async () => {
+            const command = await (await createApp()).make(ToolingListCommand);
+            console.log(JSON.stringify(await command.run(), null, 2));
+        });
+    }
+    async run() {
+        this.assertApplicationBooted();
+        return (await this.app.make(ToolingService)).listTooling();
+    }
+}

package/build/Tooling/Commands/ToolingRemoveCommand.js

@@ -0,0 +1,19 @@
+import { Command } from "../../Commands/Command.js";
+import { toolGroup } from "./groups.js";
+import { ToolingService } from "../Services/ToolingService.js";
+export class ToolingRemoveCommand extends Command {
+    static register(program, createApp) {
+        toolGroup(program)
+            .command("remove <key>")
+            .description("Remove a registered tooling command and regenerate docs/agents/tooling.md.")
+            .allowExcessArguments(false)
+            .action(async (key) => {
+            const command = await (await createApp()).make(ToolingRemoveCommand);
+            console.log(JSON.stringify(await command.run(key), null, 2));
+        });
+    }
+    async run(key) {
+        this.assertApplicationBooted();
+        return (await this.app.make(ToolingService)).removeTooling(key);
+    }
+}

package/build/Tooling/Commands/ToolingUpdateCommand.js

@@ -0,0 +1,30 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { toolGroup } from "./groups.js";
+import { ToolingService } from "../Services/ToolingService.js";
+export class ToolingUpdateCommand extends Command {
+    static register(program, createApp) {
+        toolGroup(program)
+            .command("update <key>")
+            .description("Update a registered tooling command and regenerate docs/agents/tooling.md.")
+            .option("--section <section>", "Replacement documentation section", CommandOptions.once("--section"))
+            .option("--command <command>", "Replacement command text", CommandOptions.once("--command"))
+            .option("--description <description>", "Replacement description", CommandOptions.once("--description"))
+            .option("--clear-description", "Remove the current description")
+            .allowExcessArguments(false)
+            .action(async (key, options) => {
+            const command = await (await createApp()).make(ToolingUpdateCommand);
+            console.log(JSON.stringify(await command.run({
+                key,
+                ...(options.section === undefined ? {} : { section: options.section }),
+                ...(options.command === undefined ? {} : { command: options.command }),
+                ...(options.description === undefined ? {} : { description: options.description }),
+                ...(options.clearDescription ? { clearDescription: true } : {}),
+            }), null, 2));
+        });
+    }
+    async run(input) {
+        this.assertApplicationBooted();
+        return (await this.app.make(ToolingService)).updateTooling(input);
+    }
+}

package/build/Tooling/Commands/groups.js

@@ -0,0 +1,4 @@
+export function toolGroup(root) {
+    return (root.commands.find((command) => command.name() === "tool") ??
+        root.command("tool").description("Manage project tooling command documentation."));
+}

package/build/Tooling/Models/ToolingEntry.js

@@ -0,0 +1 @@
+export {};

package/build/Tooling/Services/ToolingService.js

@@ -0,0 +1,278 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, lstatSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { LoadProjectConfiguration, } from "../../Foundation/Bootstrap/LoadProjectConfiguration.js";
+import { Service } from "../../Foundation/Service.js";
+const toolingPath = "docs/agents/tooling.md";
+const configPath = ".github/spindle.json";
+const toolingKeyPattern = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+const defaultTooling = [
+    {
+        key: "spindle-init",
+        section: "Spindle",
+        command: "spindle init",
+        description: "Install Spindle Blueprints and initialize project guidance.",
+    },
+    {
+        key: "spindle-update",
+        section: "Spindle",
+        command: "spindle update",
+        description: "Update installed Spindle Blueprints.",
+    },
+    {
+        key: "spindle-tool",
+        section: "Spindle",
+        command: "spindle tool <list|add|update|remove>",
+        description: "Manage documented project tooling commands.",
+    },
+];
+export class ToolingService extends Service {
+    async initialize(previous) {
+        this.assertApplicationBooted();
+        const workspace = this.app.workspacePath();
+        const configFile = join(workspace, configPath);
+        this.assertRegularFileOrMissing(configFile, configPath);
+        const tooling = previous.tooling === undefined
+            ? structuredClone(defaultTooling)
+            : this.migrateDefaultTooling(previous.tooling);
+        const config = {
+            ...previous,
+            stacks: previous.stacks,
+            tooling,
+        };
+        const documentFile = join(workspace, toolingPath);
+        this.assertRegularFileOrMissing(documentFile, toolingPath);
+        const documentExisted = existsSync(documentFile);
+        this.writeConfigurationAndDocumentation(configFile, `${JSON.stringify(config, null, 2)}\n`, documentFile, this.renderTooling(tooling), readFileSync(configFile));
+        await LoadProjectConfiguration.refresh(this.app);
+        return {
+            created: documentExisted ? [] : [toolingPath],
+            updated: documentExisted ? [configPath, toolingPath] : [configPath],
+        };
+    }
+    async listTooling() {
+        this.assertApplicationBooted();
+        return [...this.readInitializedConfiguration().tooling];
+    }
+    async addTooling(input) {
+        this.assertApplicationBooted();
+        const entry = this.validateEntry(input);
+        const config = this.readInitializedConfiguration();
+        const tooling = config.tooling;
+        if (tooling.some(({ key }) => key === entry.key)) {
+            throw new Error(`Tooling key '${entry.key}' already exists; use 'spindle tool update'.`);
+        }
+        const updated = [...tooling, entry];
+        await this.saveTooling(config, updated);
+        return entry;
+    }
+    async updateTooling(input) {
+        this.assertApplicationBooted();
+        this.validateKey(input.key);
+        if (input.section === undefined &&
+            input.command === undefined &&
+            input.description === undefined &&
+            !input.clearDescription) {
+            throw new Error("Provide at least one tooling field to update.");
+        }
+        if (input.clearDescription && input.description !== undefined) {
+            throw new Error("Use either --description or --clear-description, not both.");
+        }
+        const config = this.readInitializedConfiguration();
+        const tooling = config.tooling;
+        const index = tooling.findIndex(({ key }) => key === input.key);
+        if (index < 0)
+            throw new Error(`No tooling command has key '${input.key}'.`);
+        const current = tooling[index];
+        const updatedEntry = {
+            ...current,
+            ...(input.section === undefined
+                ? {}
+                : { section: this.requiredText(input.section, "section") }),
+            ...(input.command === undefined
+                ? {}
+                : { command: this.requiredText(input.command, "command") }),
+        };
+        if (input.clearDescription)
+            delete updatedEntry.description;
+        else if (input.description !== undefined) {
+            updatedEntry.description = this.requiredText(input.description, "description");
+        }
+        const updated = [...tooling];
+        updated[index] = updatedEntry;
+        await this.saveTooling(config, updated);
+        return updatedEntry;
+    }
+    async removeTooling(key) {
+        this.assertApplicationBooted();
+        this.validateKey(key);
+        const config = this.readInitializedConfiguration();
+        const tooling = config.tooling;
+        if (!tooling.some((entry) => entry.key === key)) {
+            throw new Error(`No tooling command has key '${key}'.`);
+        }
+        await this.saveTooling(config, tooling.filter((entry) => entry.key !== key));
+        return { key, removed: true };
+    }
+    readInitializedConfiguration() {
+        const state = LoadProjectConfiguration.current(this.app);
+        if (state.status === "absent") {
+            throw new Error("Project tooling is not initialized. Run `spindle init` first.");
+        }
+        if (state.status === "invalid")
+            throw new Error(state.reason, { cause: state.error });
+        if (state.data.tooling === undefined) {
+            throw new Error("Project tooling is not initialized. Run `spindle init` first.");
+        }
+        this.assertToolingDocumentAvailable();
+        return state.data;
+    }
+    async saveTooling(config, tooling) {
+        const updated = { ...config, tooling };
+        const configFile = this.app.workspacePath(configPath);
+        const documentFile = this.app.workspacePath(toolingPath);
+        this.writeConfigurationAndDocumentation(configFile, `${JSON.stringify(updated, null, 2)}\n`, documentFile, this.renderTooling(tooling), readFileSync(configFile));
+        await LoadProjectConfiguration.refresh(this.app);
+    }
+    assertToolingDocumentAvailable() {
+        const workspace = this.app.workspacePath();
+        const parent = join(workspace, "docs", "agents");
+        try {
+            if (!lstatSync(parent).isDirectory()) {
+                throw new Error("docs/agents must be a real directory.");
+            }
+        }
+        catch (error) {
+            if (isMissing(error)) {
+                throw new Error("Project tooling is not initialized. Run `spindle init` first.");
+            }
+            throw error;
+        }
+        this.assertRegularFileOrMissing(join(parent, "tooling.md"), toolingPath);
+    }
+    validateEntry(input) {
+        this.validateKey(input.key);
+        const entry = {
+            key: input.key,
+            section: this.requiredText(input.section, "section"),
+            command: this.requiredText(input.command, "command"),
+            ...(input.description === undefined
+                ? {}
+                : { description: this.requiredText(input.description, "description") }),
+        };
+        return entry;
+    }
+    migrateDefaultTooling(entries) {
+        const migrated = [...entries];
+        const legacyIndex = entries.findIndex(({ key, command }) => key === "spindle-project-init" && command === "spindle project init");
+        if (legacyIndex >= 0) {
+            if (migrated.some(({ key }) => key === "spindle-tool")) {
+                migrated.splice(legacyIndex, 1);
+            }
+            else {
+                migrated[legacyIndex] = structuredClone(defaultTooling[2]);
+            }
+        }
+        const initIndex = migrated.findIndex(({ key, command, description }) => key === "spindle-init" &&
+            command === "spindle init" &&
+            description === "Install Spindle Blueprints for selected stacks.");
+        if (initIndex >= 0) {
+            migrated[initIndex] = structuredClone(defaultTooling[0]);
+        }
+        return migrated;
+    }
+    validateKey(key) {
+        if (!toolingKeyPattern.test(key)) {
+            throw new Error("Tooling key must use lowercase letters, digits, and interior hyphens.");
+        }
+    }
+    requiredText(value, label) {
+        const trimmed = value.trim();
+        if (!trimmed)
+            throw new Error(`Tooling ${label} must not be empty.`);
+        if (/[\r\n]/.test(trimmed))
+            throw new Error(`Tooling ${label} must be a single line.`);
+        return trimmed;
+    }
+    renderTooling(entries) {
+        const sections = new Map();
+        for (const entry of entries) {
+            const section = sections.get(entry.section) ?? [];
+            section.push(entry);
+            sections.set(entry.section, section);
+        }
+        const lines = ["# Project Tooling"];
+        for (const [section, commands] of sections) {
+            lines.push("", `## ${section}`);
+            for (const entry of commands) {
+                const description = entry.description ? `: ${entry.description}` : "";
+                lines.push(`- ${inlineCode(entry.command)}${description}`);
+            }
+        }
+        return `${lines.join("\n")}\n`;
+    }
+    writeConfigurationAndDocumentation(configFile, configContent, documentFile, documentContent, previousConfig) {
+        this.assertRegularFileOrMissing(configFile, configPath);
+        this.assertRegularFileOrMissing(documentFile, toolingPath);
+        let configTemp;
+        let documentTemp;
+        try {
+            configTemp = this.writeTemporary(configFile, configContent);
+            documentTemp = this.writeTemporary(documentFile, documentContent);
+            renameSync(configTemp, configFile);
+            try {
+                renameSync(documentTemp, documentFile);
+            }
+            catch (error) {
+                try {
+                    this.restoreFile(configFile, previousConfig);
+                }
+                catch (rollbackError) {
+                    throw new AggregateError([error, rollbackError], "Could not update the tooling guide and restore the previous project configuration.");
+                }
+                throw error;
+            }
+        }
+        finally {
+            if (configTemp)
+                this.removeTemporary(configTemp);
+            if (documentTemp)
+                this.removeTemporary(documentTemp);
+        }
+    }
+    writeTemporary(path, content) {
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        writeFileSync(temporary, content, { flag: "wx" });
+        return temporary;
+    }
+    restoreFile(path, content) {
+        if (content === undefined) {
+            unlinkSync(path);
+            return;
+        }
+        writeFileSync(path, content);
+    }
+    removeTemporary(path) {
+        try {
+            unlinkSync(path);
+        }
+        catch (error) {
+            if (!isMissing(error))
+                throw error;
+        }
+    }
+    assertRegularFileOrMissing(path, relativePath) {
+        const entry = lstatSync(path, { throwIfNoEntry: false });
+        if (entry && !entry.isFile()) {
+            throw new Error(`${relativePath} must be a regular file, not a directory or symlink.`);
+        }
+    }
+}
+function inlineCode(value) {
+    const runs = value.match(/`+/g) ?? [];
+    const delimiter = "`".repeat(Math.max(0, ...runs.map((run) => run.length)) + 1);
+    return `${delimiter}${value}${delimiter}`;
+}
+function isMissing(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}