@task-mcp/cli 1.0.20 → 1.0.22

package/src/__tests__/inbox.test.ts

@@ -1,307 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-describe("inbox commands - unit tests", () => {
-  describe("inbox item status handling", () => {
-    type InboxStatus = "pending" | "promoted" | "discarded";
-
-    test("pending is the default status", () => {
-      const defaultStatus: InboxStatus = "pending";
-      expect(defaultStatus).toBe("pending");
-    });
-
-    test("all valid statuses are supported", () => {
-      const validStatuses: InboxStatus[] = ["pending", "promoted", "discarded"];
-
-      expect(validStatuses).toContain("pending");
-      expect(validStatuses).toContain("promoted");
-      expect(validStatuses).toContain("discarded");
-    });
-  });
-
-  describe("content parsing", () => {
-    // Test the tag extraction logic from parseInboxInput
-    test("extracts hashtags from content", () => {
-      const content = "Test idea #tag1 with #tag2 multiple tags";
-      const tagRegex = /#(\w+)/g;
-      const tags: string[] = [];
-      let match;
-      while ((match = tagRegex.exec(content)) !== null) {
-        tags.push(match[1]!);
-      }
-
-      expect(tags).toContain("tag1");
-      expect(tags).toContain("tag2");
-      expect(tags.length).toBe(2);
-    });
-
-    test("handles content without tags", () => {
-      const content = "Simple idea without any tags";
-      const tagRegex = /#(\w+)/g;
-      const tags: string[] = [];
-      let match;
-      while ((match = tagRegex.exec(content)) !== null) {
-        tags.push(match[1]!);
-      }
-
-      expect(tags.length).toBe(0);
-    });
-
-    test("handles empty content", () => {
-      const content = "";
-      const tagRegex = /#(\w+)/g;
-      const tags: string[] = [];
-      let match;
-      while ((match = tagRegex.exec(content)) !== null) {
-        tags.push(match[1]!);
-      }
-
-      expect(tags.length).toBe(0);
-    });
-
-    test("extracts tags with alphanumeric characters", () => {
-      const content = "Idea #feature123 and #bug456";
-      const tagRegex = /#(\w+)/g;
-      const tags: string[] = [];
-      let match;
-      while ((match = tagRegex.exec(content)) !== null) {
-        tags.push(match[1]!);
-      }
-
-      expect(tags).toContain("feature123");
-      expect(tags).toContain("bug456");
-    });
-  });
-
-  describe("title truncation for promote", () => {
-    test("truncates long content to 100 characters for title", () => {
-      const longContent = "A".repeat(150);
-      const title = longContent.slice(0, 100);
-
-      expect(title.length).toBe(100);
-    });
-
-    test("keeps short content as-is for title", () => {
-      const shortContent = "Short inbox idea";
-      const title = shortContent.slice(0, 100);
-
-      expect(title).toBe(shortContent);
-    });
-  });
-
-  describe("priority validation", () => {
-    type Priority = "critical" | "high" | "medium" | "low";
-
-    test("all valid priorities are recognized", () => {
-      const priorities: Priority[] = ["critical", "high", "medium", "low"];
-
-      expect(priorities.length).toBe(4);
-      expect(priorities).toContain("critical");
-      expect(priorities).toContain("high");
-      expect(priorities).toContain("medium");
-      expect(priorities).toContain("low");
-    });
-
-    test("default priority is medium", () => {
-      const defaultPriority: Priority = "medium";
-      expect(defaultPriority).toBe("medium");
-    });
-  });
-
-  describe("date formatting", () => {
-    test("formats ISO date string for display", () => {
-      const isoDate = "2024-12-25T10:30:00Z";
-      const date = new Date(isoDate);
-      const formatted = date.toLocaleDateString();
-
-      expect(formatted.length).toBeGreaterThan(0);
-    });
-
-    test("formats full timestamp for detailed view", () => {
-      const isoDate = "2024-12-25T10:30:00Z";
-      const date = new Date(isoDate);
-      const formatted = date.toLocaleString();
-
-      expect(formatted.length).toBeGreaterThan(0);
-      // Should include both date and time components
-    });
-  });
-
-  describe("filtering logic", () => {
-    interface InboxItem {
-      id: string;
-      status: "pending" | "promoted" | "discarded";
-    }
-
-    test("filters by pending status", () => {
-      const items: InboxItem[] = [
-        { id: "1", status: "pending" },
-        { id: "2", status: "promoted" },
-        { id: "3", status: "pending" },
-      ];
-
-      const filtered = items.filter((i) => i.status === "pending");
-
-      expect(filtered.length).toBe(2);
-    });
-
-    test("filters by promoted status", () => {
-      const items: InboxItem[] = [
-        { id: "1", status: "pending" },
-        { id: "2", status: "promoted" },
-        { id: "3", status: "promoted" },
-      ];
-
-      const filtered = items.filter((i) => i.status === "promoted");
-
-      expect(filtered.length).toBe(2);
-    });
-
-    test("returns all items when no filter applied", () => {
-      const items: InboxItem[] = [
-        { id: "1", status: "pending" },
-        { id: "2", status: "promoted" },
-        { id: "3", status: "discarded" },
-      ];
-
-      expect(items.length).toBe(3);
-    });
-  });
-
-  describe("promoted item handling", () => {
-    test("tracks promotedToTaskId when promoted", () => {
-      const item = {
-        id: "inbox_123",
-        status: "promoted" as const,
-        promotedToTaskId: "task_456",
-      };
-
-      expect(item.promotedToTaskId).toBe("task_456");
-      expect(item.status).toBe("promoted");
-    });
-
-    test("prevents double promotion", () => {
-      const item = {
-        id: "inbox_123",
-        status: "promoted" as const,
-        promotedToTaskId: "task_456",
-      };
-
-      const canPromote = item.status !== "promoted";
-
-      expect(canPromote).toBe(false);
-    });
-
-    test("allows promotion of pending items", () => {
-      const item: {
-        id: string;
-        status: "pending" | "promoted" | "discarded";
-        promotedToTaskId?: string;
-      } = {
-        id: "inbox_123",
-        status: "pending",
-        promotedToTaskId: undefined,
-      };
-
-      const canPromote = item.status !== "promoted";
-
-      expect(canPromote).toBe(true);
-    });
-  });
-});
-
-describe("inbox commands - exports", () => {
-  test("inboxAddCmd is exported", async () => {
-    const { inboxAddCmd } = await import("../commands/inbox.js");
-    expect(typeof inboxAddCmd).toBe("function");
-  });
-
-  test("inboxListCmd is exported", async () => {
-    const { inboxListCmd } = await import("../commands/inbox.js");
-    expect(typeof inboxListCmd).toBe("function");
-  });
-
-  test("inboxGetCmd is exported", async () => {
-    const { inboxGetCmd } = await import("../commands/inbox.js");
-    expect(typeof inboxGetCmd).toBe("function");
-  });
-
-  test("inboxPromoteCmd is exported", async () => {
-    const { inboxPromoteCmd } = await import("../commands/inbox.js");
-    expect(typeof inboxPromoteCmd).toBe("function");
-  });
-
-  test("inboxDiscardCmd is exported", async () => {
-    const { inboxDiscardCmd } = await import("../commands/inbox.js");
-    expect(typeof inboxDiscardCmd).toBe("function");
-  });
-
-  test("inboxDeleteCmd is exported", async () => {
-    const { inboxDeleteCmd } = await import("../commands/inbox.js");
-    expect(typeof inboxDeleteCmd).toBe("function");
-  });
-
-  test("inboxCountCmd is exported", async () => {
-    const { inboxCountCmd } = await import("../commands/inbox.js");
-    expect(typeof inboxCountCmd).toBe("function");
-  });
-});
-
-describe("inbox options interfaces", () => {
-  test("InboxAddOptions structure", () => {
-    const options: { content: string; source?: string } = {
-      content: "Test content #tag",
-      source: "cli",
-    };
-
-    expect(options.content).toBeDefined();
-    expect(options.source).toBe("cli");
-  });
-
-  test("InboxListOptions structure", () => {
-    const options: {
-      all?: boolean;
-      status?: "pending" | "promoted" | "discarded";
-    } = {
-      all: false,
-      status: "pending",
-    };
-
-    expect(options.all).toBe(false);
-    expect(options.status).toBe("pending");
-  });
-
-  test("InboxPromoteOptions structure", () => {
-    const options: {
-      itemId: string;
-      projectId?: string;
-      title?: string;
-      priority?: "critical" | "high" | "medium" | "low";
-    } = {
-      itemId: "inbox_123",
-      projectId: "proj_abc",
-      title: "Promoted Task",
-      priority: "high",
-    };
-
-    expect(options.itemId).toBe("inbox_123");
-    expect(options.projectId).toBe("proj_abc");
-    expect(options.title).toBe("Promoted Task");
-    expect(options.priority).toBe("high");
-  });
-
-  test("InboxPromoteOptions with minimal fields", () => {
-    const options: {
-      itemId: string;
-      projectId?: string;
-      title?: string;
-      priority?: "critical" | "high" | "medium" | "low";
-    } = {
-      itemId: "inbox_123",
-    };
-
-    expect(options.itemId).toBe("inbox_123");
-    expect(options.projectId).toBeUndefined();
-    expect(options.title).toBeUndefined();
-    expect(options.priority).toBeUndefined();
-  });
-});

package/src/__tests__/index.test.ts

@@ -1,140 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { parseArgs } from "../index.js";
-
-describe("parseArgs", () => {
-  // Helper: simulate argv with bun and script path
-  const argv = (...args: string[]) => ["bun", "script.ts", ...args];
-
-  describe("command parsing", () => {
-    test("defaults to dashboard when no command", () => {
-      const result = parseArgs(argv());
-      expect(result.command).toBe("dashboard");
-      expect(result.args).toEqual([]);
-    });
-
-    test("parses command from first positional arg", () => {
-      const result = parseArgs(argv("list"));
-      expect(result.command).toBe("list");
-    });
-
-    test("parses command and additional args", () => {
-      const result = parseArgs(argv("dashboard", "proj_123"));
-      expect(result.command).toBe("dashboard");
-      expect(result.args).toEqual(["proj_123"]);
-    });
-
-    test("parses multiple positional args", () => {
-      const result = parseArgs(argv("cmd", "arg1", "arg2"));
-      expect(result.command).toBe("cmd");
-      expect(result.args).toEqual(["arg1", "arg2"]);
-    });
-  });
-
-  describe("long flags (--flag)", () => {
-    test("parses --flag as boolean true", () => {
-      const result = parseArgs(argv("list", "--all"));
-      expect(result.flags.all).toBe(true);
-    });
-
-    test("parses --flag=value", () => {
-      const result = parseArgs(argv("list", "--status=pending"));
-      expect(result.flags.status).toBe("pending");
-    });
-
-    test("parses --flag value (space separated)", () => {
-      const result = parseArgs(argv("list", "--status", "pending"));
-      expect(result.flags.status).toBe("pending");
-    });
-
-    test("parses multiple flags", () => {
-      const result = parseArgs(argv("list", "--status", "pending", "--priority", "high", "--all"));
-      expect(result.flags.status).toBe("pending");
-      expect(result.flags.priority).toBe("high");
-      expect(result.flags.all).toBe(true);
-    });
-
-    test("flag value starting with dash is treated as boolean", () => {
-      const result = parseArgs(argv("list", "--flag", "--other"));
-      expect(result.flags.flag).toBe(true);
-      expect(result.flags.other).toBe(true);
-    });
-  });
-
-  describe("short flags (-f)", () => {
-    test("parses -f as boolean true", () => {
-      const result = parseArgs(argv("list", "-a"));
-      expect(result.flags.a).toBe(true);
-    });
-
-    test("parses -f value (space separated)", () => {
-      const result = parseArgs(argv("list", "-s", "pending"));
-      expect(result.flags.s).toBe("pending");
-    });
-
-    test("parses multiple short flags", () => {
-      const result = parseArgs(argv("list", "-s", "pending", "-p", "high"));
-      expect(result.flags.s).toBe("pending");
-      expect(result.flags.p).toBe("high");
-    });
-  });
-
-  describe("mixed flags and args", () => {
-    test("boolean flag before command consumes next arg as value", () => {
-      // Note: --all list is parsed as --all=list (list becomes value of all)
-      const result = parseArgs(argv("--all", "list"));
-      expect(result.command).toBe("dashboard"); // default, since 'list' was consumed
-      expect(result.flags.all).toBe("list");
-    });
-
-    test("explicit boolean flag with command works", () => {
-      // Use --all without value by putting flag after command
-      const result = parseArgs(argv("list", "--all"));
-      expect(result.command).toBe("list");
-      expect(result.flags.all).toBe(true);
-    });
-
-    test("flags after args are parsed correctly", () => {
-      const result = parseArgs(argv("list", "proj_123", "--all"));
-      expect(result.command).toBe("list");
-      expect(result.args).toEqual(["proj_123"]);
-      expect(result.flags.all).toBe(true);
-    });
-
-    test("complex mixed parsing", () => {
-      const result = parseArgs(argv(
-        "dashboard",
-        "proj_abc",
-        "--status=pending",
-        "-v",
-        "--priority", "high"
-      ));
-      expect(result.command).toBe("dashboard");
-      expect(result.args).toEqual(["proj_abc"]);
-      expect(result.flags.status).toBe("pending");
-      expect(result.flags.v).toBe(true);
-      expect(result.flags.priority).toBe("high");
-    });
-  });
-
-  describe("edge cases", () => {
-    test("handles empty argv (just bun and script)", () => {
-      const result = parseArgs(["bun", "script.ts"]);
-      expect(result.command).toBe("dashboard");
-      expect(result.args).toEqual([]);
-      expect(result.flags).toEqual({});
-    });
-
-    test("handles flag with empty value via =", () => {
-      const result = parseArgs(argv("list", "--status="));
-      expect(result.flags.status).toBe("");
-    });
-
-    test("handles help and version flags", () => {
-      expect(parseArgs(argv("--help")).command).toBe("dashboard");
-      expect(parseArgs(argv("--help")).flags.help).toBe(true);
-      expect(parseArgs(argv("-h")).flags.h).toBe(true);
-      expect(parseArgs(argv("--version")).flags.version).toBe(true);
-      expect(parseArgs(argv("-v")).flags.v).toBe(true);
-    });
-  });
-});