@bdsqqq/lnr-cli 1.1.1 → 1.2.0

package/src/router/issues.ts

@@ -0,0 +1,558 @@
+import { z } from "zod";
+import chalk from "chalk";
+import {
+  getClient,
+  listIssues,
+  getIssue,
+  createIssue,
+  updateIssue,
+  addComment,
+  priorityFromString,
+  getTeamStates,
+  getTeamLabels,
+  findTeamByKeyOrName,
+  getAvailableTeamKeys,
+  getIssueComments,
+  updateComment,
+  replyToComment,
+  deleteComment,
+  archiveIssue,
+  getSubIssues,
+  createReaction,
+  deleteReaction,
+  createIssueRelation,
+  type Issue,
+  type ListIssuesFilter,
+  type Comment,
+} from "@bdsqqq/lnr-core";
+import { router, procedure } from "./trpc";
+import { handleApiError, exitWithError, EXIT_CODES } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  formatDate,
+  formatPriority,
+  truncate,
+  outputCommentThreads,
+  type TableColumn,
+} from "../lib/output";
+
+const listIssuesInput = z.object({
+  team: z.string().optional().describe("filter by team key"),
+  state: z.string().optional().describe("filter by workflow state name"),
+  assignee: z.string().optional().describe("filter by assignee email or @me"),
+  label: z.string().optional().describe("filter by label name"),
+  project: z.string().optional().describe("filter by project name"),
+  json: z.boolean().optional().describe("output as json"),
+  quiet: z.boolean().optional().describe("output ids only"),
+  verbose: z.boolean().optional().describe("show all columns"),
+});
+
+const issueInput = z.object({
+  idOrNew: z.string().meta({ positional: true }).describe("issue identifier (e.g. ENG-123) or 'new'"),
+  json: z.boolean().optional().describe("output as json"),
+  open: z.boolean().optional().describe("open issue in browser"),
+  state: z.string().optional().describe("set workflow state"),
+  assignee: z.string().optional().describe("set assignee by email or @me"),
+  priority: z.string().optional().describe("set priority (urgent, high, medium, low, none)"),
+  label: z.string().optional().describe("set label (+name to add, -name to remove)"),
+  comment: z.string().optional().describe("add comment to issue"),
+  blocks: z.string().optional().describe("add blocks relation to issue"),
+  blockedBy: z.string().optional().describe("add blocked-by relation to issue"),
+  relatesTo: z.string().optional().describe("add relates-to relation to issue"),
+  team: z.string().optional().describe("team key (required for new)"),
+  title: z.string().optional().describe("issue title (required for new)"),
+  description: z.string().optional().describe("issue description"),
+  comments: z.boolean().optional().describe("list comments on issue"),
+  editComment: z.string().optional().describe("comment id to edit (requires --text)"),
+  text: z.string().optional().describe("text for --edit-comment or --reply-to"),
+  replyTo: z.string().optional().describe("comment id to reply to (requires --text)"),
+  deleteComment: z.string().optional().describe("comment id to delete"),
+  archive: z.boolean().optional().describe("archive the issue"),
+  react: z.string().optional().describe("comment id to add reaction (requires --emoji)"),
+  emoji: z.string().optional().describe("emoji for --react"),
+  unreact: z.string().optional().describe("reaction id to remove"),
+  parent: z.string().optional().describe("set parent issue identifier"),
+  subIssues: z.boolean().optional().describe("list sub-issues"),
+});
+
+type IssueInput = z.infer<typeof issueInput>;
+
+const issueColumns: TableColumn<Issue>[] = [
+  { header: "ID", value: (i) => i.identifier, width: 10 },
+  { header: "STATE", value: (i) => i.state ?? "-", width: 15 },
+  { header: "TITLE", value: (i) => truncate(i.title, 50), width: 50 },
+  { header: "ASSIGNEE", value: (i) => i.assignee ?? "-", width: 15 },
+  { header: "PRIORITY", value: (i) => formatPriority(i.priority), width: 8 },
+];
+
+const commentColumns: TableColumn<Comment>[] = [
+  { header: "ID", value: (c) => c.id.slice(0, 8), width: 10 },
+  { header: "USER", value: (c) => c.user ?? "-", width: 15 },
+  { header: "BODY", value: (c) => truncate(c.body, 50), width: 50 },
+  { header: "CREATED", value: (c) => formatDate(c.createdAt), width: 12 },
+];
+
+async function handleListIssues(input: z.infer<typeof listIssuesInput>): Promise<void> {
+  try {
+    const client = getClient();
+    const filter: ListIssuesFilter = {
+      team: input.team,
+      state: input.state,
+      assignee: input.assignee,
+      label: input.label,
+      project: input.project,
+    };
+
+    const issues = await listIssues(client, filter);
+    const format = input.json ? "json" : input.quiet ? "quiet" : getOutputFormat({});
+
+    if (format === "json") {
+      outputJson(issues);
+      return;
+    }
+
+    if (format === "quiet") {
+      outputQuiet(issues.map((i) => i.identifier));
+      return;
+    }
+
+    outputTable(issues, issueColumns, { verbose: input.verbose });
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+async function handleShowIssue(
+  identifier: string,
+  input: IssueInput
+): Promise<void> {
+  try {
+    const client = getClient();
+    const issue = await getIssue(client, identifier);
+
+    if (!issue) {
+      exitWithError(`issue ${identifier} not found`, undefined, EXIT_CODES.NOT_FOUND);
+    }
+
+    if (input.open) {
+      const { spawn } = await import("child_process");
+      const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      spawn(cmd, [issue.url], { detached: true, stdio: "ignore" }).unref();
+      console.log(`opened ${issue.url}`);
+      return;
+    }
+
+    if (input.comments) {
+      const { comments, error } = await getIssueComments(client, issue.id);
+      if (error) {
+        console.error(`failed to fetch comments: ${error}`);
+        return;
+      }
+      const format = input.json ? "json" : getOutputFormat({});
+      if (format === "json") {
+        outputJson(comments);
+      } else {
+        outputTable(comments, commentColumns);
+      }
+      return;
+    }
+
+    if (input.subIssues) {
+      const subIssues = await getSubIssues(client, issue.id);
+      const format = input.json ? "json" : getOutputFormat({});
+      if (format === "json") {
+        outputJson(subIssues);
+      } else {
+        outputTable(subIssues, issueColumns);
+      }
+      return;
+    }
+
+    const format = input.json ? "json" : getOutputFormat({});
+    const { comments, error: commentsError } = await getIssueComments(client, issue.id);
+
+    if (format === "json") {
+      outputJson({
+        ...issue,
+        priority: formatPriority(issue.priority),
+        createdAt: formatDate(issue.createdAt),
+        updatedAt: formatDate(issue.updatedAt),
+        comments,
+      });
+      return;
+    }
+
+    console.log(`${issue.identifier}: ${issue.title}`);
+    console.log();
+    console.log(`state:    ${issue.state ?? "-"}`);
+    console.log(`assignee: ${issue.assignee ?? "-"}`);
+    console.log(`priority: ${formatPriority(issue.priority)}`);
+    if (issue.parentId) {
+      console.log(`parent:   ${issue.parentId}`);
+    }
+    console.log(`created:  ${formatDate(issue.createdAt)}`);
+    console.log(`updated:  ${formatDate(issue.updatedAt)}`);
+    console.log(`url:      ${issue.url}`);
+
+    if (issue.description) {
+      console.log();
+      console.log(issue.description);
+    }
+
+    if (commentsError) {
+      console.log();
+      console.log(chalk.dim(`comments: failed to load (${commentsError})`));
+    } else if (comments.length > 0) {
+      console.log();
+      console.log("─".repeat(40));
+      console.log();
+      outputCommentThreads(comments);
+    }
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+async function handleUpdateIssue(
+  identifier: string,
+  input: IssueInput
+): Promise<void> {
+  try {
+    const client = getClient();
+    const issue = await getIssue(client, identifier);
+
+    if (!issue) {
+      exitWithError(`issue ${identifier} not found`, undefined, EXIT_CODES.NOT_FOUND);
+    }
+
+    if (input.comment) {
+      await addComment(client, issue.id, input.comment);
+      console.log(`commented on ${identifier}`);
+      return;
+    }
+
+    if (input.editComment) {
+      if (!input.text) {
+        exitWithError("--text is required with --edit-comment");
+      }
+      await updateComment(client, input.editComment, input.text);
+      console.log(`updated comment ${input.editComment.slice(0, 8)}`);
+      return;
+    }
+
+    if (input.replyTo) {
+      if (!input.text) {
+        exitWithError("--text is required with --reply-to");
+      }
+      await replyToComment(client, issue.id, input.replyTo, input.text);
+      console.log(`replied to comment ${input.replyTo.slice(0, 8)}`);
+      return;
+    }
+
+    if (input.deleteComment) {
+      await deleteComment(client, input.deleteComment);
+      console.log(`deleted comment ${input.deleteComment.slice(0, 8)}`);
+      return;
+    }
+
+    if (input.archive) {
+      await archiveIssue(client, issue.id);
+      console.log(`archived ${identifier}`);
+      return;
+    }
+
+    if (input.react) {
+      if (!input.emoji) {
+        exitWithError("--emoji is required with --react");
+      }
+      const success = await createReaction(client, input.react, input.emoji);
+      if (!success) {
+        exitWithError(`failed to add reaction to comment ${input.react.slice(0, 8)}`);
+      }
+      console.log(`added reaction ${input.emoji} to comment ${input.react.slice(0, 8)}`);
+      return;
+    }
+
+    if (input.unreact) {
+      const success = await deleteReaction(client, input.unreact);
+      if (!success) {
+        exitWithError(`reaction ${input.unreact.slice(0, 8)} not found`, undefined, EXIT_CODES.NOT_FOUND);
+      }
+      console.log(`removed reaction ${input.unreact.slice(0, 8)}`);
+      return;
+    }
+
+    const updatePayload: Record<string, unknown> = {};
+
+    if (input.state) {
+      const rawIssue = await (
+        client as unknown as {
+          issue: (id: string) => Promise<{ team?: { id: string } | null } | null>;
+        }
+      ).issue(identifier);
+      const teamRef =
+        rawIssue && "team" in rawIssue
+          ? await (rawIssue as unknown as { team: Promise<{ id: string } | null> }).team
+          : null;
+      if (!teamRef) {
+        exitWithError("could not determine team for issue");
+      }
+      const states = await getTeamStates(client, teamRef.id);
+      const targetState = states.find(
+        (s) => s.name.toLowerCase() === input.state!.toLowerCase()
+      );
+      if (!targetState) {
+        const available = states.map((s) => s.name).join(", ");
+        exitWithError(`state "${input.state}" not found`, `available states: ${available}`);
+      }
+      updatePayload.stateId = targetState.id;
+    }
+
+    if (input.assignee) {
+      if (input.assignee === "@me") {
+        const viewer = await client.viewer;
+        updatePayload.assigneeId = viewer.id;
+      } else {
+        const users = await client.users({ filter: { email: { eq: input.assignee } } });
+        const user = users.nodes[0];
+        if (!user) {
+          exitWithError(`user "${input.assignee}" not found`);
+        }
+        updatePayload.assigneeId = user.id;
+      }
+    }
+
+    if (input.priority) {
+      updatePayload.priority = priorityFromString(input.priority);
+    }
+
+    if (input.label) {
+      const isAdd = input.label.startsWith("+");
+      const isRemove = input.label.startsWith("-");
+      const labelName = isAdd || isRemove ? input.label.slice(1) : input.label;
+
+      const rawIssue = await (
+        client as unknown as {
+          issue: (
+            id: string
+          ) => Promise<{
+            team?: { id: string } | null;
+            labels: () => Promise<{ nodes: { id: string }[] }>;
+          } | null>;
+        }
+      ).issue(identifier);
+      const teamRef =
+        rawIssue && "team" in rawIssue
+          ? await (rawIssue as unknown as { team: Promise<{ id: string } | null> }).team
+          : null;
+      if (!teamRef) {
+        exitWithError("could not determine team for issue");
+      }
+
+      const labels = await getTeamLabels(client, teamRef.id);
+      const targetLabel = labels.find(
+        (l) => l.name.toLowerCase() === labelName.toLowerCase()
+      );
+      if (!targetLabel) {
+        const available = labels.map((l) => l.name).join(", ");
+        exitWithError(`label "${labelName}" not found`, `available labels: ${available}`);
+      }
+
+      const currentLabelsData = rawIssue ? await rawIssue.labels() : { nodes: [] };
+      const currentLabelIds = currentLabelsData.nodes.map((l) => l.id);
+
+      if (isRemove) {
+        updatePayload.labelIds = currentLabelIds.filter((id) => id !== targetLabel.id);
+      } else {
+        if (!currentLabelIds.includes(targetLabel.id)) {
+          updatePayload.labelIds = [...currentLabelIds, targetLabel.id];
+        }
+      }
+    }
+
+    if (input.parent) {
+      const parentIssue = await getIssue(client, input.parent);
+      if (!parentIssue) {
+        exitWithError(`parent issue "${input.parent}" not found`);
+      }
+      updatePayload.parentId = parentIssue.id;
+    }
+
+    if (Object.keys(updatePayload).length > 0) {
+      await updateIssue(client, issue.id, updatePayload);
+      console.log(`updated ${identifier}`);
+    }
+
+    if (input.blocks) {
+      const blockedIssue = await getIssue(client, input.blocks);
+      if (!blockedIssue) {
+        exitWithError(`issue "${input.blocks}" not found`);
+      }
+      const success = await createIssueRelation(client, issue.id, blockedIssue.id, "blocks");
+      if (!success) {
+        exitWithError(`failed to create blocks relation`);
+      }
+      console.log(`${identifier} now blocks ${input.blocks}`);
+    }
+
+    if (input.blockedBy) {
+      const blockerIssue = await getIssue(client, input.blockedBy);
+      if (!blockerIssue) {
+        exitWithError(`issue "${input.blockedBy}" not found`);
+      }
+      const success = await createIssueRelation(client, blockerIssue.id, issue.id, "blocks");
+      if (!success) {
+        exitWithError(`failed to create blocked-by relation`);
+      }
+      console.log(`${identifier} is now blocked by ${input.blockedBy}`);
+    }
+
+    if (input.relatesTo) {
+      const relatedIssue = await getIssue(client, input.relatesTo);
+      if (!relatedIssue) {
+        exitWithError(`issue "${input.relatesTo}" not found`);
+      }
+      const success = await createIssueRelation(client, issue.id, relatedIssue.id, "related");
+      if (!success) {
+        exitWithError(`failed to create relates-to relation`);
+      }
+      console.log(`${identifier} now relates to ${input.relatesTo}`);
+    }
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+async function handleCreateIssue(input: IssueInput): Promise<void> {
+  if (!input.team) {
+    exitWithError("--team is required", 'usage: lnr issue new --team ENG --title "..."');
+  }
+
+  if (!input.title) {
+    exitWithError("--title is required", 'usage: lnr issue new --team ENG --title "..."');
+  }
+
+  try {
+    const client = getClient();
+    const team = await findTeamByKeyOrName(client, input.team);
+
+    if (!team) {
+      const available = (await getAvailableTeamKeys(client)).join(", ");
+      exitWithError(`team "${input.team}" not found`, `available teams: ${available}`);
+    }
+
+    const createPayload: {
+      teamId: string;
+      title: string;
+      description?: string;
+      assigneeId?: string;
+      priority?: number;
+      labelIds?: string[];
+      parentId?: string;
+    } = {
+      teamId: team.id,
+      title: input.title,
+    };
+
+    if (input.description) {
+      createPayload.description = input.description;
+    }
+
+    if (input.assignee) {
+      if (input.assignee === "@me") {
+        const viewer = await client.viewer;
+        createPayload.assigneeId = viewer.id;
+      } else {
+        const users = await client.users({ filter: { email: { eq: input.assignee } } });
+        const user = users.nodes[0];
+        if (!user) {
+          exitWithError(`user "${input.assignee}" not found`);
+        }
+        createPayload.assigneeId = user.id;
+      }
+    }
+
+    if (input.priority) {
+      createPayload.priority = priorityFromString(input.priority);
+    }
+
+    if (input.label) {
+      const labels = await getTeamLabels(client, team.id);
+      const targetLabel = labels.find(
+        (l) => l.name.toLowerCase() === input.label!.toLowerCase()
+      );
+      if (!targetLabel) {
+        const available = labels.map((l) => l.name).join(", ");
+        exitWithError(`label "${input.label}" not found`, `available labels: ${available}`);
+      }
+      createPayload.labelIds = [targetLabel.id];
+    }
+
+    if (input.parent) {
+      const parentIssue = await getIssue(client, input.parent);
+      if (!parentIssue) {
+        exitWithError(`parent issue "${input.parent}" not found`);
+      }
+      createPayload.parentId = parentIssue.id;
+    }
+
+    const issue = await createIssue(client, createPayload);
+    if (issue) {
+      console.log(`created ${issue.identifier}: ${issue.title}`);
+    } else {
+      console.log("created issue");
+    }
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+export const issuesRouter = router({
+  issues: procedure
+    .meta({
+      description: "list issues",
+      aliases: { command: ["i"] },
+    })
+    .input(listIssuesInput)
+    .query(async ({ input }) => {
+      await handleListIssues(input);
+    }),
+
+  issue: procedure
+    .meta({
+      description: "show or update an issue, or create with 'new'",
+    })
+    .input(issueInput)
+    .mutation(async ({ input }) => {
+      if (input.idOrNew === "new") {
+        await handleCreateIssue(input);
+        return;
+      }
+
+      const hasUpdate =
+        input.state ||
+        input.assignee ||
+        input.priority ||
+        input.label ||
+        input.comment ||
+        input.editComment ||
+        input.replyTo ||
+        input.deleteComment ||
+        input.archive ||
+        input.react ||
+        input.unreact ||
+        input.parent ||
+        input.blocks ||
+        input.blockedBy ||
+        input.relatesTo;
+
+      if (hasUpdate) {
+        await handleUpdateIssue(input.idOrNew, input);
+      } else {
+        await handleShowIssue(input.idOrNew, input);
+      }
+    }),
+});