@bdsqqq/lnr-cli 1.1.1 → 1.2.0

package/src/router/labels.ts

@@ -0,0 +1,192 @@
+import { z } from "zod";
+import {
+  getClient,
+  listLabels,
+  getLabel,
+  createLabel,
+  updateLabel,
+  deleteLabel,
+  findTeamByKeyOrName,
+  getAvailableTeamKeys,
+} from "@bdsqqq/lnr-core";
+import { router, procedure } from "./trpc";
+import { exitWithError, handleApiError, EXIT_CODES } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  truncate,
+  type OutputOptions,
+} from "../lib/output";
+
+const listLabelsInput = z.object({
+  team: z.string().optional().describe("filter by team key"),
+  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 labelInput = z.object({
+  id: z.string().meta({ positional: true }).describe("label id or 'new'"),
+  name: z.string().optional().describe("label name (required for new)"),
+  color: z.string().optional().describe("hex color code"),
+  description: z.string().optional().describe("label description"),
+  team: z.string().optional().describe("team key (required for new)"),
+  delete: z.boolean().optional().describe("delete the label"),
+  json: z.boolean().optional().describe("output as json"),
+});
+
+export const labelsRouter = router({
+  labels: procedure
+    .meta({
+      description: "list labels",
+    })
+    .input(listLabelsInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        let teamId: string | undefined;
+        if (input.team) {
+          const team = await findTeamByKeyOrName(client, input.team);
+          if (!team) {
+            const available = await getAvailableTeamKeys(client);
+            exitWithError(
+              `team not found: ${input.team}`,
+              `available teams: ${available.join(", ")}`,
+              EXIT_CODES.NOT_FOUND
+            );
+          }
+          teamId = team.id;
+        }
+
+        const labels = await listLabels(client, teamId);
+
+        if (format === "json") {
+          outputJson(labels);
+          return;
+        }
+
+        if (format === "quiet") {
+          outputQuiet(labels.map((l) => l.id));
+          return;
+        }
+
+        outputTable(
+          labels,
+          [
+            { header: "ID", value: (l) => l.id.slice(0, 8), width: 10 },
+            { header: "NAME", value: (l) => truncate(l.name, 30), width: 30 },
+            { header: "COLOR", value: (l) => l.color ?? "-", width: 10 },
+            { header: "DESCRIPTION", value: (l) => truncate(l.description ?? "-", 40), width: 40 },
+          ],
+          outputOpts
+        );
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+
+  label: procedure
+    .meta({
+      description: "show label details, create with 'new', update, or delete with --delete",
+    })
+    .input(labelInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+
+        if (input.id === "new") {
+          if (!input.name) {
+            exitWithError("--name is required", "usage: lnr label new --name \"...\" --team <key>");
+          }
+          if (!input.team) {
+            exitWithError("--team is required", "usage: lnr label new --name \"...\" --team <key>");
+          }
+
+          const team = await findTeamByKeyOrName(client, input.team);
+          if (!team) {
+            const available = (await getAvailableTeamKeys(client)).join(", ");
+            exitWithError(
+              `team "${input.team}" not found`,
+              `available teams: ${available}`,
+              EXIT_CODES.NOT_FOUND
+            );
+          }
+
+          const label = await createLabel(client, {
+            name: input.name,
+            teamId: team.id,
+            color: input.color,
+            description: input.description,
+          });
+
+          if (label) {
+            console.log(`created label: ${label.name}`);
+          } else {
+            exitWithError("failed to create label");
+          }
+          return;
+        }
+
+        if (input.delete) {
+          const success = await deleteLabel(client, input.id);
+
+          if (!success) {
+            exitWithError(`label "${input.id}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+          }
+
+          console.log(`deleted label: ${input.id}`);
+          return;
+        }
+
+        if (input.name || input.color || input.description) {
+          const success = await updateLabel(client, input.id, {
+            name: input.name,
+            color: input.color,
+            description: input.description,
+          });
+
+          if (!success) {
+            exitWithError(`label "${input.id}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+          }
+
+          console.log(`updated label: ${input.id}`);
+          return;
+        }
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : undefined,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        const label = await getLabel(client, input.id);
+
+        if (!label) {
+          exitWithError(`label "${input.id}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+        }
+
+        if (format === "json") {
+          outputJson(label);
+          return;
+        }
+
+        console.log(`${label.name}`);
+        if (label.description) {
+          console.log(`  ${truncate(label.description, 80)}`);
+        }
+        console.log();
+        console.log(`id:    ${label.id}`);
+        console.log(`color: ${label.color ?? "-"}`);
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+});

package/src/{commands → router}/me.ts

@@ -1,47 +1,43 @@
-import type { Command } from "commander";
+import { z } from "zod";
 import {
   getClient,
   getViewer,
   getMyIssues,
   getMyCreatedIssues,
+  getMyActivity,
 } from "@bdsqqq/lnr-core";
-import { handleApiError } from "../lib/error";
+import { router, procedure } from "./trpc";
 import {
-  getOutputFormat,
   outputJson,
   outputQuiet,
   outputTable,
   formatPriority,
+  formatDate,
   truncate,
-  type OutputOptions,
 } from "../lib/output";
+import { handleApiError } from "../lib/error";
 
-interface MeOptions extends OutputOptions {
-  issues?: boolean;
-  created?: boolean;
-  json?: boolean;
-  quiet?: boolean;
-}
-
-export function registerMeCommand(program: Command): void {
-  program
-    .command("me")
-    .description("show current user info")
-    .option("--issues", "show my assigned issues")
-    .option("--created", "show issues i created")
-    .option("--json", "output as json")
-    .option("--quiet", "output ids only")
-    .action(async (options: MeOptions) => {
-      const format = options.json
-        ? "json"
-        : options.quiet
-          ? "quiet"
-          : getOutputFormat(options);
+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 meRouter = router({
+  me: procedure
+    .meta({
+      description: "show current user info",
+    })
+    .input(meInput)
+    .query(async ({ input }) => {
       try {
         const client = getClient();
 
-        if (options.issues) {
+        const format = input.json ? "json" : input.quiet ? "quiet" : "table";
+
+        if (input.issues) {
           const issues = await getMyIssues(client);
 
           if (format === "json") {
@@ -63,7 +59,7 @@ export function registerMeCommand(program: Command): void {
           return;
         }
 
-        if (options.created) {
+        if (input.created) {
           const issues = await getMyCreatedIssues(client);
 
           if (format === "json") {
@@ -85,6 +81,28 @@ export function registerMeCommand(program: Command): void {
           return;
         }
 
+        if (input.activity) {
+          const activity = await getMyActivity(client);
+
+          if (format === "json") {
+            outputJson(activity);
+            return;
+          }
+
+          if (format === "quiet") {
+            outputQuiet(activity.map((a) => a.identifier));
+            return;
+          }
+
+          outputTable(activity, [
+            { header: "ID", value: (a) => a.identifier, width: 12 },
+            { header: "TITLE", value: (a) => truncate(a.title, 40), width: 40 },
+            { header: "STATE", value: (a) => a.state ?? "-", width: 16 },
+            { header: "UPDATED", value: (a) => formatDate(a.updatedAt), width: 12 },
+          ]);
+          return;
+        }
+
         const viewer = await getViewer(client);
 
         if (format === "json") {
@@ -106,5 +124,5 @@ export function registerMeCommand(program: Command): void {
       } catch (error) {
         handleApiError(error);
       }
-    });
-}
+    }),
+});

package/src/router/projects.ts

@@ -0,0 +1,220 @@
+import { z } from "zod";
+import {
+  getClient,
+  listProjects,
+  getProject,
+  getProjectIssues,
+  createProject,
+  deleteProject,
+  findTeamByKeyOrName,
+  getAvailableTeamKeys,
+} from "@bdsqqq/lnr-core";
+import { router, procedure } from "./trpc";
+import { exitWithError, handleApiError, EXIT_CODES } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  formatDate,
+  truncate,
+  type OutputOptions,
+} from "../lib/output";
+
+const listProjectsInput = z.object({
+  team: z.string().optional().describe("filter by team key"),
+  status: z.string().optional().describe("filter by status (planned, started, completed, etc)"),
+  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 projectInput = z.object({
+  name: z.string().meta({ positional: true }).describe("project name or 'new'"),
+  issues: z.boolean().optional().describe("list issues in project"),
+  json: z.boolean().optional().describe("output as json"),
+  quiet: z.boolean().optional().describe("output ids only"),
+  verbose: z.boolean().optional().describe("show all columns"),
+  delete: z.boolean().optional().describe("delete the project"),
+  projectName: z.string().optional().describe("project name (required for new)"),
+  team: z.string().optional().describe("team key to associate project with"),
+  description: z.string().optional().describe("project description"),
+});
+
+export const projectsRouter = router({
+  projects: procedure
+    .meta({
+      aliases: { command: ["p"] },
+      description: "list projects",
+    })
+    .input(listProjectsInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        const projects = await listProjects(client, {
+          team: input.team,
+          status: input.status,
+        });
+
+        if (format === "json") {
+          outputJson(projects);
+          return;
+        }
+
+        if (format === "quiet") {
+          outputQuiet(projects.map((p) => p.id));
+          return;
+        }
+
+        outputTable(
+          projects,
+          [
+            { header: "NAME", value: (p) => truncate(p.name, 30), width: 30 },
+            { header: "STATE", value: (p) => p.state ?? "-", width: 12 },
+            {
+              header: "PROGRESS",
+              value: (p) => `${Math.round((p.progress ?? 0) * 100)}%`,
+              width: 10,
+            },
+            { header: "TARGET", value: (p) => formatDate(p.targetDate), width: 12 },
+          ],
+          outputOpts
+        );
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+
+  project: procedure
+    .meta({
+      description: "show project details, create with 'new', or delete with --delete",
+    })
+    .input(projectInput)
+    .query(async ({ input }) => {
+      if (input.name === "new") {
+        if (!input.projectName) {
+          exitWithError("--projectName is required", "usage: lnr project new --projectName \"...\"");
+        }
+
+        try {
+          const client = getClient();
+          let teamIds: string[] = [];
+
+          if (input.team) {
+            const team = await findTeamByKeyOrName(client, input.team);
+            if (!team) {
+              const available = (await getAvailableTeamKeys(client)).join(", ");
+              exitWithError(
+                `team "${input.team}" not found`,
+                `available teams: ${available}`,
+                EXIT_CODES.NOT_FOUND
+              );
+            }
+            teamIds = [team.id];
+          }
+
+          const project = await createProject(client, {
+            name: input.projectName,
+            description: input.description,
+            teamIds,
+          });
+
+          if (project) {
+            console.log(`created project: ${project.name}`);
+          } else {
+            console.log("created project");
+          }
+        } catch (error) {
+          handleApiError(error);
+        }
+        return;
+      }
+
+      if (input.delete) {
+        try {
+          const client = getClient();
+          const success = await deleteProject(client, input.name);
+
+          if (!success) {
+            exitWithError(`project "${input.name}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+          }
+
+          console.log(`deleted project: ${input.name}`);
+        } catch (error) {
+          handleApiError(error);
+        }
+        return;
+      }
+
+      try {
+        const client = getClient();
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        const project = await getProject(client, input.name);
+
+        if (!project) {
+          exitWithError(`project "${input.name}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+        }
+
+        if (input.issues) {
+          const issues = await getProjectIssues(client, input.name);
+
+          if (format === "json") {
+            outputJson(issues);
+            return;
+          }
+
+          if (format === "quiet") {
+            outputQuiet(issues.map((i) => i.identifier));
+            return;
+          }
+
+          outputTable(
+            issues,
+            [
+              { header: "ID", value: (i) => i.identifier, width: 12 },
+              { header: "TITLE", value: (i) => truncate(i.title, 50), width: 50 },
+              { header: "CREATED", value: (i) => formatDate(i.createdAt), width: 12 },
+            ],
+            outputOpts
+          );
+          return;
+        }
+
+        if (format === "json") {
+          outputJson(project);
+          return;
+        }
+
+        if (format === "quiet") {
+          console.log(project.id);
+          return;
+        }
+
+        console.log(`${project.name}`);
+        if (project.description) {
+          console.log(`  ${truncate(project.description, 80)}`);
+        }
+        console.log();
+        console.log(`state:    ${project.state ?? "-"}`);
+        console.log(`progress: ${Math.round((project.progress ?? 0) * 100)}%`);
+        console.log(`target:   ${formatDate(project.targetDate)}`);
+        console.log(`started:  ${formatDate(project.startDate)}`);
+        console.log(`created:  ${formatDate(project.createdAt)}`);
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+});

package/src/{commands → router}/search.ts

@@ -1,5 +1,6 @@
-import type { Command } from "commander";
+import { z } from "zod";
 import { getClient, searchIssues } from "@bdsqqq/lnr-core";
+import { router, procedure } from "./trpc";
 import { handleApiError } from "../lib/error";
 import {
   getOutputFormat,
@@ -7,28 +8,28 @@ import {
   outputQuiet,
   outputTable,
   truncate,
-  type OutputOptions,
 } from "../lib/output";
 
-interface SearchOptions extends OutputOptions {
-  team?: string;
-  json?: boolean;
-  quiet?: boolean;
-}
+const searchInput = z.object({
+  query: z.string().meta({ positional: true }).describe("search query"),
+  team: z.string().optional().describe("filter by team key"),
+  json: z.boolean().optional().describe("output as json"),
+  quiet: z.boolean().optional().describe("output ids only"),
+});
 
-export function registerSearchCommand(program: Command): void {
-  program
-    .command("search <query>")
-    .description("search issues")
-    .option("--team <key>", "filter by team")
-    .option("--json", "output as json")
-    .option("--quiet", "output ids only")
-    .action(async (query: string, options: SearchOptions) => {
-      const format = options.json ? "json" : options.quiet ? "quiet" : getOutputFormat(options);
+export const searchRouter = router({
+  search: procedure
+    .meta({
+      description: "search issues",
+      aliases: { command: ["s"] },
+    })
+    .input(searchInput)
+    .query(async ({ input }) => {
+      const format = input.json ? "json" : input.quiet ? "quiet" : getOutputFormat({});
 
       try {
         const client = getClient();
-        const issues = await searchIssues(client, query, { team: options.team });
+        const issues = await searchIssues(client, input.query, { team: input.team });
 
         if (format === "json") {
           outputJson(issues);
@@ -48,5 +49,5 @@ export function registerSearchCommand(program: Command): void {
       } catch (error) {
         handleApiError(error);
       }
-    });
-}
+    }),
+});