@bdsqqq/lnr-cli 1.6.0 → 2.0.1

package/src/router/index.ts

@@ -2,25 +2,43 @@ import { router } from "./trpc";
 import { authRouter } from "./auth";
 import { configRouter } from "./config";
 import { cyclesRouter } from "./cycles";
-import { docsRouter } from "./docs";
-import { issuesRouter } from "./issues";
-import { labelsRouter } from "./labels";
+import { viewsRouter } from "./views";
+import { generatedDocsRouter } from "../generated/doc";
+import { generatedIssuesRouter } from "../generated/issue";
+import { generatedProjectsRouter } from "../generated/project";
+import { generatedLabelsRouter } from "../generated/label";
+import { generatedTemplatesRouter } from "../generated/template";
 import { meRouter } from "./me";
-import { projectsRouter } from "./projects";
 import { searchRouter } from "./search";
 import { teamsRouter } from "./teams";
+import { usersRouter } from "./users";
+import { notificationsRouter } from "./notifications";
+import { initiativesRouter } from "./initiatives";
+import { roadmapsRouter } from "./roadmaps";
+import { gitAutomationStatesRouter } from "./git-automation-states";
+import { gitAutomationTargetBranchesRouter } from "./git-automation-target-branches";
+import { agentSessionsRouter } from "./agent-sessions";
 
 export const appRouter = router({
   ...authRouter._def.procedures,
   ...configRouter._def.procedures,
   ...cyclesRouter._def.procedures,
-  ...docsRouter._def.procedures,
-  ...issuesRouter._def.procedures,
-  ...labelsRouter._def.procedures,
+  ...viewsRouter._def.procedures,
+  ...generatedDocsRouter._def.procedures,
+  ...generatedIssuesRouter._def.procedures,
+  ...generatedProjectsRouter._def.procedures,
+  ...generatedLabelsRouter._def.procedures,
+  ...generatedTemplatesRouter._def.procedures,
   ...meRouter._def.procedures,
-  ...projectsRouter._def.procedures,
   ...searchRouter._def.procedures,
   ...teamsRouter._def.procedures,
+  ...usersRouter._def.procedures,
+  ...notificationsRouter._def.procedures,
+  ...initiativesRouter._def.procedures,
+  ...roadmapsRouter._def.procedures,
+  ...gitAutomationStatesRouter._def.procedures,
+  ...gitAutomationTargetBranchesRouter._def.procedures,
+  ...agentSessionsRouter._def.procedures,
 });
 
 export type AppRouter = typeof appRouter;

package/src/router/initiatives.ts

@@ -0,0 +1,260 @@
+import "../lib/arktype-config";
+import { type } from "arktype";
+import {
+  getClient,
+  listInitiatives,
+  getInitiative,
+  findInitiativeByName,
+  getInitiativeUpdates,
+  getInitiativeExternalLinks,
+  createReaction,
+  deleteReaction,
+  createSubscription,
+  deleteSubscription,
+  findUserSubscription,
+  type Initiative,
+  type InitiativeUpdate,
+  type EntityExternalLink,
+} from "@bdsqqq/lnr-core";
+import { router, procedure } from "./trpc";
+import { exitWithError, handleApiError, EXIT_CODES } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  type OutputOptions,
+  type TableColumn,
+} from "../lib/output";
+
+export const listInitiativesInput = type({
+  "json?": type("boolean").describe("output as json"),
+  "quiet?": type("boolean").describe("output ids only"),
+  "verbose?": type("boolean").describe("show all columns"),
+});
+
+export const initiativeInput = type({
+  nameOrId: type("string").configure({ positional: true }).describe("initiative name, slugId, or id"),
+  "json?": type("boolean").describe("output as json"),
+  "quiet?": type("boolean").describe("output id only"),
+  "verbose?": type("boolean").describe("show all columns"),
+  "updates?": type("boolean").describe("show initiative updates"),
+  "links?": type("boolean").describe("show initiative external links"),
+  "react?": type("string").describe("initiative update id to add reaction (requires --emoji)"),
+  "emoji?": type("string").describe("emoji for --react"),
+  "unreact?": type("string").describe("reaction id to remove"),
+  "subscribe?": type("boolean").describe("subscribe to initiative notifications"),
+  "unsubscribe?": type("boolean").describe("unsubscribe from initiative notifications"),
+});
+
+const initiativeColumns: TableColumn<Initiative>[] = [
+  { header: "NAME", value: (i) => i.name, width: 32 },
+  { header: "STATUS", value: (i) => i.status, width: 12 },
+  { header: "HEALTH", value: (i) => i.health ?? "-", width: 10 },
+  { header: "TARGET", value: (i) => i.targetDate ?? "-", width: 12 },
+];
+
+const verboseInitiativeColumns: TableColumn<Initiative>[] = [
+  ...initiativeColumns,
+  { header: "SLUG", value: (i) => i.slugId, width: 16 },
+  { header: "ID", value: (i) => i.id, width: 36 },
+];
+
+const updateColumns: TableColumn<InitiativeUpdate>[] = [
+  { header: "DATE", value: (u) => u.createdAt.toISOString().slice(0, 10), width: 12 },
+  { header: "HEALTH", value: (u) => u.health, width: 10 },
+  { header: "AUTHOR", value: (u) => u.userName ?? "-", width: 20 },
+  { header: "CONTENT", value: (u) => u.body.slice(0, 50).replace(/\n/g, " "), width: 52 },
+];
+
+const verboseUpdateColumns: TableColumn<InitiativeUpdate>[] = [
+  ...updateColumns,
+  { header: "ID", value: (u) => u.id, width: 36 },
+];
+
+const linkColumns: TableColumn<EntityExternalLink>[] = [
+  { header: "LABEL", value: (l) => l.label.slice(0, 30), width: 30 },
+  { header: "URL", value: (l) => l.url.slice(0, 50), width: 50 },
+];
+
+const verboseLinkColumns: TableColumn<EntityExternalLink>[] = [
+  ...linkColumns,
+  { header: "ID", value: (l) => l.id, width: 36 },
+  { header: "CREATOR", value: (l) => l.creatorName ?? "-", width: 20 },
+];
+
+export const initiativesRouter = router({
+  initiatives: procedure
+    .meta({ aliases: { command: ["init"] }, description: "list initiatives" })
+    .input(listInitiativesInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+        const initiatives = await listInitiatives(client);
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        if (format === "json") {
+          outputJson(initiatives);
+          return;
+        }
+
+        if (format === "quiet") {
+          outputQuiet(initiatives.map((i) => i.id));
+          return;
+        }
+
+        const columns = input.verbose ? verboseInitiativeColumns : initiativeColumns;
+        outputTable(initiatives, columns, outputOpts);
+      } catch (error) {
+        handleApiError(error, "initiatives");
+      }
+    }),
+
+  initiative: procedure
+    .meta({ description: "show or update initiative" })
+    .input(initiativeInput)
+    .mutation(async ({ input }) => {
+      try {
+        const client = getClient();
+        let initiative = await getInitiative(client, input.nameOrId);
+
+        if (!initiative) {
+          initiative = await findInitiativeByName(client, input.nameOrId);
+        }
+
+        if (!initiative) {
+          exitWithError(
+            `initiative "${input.nameOrId}" not found`,
+            "try: lnr initiatives",
+            EXIT_CODES.NOT_FOUND
+          );
+        }
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        if (input.react) {
+          if (!input.emoji) {
+            exitWithError("--emoji is required when using --react");
+          }
+          const success = await createReaction(client, { type: "initiativeUpdate", id: input.react }, input.emoji);
+          if (!success) {
+            exitWithError(`failed to add reaction to initiative update ${input.react.slice(0, 8)}`);
+          }
+          console.log(`added reaction ${input.emoji} to initiative update ${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;
+        }
+
+        if (input.subscribe) {
+          const subscriptionId = await createSubscription(client, { type: "initiative", initiativeId: initiative.id });
+          console.log(`subscribed to ${initiative.name} (subscription: ${subscriptionId.slice(0, 8)})`);
+          return;
+        }
+
+        if (input.unsubscribe) {
+          const subscriptionId = await findUserSubscription(client, { type: "initiative", initiativeId: initiative.id });
+          if (!subscriptionId) {
+            exitWithError(`no subscription found for ${initiative.name}`, "you may not be subscribed to this initiative");
+          }
+          const success = await deleteSubscription(client, subscriptionId);
+          if (!success) {
+            exitWithError(`failed to remove subscription`, undefined, EXIT_CODES.NOT_FOUND);
+          }
+          console.log(`unsubscribed from ${initiative.name}`);
+          return;
+        }
+
+        if (input.updates) {
+          const updates = await getInitiativeUpdates(client, initiative.id);
+
+          if (format === "json") {
+            outputJson(updates);
+            return;
+          }
+
+          if (format === "quiet") {
+            outputQuiet(updates.map((u) => u.id));
+            return;
+          }
+
+          if (updates.length === 0) {
+            console.log("no updates");
+            return;
+          }
+
+          const columns = input.verbose ? verboseUpdateColumns : updateColumns;
+          outputTable(updates, columns, outputOpts);
+          return;
+        }
+
+        if (input.links) {
+          const links = await getInitiativeExternalLinks(client, initiative.id);
+
+          if (format === "json") {
+            outputJson(links);
+            return;
+          }
+
+          if (format === "quiet") {
+            outputQuiet(links.map((l) => l.id));
+            return;
+          }
+
+          if (links.length === 0) {
+            console.log("no external links");
+            return;
+          }
+
+          const columns = input.verbose ? verboseLinkColumns : linkColumns;
+          outputTable(links, columns, outputOpts);
+          return;
+        }
+
+        if (format === "json") {
+          outputJson(initiative);
+          return;
+        }
+
+        if (format === "quiet") {
+          console.log(initiative.id);
+          return;
+        }
+
+        console.log(`${initiative.name}`);
+        console.log(`status: ${initiative.status}`);
+        if (initiative.health) {
+          console.log(`health: ${initiative.health}`);
+        }
+        if (initiative.description) {
+          console.log(`description: ${initiative.description}`);
+        }
+        if (initiative.targetDate) {
+          console.log(`target: ${initiative.targetDate}`);
+        }
+        console.log(`url: ${initiative.url}`);
+        if (input.verbose) {
+          console.log(`slugId: ${initiative.slugId}`);
+          console.log(`id: ${initiative.id}`);
+        }
+      } catch (error) {
+        handleApiError(error, "initiatives");
+      }
+    }),
+});

package/src/router/me.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import "../lib/arktype-config";
+import { type } from "arktype";
 import {
   getClient,
   getViewer,
@@ -17,12 +18,12 @@ import {
 } from "../lib/output";
 import { handleApiError } from "../lib/error";
 
-const meInput = z.object({
-  issues: z.boolean().optional().describe("list issues assigned to me"),
-  created: z.boolean().optional().describe("list issues created by me"),
-  activity: z.boolean().optional().describe("show recent activity"),
-  json: z.boolean().optional().describe("output as json"),
-  quiet: z.boolean().optional().describe("output ids only"),
+export const meInput = type({
+  "issues?": type("boolean").describe("list issues assigned to me"),
+  "created?": type("boolean").describe("list issues created by me"),
+  "activity?": type("boolean").describe("show recent activity"),
+  "json?": type("boolean").describe("output as json"),
+  "quiet?": type("boolean").describe("output ids only"),
 });
 
 export const meRouter = router({

package/src/router/notifications.ts

@@ -0,0 +1,176 @@
+import "../lib/arktype-config";
+import { type } from "arktype";
+import {
+  getClient,
+  listNotifications,
+  getNotification,
+  markNotificationRead,
+  archiveNotification,
+  type Notification,
+} from "@bdsqqq/lnr-core";
+import { router, procedure } from "./trpc";
+import { exitWithError, handleApiError, EXIT_CODES } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  type OutputOptions,
+  type TableColumn,
+} from "../lib/output";
+
+export const listNotificationsInput = type({
+  "json?": type("boolean").describe("output as json"),
+  "quiet?": type("boolean").describe("output ids only"),
+  "verbose?": type("boolean").describe("show all columns"),
+  "unread?": type("boolean").describe("show unread only"),
+});
+
+export const notificationInput = type({
+  id: type("string").configure({ positional: true }).describe("notification id"),
+  "json?": type("boolean").describe("output as json"),
+  "quiet?": type("boolean").describe("output id only"),
+  "verbose?": type("boolean").describe("show all fields"),
+  "read?": type("boolean").describe("mark as read"),
+  "archive?": type("boolean").describe("archive notification"),
+});
+
+const notificationColumns: TableColumn<Notification>[] = [
+  { header: "TYPE", value: (n) => n.type, width: 20 },
+  { header: "CATEGORY", value: (n) => n.category, width: 16 },
+  { header: "ACTOR", value: (n) => n.actorName ?? "-", width: 20 },
+  { header: "READ", value: (n) => (n.readAt ? "yes" : "no"), width: 6 },
+  {
+    header: "DATE",
+    value: (n) => n.createdAt.toISOString().split("T")[0] ?? "",
+    width: 12,
+  },
+];
+
+const verboseNotificationColumns: TableColumn<Notification>[] = [
+  ...notificationColumns,
+  {
+    header: "SNOOZED",
+    value: (n) =>
+      n.snoozedUntilAt ? n.snoozedUntilAt.toISOString().split("T")[0] ?? "-" : "-",
+    width: 12,
+  },
+  { header: "ID", value: (n) => n.id, width: 36 },
+];
+
+export const notificationsRouter = router({
+  notifications: procedure
+    .meta({ aliases: { command: ["n"] }, description: "list notifications" })
+    .input(listNotificationsInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+        const notifications = await listNotifications(client, {
+          unreadOnly: input.unread,
+        });
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        if (format === "json") {
+          outputJson(notifications);
+          return;
+        }
+
+        if (format === "quiet") {
+          outputQuiet(notifications.map((n) => n.id));
+          return;
+        }
+
+        const columns = input.verbose
+          ? verboseNotificationColumns
+          : notificationColumns;
+        outputTable(notifications, columns, outputOpts);
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+
+  notification: procedure
+    .meta({ description: "show notification details" })
+    .input(notificationInput)
+    .mutation(async ({ input }) => {
+      try {
+        const client = getClient();
+
+        if (input.read) {
+          const success = await markNotificationRead(client, input.id);
+          if (!success) {
+            exitWithError(
+              `failed to mark notification "${input.id}" as read`,
+              "check the notification id",
+              EXIT_CODES.GENERAL_ERROR
+            );
+          }
+          console.log("marked as read");
+          return;
+        }
+
+        if (input.archive) {
+          const success = await archiveNotification(client, input.id);
+          if (!success) {
+            exitWithError(
+              `failed to archive notification "${input.id}"`,
+              "check the notification id",
+              EXIT_CODES.GENERAL_ERROR
+            );
+          }
+          console.log("archived");
+          return;
+        }
+
+        const notification = await getNotification(client, input.id);
+
+        if (!notification) {
+          exitWithError(
+            `notification "${input.id}" not found`,
+            "try: lnr notifications",
+            EXIT_CODES.NOT_FOUND
+          );
+        }
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        if (format === "json") {
+          outputJson(notification);
+          return;
+        }
+
+        if (format === "quiet") {
+          console.log(notification.id);
+          return;
+        }
+
+        console.log(`type: ${notification.type}`);
+        console.log(`category: ${notification.category}`);
+        console.log(`date: ${notification.createdAt.toISOString()}`);
+        console.log(`read: ${notification.readAt ? "yes" : "no"}`);
+        if (notification.actorName) {
+          console.log(`actor: ${notification.actorName}`);
+        }
+        if (notification.snoozedUntilAt) {
+          console.log(`snoozed until: ${notification.snoozedUntilAt.toISOString()}`);
+        }
+        if (input.verbose) {
+          console.log(`id: ${notification.id}`);
+          if (notification.archivedAt) {
+            console.log(`archived: ${notification.archivedAt.toISOString()}`);
+          }
+        }
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+});

package/src/router/roadmaps.ts

@@ -0,0 +1,172 @@
+import "../lib/arktype-config";
+import { type } from "arktype";
+import {
+  getClient,
+  listRoadmaps,
+  getRoadmap,
+  findRoadmapByName,
+  getRoadmapProjects,
+  type Roadmap,
+  type Project,
+} from "@bdsqqq/lnr-core";
+import { router, procedure } from "./trpc";
+import { exitWithError, handleApiError, EXIT_CODES } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  type OutputOptions,
+  type TableColumn,
+} from "../lib/output";
+
+export const listRoadmapsInput = type({
+  "json?": type("boolean").describe("output as json"),
+  "quiet?": type("boolean").describe("output ids only"),
+  "verbose?": type("boolean").describe("show all columns"),
+});
+
+export const roadmapInput = type({
+  nameOrId: type("string").configure({ positional: true }).describe("roadmap name, slugId, or id"),
+  "json?": type("boolean").describe("output as json"),
+  "quiet?": type("boolean").describe("output id only"),
+  "verbose?": type("boolean").describe("show all columns"),
+  "projects?": type("boolean").describe("show roadmap projects"),
+});
+
+const roadmapColumns: TableColumn<Roadmap>[] = [
+  { header: "NAME", value: (r) => r.name, width: 32 },
+  { header: "OWNER", value: (r) => r.ownerName ?? "-", width: 20 },
+  { header: "SLUG", value: (r) => r.slugId, width: 16 },
+];
+
+const verboseRoadmapColumns: TableColumn<Roadmap>[] = [
+  ...roadmapColumns,
+  { header: "COLOR", value: (r) => r.color ?? "-", width: 10 },
+  { header: "ID", value: (r) => r.id, width: 36 },
+];
+
+const projectColumns: TableColumn<Project>[] = [
+  { header: "NAME", value: (p) => p.name, width: 32 },
+  { header: "STATE", value: (p) => p.state ?? "-", width: 12 },
+  { header: "PROGRESS", value: (p) => p.progress != null ? `${Math.round(p.progress * 100)}%` : "-", width: 10 },
+  { header: "TARGET", value: (p) => p.targetDate?.toISOString().slice(0, 10) ?? "-", width: 12 },
+];
+
+const verboseProjectColumns: TableColumn<Project>[] = [
+  ...projectColumns,
+  { header: "START", value: (p) => p.startDate?.toISOString().slice(0, 10) ?? "-", width: 12 },
+  { header: "ID", value: (p) => p.id, width: 36 },
+];
+
+export const roadmapsRouter = router({
+  roadmaps: procedure
+    .meta({ aliases: { command: ["rm"] }, description: "list roadmaps" })
+    .input(listRoadmapsInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+        const roadmaps = await listRoadmaps(client);
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        if (format === "json") {
+          outputJson(roadmaps);
+          return;
+        }
+
+        if (format === "quiet") {
+          outputQuiet(roadmaps.map((r) => r.id));
+          return;
+        }
+
+        const columns = input.verbose ? verboseRoadmapColumns : roadmapColumns;
+        outputTable(roadmaps, columns, outputOpts);
+      } catch (error) {
+        handleApiError(error, "roadmaps");
+      }
+    }),
+
+  roadmap: procedure
+    .meta({ description: "show roadmap details" })
+    .input(roadmapInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+        let roadmap = await getRoadmap(client, input.nameOrId);
+
+        if (!roadmap) {
+          roadmap = await findRoadmapByName(client, input.nameOrId);
+        }
+
+        if (!roadmap) {
+          exitWithError(
+            `roadmap "${input.nameOrId}" not found`,
+            "try: lnr roadmaps",
+            EXIT_CODES.NOT_FOUND
+          );
+        }
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        if (input.projects) {
+          const projects = await getRoadmapProjects(client, roadmap.id);
+
+          if (format === "json") {
+            outputJson(projects);
+            return;
+          }
+
+          if (format === "quiet") {
+            outputQuiet(projects.map((p) => p.id));
+            return;
+          }
+
+          if (projects.length === 0) {
+            console.log("no projects");
+            return;
+          }
+
+          const columns = input.verbose ? verboseProjectColumns : projectColumns;
+          outputTable(projects, columns, outputOpts);
+          return;
+        }
+
+        if (format === "json") {
+          outputJson(roadmap);
+          return;
+        }
+
+        if (format === "quiet") {
+          console.log(roadmap.id);
+          return;
+        }
+
+        console.log(`${roadmap.name}`);
+        if (roadmap.ownerName) {
+          console.log(`owner: ${roadmap.ownerName}`);
+        }
+        if (roadmap.description) {
+          console.log(`description: ${roadmap.description}`);
+        }
+        console.log(`url: ${roadmap.url}`);
+        if (input.verbose) {
+          console.log(`slugId: ${roadmap.slugId}`);
+          if (roadmap.color) {
+            console.log(`color: ${roadmap.color}`);
+          }
+          console.log(`id: ${roadmap.id}`);
+        }
+      } catch (error) {
+        handleApiError(error, "roadmaps");
+      }
+    }),
+});