@hiroleague/taskmanager 0.0.3 → 0.0.4

package/src/cli/handlers/search.ts

@@ -1,17 +1,17 @@
-import { runSearch } from "../lib/read/search";
-import type { CliContext } from "./context";
-
-export async function handleSearch(
-  ctx: CliContext,
-  queryParts: string[],
-  options: {
-    board?: string;
-    limit?: string;
-    offset?: string;
-    noPrefix?: boolean;
-    pageAll?: boolean;
-    fields?: string;
-  },
-): Promise<void> {
-  await runSearch(ctx, queryParts, options);
-}
+import { runSearch } from "../lib/read/search";
+import type { CliContext } from "./context";
+
+export async function handleSearch(
+  ctx: CliContext,
+  queryParts: string[],
+  options: {
+    board?: string;
+    limit?: string;
+    offset?: string;
+    noPrefix?: boolean;
+    pageAll?: boolean;
+    fields?: string;
+  },
+): Promise<void> {
+  await runSearch(ctx, queryParts, options);
+}

package/src/cli/lib/cli-http-errors.test.ts

@@ -1,85 +1,85 @@
-import { describe, expect, test } from "bun:test";
-import { CLI_ERR } from "../types/errors";
-import { enrichNotFoundError, mapHttpStatusToCliFailure } from "./cli-http-errors";
-import { CliError } from "./output";
-
-describe("mapHttpStatusToCliFailure", () => {
-  test.each([
-    [400, CLI_ERR.badRequest, 9, undefined],
-    [401, CLI_ERR.unauthenticated, 10, undefined],
-    [403, CLI_ERR.forbidden, 4, undefined],
-    [404, CLI_ERR.notFound, 3, undefined],
-    [408, CLI_ERR.requestTimeout, 7, true],
-    [409, CLI_ERR.conflict, 5, undefined],
-    [422, CLI_ERR.badRequest, 9, undefined],
-    [426, CLI_ERR.versionMismatch, 8, undefined],
-    [429, CLI_ERR.rateLimited, 1, true],
-    [502, CLI_ERR.internalError, 1, true],
-    [418, CLI_ERR.httpError, 1, undefined],
-  ] as const)(
-    "status %i → code %s exit %i retryable %j",
-    (status, code, exit, retryable) => {
-      const { exitCode, details } = mapHttpStatusToCliFailure(status, {
-        status,
-        url: "http://127.0.0.1:1/api/x",
-      });
-      expect(exitCode).toBe(exit);
-      expect(details.code).toBe(code);
-      if (retryable === undefined) {
-        expect(details.retryable).toBeUndefined();
-      } else {
-        expect(details.retryable).toBe(retryable);
-      }
-    },
-  );
-
-  test("599 maps to internal_error (5xx branch)", () => {
-    const { exitCode, details } = mapHttpStatusToCliFailure(599, { status: 599 });
-    expect(exitCode).toBe(1);
-    expect(details.code).toBe(CLI_ERR.internalError);
-    expect(details.retryable).toBe(true);
-  });
-
-  test("preserves API code as serverCode, not duplicate top-level code", () => {
-    const { details } = mapHttpStatusToCliFailure(400, {
-      code: "CUSTOM",
-      status: 400,
-    });
-    expect(details.code).toBe(CLI_ERR.badRequest);
-    expect(details.serverCode).toBe("CUSTOM");
-    expect((details as Record<string, unknown>).code).toBe(CLI_ERR.badRequest);
-  });
-
-  test("non-string code in body is ignored for serverCode", () => {
-    const { details } = mapHttpStatusToCliFailure(404, {
-      code: 123,
-      status: 404,
-    } as Record<string, unknown>);
-    expect(details.serverCode).toBeUndefined();
-  });
-});
-
-describe("enrichNotFoundError", () => {
-  test("merges context when details.code is not_found", () => {
-    const err = new CliError("Whatever", 3, { code: CLI_ERR.notFound });
-    try {
-      enrichNotFoundError(err, { board: "my-board", taskId: 9 });
-      expect.unreachable();
-    } catch (e) {
-      expect(e).toBeInstanceOf(CliError);
-      const c = e as CliError;
-      expect(c.message).toBe("Whatever");
-      expect(c.exitCode).toBe(3);
-      expect(c.details).toMatchObject({
-        code: CLI_ERR.notFound,
-        board: "my-board",
-        taskId: 9,
-      });
-    }
-  });
-
-  test("rethrows unchanged when code is not not_found", () => {
-    const err = new CliError("Nope", 4, { code: CLI_ERR.forbidden });
-    expect(() => enrichNotFoundError(err, { board: "x" })).toThrow(err);
-  });
-});
+import { describe, expect, test } from "bun:test";
+import { CLI_ERR } from "../types/errors";
+import { enrichNotFoundError, mapHttpStatusToCliFailure } from "./cli-http-errors";
+import { CliError } from "./output";
+
+describe("mapHttpStatusToCliFailure", () => {
+  test.each([
+    [400, CLI_ERR.badRequest, 9, undefined],
+    [401, CLI_ERR.unauthenticated, 10, undefined],
+    [403, CLI_ERR.forbidden, 4, undefined],
+    [404, CLI_ERR.notFound, 3, undefined],
+    [408, CLI_ERR.requestTimeout, 7, true],
+    [409, CLI_ERR.conflict, 5, undefined],
+    [422, CLI_ERR.badRequest, 9, undefined],
+    [426, CLI_ERR.versionMismatch, 8, undefined],
+    [429, CLI_ERR.rateLimited, 1, true],
+    [502, CLI_ERR.internalError, 1, true],
+    [418, CLI_ERR.httpError, 1, undefined],
+  ] as const)(
+    "status %i → code %s exit %i retryable %j",
+    (status, code, exit, retryable) => {
+      const { exitCode, details } = mapHttpStatusToCliFailure(status, {
+        status,
+        url: "http://127.0.0.1:1/api/x",
+      });
+      expect(exitCode).toBe(exit);
+      expect(details.code).toBe(code);
+      if (retryable === undefined) {
+        expect(details.retryable).toBeUndefined();
+      } else {
+        expect(details.retryable).toBe(retryable);
+      }
+    },
+  );
+
+  test("599 maps to internal_error (5xx branch)", () => {
+    const { exitCode, details } = mapHttpStatusToCliFailure(599, { status: 599 });
+    expect(exitCode).toBe(1);
+    expect(details.code).toBe(CLI_ERR.internalError);
+    expect(details.retryable).toBe(true);
+  });
+
+  test("preserves API code as serverCode, not duplicate top-level code", () => {
+    const { details } = mapHttpStatusToCliFailure(400, {
+      code: "CUSTOM",
+      status: 400,
+    });
+    expect(details.code).toBe(CLI_ERR.badRequest);
+    expect(details.serverCode).toBe("CUSTOM");
+    expect((details as Record<string, unknown>).code).toBe(CLI_ERR.badRequest);
+  });
+
+  test("non-string code in body is ignored for serverCode", () => {
+    const { details } = mapHttpStatusToCliFailure(404, {
+      code: 123,
+      status: 404,
+    } as Record<string, unknown>);
+    expect(details.serverCode).toBeUndefined();
+  });
+});
+
+describe("enrichNotFoundError", () => {
+  test("merges context when details.code is not_found", () => {
+    const err = new CliError("Whatever", 3, { code: CLI_ERR.notFound });
+    try {
+      enrichNotFoundError(err, { board: "my-board", taskId: 9 });
+      expect.unreachable();
+    } catch (e) {
+      expect(e).toBeInstanceOf(CliError);
+      const c = e as CliError;
+      expect(c.message).toBe("Whatever");
+      expect(c.exitCode).toBe(3);
+      expect(c.details).toMatchObject({
+        code: CLI_ERR.notFound,
+        board: "my-board",
+        taskId: 9,
+      });
+    }
+  });
+
+  test("rethrows unchanged when code is not not_found", () => {
+    const err = new CliError("Nope", 4, { code: CLI_ERR.forbidden });
+    expect(() => enrichNotFoundError(err, { board: "x" })).toThrow(err);
+  });
+});

package/src/cli/lib/write/releases.ts

@@ -3,7 +3,7 @@ import type {
   ReleaseMutationResult,
 } from "../../../shared/mutationResults";
 import type { PaginatedListBody } from "../../../shared/pagination";
-import type { ReleaseDefinition } from "../../../shared/models";
+import type { Board, ReleaseDefinition } from "../../../shared/models";
 import type { CliContext } from "../../types/context";
 import { CLI_ERR } from "../../types/errors";
 import { CLI_DEFAULTS } from "../constants";
@@ -19,6 +19,7 @@ import { fetchAllPages } from "../paginatedFetch";
 import { CliError } from "../output";
 import { assertMutuallyExclusive } from "../validation";
 import {
+  compactBoardEntity,
   compactReleaseEntity,
   writeReleaseDelete,
   writeSuccess,
@@ -306,3 +307,65 @@ export async function runReleasesDelete(
     enrichNotFoundError(e, { board: boardId, releaseId: rid });
   }
 }
+
+/**
+ * Set or clear the board default release (PATCH board `defaultReleaseId`).
+ * Validates the release exists on the board before PATCH so errors are clearer than a generic 404.
+ */
+export async function runReleasesSetDefault(
+  ctx: CliContext,
+  opts: {
+    port?: number;
+    board: string | undefined;
+    releaseId: string | undefined;
+    clear: boolean;
+  },
+): Promise<void> {
+  const boardId = opts.board?.trim();
+  if (!boardId) {
+    throw new CliError("Missing required option: --board", 2, {
+      code: CLI_ERR.missingRequired,
+    });
+  }
+  assertMutuallyExclusive([
+    ["<release-id>", opts.releaseId, "--clear", opts.clear],
+  ]);
+  const ridRaw = opts.releaseId?.trim();
+  if (!opts.clear && (ridRaw === undefined || ridRaw === "")) {
+    throw new CliError("Provide <release-id> or use --clear", 2, {
+      code: CLI_ERR.missingRequired,
+    });
+  }
+  if (!opts.clear) {
+    const rid = parsePositiveInt("releaseId", ridRaw);
+    if (rid === undefined) {
+      throw new CliError("Invalid release id", 2, {
+        code: CLI_ERR.invalidValue,
+        releaseId: ridRaw,
+      });
+    }
+    const rows = await fetchAllBoardReleases(ctx, opts.port, boardId);
+    if (!rows.some((r) => r.releaseId === rid)) {
+      throw new CliError("Release not found", 3, {
+        code: CLI_ERR.notFound,
+        board: boardId,
+        releaseId: rid,
+      });
+    }
+  }
+
+  const patch: Record<string, unknown> = {
+    defaultReleaseId: opts.clear ? null : Number(ridRaw),
+  };
+
+  try {
+    const board = await ctx.fetchApiMutate<Board>(
+      `/boards/${encodeURIComponent(boardId)}`,
+      { method: "PATCH", body: patch },
+      { port: opts.port },
+    );
+    ctx.printJson(writeSuccess(board, compactBoardEntity(board)));
+  } catch (e) {
+    enrichNotFoundError(e, { board: boardId });
+  }
+}

package/src/cli/lib/write-result.test.ts

@@ -29,6 +29,7 @@ describe("compact*Entity", () => {
       emoji: null,
       createdAt: "c",
       updatedAt: "u",
+      defaultReleaseId: null,
     });
   });
 
@@ -103,6 +104,7 @@ describe("writeSuccess / trashedEntity / writeTrashMove", () => {
         emoji: null,
         createdAt: "c",
         updatedAt: "u",
+        defaultReleaseId: null,
       },
     );
     expect(envelope).toEqual({
@@ -118,6 +120,7 @@ describe("writeSuccess / trashedEntity / writeTrashMove", () => {
         emoji: null,
         createdAt: "c",
         updatedAt: "u",
+        defaultReleaseId: null,
       },
     });
   });

package/src/cli/lib/write-result.ts

@@ -9,6 +9,8 @@ export type WriteBoardEntity = {
   emoji: string | null;
   createdAt: string;
   updatedAt: string;
+  /** Board default release for new tasks (when set). */
+  defaultReleaseId?: number | null;
 };
 
 export type WriteListEntity = {
@@ -91,6 +93,7 @@ export function compactBoardEntity(board: Board): WriteBoardEntity {
     emoji: board.emoji ?? null,
     createdAt: board.createdAt,
     updatedAt: board.updatedAt,
+    defaultReleaseId: board.defaultReleaseId ?? null,
   };
 }
 

package/src/cli/lib/writeCommands.breadth.test.ts

@@ -25,6 +25,7 @@ import {
   runListsUpdate,
   runReleasesAdd,
   runReleasesDelete,
+  runReleasesSetDefault,
   runReleasesUpdate,
   runTasksAdd,
   runTasksDelete,
@@ -118,6 +119,48 @@ describe("writeCommands breadth — validation", () => {
     });
   });
 
+  test("runReleasesSetDefault throws without board", async () => {
+    await expect(
+      runReleasesSetDefault(ctx, {
+        port: 1,
+        board: undefined,
+        releaseId: "1",
+        clear: false,
+      }),
+    ).rejects.toMatchObject({
+      exitCode: 2,
+      details: expect.objectContaining({ code: CLI_ERR.missingRequired }),
+    });
+  });
+
+  test("runReleasesSetDefault throws without release id and without --clear", async () => {
+    await expect(
+      runReleasesSetDefault(ctx, {
+        port: 1,
+        board: "b",
+        releaseId: undefined,
+        clear: false,
+      }),
+    ).rejects.toMatchObject({
+      exitCode: 2,
+      details: expect.objectContaining({ code: CLI_ERR.missingRequired }),
+    });
+  });
+
+  test("runReleasesSetDefault throws when release id and --clear together", async () => {
+    await expect(
+      runReleasesSetDefault(ctx, {
+        port: 1,
+        board: "b",
+        releaseId: "2",
+        clear: true,
+      }),
+    ).rejects.toMatchObject({
+      exitCode: 2,
+      details: expect.objectContaining({ code: CLI_ERR.mutuallyExclusiveOptions }),
+    });
+  });
+
   test("runListsMove throws on multiple placement flags", async () => {
     await expect(
       runListsMove(ctx, {
@@ -687,6 +730,106 @@ describe("writeCommands breadth — mock fetch happy paths", () => {
     });
   });
 
+  test("runReleasesSetDefault GETs releases then PATCHes board defaultReleaseId", async () => {
+    setMockFetch(async (input, init) => {
+      const u = reqUrl(input);
+      if (
+        u.includes("/boards/b/releases") &&
+        (init?.method === "GET" || init?.method === undefined)
+      ) {
+        return new Response(
+          JSON.stringify({
+            items: [
+              {
+                releaseId: 2,
+                name: "v1",
+                createdAt: "2026-01-01T00:00:00.000Z",
+              },
+            ],
+            total: 1,
+            limit: 500,
+            offset: 0,
+          }),
+          { status: 200, headers: { "content-type": "application/json" } },
+        );
+      }
+      if (u.includes("/api/boards/b") && !u.includes("/releases") && init?.method === "PATCH") {
+        expect(JSON.parse(String(init?.body))).toEqual({ defaultReleaseId: 2 });
+        return new Response(
+          JSON.stringify({
+            boardId: 1,
+            slug: "b",
+            name: "B",
+            emoji: null,
+            createdAt: "2026-01-01T00:00:00.000Z",
+            updatedAt: "2026-01-02T00:00:00.000Z",
+            defaultReleaseId: 2,
+            releases: [],
+            lists: [],
+            taskGroups: [],
+            taskPriorities: [],
+            defaultTaskGroupId: 1,
+            autoAssignReleaseOnCreateUi: false,
+            autoAssignReleaseOnCreateCli: false,
+          } as unknown as Board),
+          { status: 200, headers: { "content-type": "application/json" } },
+        );
+      }
+      throw new Error(`unexpected fetch: ${u} ${init?.method}`);
+    });
+    const out = await captureStdout(() =>
+      runReleasesSetDefault(ctx, {
+        port: 22025,
+        board: "b",
+        releaseId: "2",
+        clear: false,
+      }),
+    );
+    expect(JSON.parse(out.trim())).toMatchObject({
+      ok: true,
+      entity: { type: "board", defaultReleaseId: 2 },
+    });
+  });
+
+  test("runReleasesSetDefault --clear PATCHes defaultReleaseId null", async () => {
+    setMockFetch(async (input, init) => {
+      expect(reqUrl(input)).toContain("/api/boards/b");
+      expect(init?.method).toBe("PATCH");
+      expect(JSON.parse(String(init?.body))).toEqual({ defaultReleaseId: null });
+      return new Response(
+        JSON.stringify({
+          boardId: 1,
+          slug: "b",
+          name: "B",
+          emoji: null,
+          createdAt: "2026-01-01T00:00:00.000Z",
+          updatedAt: "2026-01-02T00:00:00.000Z",
+          defaultReleaseId: null,
+          releases: [],
+          lists: [],
+          taskGroups: [],
+          taskPriorities: [],
+          defaultTaskGroupId: 1,
+          autoAssignReleaseOnCreateUi: false,
+          autoAssignReleaseOnCreateCli: false,
+        } as unknown as Board),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    });
+    const out = await captureStdout(() =>
+      runReleasesSetDefault(ctx, {
+        port: 22026,
+        board: "b",
+        releaseId: undefined,
+        clear: true,
+      }),
+    );
+    expect(JSON.parse(out.trim())).toMatchObject({
+      ok: true,
+      entity: { type: "board", defaultReleaseId: null },
+    });
+  });
+
   test("mutating fetch sends runtime client name header", async () => {
     setRuntimeCliClientName("Cursor Agent");
     setMockFetch(async (_input, init) => {

package/src/cli/lib/writeCommands.ts

@@ -27,6 +27,7 @@ export {
   runReleasesAdd,
   runReleasesDelete,
   runReleasesList,
+  runReleasesSetDefault,
   runReleasesShow,
   runReleasesUpdate,
 } from "./write/releases";