@aaronshaf/plane 0.1.2

package/tests/cycles-extended.test.ts

@@ -0,0 +1,183 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test"
+import { Effect } from "effect"
+import { http, HttpResponse } from "msw"
+import { setupServer } from "msw/node"
+import { _clearProjectCache } from "@/resolve"
+
+const BASE = "http://cycles-ext-test.local"
+const WS = "testws"
+
+const PROJECTS = [{ id: "proj-acme", identifier: "ACME", name: "Acme Project" }]
+const ISSUES = [{ id: "i1", sequence_id: 29, name: "Migrate Button", priority: "high", state: "s1" }]
+const CYCLES = [
+  { id: "cyc1", name: "Sprint 1", status: "started", start_date: "2025-01-01", end_date: "2025-01-14" },
+  { id: "cyc2", name: "Sprint 2", status: "backlog" },
+]
+const CYCLE_ISSUES = [
+  { id: "ci1", issue: "i1", issue_detail: { id: "i1", sequence_id: 29, name: "Migrate Button" } },
+]
+
+const server = setupServer(
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+    HttpResponse.json({ results: PROJECTS }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/`, () =>
+    HttpResponse.json({ results: ISSUES }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/cycles/`, () =>
+    HttpResponse.json({ results: CYCLES }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/cycles/cyc1/cycle-issues/`, () =>
+    HttpResponse.json({ results: CYCLE_ISSUES }),
+  ),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }))
+afterAll(() => server.close())
+
+beforeEach(() => {
+  _clearProjectCache()
+  process.env["PLANE_HOST"] = BASE
+  process.env["PLANE_WORKSPACE"] = WS
+  process.env["PLANE_API_TOKEN"] = "test-token"
+})
+
+afterEach(() => {
+  server.resetHandlers()
+  delete process.env["PLANE_HOST"]
+  delete process.env["PLANE_WORKSPACE"]
+  delete process.env["PLANE_API_TOKEN"]
+})
+
+describe("cyclesList", () => {
+  it("lists cycles with status and dates", async () => {
+    const { cyclesList } = await import("@/commands/cycles")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((cyclesList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+    const output = logs.join("\n")
+    expect(output).toContain("cyc1")
+    expect(output).toContain("Sprint 1")
+    expect(output).toContain("started")
+    expect(output).toContain("2025-01-01")
+  })
+
+  it("shows em-dash for missing dates", async () => {
+    const { cyclesList } = await import("@/commands/cycles")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((cyclesList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+    expect(logs.join("\n")).toContain("—")
+  })
+
+  it("shows 'No cycles found' when empty", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/cycles/`, () =>
+        HttpResponse.json({ results: [] }),
+      ),
+    )
+    const { cyclesList } = await import("@/commands/cycles")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((cyclesList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+    expect(logs.join("\n")).toBe("No cycles found")
+  })
+})
+
+describe("cycleIssuesList", () => {
+  it("lists issues in a cycle", async () => {
+    const { cycleIssuesList } = await import("@/commands/cycles")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((cycleIssuesList as any).handler({ project: "ACME", cycleId: "cyc1" }))
+    } finally {
+      console.log = orig
+    }
+    const output = logs.join("\n")
+    expect(output).toContain("ACME-")
+    expect(output).toContain("29")
+    expect(output).toContain("Migrate Button")
+  })
+
+  it("falls back to issue UUID without detail", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/cycles/cyc1/cycle-issues/`, () =>
+        HttpResponse.json({ results: [{ id: "ci2", issue: "bare-uuid" }] }),
+      ),
+    )
+    const { cycleIssuesList } = await import("@/commands/cycles")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((cycleIssuesList as any).handler({ project: "ACME", cycleId: "cyc1" }))
+    } finally {
+      console.log = orig
+    }
+    expect(logs.join("\n")).toContain("bare-uuid")
+  })
+
+  it("shows 'No issues in cycle' when empty", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/cycles/cyc1/cycle-issues/`, () =>
+        HttpResponse.json({ results: [] }),
+      ),
+    )
+    const { cycleIssuesList } = await import("@/commands/cycles")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((cycleIssuesList as any).handler({ project: "ACME", cycleId: "cyc1" }))
+    } finally {
+      console.log = orig
+    }
+    expect(logs.join("\n")).toBe("No issues in cycle")
+  })
+})
+
+describe("cycleIssuesAdd", () => {
+  it("adds an issue to a cycle", async () => {
+    let postedBody: unknown
+    server.use(
+      http.post(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/cycles/cyc1/cycle-issues/`,
+        async ({ request }) => {
+          postedBody = await request.json()
+          return HttpResponse.json({ issues: ["i1"] }, { status: 201 })
+        },
+      ),
+    )
+    const { cycleIssuesAdd } = await import("@/commands/cycles")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise(
+        (cycleIssuesAdd as any).handler({ project: "ACME", cycleId: "cyc1", ref: "ACME-29" }),
+      )
+    } finally {
+      console.log = orig
+    }
+    expect((postedBody as any).issues).toContain("i1")
+    expect(logs.join("\n")).toContain("ACME-29")
+    expect(logs.join("\n")).toContain("cyc1")
+  })
+})

package/tests/format.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "bun:test"
+import { formatIssue } from "@/format"
+import type { Issue } from "@/config"
+
+const stateObj = { id: "s1", name: "In Progress", group: "started" }
+
+function makeIssue(overrides: Partial<Issue> = {}): Issue {
+  return {
+    id: "abc",
+    sequence_id: 7,
+    name: "Do the thing",
+    priority: "medium",
+    state: stateObj,
+    ...overrides,
+  }
+}
+
+describe("formatIssue", () => {
+  it("formats a basic issue with object state", () => {
+    const result = formatIssue(makeIssue(), "ACME")
+    expect(result).toContain("ACME-  7")
+    expect(result).toContain("[started   ]")
+    expect(result).toContain("In Progress")
+    expect(result).toContain("Do the thing")
+  })
+
+  it("shows ? for state name and group when state is a string", () => {
+    const result = formatIssue(makeIssue({ state: "some-uuid" }), "WEB")
+    expect(result).toContain("[?")
+    expect(result).toContain("?")
+  })
+
+  it("pads sequence_id to 3 characters", () => {
+    const result = formatIssue(makeIssue({ sequence_id: 1 }), "OPS")
+    expect(result).toContain("OPS-  1")
+  })
+
+  it("uses the provided project key", () => {
+    const result = formatIssue(makeIssue(), "XYZ")
+    expect(result).toStartWith("XYZ-")
+  })
+
+  it("includes issue name", () => {
+    const result = formatIssue(makeIssue({ name: "Fix everything" }), "ACME")
+    expect(result).toContain("Fix everything")
+  })
+
+  it("pads state group to 10 characters", () => {
+    const shortState = { id: "s2", name: "Todo", group: "todo" }
+    const result = formatIssue(makeIssue({ state: shortState }), "ACME")
+    // group "todo" padded to 10: "todo      "
+    expect(result).toContain("[todo      ]")
+  })
+
+  it("pads state name to 12 characters", () => {
+    const result = formatIssue(makeIssue({ state: stateObj }), "ACME")
+    // "In Progress " padded to 12
+    expect(result).toContain("In Progress ")
+  })
+})

package/tests/helpers/mock-api.ts

@@ -0,0 +1,27 @@
+import { http, HttpResponse } from "msw"
+import { setupServer } from "msw/node"
+
+export const BASE = "http://localhost:3737"
+export const WORKSPACE = "testws"
+
+export function makeServer(...handlers: Parameters<typeof setupServer>[0][]) {
+  return setupServer(...handlers)
+}
+
+export function issuesHandler(projectId: string, issues: unknown[]) {
+  return http.get(`${BASE}/api/v1/workspaces/${WORKSPACE}/projects/${projectId}/issues/`, () =>
+    HttpResponse.json({ results: issues, next_page_results: false }),
+  )
+}
+
+export function statesHandler(projectId: string, states: unknown[]) {
+  return http.get(`${BASE}/api/v1/workspaces/${WORKSPACE}/projects/${projectId}/states/`, () =>
+    HttpResponse.json({ results: states }),
+  )
+}
+
+export function projectsHandler(projects: unknown[]) {
+  return http.get(`${BASE}/api/v1/workspaces/${WORKSPACE}/projects/`, () =>
+    HttpResponse.json({ results: projects }),
+  )
+}

package/tests/intake.test.ts

@@ -0,0 +1,157 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test"
+import { Effect } from "effect"
+import { http, HttpResponse } from "msw"
+import { setupServer } from "msw/node"
+import { _clearProjectCache } from "@/resolve"
+
+const BASE = "http://intake-test.local"
+const WS = "testws"
+
+const PROJECTS = [{ id: "proj-acme", identifier: "ACME", name: "Acme Project" }]
+const INTAKE_ISSUES = [
+  {
+    id: "int1",
+    issue_detail: { id: "i1", sequence_id: 5, name: "Bug report", priority: "high" },
+    status: 0,
+    created_at: "2025-01-15T10:00:00Z",
+  },
+  {
+    id: "int2",
+    issue_detail: { id: "i2", sequence_id: 6, name: "Feature request", priority: "low" },
+    status: 1,
+    created_at: "2025-01-14T10:00:00Z",
+  },
+  {
+    id: "int3",
+    created_at: "2025-01-13T10:00:00Z",
+  },
+]
+
+const server = setupServer(
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+    HttpResponse.json({ results: PROJECTS }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/intake-issues/`, () =>
+    HttpResponse.json({ results: INTAKE_ISSUES }),
+  ),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }))
+afterAll(() => server.close())
+
+beforeEach(() => {
+  _clearProjectCache()
+  process.env["PLANE_HOST"] = BASE
+  process.env["PLANE_WORKSPACE"] = WS
+  process.env["PLANE_API_TOKEN"] = "test-token"
+})
+
+afterEach(() => {
+  server.resetHandlers()
+  delete process.env["PLANE_HOST"]
+  delete process.env["PLANE_WORKSPACE"]
+  delete process.env["PLANE_API_TOKEN"]
+})
+
+describe("intakeList", () => {
+  it("lists intake issues with status labels", async () => {
+    const { intakeList } = await import("@/commands/intake")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((intakeList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+    const output = logs.join("\n")
+    expect(output).toContain("int1")
+    expect(output).toContain("pending")
+    expect(output).toContain("Bug report")
+    expect(output).toContain("int2")
+    expect(output).toContain("accepted")
+  })
+
+  it("shows 'No intake issues' when empty", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/intake-issues/`, () =>
+        HttpResponse.json({ results: [] }),
+      ),
+    )
+    const { intakeList } = await import("@/commands/intake")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((intakeList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+    expect(logs.join("\n")).toBe("No intake issues")
+  })
+
+  it("handles intake issue without issue_detail", async () => {
+    const { intakeList } = await import("@/commands/intake")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((intakeList as any).handler({ project: "ACME" }))
+    } finally {
+      console.log = orig
+    }
+    expect(logs.join("\n")).toContain("int3")
+  })
+})
+
+describe("intakeAccept", () => {
+  it("accepts an intake issue", async () => {
+    let patchedBody: unknown
+    server.use(
+      http.patch(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/intake-issues/int1/`,
+        async ({ request }) => {
+          patchedBody = await request.json()
+          return HttpResponse.json({ id: "int1", status: 1, created_at: "2025-01-15T10:00:00Z" })
+        },
+      ),
+    )
+    const { intakeAccept } = await import("@/commands/intake")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((intakeAccept as any).handler({ project: "ACME", intakeId: "int1" }))
+    } finally {
+      console.log = orig
+    }
+    expect((patchedBody as any).status).toBe(1)
+    expect(logs.join("\n")).toContain("accepted")
+  })
+})
+
+describe("intakeReject", () => {
+  it("rejects an intake issue", async () => {
+    let patchedBody: unknown
+    server.use(
+      http.patch(
+        `${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/intake-issues/int1/`,
+        async ({ request }) => {
+          patchedBody = await request.json()
+          return HttpResponse.json({ id: "int1", status: -2, created_at: "2025-01-15T10:00:00Z" })
+        },
+      ),
+    )
+    const { intakeReject } = await import("@/commands/intake")
+    const logs: string[] = []
+    const orig = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+    try {
+      await Effect.runPromise((intakeReject as any).handler({ project: "ACME", intakeId: "int1" }))
+    } finally {
+      console.log = orig
+    }
+    expect((patchedBody as any).status).toBe(-2)
+    expect(logs.join("\n")).toContain("rejected")
+  })
+})

package/tests/issue-activity.test.ts

@@ -0,0 +1,167 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, mock } from "bun:test"
+import { Effect } from "effect"
+import { http, HttpResponse } from "msw"
+import { setupServer } from "msw/node"
+import { _clearProjectCache } from "@/resolve"
+
+const BASE = "http://act-test.local"
+const WS = "testws"
+
+const PROJECTS = [{ id: "proj-acme", identifier: "ACME", name: "Acme Project" }]
+const ISSUES = [{ id: "i1", sequence_id: 29, name: "Migrate Button", priority: "high", state: "s1" }]
+const ACTIVITIES = [
+  {
+    id: "act1",
+    actor_detail: { display_name: "Aaron" },
+    field: "state",
+    old_value: "Backlog",
+    new_value: "In Progress",
+    verb: "updated",
+    created_at: "2025-01-15T10:30:00Z",
+  },
+  {
+    id: "act2",
+    actor_detail: { display_name: "Bea" },
+    field: null,
+    old_value: null,
+    new_value: null,
+    verb: "created",
+    created_at: "2025-01-14T08:00:00Z",
+  },
+]
+
+const server = setupServer(
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
+    HttpResponse.json({ results: PROJECTS }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/`, () =>
+    HttpResponse.json({ results: ISSUES }),
+  ),
+  http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/i1/activities/`, () =>
+    HttpResponse.json({ results: ACTIVITIES }),
+  ),
+)
+
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }))
+afterAll(() => server.close())
+
+beforeEach(() => {
+  _clearProjectCache()
+  process.env["PLANE_HOST"] = BASE
+  process.env["PLANE_WORKSPACE"] = WS
+  process.env["PLANE_API_TOKEN"] = "test-token"
+})
+
+afterEach(() => {
+  server.resetHandlers()
+  delete process.env["PLANE_HOST"]
+  delete process.env["PLANE_WORKSPACE"]
+  delete process.env["PLANE_API_TOKEN"]
+})
+
+describe("issueActivity command handler", () => {
+  it("fetches and formats activity with field changes", async () => {
+    const { issueActivity } = await import("@/commands/issue")
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (issueActivity as any).handler({ ref: "ACME-29" }),
+      )
+    } finally {
+      console.log = originalLog
+    }
+
+    const output = logs.join("\n")
+    expect(output).toContain("Aaron")
+    expect(output).toContain("state")
+    expect(output).toContain("Backlog")
+    expect(output).toContain("In Progress")
+  })
+
+  it("shows 'No activity found' when empty", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/i1/activities/`, () =>
+        HttpResponse.json({ results: [] }),
+      ),
+    )
+
+    const { issueActivity } = await import("@/commands/issue")
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (issueActivity as any).handler({ ref: "ACME-29" }),
+      )
+    } finally {
+      console.log = originalLog
+    }
+
+    expect(logs.join("\n")).toContain("No activity found")
+  })
+
+  it("formats activity without field (verb-only)", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/i1/activities/`, () =>
+        HttpResponse.json({
+          results: [
+            {
+              id: "act3",
+              actor_detail: { display_name: "Bea" },
+              verb: "created",
+              created_at: "2025-01-14T08:00:00Z",
+            },
+          ],
+        }),
+      ),
+    )
+
+    const { issueActivity } = await import("@/commands/issue")
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (issueActivity as any).handler({ ref: "ACME-29" }),
+      )
+    } finally {
+      console.log = originalLog
+    }
+
+    const output = logs.join("\n")
+    expect(output).toContain("Bea")
+    expect(output).toContain("created")
+  })
+
+  it("handles missing actor_detail gracefully", async () => {
+    server.use(
+      http.get(`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/issues/i1/activities/`, () =>
+        HttpResponse.json({
+          results: [{ id: "act4", field: "priority", old_value: "low", new_value: "high", created_at: "2025-01-15T10:30:00Z" }],
+        }),
+      ),
+    )
+
+    const { issueActivity } = await import("@/commands/issue")
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (...args: unknown[]) => logs.push(args.join(" "))
+
+    try {
+      await Effect.runPromise(
+        (issueActivity as any).handler({ ref: "ACME-29" }),
+      )
+    } finally {
+      console.log = originalLog
+    }
+
+    const output = logs.join("\n")
+    expect(output).toContain("priority")
+    expect(output).toContain("?") // fallback for missing actor
+  })
+})