@lightward/mechanic-cli 0.1.0

package/dist/commands/tasks/unbundle.js

@@ -0,0 +1,84 @@
+import { Args, Flags } from "@oclif/core";
+import path from "node:path";
+import { BaseCommand } from "../../base-command.js";
+import { CliError } from "../../errors.js";
+import { pathExists } from "../../fs.js";
+import { displayTaskPath, resolveTaskSelector, unbundleTask } from "../../tasks.js";
+export default class TasksUnbundle extends BaseCommand {
+    static summary = "Unbundle one task into one helper directory.";
+    static description = "Unbundle one canonical task JSON file, linked task ID, helper directory, or unique local task slug into one editable helper task directory.";
+    static examples = [
+        "$ mechanic tasks unbundle tasks/order-tagger.json",
+        "$ mechanic tasks unbundle order-tagger",
+        "$ mechanic tasks unbundle 171578bf-79e2-46af-857a-dbd71c6b7b2b",
+        "$ mechanic tasks unbundle tasks/order-tagger.json --out helpers/order-tagger",
+    ];
+    static args = {
+        file: Args.string({ required: false, description: "Task file, helper directory, linked task ID, or unique local task slug." }),
+    };
+    static flags = {
+        json: Flags.boolean({
+            description: "Print unbundle result as JSON for agents, scripts, or editor integrations.",
+        }),
+        out: Flags.string({
+            description: "Output helper task directory. Defaults to the task file path without .json.",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TasksUnbundle);
+        if (!args.file) {
+            throw new CliError([
+                "Choose one task to unbundle.",
+                "",
+                "Example:",
+                "  mechanic tasks unbundle tasks/order-tagger.json",
+                "",
+                "By default this writes to tasks/order-tagger/. Use --out <dir> to choose another helper directory.",
+            ].join("\n"), 2);
+        }
+        const { filePath, inputDisplay, outputPath, outputDisplay } = await this.resolveUnbundlePaths(args.file, flags.out);
+        await unbundleTask(filePath, outputPath);
+        if (flags.json) {
+            this.outputJson({
+                ok: true,
+                input: inputDisplay,
+                input_path: filePath,
+                output: outputDisplay,
+                output_path: outputPath,
+            });
+            return;
+        }
+        this.log(`Unbundled ${this.taskName(inputDisplay)} -> ${this.taskName(outputDisplay)}`);
+    }
+    async resolveUnbundlePaths(input, out) {
+        const inputPath = path.resolve(input);
+        if (input.toLowerCase().endsWith(".json")) {
+            const outputDisplay = out || input.replace(/\.json$/i, "");
+            return {
+                filePath: inputPath,
+                inputDisplay: input,
+                outputPath: path.resolve(outputDisplay),
+                outputDisplay,
+            };
+        }
+        const project = await this.loadProject();
+        const selector = await resolveTaskSelector(project, input);
+        if (!selector.file) {
+            throw new CliError(`No local task file found for ${input}. Run "mechanic tasks pull" first.`, 2);
+        }
+        if (!(await pathExists(selector.file))) {
+            throw new CliError([
+                `No local task file found for ${input}.`,
+                `Run "mechanic tasks pull ${selector.remoteId || input}" first.`,
+            ].join("\n"), 2);
+        }
+        const outputPath = out ? path.resolve(out) : selector.file.replace(/\.json$/i, "");
+        const outputDisplay = out || displayTaskPath(project, outputPath);
+        return {
+            filePath: selector.file,
+            inputDisplay: displayTaskPath(project, selector.file),
+            outputPath,
+            outputDisplay,
+        };
+    }
+}

package/dist/commands/tasks/validate.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from "../../base-command.js";
+import { type ValidationResult } from "../../tasks.js";
+export default class TasksValidate extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static args: {
+        target: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    validateTaskFile(file: string): Promise<ValidationResult>;
+}
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/tasks/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/commands/tasks/validate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EAKL,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AAMxB,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,WAAW;IACpD,OAAgB,OAAO,SAAgF;IACvG,OAAgB,WAAW,SAA0G;IAErI,OAAgB,IAAI;;MAElB;IAEF,OAAgB,KAAK;;MAInB;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAiDpB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAchE"}

package/dist/commands/tasks/validate.js

@@ -0,0 +1,78 @@
+import { Args, Flags } from "@oclif/core";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { BaseCommand } from "../../base-command.js";
+import { CliError } from "../../errors.js";
+import { pathExists } from "../../fs.js";
+import { rawTaskFromHelperDir, readRawTaskFile, unbundledHelperDirForTaskFile, validateTask, } from "../../tasks.js";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export default class TasksValidate extends BaseCommand {
+    static summary = "Validate one task file, helper directory, or directory of task JSON files.";
+    static description = "Validate one canonical task JSON file, one helper task directory, or a directory of task JSON files.";
+    static args = {
+        target: Args.string({ required: true, description: "Task JSON file, helper dir, or directory of task JSON files." }),
+    };
+    static flags = {
+        json: Flags.boolean({
+            description: "Print validation results as JSON for agents, scripts, or editor integrations.",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TasksValidate);
+        const target = path.resolve(args.target);
+        const results = [];
+        const stat = await fs.stat(target).catch((error) => {
+            throw new CliError(`Unable to access ${target}: ${errorMessage(error)}`, 2);
+        });
+        if (stat.isFile()) {
+            results.push(await this.validateTaskFile(target));
+        }
+        else if (await pathExists(path.join(target, "task.json"))) {
+            results.push(validateTask(await rawTaskFromHelperDir(target), target));
+        }
+        else {
+            const entries = await fs.readdir(target, { withFileTypes: true }).catch((error) => {
+                throw new CliError(`Unable to read directory ${target}: ${errorMessage(error)}`, 2);
+            });
+            const files = entries
+                .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+                .map((entry) => path.join(target, entry.name))
+                .sort();
+            for (const file of files) {
+                results.push(await this.validateTaskFile(file));
+            }
+        }
+        if (results.length === 0) {
+            throw new CliError(`No task JSON files found in ${target}.`);
+        }
+        if (flags.json) {
+            this.outputJson({
+                ok: results.every((result) => result.ok),
+                results,
+            });
+        }
+        else {
+            for (const result of results) {
+                this.log(`${result.ok ? this.success("OK") : this.color("red", "ERROR")} ${this.taskName(result.source)}`);
+                for (const error of result.errors) {
+                    this.log(`  ${this.color("red", error)}`);
+                }
+            }
+        }
+        if (results.some((result) => !result.ok)) {
+            throw new CliError("Task validation failed.", 2);
+        }
+    }
+    async validateTaskFile(file) {
+        const task = await readRawTaskFile(file);
+        const result = validateTask(task, file);
+        const helperDir = await unbundledHelperDirForTaskFile(file, task);
+        if (helperDir) {
+            result.ok = false;
+            result.errors.push(`Helper directory ${path.relative(process.cwd(), helperDir) || helperDir} has changes that are not bundled into this JSON file.`);
+        }
+        return result;
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+import type { LinkEntry, LinksFile, MechanicConfig, Project } from "./types.js";
+export declare const DEFAULT_API_BASE_URL: string;
+export declare function normalizeApiBaseUrl(value: string): string;
+export declare function defaultAppUrl(shopDomain: string, appAlias?: string): string;
+export declare function taskAdminUrl(project: Project, taskId: string): string;
+export declare function defaultConfig(shopDomain: string, apiBaseUrl?: string, appUrl?: string): MechanicConfig;
+export declare function emptyLinks(): LinksFile;
+export declare function initProject(cwd: string, shopDomain: string, apiBaseUrl?: string, appUrl?: string, force?: boolean): Promise<Project>;
+export declare function ensureMechanicPrettierIgnore(cwd: string): Promise<boolean>;
+export declare function loadProject(cwd?: string): Promise<Project>;
+export declare function saveLinks(project: Project, links: LinksFile): Promise<void>;
+export declare function linkForSlug(project: Project, slug: string): LinkEntry | null;
+export declare function slugForRemoteId(project: Project, remoteId: string): string | null;
+export declare function updateLink(project: Project, slug: string, remoteId: string, contentHash: string): LinksFile;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEhF,eAAO,MAAM,oBAAoB,QAAkE,CAAC;AA0BpG,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAyBzD;AA+BD,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,SAA4B,GAAG,MAAM,CAG9F;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAMrE;AAED,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,EAClB,UAAU,SAAuB,EACjC,MAAM,SAA4D,GACjE,cAAc,CAOhB;AAED,wBAAgB,UAAU,IAAI,SAAS,CAEtC;AAkED,wBAAsB,WAAW,CAC/B,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,MAAM,EACf,KAAK,UAAQ,GACZ,OAAO,CAAC,OAAO,CAAC,CAyBlB;AAED,wBAAsB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CA0BhF;AAED,wBAAsB,WAAW,CAAC,GAAG,SAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAkCvE;AAED,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjF;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAE5E;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEjF;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,CAW3G"}

package/dist/config.js

@@ -0,0 +1,227 @@
+import path from "node:path";
+import { CliError } from "./errors.js";
+import { ensureDir, pathExists, readJson, readText, writeJson, writeText } from "./fs.js";
+export const DEFAULT_API_BASE_URL = process.env.MECHANIC_API_BASE_URL || "https://api.mechanic.dev";
+const TRUSTED_API_HOSTS = new Set([
+    "api.mechanic.dev",
+]);
+const DEFAULT_SHOPIFY_APP_ALIAS = "mechanic";
+const DEFAULT_TASKS_DIR = "tasks";
+const MECHANIC_PRETTIERIGNORE_COMMENT = "# Mechanic Liquid files are executable task source; formatting can change behavior.";
+const MECHANIC_PRETTIERIGNORE_PATTERNS = [
+    "**/script.liquid",
+    "**/subscriptions.liquid",
+    "**/online_store_javascript.js.liquid",
+    "**/order_status_javascript.js.liquid",
+];
+function isLoopbackHost(hostname) {
+    return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(hostname.toLowerCase());
+}
+function parseConfigUrl(value, label) {
+    try {
+        return new URL(value);
+    }
+    catch {
+        throw new CliError(`${label} must be a valid URL.`);
+    }
+}
+export function normalizeApiBaseUrl(value) {
+    const url = parseConfigUrl(value, "api_base_url");
+    const hostname = url.hostname.toLowerCase();
+    if (!["http:", "https:"].includes(url.protocol)) {
+        throw new CliError("api_base_url must use http or https.");
+    }
+    const trustedHost = ((url.protocol === "https:" && TRUSTED_API_HOSTS.has(hostname)));
+    if (url.username || url.password || url.search || url.hash || !["", "/"].includes(url.pathname)) {
+        throw new CliError("api_base_url must be a plain Mechanic API origin, like https://api.mechanic.dev.");
+    }
+    if (!trustedHost && process.env.MECHANIC_TRUST_API_BASE_URL !== "1") {
+        throw new CliError([
+            `Untrusted Mechanic API base URL: ${url.origin}`,
+            "To protect API tokens, mechanic only sends tokens to api.mechanic.dev by default.",
+            "Set MECHANIC_TRUST_API_BASE_URL=1 only for a URL you control.",
+        ].join("\n"), 2);
+    }
+    return url.origin;
+}
+function normalizeAppUrl(value) {
+    const url = parseConfigUrl(value, "app_url");
+    const hostname = url.hostname.toLowerCase();
+    if (!["http:", "https:"].includes(url.protocol)) {
+        throw new CliError("app_url must use http or https.");
+    }
+    const trustedHost = ((url.protocol === "https:" && hostname === "admin.shopify.com")
+        || (["http:", "https:"].includes(url.protocol) && isLoopbackHost(hostname) && process.env.MECHANIC_TRUST_APP_URL === "1"));
+    if (url.username || url.password) {
+        throw new CliError("app_url must not include credentials.");
+    }
+    if (!trustedHost && process.env.MECHANIC_TRUST_APP_URL !== "1") {
+        throw new CliError([
+            `Untrusted Mechanic app URL: ${url.origin}`,
+            "Task links open in the Shopify admin by default. Use an admin.shopify.com URL, or set MECHANIC_TRUST_APP_URL=1 only for a URL you control.",
+        ].join("\n"), 2);
+    }
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/+$/, "");
+}
+export function defaultAppUrl(shopDomain, appAlias = DEFAULT_SHOPIFY_APP_ALIAS) {
+    const shopHandle = shopDomain.replace(/\.myshopify\.com$/i, "");
+    return `https://admin.shopify.com/store/${shopHandle}/apps/${appAlias}`;
+}
+export function taskAdminUrl(project, taskId) {
+    const appUrl = new URL(project.appUrl);
+    appUrl.pathname = `${appUrl.pathname.replace(/\/+$/, "")}/tasks/${encodeURIComponent(taskId)}`;
+    appUrl.search = "";
+    appUrl.hash = "";
+    return appUrl.toString();
+}
+export function defaultConfig(shopDomain, apiBaseUrl = DEFAULT_API_BASE_URL, appUrl = process.env.MECHANIC_APP_URL || defaultAppUrl(shopDomain)) {
+    return {
+        shop_domain: shopDomain,
+        api_base_url: apiBaseUrl,
+        app_url: appUrl,
+        tasks_dir: DEFAULT_TASKS_DIR,
+    };
+}
+export function emptyLinks() {
+    return { tasks: {} };
+}
+function normalizeLinkEntry(slug, entry) {
+    if (!entry || typeof entry !== "object" || !entry.remote_id || !entry.last_remote_content_hash) {
+        return null;
+    }
+    return [slug, {
+            file: entry.file || `${DEFAULT_TASKS_DIR}/${slug}.json`,
+            remote_id: entry.remote_id,
+            last_remote_content_hash: entry.last_remote_content_hash,
+        }];
+}
+function normalizeLegacyLinkEntry(slug, entry) {
+    if (!entry || typeof entry !== "object" || !entry.task_id || !entry.last_remote_hash) {
+        return null;
+    }
+    return [slug, {
+            file: `${DEFAULT_TASKS_DIR}/${slug}.json`,
+            remote_id: entry.task_id,
+            last_remote_content_hash: entry.last_remote_hash,
+        }];
+}
+function normalizeLinks(value, shopDomain) {
+    if (!value || typeof value !== "object") {
+        return emptyLinks();
+    }
+    const links = value;
+    if (links.tasks && typeof links.tasks === "object") {
+        return {
+            tasks: Object.fromEntries(Object.entries(links.tasks).flatMap(([slug, entry]) => {
+                const normalized = normalizeLinkEntry(slug, entry);
+                return normalized ? [normalized] : [];
+            })),
+        };
+    }
+    const shopLinks = links.shops?.[shopDomain]?.tasks;
+    if (shopLinks && typeof shopLinks === "object") {
+        return {
+            tasks: Object.fromEntries(Object.entries(shopLinks).flatMap(([slug, entry]) => {
+                const normalized = normalizeLegacyLinkEntry(slug, entry);
+                return normalized ? [normalized] : [];
+            })),
+        };
+    }
+    return emptyLinks();
+}
+export async function initProject(cwd, shopDomain, apiBaseUrl, appUrl, force = false) {
+    const config = defaultConfig(shopDomain, apiBaseUrl, appUrl);
+    const configPath = path.join(cwd, "mechanic.json");
+    const linksPath = path.join(cwd, ".mechanic", "links.json");
+    if (!force && ((await pathExists(configPath)) || (await pathExists(linksPath)))) {
+        throw new CliError([
+            "Mechanic project files already exist.",
+            "Re-run with --force to overwrite mechanic.json while preserving existing task links.",
+        ].join("\n"), 2);
+    }
+    const existingConfig = force ? await readJson(configPath, {}) : {};
+    const preserveLinks = force && existingConfig.shop_domain === shopDomain;
+    const links = preserveLinks ? normalizeLinks(await readJson(linksPath, emptyLinks()), shopDomain) : emptyLinks();
+    config.api_base_url = normalizeApiBaseUrl(config.api_base_url);
+    config.app_url = normalizeAppUrl(config.app_url || defaultAppUrl(config.shop_domain));
+    await ensureDir(path.join(cwd, config.tasks_dir));
+    await ensureDir(path.dirname(linksPath));
+    await writeJson(configPath, config);
+    await writeJson(linksPath, links);
+    return loadProject(cwd);
+}
+export async function ensureMechanicPrettierIgnore(cwd) {
+    const filePath = path.join(cwd, ".prettierignore");
+    const existing = await readText(filePath, "");
+    const existingLines = new Set(existing
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean));
+    const missingPatterns = MECHANIC_PRETTIERIGNORE_PATTERNS.filter((pattern) => !existingLines.has(pattern));
+    if (missingPatterns.length === 0) {
+        return false;
+    }
+    const additionLines = [
+        ...(existing.includes(MECHANIC_PRETTIERIGNORE_COMMENT) ? [] : [MECHANIC_PRETTIERIGNORE_COMMENT]),
+        ...missingPatterns,
+    ];
+    const prefix = [
+        existing.length > 0 && !existing.endsWith("\n") ? "\n" : "",
+        existing.trim().length > 0 ? "\n" : "",
+    ].join("");
+    await writeText(filePath, `${existing}${prefix}${additionLines.join("\n")}\n`);
+    return true;
+}
+export async function loadProject(cwd = process.cwd()) {
+    const configPath = path.join(cwd, "mechanic.json");
+    if (!(await pathExists(configPath))) {
+        throw new CliError(`No mechanic.json found in ${cwd}. Run "mechanic init --shop <domain>" first.`);
+    }
+    const config = await readJson(configPath);
+    if (!config.shop_domain) {
+        throw new CliError("mechanic.json must include shop_domain");
+    }
+    if (!config.api_base_url) {
+        throw new CliError("mechanic.json must include api_base_url");
+    }
+    const tasksDirName = config.tasks_dir || DEFAULT_TASKS_DIR;
+    const linksPath = path.join(cwd, ".mechanic", "links.json");
+    const links = normalizeLinks(await readJson(linksPath, emptyLinks()), config.shop_domain);
+    const apiBaseUrl = normalizeApiBaseUrl(process.env.MECHANIC_API_BASE_URL || config.api_base_url);
+    const appUrl = normalizeAppUrl(process.env.MECHANIC_APP_URL || config.app_url || defaultAppUrl(config.shop_domain));
+    return {
+        cwd,
+        configPath,
+        linksPath,
+        shopDomain: config.shop_domain,
+        apiBaseUrl,
+        appUrl,
+        tasksDir: path.join(cwd, tasksDirName),
+        tasksDirName,
+        links,
+    };
+}
+export async function saveLinks(project, links) {
+    await writeJson(project.linksPath, links);
+    project.links = links;
+}
+export function linkForSlug(project, slug) {
+    return project.links.tasks[slug] || null;
+}
+export function slugForRemoteId(project, remoteId) {
+    return Object.entries(project.links.tasks).find(([, link]) => link.remote_id === remoteId)?.[0] || null;
+}
+export function updateLink(project, slug, remoteId, contentHash) {
+    return {
+        tasks: {
+            ...project.links.tasks,
+            [slug]: {
+                file: `${project.tasksDirName}/${slug}.json`,
+                remote_id: remoteId,
+                last_remote_content_hash: contentHash,
+            },
+        },
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}
+export declare class HttpError extends CliError {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAI;CAK1C;AAED,qBAAa,SAAU,SAAQ,QAAQ;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;gBAEX,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAM3D"}

package/dist/errors.js

@@ -0,0 +1,18 @@
+export class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = "Error";
+        this.exitCode = exitCode;
+    }
+}
+export class HttpError extends CliError {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message, status === 409 ? 2 : 1);
+        this.name = "HttpError";
+        this.status = status;
+        this.body = body;
+    }
+}

package/dist/fs.d.ts

@@ -0,0 +1,10 @@
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function ensureDir(directoryPath: string): Promise<void>;
+export declare function readText(filePath: string, fallback?: string): Promise<string>;
+export declare function writeText(filePath: string, value: string): Promise<void>;
+export declare function removeFile(filePath: string): Promise<void>;
+export declare function readJson<T>(filePath: string, fallback?: T): Promise<T>;
+export declare function writeJson(filePath: string, value: unknown): Promise<void>;
+export declare function configHome(): string;
+export declare function appConfigPath(...segments: string[]): string;
+//# sourceMappingURL=fs.d.ts.map

package/dist/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAMA,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOnE;AAED,wBAAsB,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpE;AAED,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAUnF;AAED,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG9E;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhE;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAU5E;AAED,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/E;AAED,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,wBAAgB,aAAa,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAE3D"}

package/dist/fs.js

@@ -0,0 +1,51 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { CliError } from "./errors.js";
+import { parseJson, stableStringify } from "./json.js";
+export async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureDir(directoryPath) {
+    await fs.mkdir(directoryPath, { recursive: true });
+}
+export async function readText(filePath, fallback) {
+    if (!(await pathExists(filePath))) {
+        if (fallback !== undefined) {
+            return fallback;
+        }
+        throw new CliError(`Missing required file: ${filePath}`);
+    }
+    return fs.readFile(filePath, "utf8");
+}
+export async function writeText(filePath, value) {
+    await ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, value, "utf8");
+}
+export async function removeFile(filePath) {
+    await fs.rm(filePath, { force: true });
+}
+export async function readJson(filePath, fallback) {
+    if (!(await pathExists(filePath))) {
+        if (fallback !== undefined) {
+            return fallback;
+        }
+        throw new CliError(`Missing required file: ${filePath}`);
+    }
+    return parseJson(await fs.readFile(filePath, "utf8"), filePath);
+}
+export async function writeJson(filePath, value) {
+    await writeText(filePath, `${stableStringify(value)}\n`);
+}
+export function configHome() {
+    return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+}
+export function appConfigPath(...segments) {
+    return path.join(configHome(), "mechanic-cli", ...segments);
+}

package/dist/github-workflows.d.ts

@@ -0,0 +1,6 @@
+export type GithubWorkflowFile = {
+    path: string;
+    contents: string;
+};
+export declare function githubWorkflowFiles(): GithubWorkflowFile[];
+//# sourceMappingURL=github-workflows.d.ts.map

package/dist/github-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-workflows.d.ts","sourceRoot":"","sources":["../src/github-workflows.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAuRF,wBAAgB,mBAAmB,IAAI,kBAAkB,EAAE,CAe1D"}