@soapjs/cli 1.0.0

package/build/config/schemas/types.d.ts

@@ -0,0 +1,127 @@
+import { PackageManager } from "../../core/command-context";
+export type Framework = "express";
+export type Architecture = "regular" | "cqrs";
+export type Language = "typescript";
+export type DatabaseCapability = "mongo" | "postgres" | "mysql" | "sqlite" | "redis";
+export type AuthCapability = "jwt" | "api-key" | "local";
+export type MessagingCapability = "in-memory" | "kafka";
+export type RealtimeCapability = "ws";
+export type TelemetryCapability = "logs" | "otel-noop";
+export type ApiClientCapability = "bruno";
+export type DocsCapability = "openapi";
+export type ContractsCapability = "zod";
+export type ApiZone = "public" | "private" | "admin";
+export type ResourceFieldType = "string" | "number" | "boolean" | "date";
+export interface ResourceFieldDefinition {
+    name: string;
+    type: ResourceFieldType;
+    required: boolean;
+}
+export type AuthPolicy = {
+    type: "admin";
+} | {
+    type: "roles";
+    roles: string[];
+} | {
+    type: "custom";
+    name: string;
+};
+export interface ProjectCapabilities {
+    databases: DatabaseCapability[];
+    auth: AuthCapability[];
+    messaging: MessagingCapability[];
+    realtime: RealtimeCapability[];
+    telemetry: TelemetryCapability[];
+    apiClient: ApiClientCapability[];
+    docs: DocsCapability[];
+    contracts: ContractsCapability[];
+}
+export interface SoapProjectConfig {
+    schemaVersion: 1;
+    name: string;
+    framework: Framework;
+    architecture: Architecture;
+    language: Language;
+    packageManager: PackageManager;
+    capabilities: ProjectCapabilities;
+    zones: ApiZone[];
+}
+export interface SoapStructureConfig {
+    featuresRoot: string;
+    commonRoot: string;
+    configRoot: string;
+    paths: {
+        domain: string;
+        application: string;
+        ports: string;
+        useCases: string;
+        commands: string;
+        queries: string;
+        data: string;
+        api: string;
+        contracts: string;
+        sockets: string;
+    };
+}
+export interface SoapApiConfig {
+    baseUrl: string;
+    health: {
+        method: "GET";
+        path: string;
+    };
+    auth: {
+        default: "none" | AuthCapability;
+        loginRoute?: {
+            method: "POST";
+            path: string;
+            tokenVariable: string;
+        };
+    };
+    bruno: {
+        enabled: boolean;
+        collectionPath: string;
+        environment: string;
+    };
+}
+export type GeneratedFileType = "project" | "resource" | "entity" | "use-case" | "repository" | "route" | "bruno" | "docker" | "config";
+export interface GeneratedFileEntry {
+    path: string;
+    type: GeneratedFileType;
+    owner?: string;
+    hash: string;
+    generatedAt: string;
+}
+export interface ResourceRegistryEntry {
+    name: string;
+    path: string;
+    crud: boolean;
+    db: "none" | DatabaseCapability;
+    auth: "none" | AuthCapability;
+    zone: ApiZone;
+    fields: ResourceFieldDefinition[];
+    policy?: AuthPolicy;
+    generatedAt: string;
+}
+export interface RouteRegistryEntry {
+    resource: string;
+    name: string;
+    method: string;
+    path: string;
+    auth: "none" | AuthCapability;
+    zone: ApiZone;
+    policy?: AuthPolicy;
+    bruno?: boolean;
+    generatedAt: string;
+}
+export interface SoapRegistryConfig {
+    resources: ResourceRegistryEntry[];
+    routes: RouteRegistryEntry[];
+    generatedFiles: GeneratedFileEntry[];
+}
+export interface SoapConfig {
+    root: string;
+    project: SoapProjectConfig;
+    structure: SoapStructureConfig;
+    api: SoapApiConfig;
+    registry: SoapRegistryConfig;
+}

package/build/config/schemas/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/config/schemas/validation.d.ts

@@ -0,0 +1,5 @@
+import { SoapApiConfig, SoapProjectConfig, SoapRegistryConfig, SoapStructureConfig } from "./types";
+export declare function validateProjectConfig(value: unknown): SoapProjectConfig;
+export declare function validateStructureConfig(value: unknown): SoapStructureConfig;
+export declare function validateApiConfig(value: unknown): SoapApiConfig;
+export declare function validateRegistryConfig(value: unknown): SoapRegistryConfig;

package/build/config/schemas/validation.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRegistryConfig = exports.validateApiConfig = exports.validateStructureConfig = exports.validateProjectConfig = void 0;
+const errors_1 = require("../../core/errors");
+const frameworks = ["express"];
+const architectures = ["regular", "cqrs"];
+const packageManagers = ["npm", "pnpm", "yarn", "bun"];
+const databases = ["mongo", "postgres", "mysql", "sqlite", "redis"];
+const auth = ["jwt", "api-key", "local"];
+const messaging = ["in-memory", "kafka"];
+const realtime = ["ws"];
+const telemetry = ["logs", "otel-noop"];
+const apiClients = ["bruno"];
+const docs = ["openapi"];
+const contracts = ["zod"];
+const zones = ["public", "private", "admin"];
+function assertObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new errors_1.CliError(`${label} must be an object.`);
+    }
+}
+function assertString(value, label) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new errors_1.CliError(`${label} must be a non-empty string.`);
+    }
+}
+function assertArrayOf(value, label, allowed) {
+    if (!Array.isArray(value)) {
+        throw new errors_1.CliError(`${label} must be an array.`);
+    }
+    const invalid = value.find((item) => typeof item !== "string" || !allowed.includes(item));
+    if (invalid) {
+        throw new errors_1.CliError(`${label} contains unsupported value "${String(invalid)}".`);
+    }
+}
+function assertOneOf(value, label, allowed) {
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        throw new errors_1.CliError(`${label} must be one of: ${allowed.join(", ")}.`);
+    }
+}
+function validateProjectConfig(value) {
+    assertObject(value, ".soap/project.json");
+    if (value.schemaVersion !== 1) {
+        throw new errors_1.CliError(".soap/project.json schemaVersion must be 1.");
+    }
+    assertString(value.name, "project.name");
+    assertOneOf(value.framework, "project.framework", frameworks);
+    assertOneOf(value.architecture, "project.architecture", architectures);
+    if (value.language !== "typescript") {
+        throw new errors_1.CliError("project.language must be typescript.");
+    }
+    assertOneOf(value.packageManager, "project.packageManager", packageManagers);
+    assertObject(value.capabilities, "project.capabilities");
+    assertArrayOf(value.capabilities.databases, "project.capabilities.databases", databases);
+    assertArrayOf(value.capabilities.auth, "project.capabilities.auth", auth);
+    assertArrayOf(value.capabilities.messaging, "project.capabilities.messaging", messaging);
+    assertArrayOf(value.capabilities.realtime, "project.capabilities.realtime", realtime);
+    assertArrayOf(value.capabilities.telemetry, "project.capabilities.telemetry", telemetry);
+    assertArrayOf(value.capabilities.apiClient, "project.capabilities.apiClient", apiClients);
+    assertArrayOf(value.capabilities.docs, "project.capabilities.docs", docs);
+    if (!Array.isArray(value.capabilities.contracts)) {
+        value.capabilities.contracts = [];
+    }
+    assertArrayOf(value.capabilities.contracts, "project.capabilities.contracts", contracts);
+    assertArrayOf(value.zones, "project.zones", zones);
+    return value;
+}
+exports.validateProjectConfig = validateProjectConfig;
+function validateStructureConfig(value) {
+    assertObject(value, ".soap/structure.json");
+    assertString(value.featuresRoot, "structure.featuresRoot");
+    assertString(value.commonRoot, "structure.commonRoot");
+    assertString(value.configRoot, "structure.configRoot");
+    assertObject(value.paths, "structure.paths");
+    return value;
+}
+exports.validateStructureConfig = validateStructureConfig;
+function validateApiConfig(value) {
+    assertObject(value, ".soap/api.json");
+    assertString(value.baseUrl, "api.baseUrl");
+    assertObject(value.health, "api.health");
+    assertObject(value.auth, "api.auth");
+    assertObject(value.bruno, "api.bruno");
+    return value;
+}
+exports.validateApiConfig = validateApiConfig;
+function validateRegistryConfig(value) {
+    assertObject(value, ".soap/registry.json");
+    if (!Array.isArray(value.resources) || !Array.isArray(value.routes) || !Array.isArray(value.generatedFiles)) {
+        throw new errors_1.CliError(".soap/registry.json must contain resources, routes, and generatedFiles arrays.");
+    }
+    for (const resource of value.resources) {
+        if (resource && typeof resource === "object" && !Array.isArray(resource) && !Array.isArray(resource.fields)) {
+            resource.fields = [];
+        }
+        if (resource && typeof resource === "object" && !Array.isArray(resource)) {
+            assertAuthPolicy(resource.policy, "resource.policy");
+        }
+    }
+    for (const route of value.routes) {
+        if (route && typeof route === "object" && !Array.isArray(route) && typeof route.bruno !== "boolean") {
+            route.bruno = true;
+        }
+        if (route && typeof route === "object" && !Array.isArray(route)) {
+            assertAuthPolicy(route.policy, "route.policy");
+        }
+    }
+    return value;
+}
+exports.validateRegistryConfig = validateRegistryConfig;
+function assertAuthPolicy(value, label) {
+    if (value === undefined) {
+        return;
+    }
+    assertObject(value, label);
+    if (value.type === "admin") {
+        return;
+    }
+    if (value.type === "roles") {
+        if (!Array.isArray(value.roles) || value.roles.some((role) => typeof role !== "string" || role.trim() === "")) {
+            throw new errors_1.CliError(`${label}.roles must contain non-empty strings.`);
+        }
+        return;
+    }
+    if (value.type === "custom") {
+        assertString(value.name, `${label}.name`);
+        return;
+    }
+    throw new errors_1.CliError(`${label}.type must be admin, roles, or custom.`);
+}

package/build/config/soap-config.service.d.ts

@@ -0,0 +1,4 @@
+export { findSoapRoot } from "./find-soap-root";
+export { loadSoapConfig } from "./load-soap-config";
+export { writeSoapConfig } from "./write-soap-config";
+export * from "./schemas/types";

package/build/config/soap-config.service.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSoapConfig = exports.loadSoapConfig = exports.findSoapRoot = void 0;
+var find_soap_root_1 = require("./find-soap-root");
+Object.defineProperty(exports, "findSoapRoot", { enumerable: true, get: function () { return find_soap_root_1.findSoapRoot; } });
+var load_soap_config_1 = require("./load-soap-config");
+Object.defineProperty(exports, "loadSoapConfig", { enumerable: true, get: function () { return load_soap_config_1.loadSoapConfig; } });
+var write_soap_config_1 = require("./write-soap-config");
+Object.defineProperty(exports, "writeSoapConfig", { enumerable: true, get: function () { return write_soap_config_1.writeSoapConfig; } });
+__exportStar(require("./schemas/types"), exports);

package/build/config/write-soap-config.d.ts

@@ -0,0 +1,8 @@
+import { CommandContext } from "../core/command-context";
+import { SoapApiConfig, SoapProjectConfig, SoapRegistryConfig, SoapStructureConfig } from "./schemas/types";
+export declare function writeSoapConfig(root: string, config: {
+    project: SoapProjectConfig;
+    structure: SoapStructureConfig;
+    api: SoapApiConfig;
+    registry: SoapRegistryConfig;
+}, context: CommandContext): Promise<void>;

package/build/config/write-soap-config.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSoapConfig = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+async function writeJson(filePath, value, context) {
+    const content = `${JSON.stringify(value, null, 2)}\n`;
+    if (context.dryRun) {
+        context.output.info(`[dry-run] write ${filePath}`);
+        return;
+    }
+    await promises_1.default.mkdir(path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, content, "utf8");
+}
+async function writeSoapConfig(root, config, context) {
+    const soapRoot = path_1.default.join(root, ".soap");
+    await writeJson(path_1.default.join(soapRoot, "project.json"), config.project, context);
+    await writeJson(path_1.default.join(soapRoot, "structure.json"), config.structure, context);
+    await writeJson(path_1.default.join(soapRoot, "api.json"), config.api, context);
+    await writeJson(path_1.default.join(soapRoot, "registry.json"), config.registry, context);
+}
+exports.writeSoapConfig = writeSoapConfig;

package/build/core/command-context.d.ts

@@ -0,0 +1,20 @@
+import { Output } from "./output";
+export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
+export interface GlobalOptions {
+    cwd?: string;
+    verbose?: boolean;
+    silent?: boolean;
+    dryRun?: boolean;
+}
+export interface CommandContext {
+    cwd: string;
+    verbose: boolean;
+    silent: boolean;
+    dryRun: boolean;
+    packageManager?: PackageManager;
+    output: Output;
+}
+export declare function createCommandContext(options?: GlobalOptions): CommandContext;
+export declare function getCommandContext(command: {
+    getOptionValue(name: string): unknown;
+}): CommandContext;

package/build/core/command-context.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandContext = exports.createCommandContext = void 0;
+const path_1 = __importDefault(require("path"));
+const output_1 = require("./output");
+function createCommandContext(options = {}) {
+    const cwd = path_1.default.resolve(options.cwd ?? process.cwd());
+    const verbose = Boolean(options.verbose);
+    const silent = Boolean(options.silent);
+    const dryRun = Boolean(options.dryRun);
+    return {
+        cwd,
+        verbose,
+        silent,
+        dryRun,
+        output: (0, output_1.createOutput)({ verbose, silent }),
+    };
+}
+exports.createCommandContext = createCommandContext;
+function getCommandContext(command) {
+    const context = command.getOptionValue("_context");
+    if (!context) {
+        return createCommandContext();
+    }
+    return context;
+}
+exports.getCommandContext = getCommandContext;

package/build/core/errors.d.ts

@@ -0,0 +1,6 @@
+import { CommandContext } from "./command-context";
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}
+export declare function handleCliError(error: unknown, context: CommandContext): void;

package/build/core/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCliError = exports.CliError = void 0;
+class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "CliError";
+    }
+}
+exports.CliError = CliError;
+function handleCliError(error, context) {
+    if (error instanceof Error) {
+        context.output.error(error.message);
+        if (context.verbose && error.stack) {
+            context.output.debug(error.stack);
+        }
+        return;
+    }
+    context.output.error(String(error));
+}
+exports.handleCliError = handleCliError;

package/build/core/output.d.ts

@@ -0,0 +1,12 @@
+export interface Output {
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+}
+export interface OutputOptions {
+    verbose: boolean;
+    silent: boolean;
+}
+export declare function createOutput(options: OutputOptions): Output;

package/build/core/output.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOutput = void 0;
+function createOutput(options) {
+    const write = (stream, message) => {
+        stream.write(`${message}\n`);
+    };
+    return {
+        info(message) {
+            if (!options.silent)
+                write(process.stdout, message);
+        },
+        success(message) {
+            if (!options.silent)
+                write(process.stdout, message);
+        },
+        warn(message) {
+            if (!options.silent)
+                write(process.stderr, `Warning: ${message}`);
+        },
+        error(message) {
+            write(process.stderr, `Error: ${message}`);
+        },
+        debug(message) {
+            if (options.verbose && !options.silent)
+                write(process.stderr, `Debug: ${message}`);
+        },
+    };
+}
+exports.createOutput = createOutput;

package/build/core/result.d.ts

@@ -0,0 +1,9 @@
+export type Result<T, E = Error> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+export declare function ok<T>(value: T): Result<T>;
+export declare function err<E = Error>(error: E): Result<never, E>;

package/build/core/result.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.err = exports.ok = void 0;
+function ok(value) {
+    return { ok: true, value };
+}
+exports.ok = ok;
+function err(error) {
+    return { ok: false, error };
+}
+exports.err = err;

package/build/dependencies/dependency-resolver.d.ts

@@ -0,0 +1,6 @@
+import { ProjectCapabilities } from "../config/schemas/types";
+export interface ResolvedDependencies {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+}
+export declare function resolveDependencies(capabilities: ProjectCapabilities): ResolvedDependencies;

package/build/dependencies/dependency-resolver.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDependencies = void 0;
+function resolveDependencies(capabilities) {
+    const dependencies = {
+        "@soapjs/soap": "^0.12.1",
+        "@soapjs/soap-express": "^0.5.1",
+        dotenv: "^16.4.5",
+        express: "^4.18.2",
+        "reflect-metadata": "^0.2.2",
+    };
+    const devDependencies = {
+        "@types/express": "^4.17.21",
+        "@types/node": "^24.0.0",
+        tsx: "^4.7.1",
+        typescript: "^5.4.0",
+    };
+    if (capabilities.databases.includes("mongo")) {
+        dependencies["@soapjs/soap-node-mongo"] = "^0.7.1";
+        dependencies.mongodb = "^6.3.0";
+    }
+    if (capabilities.databases.includes("postgres") || capabilities.databases.includes("mysql") || capabilities.databases.includes("sqlite")) {
+        dependencies["@soapjs/soap-node-sql"] = "^0.2.1";
+    }
+    if (capabilities.databases.includes("postgres")) {
+        dependencies.pg = "^8.11.3";
+        devDependencies["@types/pg"] = "^8.11.6";
+    }
+    if (capabilities.databases.includes("mysql")) {
+        dependencies.mysql2 = "^3.11.0";
+    }
+    if (capabilities.databases.includes("sqlite")) {
+        dependencies["better-sqlite3"] = "^11.1.2";
+        devDependencies["@types/better-sqlite3"] = "^7.6.11";
+    }
+    if (capabilities.databases.includes("redis")) {
+        dependencies["@soapjs/soap-node-redis"] = "^0.1.0";
+        dependencies.redis = "^4.6.13";
+    }
+    if (capabilities.auth.length > 0) {
+        dependencies["@soapjs/soap-auth"] = "^0.4.4";
+        dependencies.jsonwebtoken = "^9.0.2";
+        devDependencies["@types/jsonwebtoken"] = "^9.0.6";
+    }
+    if (capabilities.messaging.includes("kafka")) {
+        dependencies["@soapjs/soap-node-kafka"] = "^0.1.3";
+        dependencies.kafkajs = "^2.2.4";
+    }
+    if (capabilities.realtime.includes("ws")) {
+        dependencies["@soapjs/soap-node-socket"] = "^0.0.3";
+        dependencies.ws = "^8.16.0";
+        devDependencies["@types/ws"] = "^8.5.10";
+    }
+    if (capabilities.telemetry.includes("otel-noop")) {
+        dependencies["@soapjs/soap-node-otel"] = "^0.1.3";
+    }
+    if (capabilities.docs.includes("openapi")) {
+        dependencies["@soapjs/soap-openapi"] = "^0.1.1";
+    }
+    if (capabilities.contracts.includes("zod")) {
+        dependencies.zod = "^3.23.8";
+    }
+    if (capabilities.apiClient.includes("bruno")) {
+        devDependencies["@usebruno/cli"] = "^3.4.2";
+    }
+    return { dependencies, devDependencies };
+}
+exports.resolveDependencies = resolveDependencies;

package/build/dependencies/package-manager.d.ts

@@ -0,0 +1,7 @@
+import { PackageManager } from "../core/command-context";
+export declare function detectPackageManager(root: string, override?: PackageManager): PackageManager;
+export declare function installCommand(packageManager: PackageManager): string;
+export declare function installCommandParts(packageManager: PackageManager): {
+    command: string;
+    args: string[];
+};

package/build/dependencies/package-manager.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installCommandParts = exports.installCommand = exports.detectPackageManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function detectPackageManager(root, override) {
+    if (override) {
+        return override;
+    }
+    const lockfiles = [
+        ["pnpm-lock.yaml", "pnpm"],
+        ["yarn.lock", "yarn"],
+        ["bun.lockb", "bun"],
+        ["package-lock.json", "npm"],
+    ];
+    for (const [lockfile, packageManager] of lockfiles) {
+        if (fs_1.default.existsSync(path_1.default.join(root, lockfile))) {
+            return packageManager;
+        }
+    }
+    return "npm";
+}
+exports.detectPackageManager = detectPackageManager;
+function installCommand(packageManager) {
+    switch (packageManager) {
+        case "pnpm":
+            return "pnpm install";
+        case "yarn":
+            return "yarn install";
+        case "bun":
+            return "bun install";
+        case "npm":
+        default:
+            return "npm install";
+    }
+}
+exports.installCommand = installCommand;
+function installCommandParts(packageManager) {
+    switch (packageManager) {
+        case "pnpm":
+            return { command: "pnpm", args: ["install"] };
+        case "yarn":
+            return { command: "yarn", args: ["install"] };
+        case "bun":
+            return { command: "bun", args: ["install"] };
+        case "npm":
+        default:
+            return { command: "npm", args: ["install"] };
+    }
+}
+exports.installCommandParts = installCommandParts;

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+(0, cli_1.runCli)(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/build/io/conflict-policy.d.ts

@@ -0,0 +1,10 @@
+export type ConflictPolicy = "ask" | "skip" | "overwrite" | "new" | "abort";
+export interface ConflictPolicyOptions {
+    force?: boolean;
+    writeNew?: boolean;
+    skipModified?: boolean;
+    onConflict?: string;
+}
+export declare function parseConflictPolicy(value: string): ConflictPolicy;
+export declare function resolveConflictPolicy(options?: ConflictPolicyOptions): ConflictPolicy;
+export declare function conflictPolicyHelp(): string;