@a5c-ai/tasks-adapter 5.1.1-staging.00ceebd28cf2

package/dist/cli/commands/breakpoints.js

@@ -0,0 +1,311 @@
+import { Command } from "commander";
+import { ResponderClient, AnswerPoller, } from "../../client/index.js";
+import { formatBreakpoint, formatAnswer, formatTable, printError } from "../output.js";
+import { createCliServerClient } from "../client-config.js";
+import { GitNativeBackend } from "../../backends/git-native.js";
+function backend(opts) {
+    return new GitNativeBackend({ breakpointsDir: opts.breakpointsDir });
+}
+function splitCsv(value) {
+    return value?.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function printResult(value, jsonMode) {
+    if (jsonMode) {
+        console.log(JSON.stringify(value, null, 2));
+        return;
+    }
+    console.log(JSON.stringify(value, null, 2));
+}
+export function createBreakpointsCommand() {
+    const cmd = new Command("breakpoints")
+        .description("Manage breakpoints and answers")
+        .option("--breakpoints-dir <path>", "Path to .breakpoints directory for local lifecycle commands");
+    cmd
+        .command("list")
+        .description("List breakpoints, optionally filtered by status")
+        .option("--status <csv>", "Comma-separated statuses")
+        .option("--priority <csv>", "Comma-separated priorities")
+        .option("--assignee <id>", "Assignee responder id")
+        .option("--responder <id>", "Target/claimed/answering responder id")
+        .option("--limit <n>", "Maximum result count")
+        .action(async (opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).searchBreakpoints({
+                status: splitCsv(opts.status),
+                priority: splitCsv(opts.priority),
+                assigneeId: opts.assignee,
+                responderId: opts.responder,
+                limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
+            });
+            if (jsonMode) {
+                printResult(result, true);
+            }
+            else {
+                const rows = result.items.map((b) => [
+                    b.id,
+                    b.status,
+                    b.priority ?? "medium",
+                    b.assigneeId ?? "",
+                    b.text,
+                ]);
+                console.log(formatTable(rows, ["ID", "Status", "Priority", "Assignee", "Breakpoint"]));
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("search")
+        .description("Search breakpoints across lifecycle states")
+        .option("-q, --query <text>", "Text query")
+        .option("--status <csv>", "Comma-separated statuses")
+        .option("--priority <csv>", "Comma-separated priorities")
+        .option("--assignee <id>", "Assignee responder id")
+        .option("--responder <id>", "Target/claimed/answering responder id")
+        .option("--tag <csv>", "Comma-separated tags")
+        .option("--domain <domain>", "Domain filter")
+        .option("--limit <n>", "Maximum result count")
+        .action(async (opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).searchBreakpoints({
+                query: opts.query,
+                status: splitCsv(opts.status),
+                priority: splitCsv(opts.priority),
+                assigneeId: opts.assignee,
+                responderId: opts.responder,
+                tags: splitCsv(opts.tag),
+                domain: opts.domain,
+                limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
+            });
+            printResult(result, jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    for (const commandName of ["assign", "reassign"]) {
+        cmd
+            .command(commandName)
+            .description(`${commandName === "assign" ? "Assign" : "Reassign"} a breakpoint`)
+            .argument("<breakpointId>", "Breakpoint ID")
+            .requiredOption("--assignee <id>", "Assignee responder id")
+            .option("--assignee-name <name>", "Assignee display name")
+            .option("--actor <id>", "Actor id")
+            .action(async (breakpointId, opts, command) => {
+            const allOpts = command.optsWithGlobals();
+            const jsonMode = allOpts.json === true;
+            try {
+                const result = await backend(allOpts).assignBreakpoint(breakpointId, {
+                    assigneeId: opts.assignee ?? "",
+                    assigneeName: opts.assigneeName,
+                    actorId: opts.actor,
+                });
+                printResult(result, jsonMode);
+            }
+            catch (error) {
+                printError(error, jsonMode);
+                process.exitCode = 1;
+            }
+        });
+    }
+    cmd
+        .command("close")
+        .description("Mark a breakpoint completed")
+        .argument("<breakpointId>", "Breakpoint ID")
+        .option("--actor <id>", "Actor id")
+        .option("--message <text>", "History message")
+        .action(async (breakpointId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).transitionBreakpoint(breakpointId, {
+                status: "completed",
+                actorId: opts.actor,
+                message: opts.message,
+            });
+            printResult(result, jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("approve")
+        .description("Approve a breakpoint by submitting an approved answer")
+        .argument("<breakpointId>", "Breakpoint ID")
+        .requiredOption("-a, --answer <text>", "Approved answer text")
+        .requiredOption("-e, --responder <responderId>", "Responder ID")
+        .option("--responder-name <name>", "Responder display name")
+        .option("--confidence <number>", "Confidence level (0-100)", "100")
+        .action(async (breakpointId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const answer = await backend(allOpts).answerBreakpoint(breakpointId, {
+                responderId: opts.responder ?? "",
+                responderName: opts.responderName ?? opts.responder ?? "",
+                text: opts.answer ?? "",
+                approved: true,
+                confidence: Number.parseInt(opts.confidence ?? "100", 10),
+            });
+            printResult(answer, jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("pending")
+        .description("List pending breakpoints for a responder")
+        .requiredOption("-e, --responder <responderId>", "Responder ID")
+        .action(async (opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const localOpts = opts;
+        const jsonMode = allOpts.json === true;
+        try {
+            const client = await createCliServerClient({
+                serverUrl: allOpts.serverUrl,
+                authToken: allOpts.authToken,
+            });
+            const responderClient = new ResponderClient(client, localOpts.responder);
+            const breakpoints = await responderClient.fetchPendingBreakpoints();
+            if (jsonMode) {
+                console.log(JSON.stringify(breakpoints, null, 2));
+            }
+            else if (breakpoints.length === 0) {
+                console.log("No pending breakpoints.");
+            }
+            else {
+                const rows = breakpoints.map((b) => [
+                    b.id,
+                    b.status,
+                    b.text.length > 60 ? b.text.substring(0, 57) + "..." : b.text,
+                    b.createdAt,
+                ]);
+                console.log(formatTable(rows, ["ID", "Status", "Breakpoint", "Created"]));
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("answer")
+        .description("Submit an answer to a breakpoint")
+        .argument("<breakpointId>", "Breakpoint ID")
+        .requiredOption("-a, --answer <text>", "Answer text")
+        .requiredOption("-e, --responder <responderId>", "Responder ID")
+        .option("--confidence <number>", "Confidence level (0-100)", "80")
+        .action(async (breakpointId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const localOpts = opts;
+        const jsonMode = allOpts.json === true;
+        try {
+            const client = await createCliServerClient({
+                serverUrl: allOpts.serverUrl,
+                authToken: allOpts.authToken,
+            });
+            const responderClient = new ResponderClient(client, localOpts.responder);
+            const confidence = parseInt(localOpts.confidence ?? "80", 10);
+            const answer = await responderClient.submitAnswer(breakpointId, localOpts.answer, confidence);
+            if (jsonMode) {
+                console.log(JSON.stringify(answer, null, 2));
+            }
+            else {
+                console.log(formatAnswer(answer, false));
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("status")
+        .description("Check breakpoint status")
+        .argument("<breakpointId>", "Breakpoint ID")
+        .action(async (breakpointId, _opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const client = await createCliServerClient({
+                serverUrl: allOpts.serverUrl,
+                authToken: allOpts.authToken,
+            });
+            const breakpoint = await client.getBreakpoint(breakpointId);
+            if (jsonMode) {
+                console.log(JSON.stringify(breakpoint, null, 2));
+            }
+            else {
+                console.log(formatBreakpoint(breakpoint, false));
+                if (breakpoint.answers.length > 0) {
+                    console.log("\nAnswers:");
+                    for (const answer of breakpoint.answers) {
+                        console.log("");
+                        console.log(formatAnswer(answer, false));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("poll")
+        .description("Poll for an answer to a breakpoint")
+        .argument("<breakpointId>", "Breakpoint ID")
+        .option("-t, --timeout <seconds>", "Timeout in seconds", "300")
+        .option("-i, --interval <seconds>", "Polling interval in seconds", "5")
+        .action(async (breakpointId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const localOpts = opts;
+        const jsonMode = allOpts.json === true;
+        try {
+            const client = await createCliServerClient({
+                serverUrl: allOpts.serverUrl,
+                authToken: allOpts.authToken,
+            });
+            const poller = new AnswerPoller(client);
+            const timeoutMs = parseInt(localOpts.timeout ?? "300", 10) * 1000;
+            const pollIntervalMs = parseInt(localOpts.interval ?? "5", 10) * 1000;
+            if (!jsonMode) {
+                console.log(`Polling for answer to ${breakpointId}...`);
+            }
+            const result = await poller.waitForAnswer(breakpointId, {
+                timeoutMs,
+                pollIntervalMs,
+                useSSE: true,
+            });
+            if (jsonMode) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log(formatBreakpoint(result.breakpoint, false));
+                if (result.answer) {
+                    console.log("");
+                    console.log(formatAnswer(result.answer, false));
+                }
+                else {
+                    console.log("\nNo answer received within timeout.");
+                }
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}

package/dist/cli/commands/responder-loop.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createResponderLoopCommand(): Command;
+//# sourceMappingURL=responder-loop.d.ts.map

package/dist/cli/commands/responder-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responder-loop.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/responder-loop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC,wBAAgB,0BAA0B,IAAI,OAAO,CAiEpD"}

package/dist/cli/commands/responder-loop.js

@@ -0,0 +1,78 @@
+import { Command } from "commander";
+import { ResponderClient, } from "../../client/index.js";
+import { formatTable, printError } from "../output.js";
+import { createCliServerClient } from "../client-config.js";
+export function createResponderLoopCommand() {
+    const cmd = new Command("responder-loop")
+        .description("Start a polling loop to check for new breakpoints")
+        .requiredOption("-e, --responder <responderId>", "Responder ID")
+        .option("-i, --interval <seconds>", "Polling interval in seconds", "30")
+        .option("--once", "Check once and exit (for agent integration)", false)
+        .action(async (opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const localOpts = opts;
+        const jsonMode = allOpts.json === true;
+        try {
+            const client = await createCliServerClient({
+                serverUrl: allOpts.serverUrl,
+                authToken: allOpts.authToken,
+            });
+            const responderClient = new ResponderClient(client, localOpts.responder);
+            const intervalMs = parseInt(localOpts.interval ?? "30", 10) * 1000;
+            if (localOpts.once) {
+                // Single check mode
+                const breakpoints = await responderClient.fetchPendingBreakpoints();
+                displayBreakpoints(breakpoints, jsonMode);
+                return;
+            }
+            // Continuous polling mode
+            if (!jsonMode) {
+                console.log(`Starting responder loop for ${localOpts.responder} (interval: ${localOpts.interval ?? "30"}s)`);
+                console.log("Press Ctrl+C to stop.\n");
+            }
+            const stop = responderClient.startPollingLoop((breakpoints) => {
+                displayBreakpoints(breakpoints, jsonMode);
+            }, intervalMs);
+            // Handle graceful shutdown
+            const shutdown = () => {
+                stop();
+                if (!jsonMode) {
+                    console.log("\nResponder loop stopped.");
+                }
+                process.exit(0);
+            };
+            process.on("SIGTERM", shutdown);
+            process.on("SIGINT", shutdown);
+            // Keep the process alive
+            await new Promise(() => {
+                // This promise never resolves; the process is kept alive
+                // until SIGTERM/SIGINT is received.
+            });
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}
+function displayBreakpoints(breakpoints, jsonMode) {
+    if (jsonMode) {
+        console.log(JSON.stringify(breakpoints, null, 2));
+        return;
+    }
+    if (breakpoints.length === 0) {
+        console.log("No pending breakpoints.");
+        return;
+    }
+    console.log(`Found ${breakpoints.length} pending breakpoint(s):\n`);
+    const rows = breakpoints.map((b) => [
+        b.id,
+        b.status,
+        b.text.length > 60 ? b.text.substring(0, 57) + "..." : b.text,
+        b.routing.strategy,
+        b.createdAt,
+    ]);
+    console.log(formatTable(rows, ["ID", "Status", "Breakpoint", "Strategy", "Created"]));
+    console.log("");
+}

package/dist/cli/commands/responders.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createRespondersCommand(): Command;
+//# sourceMappingURL=responders.d.ts.map

package/dist/cli/commands/responders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responders.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/responders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC,wBAAgB,uBAAuB,IAAI,OAAO,CA8JjD"}

package/dist/cli/commands/responders.js

@@ -0,0 +1,157 @@
+import { Command } from "commander";
+import { ResponderMatcher } from "../../client/index.js";
+import { formatResponder, formatTable, printError } from "../output.js";
+export function createRespondersCommand() {
+    const cmd = new Command("responders").description("Manage and view responder profiles");
+    cmd
+        .command("list")
+        .description("List available responders")
+        .option("-d, --domain <domain>", "Filter by domain")
+        .action(async (opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const localOpts = opts;
+        const jsonMode = allOpts.json === true;
+        try {
+            const matcher = new ResponderMatcher({
+                responderDir: allOpts.responderDir,
+                repoRoot: allOpts.repoRoot,
+                configRoot: allOpts.configRoot,
+            });
+            const responders = await matcher.loadResponders();
+            let filtered = responders;
+            if (localOpts.domain) {
+                const domain = localOpts.domain.toLowerCase();
+                filtered = responders.filter((r) => r.domains.some((d) => d.toLowerCase().includes(domain)));
+            }
+            if (jsonMode) {
+                console.log(JSON.stringify(filtered, null, 2));
+            }
+            else if (filtered.length === 0) {
+                console.log("No responders found.");
+            }
+            else {
+                const rows = filtered.map((r) => [
+                    r.id,
+                    r.name,
+                    r.title,
+                    r.availability ? "yes" : "no",
+                    r.domains.join(", "),
+                ]);
+                console.log(formatTable(rows, ["ID", "Name", "Title", "Available", "Domains"]));
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("search")
+        .description("Search responder profiles")
+        .option("-q, --query <text>", "Text query")
+        .option("-d, --domain <domain>", "Filter by domain")
+        .action(async (opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const localOpts = opts;
+        const jsonMode = allOpts.json === true;
+        try {
+            const matcher = new ResponderMatcher({
+                responderDir: allOpts.responderDir,
+                repoRoot: allOpts.repoRoot,
+                configRoot: allOpts.configRoot,
+            });
+            const query = localOpts.query?.toLowerCase();
+            const domain = localOpts.domain?.toLowerCase();
+            const responders = (await matcher.loadResponders()).filter((responder) => {
+                if (domain && !responder.domains.some((item) => item.toLowerCase().includes(domain))) {
+                    return false;
+                }
+                if (!query)
+                    return true;
+                return [
+                    responder.id,
+                    responder.name,
+                    responder.title,
+                    ...responder.domains,
+                ].join("\n").toLowerCase().includes(query);
+            });
+            if (jsonMode) {
+                console.log(JSON.stringify(responders, null, 2));
+            }
+            else if (responders.length === 0) {
+                console.log("No responders found.");
+            }
+            else {
+                const rows = responders.map((r) => [
+                    r.id,
+                    r.name,
+                    r.title,
+                    r.availability ? "yes" : "no",
+                    r.domains.join(", "),
+                ]);
+                console.log(formatTable(rows, ["ID", "Name", "Title", "Available", "Domains"]));
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("stats")
+        .description("Show responder profile statistics")
+        .action(async (_opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const matcher = new ResponderMatcher({
+                responderDir: allOpts.responderDir,
+                repoRoot: allOpts.repoRoot,
+                configRoot: allOpts.configRoot,
+            });
+            const responders = await matcher.loadResponders();
+            const byDomain = responders.reduce((acc, responder) => {
+                for (const domain of responder.domains)
+                    acc[domain] = (acc[domain] ?? 0) + 1;
+                return acc;
+            }, {});
+            const stats = {
+                total: responders.length,
+                available: responders.filter((responder) => responder.availability).length,
+                unavailable: responders.filter((responder) => !responder.availability).length,
+                byDomain,
+            };
+            console.log(JSON.stringify(stats, null, 2));
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("show")
+        .description("Show responder profile details")
+        .argument("<responderId>", "Responder ID")
+        .action(async (responderId, _opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const matcher = new ResponderMatcher({
+                responderDir: allOpts.responderDir,
+                repoRoot: allOpts.repoRoot,
+                configRoot: allOpts.configRoot,
+            });
+            const responders = await matcher.loadResponders();
+            const responder = responders.find((r) => r.id === responderId);
+            if (!responder) {
+                throw new Error(`Responder not found: ${responderId}`);
+            }
+            console.log(formatResponder(responder, jsonMode));
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}

package/dist/cli/commands/rules.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createRulesCommand(): Command;
+//# sourceMappingURL=rules.d.ts.map

package/dist/cli/commands/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/rules.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+CpC,wBAAgB,kBAAkB,IAAI,OAAO,CAkE5C"}

package/dist/cli/commands/rules.js

@@ -0,0 +1,105 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { Command } from "commander";
+import { resolveRoutingConfigPath, resolveConfigRoot } from "../../config.js";
+import { printError } from "../output.js";
+function routingPath(opts) {
+    return resolveRoutingConfigPath(resolveConfigRoot({
+        repoRoot: opts.repoRoot,
+        configRoot: opts.configRoot,
+    }));
+}
+async function readRoutingConfig(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            defaultBackend: parsed.defaultBackend ?? "git-native",
+            routes: parsed.routes ?? [],
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { defaultBackend: "git-native", routes: [] };
+        }
+        throw error;
+    }
+}
+async function writeRoutingConfig(filePath, config) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function printValue(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+export function createRulesCommand() {
+    const cmd = new Command("rules").description("Manage tasks-adapter routing rules");
+    cmd
+        .command("list")
+        .description("List routing rules")
+        .action(async (_opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        try {
+            printValue((await readRoutingConfig(routingPath(allOpts))).routes);
+        }
+        catch (error) {
+            printError(error, allOpts.json === true);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("add")
+        .description("Add or replace a routing rule")
+        .argument("<ruleId>", "Rule id")
+        .requiredOption("--backend <backend>", "Backend name")
+        .option("--domain <csv>", "Comma-separated domains")
+        .option("--tag <csv>", "Comma-separated tags")
+        .action(async (ruleId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        try {
+            const filePath = routingPath(allOpts);
+            const config = await readRoutingConfig(filePath);
+            const rule = {
+                id: ruleId,
+                backend: opts.backend ?? "git-native",
+                backendConfig: {},
+                domains: splitCsv(opts.domain),
+                tags: splitCsv(opts.tag),
+            };
+            const existingIndex = config.routes.findIndex((item) => item.id === ruleId);
+            if (existingIndex === -1)
+                config.routes.push(rule);
+            else
+                config.routes[existingIndex] = rule;
+            await writeRoutingConfig(filePath, config);
+            printValue(rule);
+        }
+        catch (error) {
+            printError(error, allOpts.json === true);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("remove")
+        .description("Remove a routing rule")
+        .argument("<ruleId>", "Rule id")
+        .action(async (ruleId, _opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        try {
+            const filePath = routingPath(allOpts);
+            const config = await readRoutingConfig(filePath);
+            const before = config.routes.length;
+            config.routes = config.routes.filter((rule) => rule.id !== ruleId);
+            await writeRoutingConfig(filePath, config);
+            printValue({ id: ruleId, removed: before !== config.routes.length });
+        }
+        catch (error) {
+            printError(error, allOpts.json === true);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}
+function splitCsv(value) {
+    return value?.split(",").map((item) => item.trim()).filter(Boolean);
+}

package/dist/cli/commands/server.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createServerCommand(): Command;
+//# sourceMappingURL=server.d.ts.map

package/dist/cli/commands/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,wBAAgB,mBAAmB,IAAI,OAAO,CAoC7C"}