boringpm 0.1.2

package/dist/index.js

@@ -0,0 +1,786 @@
+#!/usr/bin/env node
+import { cancel, confirm, intro, isCancel, note, outro, spinner, text } from "@clack/prompts";
+import { Command, InvalidArgumentError } from "commander";
+import { clearStoredAuthSession, loadStoredAuthToken, saveStoredAuthSession, } from "./auth-store.js";
+import { ApiClient } from "./api.js";
+import { PLAN_SPEC_STATUSES, TASK_STATUSES, TEST_SCENARIO_STATUSES, TEST_SCENARIO_TYPES, } from "./types.js";
+function parseStatus(value) {
+    if (!TASK_STATUSES.includes(value)) {
+        throw new InvalidArgumentError(`Invalid status \"${value}\". Must be one of: ${TASK_STATUSES.join(", ")}`);
+    }
+    return value;
+}
+function parsePlanSpecStatus(value) {
+    if (!PLAN_SPEC_STATUSES.includes(value)) {
+        throw new InvalidArgumentError(`Invalid spec status \"${value}\". Must be one of: ${PLAN_SPEC_STATUSES.join(", ")}`);
+    }
+    return value;
+}
+function parseTestScenarioStatus(value) {
+    if (!TEST_SCENARIO_STATUSES.includes(value)) {
+        throw new InvalidArgumentError(`Invalid test scenario status \"${value}\". Must be one of: ${TEST_SCENARIO_STATUSES.join(", ")}`);
+    }
+    return value;
+}
+function parseTestScenarioType(value) {
+    if (!TEST_SCENARIO_TYPES.includes(value)) {
+        throw new InvalidArgumentError(`Invalid test scenario type \"${value}\". Must be one of: ${TEST_SCENARIO_TYPES.join(", ")}`);
+    }
+    return value;
+}
+function parseCsvList(value) {
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+async function resolveProjectId(client, projectReference) {
+    const input = projectReference.trim();
+    if (!input) {
+        throw new Error("Project reference is required");
+    }
+    const projects = await client.listProjects();
+    const byId = projects.find((project) => project.id === input);
+    if (byId) {
+        return byId.id;
+    }
+    const byName = projects.filter((project) => project.name.toLowerCase() === input.toLowerCase());
+    if (byName.length === 1) {
+        return byName[0].id;
+    }
+    if (byName.length > 1) {
+        throw new Error(`Multiple projects found with name \"${projectReference}\". Use project ID instead. Matching IDs: ${byName
+            .map((project) => project.id)
+            .join(", ")}`);
+    }
+    throw new Error(`Project \"${projectReference}\" not found. Run \"boringpm project list\" to see available projects.`);
+}
+async function resolveCurrentUserId(client) {
+    const me = await client.me();
+    return me.id;
+}
+async function resolveAssigneeReference(client, assigneeReference) {
+    if (assigneeReference === undefined) {
+        return undefined;
+    }
+    const value = assigneeReference.trim();
+    if (!value) {
+        throw new Error("Assignee reference cannot be empty");
+    }
+    const normalized = value.toLowerCase();
+    if (normalized === "none" || normalized === "null" || normalized === "unassigned") {
+        return null;
+    }
+    if (normalized === "me") {
+        return resolveCurrentUserId(client);
+    }
+    return value;
+}
+async function assertTaskInProject(client, taskId, projectId) {
+    const task = await client.getTask(taskId);
+    if (task.project !== projectId) {
+        throw new Error(`Task ${taskId} does not belong to project ${projectId}`);
+    }
+}
+function printTaskComments(comments) {
+    if (comments.length === 0) {
+        console.log("No comments yet.");
+        return;
+    }
+    for (const comment of comments) {
+        console.log(`[${comment.created_at}] ${comment.author}: ${comment.content}`);
+    }
+}
+function printTestScenarios(scenarios) {
+    if (scenarios.length === 0) {
+        console.log("No test scenarios yet.");
+        return;
+    }
+    for (const scenario of scenarios) {
+        console.log(`- ${scenario.id} [${scenario.status}] (${scenario.type}) ${scenario.title}`);
+        if (scenario.ran_at || scenario.ran_by) {
+            console.log(`  ran: ${scenario.ran_at ?? "n/a"} by ${scenario.ran_by ?? "n/a"}`);
+        }
+        if (scenario.evidence) {
+            console.log(`  evidence: ${scenario.evidence}`);
+        }
+    }
+}
+function resolveAuthToken(options) {
+    if (options.token?.trim()) {
+        return options.token.trim();
+    }
+    if (process.env.PM_AUTH_TOKEN?.trim()) {
+        return process.env.PM_AUTH_TOKEN.trim();
+    }
+    return loadStoredAuthToken();
+}
+function resolveClient(program) {
+    const options = program.opts();
+    return new ApiClient({
+        baseUrl: options.apiUrl,
+        authToken: resolveAuthToken(options),
+        actorName: options.actorName || process.env.PM_ACTOR_NAME || undefined,
+    });
+}
+function printJson(payload) {
+    console.log(JSON.stringify(payload, null, 2));
+}
+function unwrapPromptValue(value, cancelledMessage) {
+    if (isCancel(value)) {
+        cancel(cancelledMessage);
+        throw new Error(cancelledMessage);
+    }
+    return String(value).trim();
+}
+async function confirmDeleteAction(entityLabel, force) {
+    if (force) {
+        return;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error(`Refusing to delete ${entityLabel} without confirmation in non-interactive mode. Use --force to proceed.`);
+    }
+    const confirmed = await confirm({
+        message: `Delete ${entityLabel}? This cannot be undone.`,
+        initialValue: false,
+    });
+    if (isCancel(confirmed) || !confirmed) {
+        const message = "Delete cancelled";
+        cancel(message);
+        throw new Error(message);
+    }
+}
+const program = new Command();
+program
+    .name("boringpm")
+    .description("Project manager CLI")
+    .version("0.1.2")
+    .option("--api-url <url>", "Project manager API base URL", process.env.PM_API_URL ?? "http://localhost:4000")
+    .option("--token <token>", "Auth token (overrides PM_AUTH_TOKEN and stored token)")
+    .option("--actor-name <name>", "Display name for notifications (overrides PM_ACTOR_NAME)");
+program
+    .command("ping")
+    .description("Ping the API server")
+    .action(async () => {
+    const client = resolveClient(program);
+    const payload = await client.health();
+    printJson(payload);
+});
+program
+    .command("login")
+    .description("Interactive login with magic link and verification code")
+    .action(async () => {
+    const client = resolveClient(program);
+    intro("Project Manager Login");
+    const emailInput = await text({
+        message: "Email",
+        placeholder: "you@company.com",
+        validate: (value) => {
+            const email = value.trim();
+            if (!email) {
+                return "Email is required";
+            }
+            if (!email.includes("@")) {
+                return "Enter a valid email";
+            }
+        },
+    });
+    const email = unwrapPromptValue(emailInput, "Login cancelled");
+    const sendSpinner = spinner();
+    sendSpinner.start("Sending magic link/code email...");
+    await client.sendMagicLink(email);
+    sendSpinner.stop("Magic link/code sent");
+    note("Check your email and paste the verification code below.", "Email sent");
+    const codeInput = await text({
+        message: "Verification code",
+        placeholder: "123456",
+        validate: (value) => {
+            if (!value.trim()) {
+                return "Verification code is required";
+            }
+        },
+    });
+    const code = unwrapPromptValue(codeInput, "Login cancelled");
+    const verifySpinner = spinner();
+    verifySpinner.start("Verifying code...");
+    const authPayload = await client.verifyMagicCode(email, code);
+    await saveStoredAuthSession({
+        token: authPayload.token,
+        user: authPayload.user,
+        savedAt: new Date().toISOString(),
+    });
+    verifySpinner.stop("Logged in");
+    note(`Signed in as ${authPayload.user.email ?? authPayload.user.id}. Token saved to local auth store.`, "Success");
+    outro("Login complete");
+});
+program
+    .command("logout")
+    .description("Remove stored auth token")
+    .action(async () => {
+    await clearStoredAuthSession();
+    console.log("Logged out. Stored auth token removed.");
+});
+program
+    .command("whoami")
+    .description("Show currently authenticated user")
+    .action(async () => {
+    const client = resolveClient(program);
+    const payload = await client.me();
+    printJson(payload);
+});
+const auth = program.command("auth").description("Authentication commands");
+auth
+    .command("send-link")
+    .description("Send magic link/code email")
+    .argument("<email>", "Email address")
+    .action(async (email) => {
+    const client = resolveClient(program);
+    const payload = await client.sendMagicLink(email);
+    printJson(payload);
+});
+auth
+    .command("verify")
+    .description("Verify email with magic code and return token")
+    .argument("<email>", "Email address")
+    .argument("<code>", "Verification code")
+    .action(async (email, code) => {
+    const client = resolveClient(program);
+    const payload = await client.verifyMagicCode(email, code);
+    printJson(payload);
+});
+auth
+    .command("me")
+    .description("Show currently authenticated user")
+    .action(async () => {
+    const client = resolveClient(program);
+    const payload = await client.me();
+    printJson(payload);
+});
+const team = program.command("team").description("Team operations");
+team
+    .command("list")
+    .description("List teams you belong to")
+    .action(async () => {
+    const client = resolveClient(program);
+    const teams = await client.listTeams();
+    printJson(teams);
+});
+team
+    .command("create")
+    .description("Create a new team")
+    .argument("<name>", "Team name")
+    .action(async (name) => {
+    const client = resolveClient(program);
+    const created = await client.createTeam({ name });
+    printJson(created);
+});
+team
+    .command("view")
+    .description("View a team")
+    .argument("<teamId>", "Team ID")
+    .action(async (teamId) => {
+    const client = resolveClient(program);
+    const teamItem = await client.getTeam(teamId);
+    printJson(teamItem);
+});
+team
+    .command("update")
+    .description("Update a team (owner only)")
+    .argument("<teamId>", "Team ID")
+    .option("--name <name>", "New team name")
+    .action(async (teamId, options) => {
+    if (!options.name) {
+        throw new Error("Provide --name to update");
+    }
+    const client = resolveClient(program);
+    const updated = await client.updateTeam({ teamId, name: options.name });
+    printJson(updated);
+});
+team
+    .command("delete")
+    .description("Delete a team (owner only, blocked if projects linked)")
+    .argument("<teamId>", "Team ID")
+    .option("--force", "Skip confirmation prompt")
+    .action(async (teamId, options) => {
+    await confirmDeleteAction(`team ${teamId}`, options.force);
+    const client = resolveClient(program);
+    const result = await client.deleteTeam(teamId);
+    printJson(result);
+});
+team
+    .command("add-member")
+    .description("Add a member to a team (owner only)")
+    .argument("<teamId>", "Team ID")
+    .argument("<userId>", "User ID to add")
+    .action(async (teamId, userId) => {
+    const client = resolveClient(program);
+    const updated = await client.addTeamMember(teamId, userId);
+    printJson(updated);
+});
+team
+    .command("remove-member")
+    .description("Remove a member from a team (owner only)")
+    .argument("<teamId>", "Team ID")
+    .argument("<userId>", "User ID to remove")
+    .action(async (teamId, userId) => {
+    const client = resolveClient(program);
+    const updated = await client.removeTeamMember(teamId, userId);
+    printJson(updated);
+});
+team
+    .command("projects")
+    .description("List projects in a team")
+    .argument("<teamId>", "Team ID")
+    .action(async (teamId) => {
+    const client = resolveClient(program);
+    const projects = await client.listTeamProjects(teamId);
+    printJson(projects);
+});
+const project = program.command("project").description("Project operations");
+project
+    .command("list")
+    .description("List visible projects")
+    .action(async () => {
+    const client = resolveClient(program);
+    const projects = await client.listProjects();
+    printJson(projects);
+});
+project
+    .command("view")
+    .description("View a single project")
+    .argument("<project>", "Project ID or project name")
+    .action(async (projectReference) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    const projectItem = await client.getProject(projectId);
+    printJson(projectItem);
+});
+project
+    .command("create")
+    .description("Create a project")
+    .argument("<name>", "Project name")
+    .option("--participants <users>", "Comma-separated participant user IDs")
+    .option("--team <teamId>", "Team ID to link this project to")
+    .action(async (name, options) => {
+    const client = resolveClient(program);
+    const created = await client.createProject({
+        name,
+        participants: options.participants ? parseCsvList(options.participants) : undefined,
+        team: options.team,
+    });
+    printJson(created);
+});
+project
+    .command("add-user")
+    .description("Add a participant to a project")
+    .argument("<project>", "Project ID or project name")
+    .argument("<userId>", "User ID to add")
+    .action(async (projectReference, userId) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    const updated = await client.addProjectParticipant(projectId, userId);
+    printJson(updated);
+});
+project
+    .command("remove-user")
+    .description("Remove a participant from a project")
+    .argument("<project>", "Project ID or project name")
+    .argument("<userId>", "User ID to remove")
+    .action(async (projectReference, userId) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    const updated = await client.removeProjectParticipant(projectId, userId);
+    printJson(updated);
+});
+const plan = program.command("plan").description("Plan operations");
+plan
+    .command("list")
+    .description("List plans in a project")
+    .argument("<project>", "Project ID or project name")
+    .action(async (projectReference) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    const plans = await client.listPlans(projectId);
+    printJson(plans);
+});
+plan
+    .command("view")
+    .description("View a single plan")
+    .argument("<planId>", "Plan ID")
+    .action(async (planId) => {
+    const client = resolveClient(program);
+    const planItem = await client.getPlan(planId);
+    printJson(planItem);
+});
+plan
+    .command("create")
+    .description("Create a plan in a project")
+    .argument("<project>", "Project ID or project name")
+    .argument("<title>", "Plan title")
+    .option("--content <content>", "Plan content", "")
+    .option("--spec-status <status>", "Spec status", parsePlanSpecStatus, "draft")
+    .action(async (projectReference, title, options) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    const created = await client.createPlan({
+        projectId,
+        title,
+        content: options.content,
+        spec_status: options.specStatus,
+    });
+    printJson(created);
+});
+plan
+    .command("update")
+    .description("Update a plan")
+    .argument("<planId>", "Plan ID")
+    .option("--title <title>", "New title")
+    .option("--content <content>", "New content")
+    .option("--spec-status <status>", "Spec status", parsePlanSpecStatus)
+    .action(async (planId, options) => {
+    if (options.title === undefined &&
+        options.content === undefined &&
+        options.specStatus === undefined) {
+        throw new Error("Provide --title, --content, --spec-status, or a combination");
+    }
+    const client = resolveClient(program);
+    const updated = await client.updatePlan({
+        planId,
+        title: options.title,
+        content: options.content,
+        spec_status: options.specStatus,
+    });
+    printJson(updated);
+});
+plan
+    .command("approve")
+    .description("Mark a spec plan as approved")
+    .argument("<planId>", "Plan ID")
+    .action(async (planId) => {
+    const client = resolveClient(program);
+    const updated = await client.updatePlan({
+        planId,
+        spec_status: "approved",
+    });
+    printJson(updated);
+});
+plan
+    .command("delete")
+    .description("Delete a plan")
+    .argument("<planId>", "Plan ID")
+    .option("-f, --force", "Skip confirmation prompt")
+    .action(async (planId, options) => {
+    await confirmDeleteAction(`plan ${planId}`, options.force);
+    const client = resolveClient(program);
+    const deleted = await client.deletePlan(planId);
+    printJson(deleted);
+});
+const task = program.command("task").description("Task operations");
+task
+    .command("list")
+    .description("List tasks in a project")
+    .argument("<project>", "Project ID or project name")
+    .option("--status <status>", "Filter by status", parseStatus)
+    .option("--assignee <userId|me|none>", "Filter by assignee")
+    .option("--agent <name|none>", "Filter by agent tag")
+    .option("--mine", "Shortcut for --assignee me")
+    .action(async (projectReference, options) => {
+    if (options.mine && options.assignee !== undefined) {
+        throw new Error("Use either --mine or --assignee, not both");
+    }
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    const assignee = options.mine
+        ? await resolveCurrentUserId(client)
+        : await resolveAssigneeReference(client, options.assignee);
+    const agentFilter = options.agent === "none" ? null : options.agent;
+    const tasks = await client.listTasks(projectId, {
+        status: options.status,
+        assignee,
+        agent: agentFilter,
+    });
+    printJson(tasks);
+});
+task
+    .command("mine")
+    .description("List tasks assigned to you across all visible projects")
+    .option("--status <status>", "Filter by status", parseStatus)
+    .option("--agent <name>", "Filter by agent tag")
+    .action(async (options) => {
+    const client = resolveClient(program);
+    const myUserId = await resolveCurrentUserId(client);
+    const projects = await client.listProjects();
+    const agentFilter = options.agent === "none" ? null : options.agent;
+    const mineByProject = await Promise.all(projects.map(async (projectItem) => {
+        const tasks = await client.listTasks(projectItem.id, {
+            status: options.status,
+            assignee: myUserId,
+            agent: agentFilter,
+        });
+        return tasks.map((taskItem) => ({
+            projectId: projectItem.id,
+            projectName: projectItem.name,
+            ...taskItem,
+        }));
+    }));
+    const tasks = mineByProject
+        .flat()
+        .sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+    printJson(tasks);
+});
+task
+    .command("view")
+    .description("View a single task")
+    .argument("<taskId>", "Task ID")
+    .action(async (taskId) => {
+    const client = resolveClient(program);
+    const taskItem = await client.getTask(taskId);
+    printJson(taskItem);
+});
+task
+    .command("create")
+    .description("Create a task")
+    .argument("<project>", "Project ID or project name")
+    .argument("[title]", "Task title")
+    .option("--title <title>", "Task title (alternative to positional)")
+    .option("--description <description>", "Task description", "")
+    .option("--plan <planId>", "Required approved spec plan ID")
+    .option("--agent <name>", "Agent tag (e.g. claudinho, anton, linus)")
+    .action(async (projectReference, positionalTitle, options) => {
+    const title = positionalTitle?.trim() || options.title?.trim() || "";
+    if (!title) {
+        throw new Error("Task title is required. Provide [title] or --title <title>");
+    }
+    if (!options.plan?.trim()) {
+        throw new Error("Task requires an approved spec link. Provide --plan <planId>");
+    }
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    const agent = options.agent?.trim();
+    const created = await client.createTask({
+        projectId,
+        title,
+        description: options.description,
+        status: "pending",
+        plan: options.plan.trim(),
+        agent: agent ? agent : null,
+    });
+    printJson(created);
+});
+task
+    .command("update")
+    .description("Update a task")
+    .argument("<taskId>", "Task ID")
+    .option("--title <title>", "New title")
+    .option("--description <description>", "New description")
+    .option("--status <status>", "New status", parseStatus)
+    .option("--plan <planId>", "New approved spec plan ID")
+    .option("--assignee <userId|me|none>", "Set assignee (self-assignment only enforced by API)")
+    .option("--agent <name|none>", "Set agent tag or 'none' to clear")
+    .action(async (taskId, options) => {
+    if (options.title === undefined &&
+        options.description === undefined &&
+        options.status === undefined &&
+        options.plan === undefined &&
+        options.assignee === undefined &&
+        options.agent === undefined) {
+        throw new Error("Provide at least one option to update");
+    }
+    const client = resolveClient(program);
+    if (options.plan !== undefined && !options.plan.trim()) {
+        throw new Error("Plan ID cannot be empty");
+    }
+    const plan = options.plan !== undefined ? options.plan.trim() : undefined;
+    const assignee = await resolveAssigneeReference(client, options.assignee);
+    const agent = options.agent === "none" ? null : options.agent;
+    const updated = await client.updateTask({
+        taskId,
+        title: options.title,
+        description: options.description,
+        status: options.status,
+        plan,
+        assignee,
+        agent,
+    });
+    printJson(updated);
+});
+task
+    .command("claim")
+    .description("Claim a task for yourself and move it to in_progress")
+    .argument("<taskId>", "Task ID")
+    .action(async (taskId) => {
+    const client = resolveClient(program);
+    const claimed = await client.claimTask(taskId);
+    printJson(claimed);
+});
+task
+    .command("release")
+    .description("Release a task assignment")
+    .argument("<taskId>", "Task ID")
+    .option("--status <status>", "Status after release", parseStatus)
+    .action(async (taskId, options) => {
+    const client = resolveClient(program);
+    const released = await client.releaseTask({
+        taskId,
+        status: options.status,
+    });
+    printJson(released);
+});
+task
+    .command("next")
+    .description("Claim the next available pending task in a project")
+    .argument("<project>", "Project ID or project name")
+    .action(async (projectReference) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    const claimed = await client.claimNextTask(projectId);
+    printJson(claimed);
+});
+task
+    .command("done")
+    .description("Mark a task as completed")
+    .argument("<taskId>", "Task ID")
+    .option("--note <note>", "Completion note", "")
+    .option("--force", "Force completion with waiver fields")
+    .option("--waiver-reason <reason>", "Reason for forced completion")
+    .option("--approved-by <userId>", "Approver id for forced completion")
+    .action(async (taskId, options) => {
+    if (options.force && (!options.waiverReason?.trim() || !options.approvedBy?.trim())) {
+        throw new Error("--force requires both --waiver-reason and --approved-by");
+    }
+    const client = resolveClient(program);
+    const completed = await client.completeTask({
+        taskId,
+        note: options.note,
+        force: options.force,
+        waiver_reason: options.waiverReason,
+        approved_by: options.approvedBy,
+    });
+    printJson(completed);
+});
+task
+    .command("tests")
+    .description("List test scenarios for a task")
+    .argument("<project>", "Project ID or project name")
+    .argument("<taskId>", "Task ID")
+    .action(async (projectReference, taskId) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    await assertTaskInProject(client, taskId, projectId);
+    const scenarios = await client.listTestScenarios(taskId);
+    printTestScenarios(scenarios);
+});
+task
+    .command("test-add")
+    .description("Add a test scenario to a task")
+    .argument("<project>", "Project ID or project name")
+    .argument("<taskId>", "Task ID")
+    .argument("<title>", "Scenario title")
+    .requiredOption("--steps <steps>", "Scenario steps")
+    .requiredOption("--expected <result>", "Expected result")
+    .option("--type <type>", "Scenario type", parseTestScenarioType, "manual")
+    .action(async (projectReference, taskId, title, options) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    await assertTaskInProject(client, taskId, projectId);
+    const scenario = await client.createTestScenario({
+        taskId,
+        title,
+        type: options.type,
+        steps: options.steps,
+        expected_result: options.expected,
+    });
+    printJson(scenario);
+});
+task
+    .command("test-result")
+    .description("Record a test scenario result")
+    .argument("<project>", "Project ID or project name")
+    .argument("<taskId>", "Task ID")
+    .argument("<scenarioId>", "Scenario ID")
+    .argument("<status>", "Result status", parseTestScenarioStatus)
+    .option("--evidence <text>", "Evidence details (logs, links, notes)")
+    .action(async (projectReference, taskId, scenarioId, status, options) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    await assertTaskInProject(client, taskId, projectId);
+    const updated = await client.updateTestScenarioResult({
+        taskId,
+        scenarioId,
+        status,
+        evidence: options.evidence,
+    });
+    printJson(updated);
+});
+task
+    .command("comments")
+    .description("List comments for a task")
+    .argument("<project>", "Project ID or project name")
+    .argument("<taskId>", "Task ID")
+    .action(async (projectReference, taskId) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    await assertTaskInProject(client, taskId, projectId);
+    const comments = await client.listTaskComments(taskId);
+    printTaskComments(comments);
+});
+task
+    .command("comment")
+    .description("Add a comment to a task")
+    .argument("<project>", "Project ID or project name")
+    .argument("<taskId>", "Task ID")
+    .argument("<message>", "Comment message")
+    .action(async (projectReference, taskId, message) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    await assertTaskInProject(client, taskId, projectId);
+    const comment = await client.createTaskComment(taskId, message);
+    printJson(comment);
+});
+task
+    .command("unclaim")
+    .description("Clear assignee from a task")
+    .argument("<taskId>", "Task ID")
+    .action(async (taskId) => {
+    const client = resolveClient(program);
+    const updated = await client.updateTask({
+        taskId,
+        assignee: null,
+    });
+    printJson(updated);
+});
+task
+    .command("delete")
+    .description("Delete a task")
+    .argument("<taskId>", "Task ID")
+    .option("-f, --force", "Skip confirmation prompt")
+    .action(async (taskId, options) => {
+    await confirmDeleteAction(`task ${taskId}`, options.force);
+    const client = resolveClient(program);
+    const deleted = await client.deleteTask(taskId);
+    printJson(deleted);
+});
+task
+    .command("move")
+    .description("Move a task to a new status")
+    .argument("<taskId>", "Task ID")
+    .argument("<status>", "New task status", parseStatus)
+    .action(async (taskId, status) => {
+    const client = resolveClient(program);
+    const updated = await client.updateTask({ taskId, status });
+    printJson(updated);
+});
+program
+    .command("board")
+    .description("Fetch board data for a project")
+    .argument("<project>", "Project ID or project name")
+    .action(async (projectReference) => {
+    const client = resolveClient(program);
+    const projectId = await resolveProjectId(client, projectReference);
+    const board = await client.board(projectId);
+    printJson(board);
+});
+program.parseAsync(process.argv).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});