@a5c-ai/tasks-adapter 5.1.1-staging.0007199a1cb2

package/dist/cli/commands/server.js

@@ -0,0 +1,34 @@
+import { Command } from "commander";
+import { printError } from "../output.js";
+export function createServerCommand() {
+    const cmd = new Command("server").description("Server management commands");
+    cmd
+        .command("start")
+        .description("Start the tasks-adapter MCP server (stdio)")
+        .action(async (_opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            if (allOpts.responderDir) {
+                process.env.BMUX_RESPONDER_DIR = allOpts.responderDir;
+            }
+            if (allOpts.repoRoot) {
+                process.env.BMUX_REPO_ROOT = allOpts.repoRoot;
+            }
+            if (allOpts.configRoot) {
+                process.env.BMUX_CONFIG_ROOT = allOpts.configRoot;
+            }
+            // Dynamically import the MCP server to avoid heavy dependency at load time
+            const { startBreakpointMcpServer } = await import("../../mcp/index.js");
+            if (!jsonMode) {
+                console.error("Starting tasks-adapter MCP server on stdio...");
+            }
+            await startBreakpointMcpServer();
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}

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

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

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

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

package/dist/cli/commands/tasks.js

@@ -0,0 +1,281 @@
+import { Command } from "commander";
+import { GitNativeBackend } from "../../backends/git-native.js";
+import { formatTable, printError } from "../output.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 createTasksCommand() {
+    const cmd = new Command("tasks")
+        .description("Manage task-like breakpoints with git-native task-management features")
+        .option("--breakpoints-dir <path>", "Path to .breakpoints directory");
+    cmd
+        .command("search")
+        .description("Search task-like breakpoints")
+        .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,
+            });
+            if (jsonMode) {
+                printResult(result, true);
+            }
+            else {
+                const rows = result.items.map((task) => [
+                    task.id,
+                    task.status,
+                    task.priority ?? "medium",
+                    task.assigneeId ?? "",
+                    task.text,
+                ]);
+                console.log(formatTable(rows, ["ID", "Status", "Priority", "Assignee", "Task"]));
+            }
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("assign")
+        .description("Assign or reassign a task-like breakpoint")
+        .argument("<taskId>")
+        .requiredOption("--assignee <id>", "Assignee responder id")
+        .option("--assignee-name <name>", "Assignee display name")
+        .option("--actor <id>", "Actor id")
+        .action(async (taskId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).assignBreakpoint(taskId, {
+                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 task-like breakpoint completed")
+        .argument("<taskId>")
+        .option("--actor <id>", "Actor id")
+        .option("--message <text>", "History message")
+        .action(async (taskId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).transitionBreakpoint(taskId, {
+                status: "completed",
+                actorId: opts.actor,
+                message: opts.message,
+            });
+            printResult(result, jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("comment")
+        .description("Add a discussion comment to a task-like breakpoint")
+        .argument("<taskId>")
+        .requiredOption("--author <id>", "Author id")
+        .requiredOption("--text <text>", "Comment text")
+        .option("--author-name <name>", "Author display name")
+        .action(async (taskId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).addBreakpointComment(taskId, {
+                authorId: opts.author ?? "",
+                authorName: opts.authorName,
+                text: opts.text ?? "",
+            });
+            printResult(result, jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("approve")
+        .description("Approve a task-like breakpoint by submitting an approved answer")
+        .argument("<taskId>")
+        .requiredOption("--responder <id>", "Approving responder id")
+        .requiredOption("--responder-name <name>", "Approving responder display name")
+        .requiredOption("--text <text>", "Approval answer text")
+        .option("--actor <id>", "Actor id")
+        .action(async (taskId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).bulkUpdateBreakpoints({
+                ids: [taskId],
+                action: "approve",
+                actorId: opts.actor,
+                answer: {
+                    responderId: opts.responder ?? "",
+                    responderName: opts.responderName ?? "",
+                    text: opts.text ?? "",
+                    approved: true,
+                },
+            });
+            printResult(result, jsonMode);
+            if (result.failed > 0)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("cancel")
+        .description("Cancel a task-like breakpoint")
+        .argument("<taskId>")
+        .action(async (taskId, _opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).bulkUpdateBreakpoints({
+                ids: [taskId],
+                action: "cancel",
+            });
+            printResult(result, jsonMode);
+            if (result.failed > 0)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("transition")
+        .description("Transition a task-like breakpoint to a lifecycle status")
+        .argument("<taskId>")
+        .requiredOption("--status <status>", "Target breakpoint status")
+        .option("--actor <id>", "Actor id")
+        .option("--message <text>", "History message")
+        .action(async (taskId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).transitionBreakpoint(taskId, {
+                status: opts.status,
+                actorId: opts.actor,
+                message: opts.message,
+            });
+            printResult(result, jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("bulk")
+        .description("Apply a bulk task operation with per-item results")
+        .requiredOption("--ids <csv>", "Comma-separated task ids")
+        .requiredOption("--action <action>", "approve, close, cancel, reassign, or transition")
+        .option("--actor <id>", "Actor id")
+        .option("--assignee <id>", "Assignee responder id for reassign")
+        .option("--assignee-name <name>", "Assignee display name for reassign")
+        .option("--status <status>", "Target status for transition")
+        .option("--message <text>", "History message")
+        .option("--responder <id>", "Approving responder id")
+        .option("--responder-name <name>", "Approving responder display name")
+        .option("--text <text>", "Approval answer text")
+        .action(async (opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const result = await backend(allOpts).bulkUpdateBreakpoints({
+                ids: splitCsv(opts.ids) ?? [],
+                action: opts.action,
+                actorId: opts.actor,
+                assigneeId: opts.assignee,
+                assigneeName: opts.assigneeName,
+                status: opts.status,
+                message: opts.message,
+                answer: opts.action === "approve"
+                    ? {
+                        responderId: opts.responder ?? opts.actor ?? "cli",
+                        responderName: opts.responderName ?? opts.responder ?? opts.actor ?? "CLI",
+                        text: opts.text ?? opts.message ?? "Approved",
+                        approved: true,
+                    }
+                    : undefined,
+            });
+            printResult(result, jsonMode);
+            if (result.failed > 0)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("stats")
+        .description("Show task metrics grouped by status and priority")
+        .action(async (_opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            printResult(await backend(allOpts).getBreakpointMetrics(), jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("export")
+        .description("Export task-like breakpoints with credential redaction")
+        .action(async (_opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            printResult(await backend(allOpts).exportBreakpoints(), jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}

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

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

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

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

package/dist/cli/commands/templates.js

@@ -0,0 +1,100 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { Command } from "commander";
+import { resolveConfigRoot } from "../../config.js";
+import { printError } from "../output.js";
+function templatesPath(opts) {
+    return path.join(resolveConfigRoot({
+        repoRoot: opts.repoRoot,
+        configRoot: opts.configRoot,
+    }), "tasks-adapter", "templates.json");
+}
+async function readTemplates(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function writeTemplates(filePath, templates) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(templates, null, 2) + "\n", "utf-8");
+}
+function printValue(value, jsonMode) {
+    if (jsonMode || Array.isArray(value) || typeof value === "object") {
+        console.log(JSON.stringify(value, null, 2));
+        return;
+    }
+    console.log(String(value));
+}
+export function createTemplatesCommand() {
+    const cmd = new Command("templates").description("Manage reusable task templates");
+    cmd
+        .command("list")
+        .description("List task templates")
+        .action(async (_opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            printValue(await readTemplates(templatesPath(allOpts)), jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("show")
+        .description("Show a task template")
+        .argument("<templateId>", "Template id")
+        .action(async (templateId, _opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const template = (await readTemplates(templatesPath(allOpts))).find((item) => item.id === templateId);
+            if (!template)
+                throw new Error(`Template not found: ${templateId}`);
+            printValue(template, jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    cmd
+        .command("create")
+        .description("Create or replace a task template")
+        .argument("<templateId>", "Template id")
+        .requiredOption("--title <title>", "Template title")
+        .requiredOption("--body <body>", "Template body")
+        .action(async (templateId, opts, command) => {
+        const allOpts = command.optsWithGlobals();
+        const jsonMode = allOpts.json === true;
+        try {
+            const filePath = templatesPath(allOpts);
+            const templates = await readTemplates(filePath);
+            const next = {
+                id: templateId,
+                title: opts.title,
+                body: opts.body,
+                createdAt: new Date().toISOString(),
+            };
+            const existingIndex = templates.findIndex((item) => item.id === templateId);
+            if (existingIndex === -1)
+                templates.push(next);
+            else
+                templates[existingIndex] = next;
+            await writeTemplates(filePath, templates);
+            printValue(next, jsonMode);
+        }
+        catch (error) {
+            printError(error, jsonMode);
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export { createProgram } from "./program.js";
+export declare const CLI_VERSION = "5.0.0";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,eAAO,MAAM,WAAW,UAAU,CAAC"}

package/dist/cli/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { createProgram } from "./program.js";
+export { createProgram } from "./program.js";
+export const CLI_VERSION = "5.0.0";
+const program = createProgram();
+program.parseAsync(process.argv).catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/cli/output.d.ts

@@ -0,0 +1,26 @@
+import type { Breakpoint, BreakpointAnswer, ResponderProfile } from "../types.js";
+/**
+ * Format a breakpoint for display.
+ */
+export declare function formatBreakpoint(breakpoint: Breakpoint, jsonMode: boolean): string;
+/**
+ * Format an answer for display.
+ */
+export declare function formatAnswer(answer: BreakpointAnswer, jsonMode: boolean): string;
+/**
+ * Format a responder profile for display.
+ */
+export declare function formatResponder(responder: ResponderProfile, jsonMode: boolean): string;
+/**
+ * Format data as a simple table.
+ */
+export declare function formatTable(rows: string[][], headers: string[]): string;
+/**
+ * Print output, handling JSON mode.
+ */
+export declare function printOutput(data: unknown, jsonMode: boolean): void;
+/**
+ * Print an error, handling JSON mode.
+ */
+export declare function printError(error: unknown, jsonMode: boolean): void;
+//# sourceMappingURL=output.d.ts.map

package/dist/cli/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../src/cli/output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAmBlF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAuBlF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CA8BhF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAqBtF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CA2BvE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAQlE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAQlE"}

package/dist/cli/output.js

@@ -0,0 +1,143 @@
+/**
+ * Format a duration in milliseconds as a human-readable string.
+ */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) {
+        return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+}
+/**
+ * Format a breakpoint for display.
+ */
+export function formatBreakpoint(breakpoint, jsonMode) {
+    if (jsonMode) {
+        return JSON.stringify(breakpoint, null, 2);
+    }
+    const lines = [];
+    lines.push(`Breakpoint: ${breakpoint.id}`);
+    lines.push(`Status:     ${breakpoint.status}`);
+    lines.push(`Text:       ${breakpoint.text}`);
+    lines.push(`Strategy:   ${breakpoint.routing.strategy}`);
+    lines.push(`Responders: ${breakpoint.routing.targetResponders.join(", ") || "(none)"}`);
+    lines.push(`Created:    ${breakpoint.createdAt}`);
+    lines.push(`Expires:    ${breakpoint.expiresAt}`);
+    if (breakpoint.context.tags.length > 0) {
+        lines.push(`Tags:       ${breakpoint.context.tags.join(", ")}`);
+    }
+    if (breakpoint.answers.length > 0) {
+        lines.push(`Answers:    ${breakpoint.answers.length}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format an answer for display.
+ */
+export function formatAnswer(answer, jsonMode) {
+    if (jsonMode) {
+        return JSON.stringify(answer, null, 2);
+    }
+    const lines = [];
+    lines.push(`Answer:     ${answer.id}`);
+    lines.push(`Breakpoint: ${answer.breakpointId}`);
+    lines.push(`Responder:  ${answer.responderName} (${answer.responderId})`);
+    lines.push(`Confidence: ${answer.confidence}%`);
+    lines.push(`Answered:   ${answer.answeredAt}`);
+    lines.push(`---`);
+    lines.push(answer.text);
+    if (answer.references.length > 0) {
+        lines.push(`---`);
+        lines.push(`References:`);
+        for (const ref of answer.references) {
+            lines.push(`  - ${ref}`);
+        }
+    }
+    if (answer.followUpQuestions.length > 0) {
+        lines.push(`Follow-up questions:`);
+        for (const q of answer.followUpQuestions) {
+            lines.push(`  - ${q}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a responder profile for display.
+ */
+export function formatResponder(responder, jsonMode) {
+    if (jsonMode) {
+        return JSON.stringify(responder, null, 2);
+    }
+    const lines = [];
+    lines.push(`Responder: ${responder.id}`);
+    lines.push(`Name:      ${responder.name}`);
+    lines.push(`Title:     ${responder.title}`);
+    lines.push(`Available: ${responder.availability ? "yes" : "no"}`);
+    lines.push(`Response SLA: ${formatDuration(responder.responseTimeSla)}`);
+    if (responder.domains.length > 0) {
+        lines.push(`Domains:   ${responder.domains.join(", ")}`);
+    }
+    if (responder.tags.length > 0) {
+        lines.push(`Tags:      ${responder.tags.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format data as a simple table.
+ */
+export function formatTable(rows, headers) {
+    if (rows.length === 0) {
+        return "(no results)";
+    }
+    // Calculate column widths
+    const widths = headers.map((h, i) => {
+        const maxDataWidth = rows.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
+        return Math.max(h.length, maxDataWidth);
+    });
+    const pad = (str, width) => str.padEnd(width);
+    const lines = [];
+    // Header row
+    lines.push(headers.map((h, i) => pad(h, widths[i])).join("  "));
+    // Separator
+    lines.push(widths.map((w) => "-".repeat(w)).join("  "));
+    // Data rows
+    for (const row of rows) {
+        lines.push(row.map((cell, i) => pad(cell ?? "", widths[i])).join("  "));
+    }
+    return lines.join("\n");
+}
+/**
+ * Print output, handling JSON mode.
+ */
+export function printOutput(data, jsonMode) {
+    if (jsonMode) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else if (typeof data === "string") {
+        console.log(data);
+    }
+    else {
+        console.log(data);
+    }
+}
+/**
+ * Print an error, handling JSON mode.
+ */
+export function printError(error, jsonMode) {
+    if (jsonMode) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(JSON.stringify({ error: message }));
+    }
+    else {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+    }
+}

package/dist/cli/program.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+/**
+ * Create and configure the main CLI program.
+ */
+export declare function createProgram(): Command;
+//# sourceMappingURL=program.d.ts.map

package/dist/cli/program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../src/cli/program.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAsCvC"}

package/dist/cli/program.js

@@ -0,0 +1,38 @@
+import { Command } from "commander";
+import { createAskCommand } from "./commands/ask.js";
+import { createRespondersCommand } from "./commands/responders.js";
+import { createBreakpointsCommand } from "./commands/breakpoints.js";
+import { createServerCommand } from "./commands/server.js";
+import { createResponderLoopCommand } from "./commands/responder-loop.js";
+import { createAuthCommand } from "./commands/auth.js";
+import { createTasksCommand } from "./commands/tasks.js";
+import { createTemplatesCommand } from "./commands/templates.js";
+import { createRulesCommand } from "./commands/rules.js";
+import { DEFAULT_BMUX_SERVER_URL } from "../client/index.js";
+/**
+ * Create and configure the main CLI program.
+ */
+export function createProgram() {
+    const program = new Command();
+    program
+        .name("adapters-tasks")
+        .version("5.0.0")
+        .description("CLI for Breakpoints Adapter - route breakpoints to domain responders")
+        .option("--server-url <url>", `Server URL (defaults to ${DEFAULT_BMUX_SERVER_URL})`)
+        .option("--auth-token <token>", "Bearer token for BMUX API access")
+        .option("--json", "Output in JSON format", false)
+        .option("--responder-dir <path>", "Responder profile directory, relative to the associated repo or config root when not absolute")
+        .option("--repo-root <path>", "Associated repository root for resolving .a5c-based configuration")
+        .option("--config-root <path>", "Associated configuration root (.a5c) for resolving repo-scoped responder config");
+    // Register subcommands
+    program.addCommand(createAskCommand());
+    program.addCommand(createRespondersCommand());
+    program.addCommand(createBreakpointsCommand());
+    program.addCommand(createTasksCommand());
+    program.addCommand(createTemplatesCommand());
+    program.addCommand(createRulesCommand());
+    program.addCommand(createServerCommand());
+    program.addCommand(createResponderLoopCommand());
+    program.addCommand(createAuthCommand());
+    return program;
+}