skyboard-cli 0.1.0 → 0.1.1

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "skyboard-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "CLI for Skyboard – a collaborative kanban board on AT Protocol",
   "author": {
     "name": "Tim Disney"
   },
   "type": "module",
+  "files": [
+    "dist",
+    "bin"
+  ],
   "bin": {
     "sb": "./bin/sb.js"
   },

package/src/__tests__/auth-state.test.ts

@@ -1,111 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { OWNER_DID, USER_DID, BOARD_RKEY } from "./helpers.js";
-
-// Mock config module
-const mockLoadAuthInfo = vi.fn();
-const mockClearDefaultBoard = vi.fn();
-const mockGetDefaultBoard = vi.fn();
-
-vi.mock("../lib/config.js", () => ({
-  loadAuthInfo: (...args: unknown[]) => mockLoadAuthInfo(...args),
-  clearDefaultBoard: (...args: unknown[]) => mockClearDefaultBoard(...args),
-  getDefaultBoard: (...args: unknown[]) => mockGetDefaultBoard(...args),
-}));
-
-// Mock auth module
-const mockLogin = vi.fn();
-const mockLogout = vi.fn();
-
-vi.mock("../lib/auth.js", () => ({
-  login: (...args: unknown[]) => mockLogin(...args),
-  logout: (...args: unknown[]) => mockLogout(...args),
-}));
-
-import { logoutCommand } from "../commands/logout.js";
-import { loginCommand } from "../commands/login.js";
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  vi.spyOn(console, "log").mockImplementation(() => {});
-  vi.spyOn(console, "error").mockImplementation(() => {});
-});
-
-describe("logoutCommand", () => {
-  it("clears the default board on logout", () => {
-    mockLoadAuthInfo.mockReturnValue({
-      did: OWNER_DID,
-      handle: "owner.test",
-      service: "https://pds.example.com",
-    });
-
-    logoutCommand();
-
-    expect(mockLogout).toHaveBeenCalledOnce();
-    expect(mockClearDefaultBoard).toHaveBeenCalledOnce();
-  });
-
-  it("does not clear board if not logged in", () => {
-    mockLoadAuthInfo.mockReturnValue(null);
-
-    logoutCommand();
-
-    expect(mockLogout).not.toHaveBeenCalled();
-    expect(mockClearDefaultBoard).not.toHaveBeenCalled();
-  });
-});
-
-describe("loginCommand", () => {
-  it("clears the default board when switching to a different account", async () => {
-    mockLoadAuthInfo.mockReturnValue({
-      did: OWNER_DID,
-      handle: "owner.test",
-      service: "https://pds.example.com",
-    });
-    mockLogin.mockResolvedValue({ did: USER_DID, handle: "user.test" });
-
-    await loginCommand("user.test");
-
-    expect(mockClearDefaultBoard).toHaveBeenCalledOnce();
-  });
-
-  it("does not clear the default board when logging in as the same account", async () => {
-    mockLoadAuthInfo.mockReturnValue({
-      did: OWNER_DID,
-      handle: "owner.test",
-      service: "https://pds.example.com",
-    });
-    mockLogin.mockResolvedValue({ did: OWNER_DID, handle: "owner.test" });
-
-    await loginCommand("owner.test");
-
-    expect(mockClearDefaultBoard).not.toHaveBeenCalled();
-  });
-
-  it("does not clear the default board on first login (no previous auth)", async () => {
-    mockLoadAuthInfo.mockReturnValue(null);
-    mockLogin.mockResolvedValue({ did: OWNER_DID, handle: "owner.test" });
-
-    await loginCommand("owner.test");
-
-    expect(mockClearDefaultBoard).not.toHaveBeenCalled();
-  });
-
-  it("does not clear the default board if login fails", async () => {
-    mockLoadAuthInfo.mockReturnValue({
-      did: OWNER_DID,
-      handle: "owner.test",
-      service: "https://pds.example.com",
-    });
-    mockLogin.mockRejectedValue(new Error("OAuth failed"));
-
-    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {
-      throw new Error("process.exit");
-    }) as any);
-
-    await expect(loginCommand("user.test")).rejects.toThrow("process.exit");
-
-    expect(mockClearDefaultBoard).not.toHaveBeenCalled();
-
-    exitSpy.mockRestore();
-  });
-});

package/src/__tests__/card-ref.test.ts

@@ -1,42 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { resolveCardRef } from "../lib/card-ref.js";
-import { makeMaterializedTask, TASK_RKEY_1, TASK_RKEY_2, TASK_RKEY_3 } from "./helpers.js";
-
-describe("resolveCardRef", () => {
-  const tasks = [
-    makeMaterializedTask({ rkey: TASK_RKEY_1, title: "First Task" }),
-    makeMaterializedTask({ rkey: TASK_RKEY_2, title: "Second Task" }),
-    makeMaterializedTask({ rkey: TASK_RKEY_3, title: "Third Task" }),
-  ];
-
-  it("matches a task by 4+ character rkey prefix", () => {
-    // TASK_RKEY_1 = "3jui7a2zbbb22" — need enough chars to disambiguate from TASK_RKEY_2 "3jui7a2zbbb33"
-    const result = resolveCardRef(TASK_RKEY_1.slice(0, 12), tasks);
-    expect(result.rkey).toBe(TASK_RKEY_1);
-  });
-
-  it("matches a task by full rkey", () => {
-    const result = resolveCardRef(TASK_RKEY_2, tasks);
-    expect(result.rkey).toBe(TASK_RKEY_2);
-  });
-
-  it("throws on too-short prefix (< 4 chars)", () => {
-    expect(() => resolveCardRef("3ju", tasks)).toThrow("too short");
-  });
-
-  it("throws when no task matches", () => {
-    expect(() => resolveCardRef("zzzz", tasks)).toThrow('No card found');
-  });
-
-  it("throws on ambiguous match with list of candidates", () => {
-    // TASK_RKEY_1 = "3jui7a2zbbb22", TASK_RKEY_2 = "3jui7a2zbbb33"
-    // They share prefix "3jui7a2zbbb"
-    expect(() => resolveCardRef("3jui7a2zbbb", tasks)).toThrow("Ambiguous");
-  });
-
-  it("resolves unambiguous prefix that partially overlaps", () => {
-    // TASK_RKEY_3 = "3jui7a2zbcc44" — prefix "3jui7a2zbcc" is unique
-    const result = resolveCardRef("3jui7a2zbcc", tasks);
-    expect(result.rkey).toBe(TASK_RKEY_3);
-  });
-});

package/src/__tests__/column-match.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { resolveColumn } from "../lib/column-match.js";
-import { COLUMNS } from "./helpers.js";
-
-describe("resolveColumn", () => {
-  // COLUMNS: To Do (0), In Progress (1), Done (2)
-
-  it("matches by 1-based numeric index", () => {
-    expect(resolveColumn("1", COLUMNS)).toEqual(COLUMNS[0]); // To Do
-    expect(resolveColumn("2", COLUMNS)).toEqual(COLUMNS[1]); // In Progress
-    expect(resolveColumn("3", COLUMNS)).toEqual(COLUMNS[2]); // Done
-  });
-
-  it("matches by exact name (case-insensitive)", () => {
-    expect(resolveColumn("To Do", COLUMNS)).toEqual(COLUMNS[0]);
-    expect(resolveColumn("to do", COLUMNS)).toEqual(COLUMNS[0]);
-    expect(resolveColumn("IN PROGRESS", COLUMNS)).toEqual(COLUMNS[1]);
-    expect(resolveColumn("done", COLUMNS)).toEqual(COLUMNS[2]);
-  });
-
-  it("matches by prefix", () => {
-    expect(resolveColumn("Do", COLUMNS)).toEqual(COLUMNS[2]); // "Done" unique prefix
-  });
-
-  it("matches by substring", () => {
-    expect(resolveColumn("Prog", COLUMNS)).toEqual(COLUMNS[1]); // "In Progress"
-  });
-
-  it("throws on ambiguous prefix match", () => {
-    // Columns with ambiguous prefixes
-    const cols = [
-      { id: "a", name: "Alpha One", order: 0 },
-      { id: "b", name: "Alpha Two", order: 1 },
-    ];
-    expect(() => resolveColumn("Alpha", cols)).toThrow("Ambiguous");
-  });
-
-  it("throws on ambiguous substring match", () => {
-    const cols = [
-      { id: "a", name: "Pre-Review", order: 0 },
-      { id: "b", name: "Post-Review", order: 1 },
-    ];
-    // "Review" is a substring of both but not a prefix of either
-    expect(() => resolveColumn("Review", cols)).toThrow("Ambiguous");
-  });
-
-  it("throws on no match with available columns", () => {
-    expect(() => resolveColumn("Nonexistent", COLUMNS)).toThrow("No column matching");
-    expect(() => resolveColumn("Nonexistent", COLUMNS)).toThrow("To Do");
-  });
-
-  it("ignores out-of-range numeric index", () => {
-    // "0" is out of 1-based range, and doesn't match any name
-    expect(() => resolveColumn("0", COLUMNS)).toThrow("No column matching");
-    expect(() => resolveColumn("99", COLUMNS)).toThrow("No column matching");
-  });
-});

package/src/__tests__/commands.test.ts

@@ -1,326 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { BoardData } from "../lib/pds.js";
-import {
-  OWNER_DID,
-  USER_DID,
-  BOARD_RKEY,
-  BOARD_URI,
-  TASK_RKEY_1,
-  TASK_URI_1,
-  COLUMNS,
-  makeBoard,
-  makeMaterializedTask,
-  makeComment,
-} from "./helpers.js";
-
-// Mock modules before importing commands
-vi.mock("../lib/auth.js", () => ({
-  requireAgent: vi.fn(),
-}));
-
-vi.mock("../lib/config.js", () => ({
-  getDefaultBoard: vi.fn(),
-  loadConfig: vi.fn(() => ({ knownBoards: [] })),
-  saveConfig: vi.fn(),
-}));
-
-vi.mock("../lib/pds.js", () => ({
-  fetchBoardData: vi.fn(),
-  fetchBoard: vi.fn(),
-}));
-
-// Mock generateTID to return a predictable value
-vi.mock("../lib/tid.js", async (importOriginal) => {
-  const orig = await importOriginal<typeof import("../lib/tid.js")>();
-  return {
-    ...orig,
-    generateTID: vi.fn(() => "3juitestid0000000"),
-  };
-});
-
-import { requireAgent } from "../lib/auth.js";
-import { getDefaultBoard } from "../lib/config.js";
-import { fetchBoardData } from "../lib/pds.js";
-import { newCommand } from "../commands/new.js";
-import { mvCommand } from "../commands/mv.js";
-import { editCommand } from "../commands/edit.js";
-import { rmCommand } from "../commands/rm.js";
-import { showCommand } from "../commands/show.js";
-import { cardsCommand } from "../commands/cards.js";
-
-const mockPutRecord = vi.fn(async (_input: any) => ({ uri: "at://fake", cid: "fakecid" }));
-const mockDeleteRecord = vi.fn(async (_input: any) => ({}));
-const mockAgent = {
-  com: {
-    atproto: {
-      repo: {
-        putRecord: mockPutRecord,
-        deleteRecord: mockDeleteRecord,
-        listRecords: vi.fn(async () => ({ data: { records: [] } })),
-      },
-    },
-  },
-};
-
-function setupMocks(taskOverrides?: Parameters<typeof makeMaterializedTask>[0]) {
-  vi.mocked(requireAgent).mockResolvedValue({
-    agent: mockAgent as any,
-    did: OWNER_DID,
-    handle: "owner.test",
-  });
-
-  vi.mocked(getDefaultBoard).mockReturnValue({
-    did: OWNER_DID,
-    rkey: BOARD_RKEY,
-    name: "Test Board",
-  });
-
-  const task = makeMaterializedTask(
-    { rkey: TASK_RKEY_1, did: OWNER_DID, title: "Test Task", ...taskOverrides },
-    { effectiveTitle: taskOverrides?.title ?? "Test Task" },
-  );
-
-  const boardData: BoardData = {
-    board: makeBoard(),
-    tasks: [task],
-    trusts: [],
-    comments: [],
-    allParticipants: [OWNER_DID],
-  };
-
-  vi.mocked(fetchBoardData).mockResolvedValue(boardData);
-
-  return { task, boardData };
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  // Suppress console output during tests
-  vi.spyOn(console, "log").mockImplementation(() => {});
-  vi.spyOn(console, "error").mockImplementation(() => {});
-});
-
-describe("newCommand", () => {
-  it("creates a task record via putRecord", async () => {
-    setupMocks();
-
-    await newCommand("My New Task", { json: true });
-
-    expect(mockPutRecord).toHaveBeenCalledOnce();
-    const call = mockPutRecord.mock.calls[0][0];
-    expect(call.repo).toBe(OWNER_DID);
-    expect(call.collection).toBe("dev.skyboard.task");
-    expect(call.record.$type).toBe("dev.skyboard.task");
-    expect(call.record.title).toBe("My New Task");
-    expect(call.record.columnId).toBe("col-todo"); // first column
-    expect(call.record.position).toBeDefined();
-    expect(call.record.boardUri).toContain(BOARD_RKEY);
-  });
-
-  it("creates task in specified column", async () => {
-    setupMocks();
-
-    await newCommand("Task in Done", { column: "Done", json: true });
-
-    const call = mockPutRecord.mock.calls[0][0];
-    expect(call.record.columnId).toBe("col-done");
-  });
-
-  it("includes description when provided", async () => {
-    setupMocks();
-
-    await newCommand("With Desc", { description: "A description", json: true });
-
-    const call = mockPutRecord.mock.calls[0][0];
-    expect(call.record.description).toBe("A description");
-  });
-
-  it("outputs JSON when --json flag is set", async () => {
-    setupMocks();
-
-    await newCommand("JSON Task", { json: true });
-
-    expect(console.log).toHaveBeenCalled();
-    const output = vi.mocked(console.log).mock.calls[0][0];
-    const parsed = JSON.parse(output);
-    expect(parsed.title).toBe("JSON Task");
-    expect(parsed.column).toBe("To Do");
-  });
-});
-
-describe("mvCommand", () => {
-  it("creates an op record with columnId and position", async () => {
-    setupMocks();
-
-    await mvCommand(TASK_RKEY_1, "Done", { json: true });
-
-    expect(mockPutRecord).toHaveBeenCalledOnce();
-    const call = mockPutRecord.mock.calls[0][0];
-    expect(call.repo).toBe(OWNER_DID);
-    expect(call.collection).toBe("dev.skyboard.op");
-    expect(call.record.$type).toBe("dev.skyboard.op");
-    expect(call.record.fields.columnId).toBe("col-done");
-    expect(call.record.fields.position).toBeDefined();
-    expect(call.record.targetTaskUri).toContain(TASK_RKEY_1);
-  });
-
-  it("outputs JSON with rkey and column name", async () => {
-    setupMocks();
-
-    await mvCommand(TASK_RKEY_1, "In Progress", { json: true });
-
-    const output = vi.mocked(console.log).mock.calls[0][0];
-    const parsed = JSON.parse(output);
-    expect(parsed.rkey).toBe(TASK_RKEY_1);
-    expect(parsed.column).toBe("In Progress");
-  });
-});
-
-describe("editCommand", () => {
-  it("creates an op with title field", async () => {
-    setupMocks();
-
-    await editCommand(TASK_RKEY_1, { title: "New Title", json: true });
-
-    expect(mockPutRecord).toHaveBeenCalledOnce();
-    const call = mockPutRecord.mock.calls[0][0];
-    expect(call.collection).toBe("dev.skyboard.op");
-    expect(call.record.fields.title).toBe("New Title");
-    expect(call.record.targetTaskUri).toContain(TASK_RKEY_1);
-  });
-
-  it("creates an op with description field", async () => {
-    setupMocks();
-
-    await editCommand(TASK_RKEY_1, { description: "New Desc", json: true });
-
-    const call = mockPutRecord.mock.calls[0][0];
-    expect(call.record.fields.description).toBe("New Desc");
-  });
-
-  it("resolves label names to IDs", async () => {
-    setupMocks();
-
-    await editCommand(TASK_RKEY_1, { label: ["bug"], json: true });
-
-    const call = mockPutRecord.mock.calls[0][0];
-    expect(call.record.fields.labelIds).toEqual(["lbl-bug"]);
-  });
-
-  it("exits when no fields provided", async () => {
-    setupMocks();
-
-    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {
-      throw new Error("process.exit");
-    }) as any);
-
-    await expect(editCommand(TASK_RKEY_1, {})).rejects.toThrow("process.exit");
-    expect(mockPutRecord).not.toHaveBeenCalled();
-
-    exitSpy.mockRestore();
-  });
-});
-
-describe("rmCommand", () => {
-  it("deletes own task via deleteRecord with --force", async () => {
-    setupMocks();
-
-    await rmCommand(TASK_RKEY_1, { force: true, json: true });
-
-    expect(mockDeleteRecord).toHaveBeenCalledOnce();
-    const call = mockDeleteRecord.mock.calls[0][0];
-    expect(call.repo).toBe(OWNER_DID);
-    expect(call.collection).toBe("dev.skyboard.task");
-    expect(call.rkey).toBe(TASK_RKEY_1);
-  });
-
-  it("rejects deletion of task owned by another user", async () => {
-    // Task owned by USER_DID, but we're logged in as OWNER_DID
-    setupMocks({ did: USER_DID });
-
-    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {
-      throw new Error("process.exit");
-    }) as any);
-
-    await expect(
-      rmCommand(TASK_RKEY_1, { force: true, json: true }),
-    ).rejects.toThrow("process.exit");
-
-    expect(mockDeleteRecord).not.toHaveBeenCalled();
-    expect(console.error).toHaveBeenCalled();
-
-    exitSpy.mockRestore();
-  });
-
-  it("outputs JSON with deleted rkey", async () => {
-    setupMocks();
-
-    await rmCommand(TASK_RKEY_1, { force: true, json: true });
-
-    const output = vi.mocked(console.log).mock.calls[0][0];
-    const parsed = JSON.parse(output);
-    expect(parsed.deleted).toBe(TASK_RKEY_1);
-  });
-});
-
-describe("showCommand", () => {
-  it("displays card details in JSON mode", async () => {
-    const { boardData } = setupMocks();
-
-    await showCommand(TASK_RKEY_1, { json: true });
-
-    expect(console.log).toHaveBeenCalled();
-    const output = vi.mocked(console.log).mock.calls[0][0];
-    const parsed = JSON.parse(output);
-    expect(parsed.rkey).toBe(TASK_RKEY_1);
-    expect(parsed.title).toBe("Test Task");
-    expect(parsed.column).toBe("To Do");
-  });
-
-  it("includes comments in JSON output", async () => {
-    const { boardData } = setupMocks();
-    const comment = makeComment({
-      targetTaskUri: `at://${OWNER_DID}/dev.skyboard.task/${TASK_RKEY_1}`,
-      text: "Hello!",
-    });
-    boardData.comments = [comment];
-    vi.mocked(fetchBoardData).mockResolvedValue(boardData);
-
-    await showCommand(TASK_RKEY_1, { json: true });
-
-    const output = vi.mocked(console.log).mock.calls[0][0];
-    const parsed = JSON.parse(output);
-    expect(parsed.comments).toHaveLength(1);
-    expect(parsed.comments[0].text).toBe("Hello!");
-  });
-});
-
-describe("cardsCommand", () => {
-  it("outputs JSON with columns and cards", async () => {
-    setupMocks();
-
-    await cardsCommand({ json: true });
-
-    expect(console.log).toHaveBeenCalled();
-    const output = vi.mocked(console.log).mock.calls[0][0];
-    const parsed = JSON.parse(output);
-    expect(parsed).toBeInstanceOf(Array);
-    expect(parsed).toHaveLength(3); // 3 columns
-    expect(parsed[0].column).toBe("To Do");
-    expect(parsed[0].cards).toHaveLength(1);
-    expect(parsed[0].cards[0].title).toBe("Test Task");
-  });
-
-  it("includes all columns even if empty", async () => {
-    setupMocks();
-
-    await cardsCommand({ json: true });
-
-    const output = vi.mocked(console.log).mock.calls[0][0];
-    const parsed = JSON.parse(output);
-    expect(parsed[1].column).toBe("In Progress");
-    expect(parsed[1].cards).toHaveLength(0);
-    expect(parsed[2].column).toBe("Done");
-    expect(parsed[2].cards).toHaveLength(0);
-  });
-});