@soapjs/cli 1.0.0

package/build/commands/doctor/doctor.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerDoctorCommand(program: Command): void;

package/build/commands/doctor/doctor.command.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDoctorCommand = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const command_context_1 = require("../../core/command-context");
+const find_soap_root_1 = require("../../config/find-soap-root");
+const load_soap_config_1 = require("../../config/load-soap-config");
+function registerDoctorCommand(program) {
+    program
+        .command("doctor")
+        .description("Validate local SoapJS CLI/project setup.")
+        .action(async (_options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const soapRoot = (0, find_soap_root_1.findSoapRoot)(context.cwd);
+        context.output.info(`Node.js: ${process.version}`);
+        if (!soapRoot) {
+            context.output.warn("No .soap project found from current directory.");
+            return;
+        }
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        context.output.success(`Found SoapJS project: ${config.project.name}`);
+        const requiredFiles = [".soap/project.json", ".soap/structure.json", ".soap/api.json", ".soap/registry.json"];
+        for (const file of requiredFiles) {
+            const absolute = path_1.default.join(soapRoot, file);
+            if (fs_1.default.existsSync(absolute)) {
+                context.output.success(`ok ${file}`);
+            }
+            else {
+                context.output.error(`missing ${file}`);
+            }
+        }
+    });
+}
+exports.registerDoctorCommand = registerDoctorCommand;

package/build/commands/generate/bruno-analysis.d.ts

@@ -0,0 +1,19 @@
+import { PlannedFile } from "../../io/file-writer";
+import { SoapConfig } from "../../config/schemas/types";
+export interface BrunoFileAnalysis {
+    file: PlannedFile;
+    exists: boolean;
+    tracked: boolean;
+    modified: boolean;
+}
+export interface BrunoGenerationAnalysis {
+    routeCount: number;
+    files: BrunoFileAnalysis[];
+    existingCount: number;
+    missingCount: number;
+    modifiedCount: number;
+}
+export declare function analyzeBrunoFiles(config: SoapConfig, files: PlannedFile[]): Promise<BrunoGenerationAnalysis>;
+export declare function formatBrunoGenerationAnalysis(analysis: BrunoGenerationAnalysis): string;
+export declare function selectMissingBrunoFiles(analysis: BrunoGenerationAnalysis): PlannedFile[];
+export declare function selectUnmodifiedBrunoFiles(analysis: BrunoGenerationAnalysis): PlannedFile[];

package/build/commands/generate/bruno-analysis.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectUnmodifiedBrunoFiles = exports.selectMissingBrunoFiles = exports.formatBrunoGenerationAnalysis = exports.analyzeBrunoFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const registry_service_1 = require("../../registry/registry.service");
+async function analyzeBrunoFiles(config, files) {
+    const analyzedFiles = await Promise.all(files.map((file) => analyzeBrunoFile(config, file)));
+    return {
+        routeCount: config.registry.routes.length,
+        files: analyzedFiles,
+        existingCount: analyzedFiles.filter((entry) => entry.exists).length,
+        missingCount: analyzedFiles.filter((entry) => !entry.exists).length,
+        modifiedCount: analyzedFiles.filter((entry) => entry.modified).length,
+    };
+}
+exports.analyzeBrunoFiles = analyzeBrunoFiles;
+function formatBrunoGenerationAnalysis(analysis) {
+    return [
+        `Detected routes: ${analysis.routeCount}`,
+        `Existing Bruno files: ${analysis.existingCount}`,
+        `Missing Bruno files: ${analysis.missingCount}`,
+        `Modified generated Bruno files: ${analysis.modifiedCount}`,
+    ].join("\n");
+}
+exports.formatBrunoGenerationAnalysis = formatBrunoGenerationAnalysis;
+function selectMissingBrunoFiles(analysis) {
+    return analysis.files
+        .filter((entry) => !entry.exists)
+        .map((entry) => entry.file);
+}
+exports.selectMissingBrunoFiles = selectMissingBrunoFiles;
+function selectUnmodifiedBrunoFiles(analysis) {
+    return analysis.files
+        .filter((entry) => !entry.modified)
+        .map((entry) => entry.file);
+}
+exports.selectUnmodifiedBrunoFiles = selectUnmodifiedBrunoFiles;
+async function analyzeBrunoFile(config, file) {
+    const targetPath = path_1.default.join(config.root, file.path);
+    const currentHash = await (0, registry_service_1.readFileHash)(targetPath);
+    const registryEntry = config.registry.generatedFiles.find((entry) => entry.path === file.path);
+    return {
+        file,
+        exists: currentHash !== undefined,
+        tracked: registryEntry !== undefined,
+        modified: Boolean(currentHash && registryEntry && currentHash !== registryEntry.hash),
+    };
+}

package/build/commands/generate/bruno-plan.d.ts

@@ -0,0 +1,6 @@
+import { SoapConfig } from "../../config/schemas/types";
+import { PlannedFile } from "../../io/file-writer";
+export interface BrunoGenerationOptions {
+    e2e?: boolean;
+}
+export declare function createBrunoFiles(config: SoapConfig, options?: BrunoGenerationOptions): PlannedFile[];

package/build/commands/generate/bruno-plan.js

@@ -0,0 +1,326 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrunoFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const naming_1 = require("../../templates/naming");
+function createBrunoFiles(config, options = {}) {
+    const collectionPath = config.api.bruno.collectionPath || "bruno";
+    const environment = config.api.bruno.environment || "Local";
+    const files = [
+        {
+            path: path_1.default.posix.join(collectionPath, "bruno.json"),
+            type: "bruno",
+            content: JSON.stringify({
+                version: "1",
+                name: config.project.name,
+                type: "collection",
+            }, null, 2),
+        },
+        {
+            path: path_1.default.posix.join(collectionPath, "environments", `${environment}.bru`),
+            type: "bruno",
+            content: `vars {
+  baseUrl: ${config.api.baseUrl}
+  accessToken:
+  apiKey:
+  id:
+  email: admin@example.com
+  password: admin123
+}
+`,
+        },
+        {
+            path: path_1.default.posix.join(collectionPath, "Health", "health.bru"),
+            type: "bruno",
+            content: createRequestBru({
+                name: "Health",
+                method: config.api.health.method,
+                path: config.api.health.path,
+                sequence: 1,
+                auth: "none",
+            }),
+        },
+    ];
+    if (usesJwtAuth(config.project.capabilities.auth)) {
+        files.push({
+            path: path_1.default.posix.join(collectionPath, "Auth", "login.bru"),
+            type: "bruno",
+            owner: "auth",
+            content: createLoginBru(2),
+        }, {
+            path: path_1.default.posix.join(collectionPath, "Auth", "me.bru"),
+            type: "bruno",
+            owner: "auth",
+            content: createRequestBru({
+                name: "Me",
+                method: "GET",
+                path: "/auth/me",
+                sequence: 3,
+                auth: "jwt",
+            }),
+        });
+    }
+    const grouped = groupRoutesByResource(config.registry.routes.filter((route) => route.bruno !== false));
+    const fieldsByResource = new Map(config.registry.resources.map((resource) => [resource.name, resource.fields]));
+    let sequence = usesJwtAuth(config.project.capabilities.auth) ? 4 : 2;
+    for (const [resourceName, routes] of Array.from(grouped.entries()).sort(([left], [right]) => left.localeCompare(right))) {
+        const resourceNames = (0, naming_1.createNameVariants)(resourceName);
+        for (const route of routes.sort(compareRoutes)) {
+            const routeNames = (0, naming_1.createNameVariants)(route.name);
+            files.push({
+                path: path_1.default.posix.join(collectionPath, resourceNames.pascalName, `${routeNames.pascalName}.bru`),
+                type: "bruno",
+                owner: resourceName,
+                content: createRequestBru({
+                    name: routeNames.pascalName,
+                    method: route.method,
+                    path: route.path,
+                    sequence,
+                    auth: route.auth,
+                    includeJsonBody: ["POST", "PUT", "PATCH"].includes(route.method.toUpperCase()),
+                    fields: fieldsByResource.get(resourceName),
+                    expectBody: route.method.toUpperCase() === "GET" && ["list", "get"].includes(route.name),
+                    captureId: route.method.toUpperCase() === "POST" && route.name === "create",
+                }),
+            });
+            sequence += 1;
+        }
+    }
+    if (options.e2e) {
+        files.push(...createE2eFlowFiles(config, grouped, sequence));
+    }
+    return files;
+}
+exports.createBrunoFiles = createBrunoFiles;
+function compareRoutes(left, right) {
+    const rank = new Map([
+        ["list", 0],
+        ["create", 1],
+        ["get", 2],
+        ["update", 3],
+        ["delete", 4],
+    ]);
+    const leftRank = rank.get(left.name) ?? 100;
+    const rightRank = rank.get(right.name) ?? 100;
+    if (leftRank !== rightRank) {
+        return leftRank - rightRank;
+    }
+    return `${left.method} ${left.path} ${left.name}`.localeCompare(`${right.method} ${right.path} ${right.name}`);
+}
+function createE2eFlowFiles(config, grouped, startSequence) {
+    const collectionPath = config.api.bruno.collectionPath || "bruno";
+    const files = [];
+    let sequence = startSequence;
+    for (const [resourceName, routes] of Array.from(grouped.entries()).sort(([left], [right]) => left.localeCompare(right))) {
+        const crud = resolveCrudRoutes(routes);
+        if (!crud) {
+            continue;
+        }
+        const resourceNames = (0, naming_1.createNameVariants)(resourceName);
+        const itemNames = (0, naming_1.createNameVariants)(singularizeResourceName(resourceNames.kebabName));
+        let step = 1;
+        if (usesJwtAuth(config.project.capabilities.auth)) {
+            files.push({
+                path: path_1.default.posix.join(collectionPath, "E2E Flow", `${formatStep(step)}-login.bru`),
+                type: "bruno",
+                owner: resourceName,
+                content: createLoginBru(sequence),
+            });
+            step += 1;
+            sequence += 1;
+        }
+        const flowSteps = [
+            { label: `create-${itemNames.kebabName}`, route: crud.create, includeJsonBody: true, captureId: true },
+            { label: `get-${itemNames.kebabName}`, route: crud.get, expectBody: true },
+            { label: `list-${resourceNames.kebabName}`, route: crud.list, expectBody: true },
+            { label: `update-${itemNames.kebabName}`, route: crud.update, includeJsonBody: true, expectBody: true },
+            { label: `delete-${itemNames.kebabName}`, route: crud.delete, expectBody: true },
+        ];
+        for (const flowStep of flowSteps) {
+            files.push({
+                path: path_1.default.posix.join(collectionPath, "E2E Flow", `${formatStep(step)}-${flowStep.label}.bru`),
+                type: "bruno",
+                owner: resourceName,
+                content: createRequestBru({
+                    name: flowStep.label,
+                    method: flowStep.route.method,
+                    path: flowStep.route.path,
+                    sequence,
+                    auth: flowStep.route.auth,
+                    includeJsonBody: flowStep.includeJsonBody,
+                    fields: config.registry.resources.find((resource) => resource.name === resourceName)?.fields,
+                    expectBody: flowStep.expectBody,
+                    captureId: flowStep.captureId,
+                }),
+            });
+            step += 1;
+            sequence += 1;
+        }
+    }
+    return files;
+}
+function resolveCrudRoutes(routes) {
+    const byName = new Map(routes.map((route) => [route.name, route]));
+    const list = byName.get("list");
+    const get = byName.get("get");
+    const create = byName.get("create");
+    const update = byName.get("update");
+    const deleteRoute = byName.get("delete");
+    if (!list || !get || !create || !update || !deleteRoute) {
+        return undefined;
+    }
+    return {
+        list,
+        get,
+        create,
+        update,
+        delete: deleteRoute,
+    };
+}
+function formatStep(value) {
+    return String(value).padStart(2, "0");
+}
+function singularizeResourceName(name) {
+    if (name.endsWith("ies")) {
+        return `${name.slice(0, -3)}y`;
+    }
+    if (name.endsWith("ses") || name.endsWith("xes") || name.endsWith("zes") || name.endsWith("ches") || name.endsWith("shes")) {
+        return name.slice(0, -2);
+    }
+    if (name.endsWith("s") && name.length > 1) {
+        return name.slice(0, -1);
+    }
+    return name;
+}
+function usesJwtAuth(values) {
+    return values.includes("jwt") || values.includes("local");
+}
+function createLoginBru(sequence) {
+    return `meta {
+  name: Login
+  type: http
+  seq: ${sequence}
+}
+
+post {
+  url: {{baseUrl}}/auth/login
+  body: json
+  auth: none
+}
+
+body:json {
+  {
+    "email": "{{email}}",
+    "password": "{{password}}"
+  }
+}
+
+script:post-response {
+  const data = res.getBody();
+  if (data?.accessToken) {
+    bru.setEnvVar("accessToken", data.accessToken);
+  }
+}
+
+tests {
+  function onResponse(request, response) {
+    expect(response.status).to.be.within(200, 299);
+    const body = response.getBody();
+    expect(body.accessToken).to.be.a('string').and.not.empty;
+  }
+}
+`;
+}
+function groupRoutesByResource(routes) {
+    const grouped = new Map();
+    for (const route of routes) {
+        const routesForResource = grouped.get(route.resource) ?? [];
+        routesForResource.push(route);
+        grouped.set(route.resource, routesForResource);
+    }
+    return grouped;
+}
+function createRequestBru(options) {
+    const method = options.method.toLowerCase();
+    const requestPath = toBrunoPath(options.path);
+    const bodyType = options.includeJsonBody ? "json" : "none";
+    const authBlock = options.auth === "jwt"
+        ? `
+headers {
+  Authorization: Bearer {{accessToken}}
+}
+`
+        : options.auth === "api-key"
+            ? `
+headers {
+  x-api-key: {{apiKey}}
+}
+`
+            : "";
+    const bodyBlock = options.includeJsonBody
+        ? `
+body:json {
+${createExampleJsonBody(options.fields)}
+}
+`
+        : "";
+    const createScriptBlock = options.captureId
+        ? `
+script:post-response {
+  const data = res.getBody();
+  const id = data?.content?.id || data?.id;
+  if (id) {
+    bru.setEnvVar("id", id);
+  }
+}
+`
+        : "";
+    const bodyExpectation = options.expectBody
+        ? `
+    expect(response.getBody()).to.exist;`
+        : "";
+    const testsBlock = `
+tests {
+  function onResponse(request, response) {
+    expect(response.status).to.be.within(200, 299);${bodyExpectation}
+  }
+}
+`;
+    return `meta {
+  name: ${options.name}
+  type: http
+  seq: ${options.sequence}
+}
+
+${method} {
+  url: {{baseUrl}}${requestPath}
+  body: ${bodyType}
+  auth: none
+}
+${authBlock}${bodyBlock}${createScriptBlock}${testsBlock}`;
+}
+function createExampleJsonBody(fields) {
+    const bodyFields = fields && fields.length > 0
+        ? fields
+        : [{ name: "name", type: "string", required: true }];
+    const body = Object.fromEntries(bodyFields.map((field) => [field.name, exampleValueForField(field)]));
+    return JSON.stringify(body, null, 2)
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n");
+}
+function exampleValueForField(field) {
+    if (field.type === "number")
+        return 42;
+    if (field.type === "boolean")
+        return true;
+    if (field.type === "date")
+        return "2026-01-01T00:00:00.000Z";
+    return "Example";
+}
+function toBrunoPath(routePath) {
+    return routePath.replace(/:([A-Za-z0-9_]+)/g, "{{$1}}");
+}

package/build/commands/generate/generate.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerGenerateCommand(program: Command): void;

package/build/commands/generate/generate.command.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGenerateCommand = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const command_context_1 = require("../../core/command-context");
+const errors_1 = require("../../core/errors");
+const load_soap_config_1 = require("../../config/load-soap-config");
+const write_soap_config_1 = require("../../config/write-soap-config");
+const file_writer_1 = require("../../io/file-writer");
+const common_options_1 = require("../shared/common-options");
+const bruno_plan_1 = require("./bruno-plan");
+const generate_bruno_resolver_1 = require("../../resolvers/generate-bruno.resolver");
+const prompts_1 = require("../../prompts");
+const bruno_analysis_1 = require("./bruno-analysis");
+function registerGenerateCommand(program) {
+    const generate = program.command("generate").description("Generate secondary artifacts.");
+    (0, common_options_1.addConflictOption)((0, common_options_1.addInteractiveOption)(generate
+        .command("bruno")
+        .description("Generate Bruno collection files from .soap registry metadata.")
+        .option("--e2e", "generate runnable CRUD E2E flow requests", false)
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)))
+        .action(async (options, command) => {
+        (0, common_options_1.assertInteractiveTerminal)(options);
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const resolved = generate_bruno_resolver_1.generateBrunoResolver.resolve({ flags: options, projectConfig: config });
+        let files = (0, bruno_plan_1.createBrunoFiles)(config, { e2e: resolved.e2e });
+        if (options.interactive) {
+            const prompt = new prompts_1.InquirerPromptAdapter();
+            const baseFiles = (0, bruno_plan_1.createBrunoFiles)(config);
+            const baseAnalysis = await (0, bruno_analysis_1.analyzeBrunoFiles)(config, baseFiles);
+            context.output.info((0, bruno_analysis_1.formatBrunoGenerationAnalysis)(baseAnalysis));
+            const mode = isCliOption(command, "e2e")
+                ? "e2e"
+                : (await (0, prompts_1.promptGenerateBruno)(prompt, baseAnalysis)).mode;
+            if (mode === "abort") {
+                context.output.warn("Bruno generation aborted.");
+                return;
+            }
+            if (mode === "missing") {
+                files = (0, bruno_analysis_1.selectMissingBrunoFiles)(baseAnalysis);
+            }
+            if (mode === "all") {
+                files = options.force ? baseFiles : (0, bruno_analysis_1.selectUnmodifiedBrunoFiles)(baseAnalysis);
+            }
+            if (mode === "e2e") {
+                const e2eFiles = (0, bruno_plan_1.createBrunoFiles)(config, { e2e: true });
+                const e2eAnalysis = await (0, bruno_analysis_1.analyzeBrunoFiles)(config, e2eFiles);
+                files = options.force ? e2eFiles : (0, bruno_analysis_1.selectUnmodifiedBrunoFiles)(e2eAnalysis);
+            }
+            if (files.length === 0) {
+                context.output.warn("No Bruno files selected for generation.");
+                return;
+            }
+        }
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files,
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+            onConflict: options.onConflict,
+            skipModified: !options.force && !options.writeNew,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Generated Bruno collection with ${files.length} files.`);
+    });
+    generate
+        .command("openapi")
+        .description("Fetch OpenAPI JSON from the running local API.")
+        .option("--output <path>", "write OpenAPI JSON to a file instead of stdout")
+        .action(async (options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        if (!config.project.capabilities.docs.includes("openapi")) {
+            throw new errors_1.CliError("OpenAPI is not enabled for this project. Create the project with `--docs openapi`.");
+        }
+        const openApiUrl = createOpenApiUrl(config.api.baseUrl);
+        if (options.output) {
+            const outputPath = path_1.default.resolve(context.cwd, options.output);
+            if (context.dryRun) {
+                context.output.info(`[dry-run] write ${outputPath}`);
+                return;
+            }
+            const content = await fetchOpenApiJson(openApiUrl);
+            await promises_1.default.mkdir(path_1.default.dirname(outputPath), { recursive: true });
+            await promises_1.default.writeFile(outputPath, content, "utf8");
+            context.output.success(`Wrote OpenAPI JSON to ${options.output}`);
+            return;
+        }
+        const content = await fetchOpenApiJson(openApiUrl);
+        context.output.info(content);
+    });
+}
+exports.registerGenerateCommand = registerGenerateCommand;
+function isCliOption(command, name) {
+    return command.getOptionValueSource(name) === "cli";
+}
+function createOpenApiUrl(baseUrl) {
+    const normalized = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    return `${normalized}/openapi.json`;
+}
+async function fetchOpenApiJson(url) {
+    let response;
+    try {
+        response = await fetch(url, {
+            headers: {
+                accept: "application/json",
+            },
+        });
+    }
+    catch (error) {
+        throw new errors_1.CliError(`Could not fetch OpenAPI JSON from ${url}. Start the API and run again.`);
+    }
+    if (!response.ok) {
+        throw new errors_1.CliError(`Could not fetch OpenAPI JSON from ${url}. Server returned ${response.status} ${response.statusText}.`);
+    }
+    const text = await response.text();
+    try {
+        return `${JSON.stringify(JSON.parse(text), null, 2)}\n`;
+    }
+    catch (error) {
+        throw new errors_1.CliError(`OpenAPI endpoint ${url} did not return valid JSON.`);
+    }
+}

package/build/commands/info/info.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerInfoCommand(program: Command): void;

package/build/commands/info/info.command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInfoCommand = void 0;
+const command_context_1 = require("../../core/command-context");
+const load_soap_config_1 = require("../../config/load-soap-config");
+function registerInfoCommand(program) {
+    program
+        .command("info")
+        .description("Print SoapJS project metadata.")
+        .action(async (_options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const project = config.project;
+        context.output.info(`Name: ${project.name}`);
+        context.output.info(`Root: ${config.root}`);
+        context.output.info(`Framework: ${project.framework}`);
+        context.output.info(`Architecture: ${project.architecture}`);
+        context.output.info(`Package manager: ${project.packageManager}`);
+        context.output.info(`Databases: ${project.capabilities.databases.join(", ") || "none"}`);
+        context.output.info(`Auth: ${project.capabilities.auth.join(", ") || "none"}`);
+        context.output.info(`Messaging: ${project.capabilities.messaging.join(", ") || "none"}`);
+        context.output.info(`Zones: ${project.zones.join(", ")}`);
+        context.output.info(`Generated files: ${config.registry.generatedFiles.length}`);
+    });
+}
+exports.registerInfoCommand = registerInfoCommand;

package/build/commands/remove/remove.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerRemoveCommand(program: Command): void;