@bdsqqq/lnr-cli 1.1.1 → 1.2.0

package/src/router/config.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import {
+  loadConfig,
+  getConfigValue,
+  setConfigValue,
+  type Config,
+} from "@bdsqqq/lnr-core";
+import { router, procedure } from "./trpc";
+import { exitWithError } from "../lib/error";
+
+const getInput = z.object({
+  key: z.enum(["api_key", "default_team", "output_format"]).meta({ positional: true }).describe("config key to get"),
+});
+
+const setInput = z.object({
+  key: z.enum(["api_key", "default_team", "output_format"]).meta({ positional: true }).describe("config key to set"),
+  value: z.string().meta({ positional: true }).describe("value to set"),
+});
+
+export const configRouter = router({
+  config: router({
+    get: procedure
+      .meta({
+        description: "get a config value",
+      })
+      .input(getInput)
+      .query(({ input }) => {
+        const value = getConfigValue(input.key as keyof Config);
+        if (value === undefined) {
+          console.log("(not set)");
+        } else {
+          console.log(value);
+        }
+      }),
+
+    set: procedure
+      .meta({
+        description: "set a config value",
+      })
+      .input(setInput)
+      .mutation(({ input }) => {
+        if (input.key === "output_format" && !["table", "json", "quiet"].includes(input.value)) {
+          exitWithError(`invalid output_format: ${input.value}`, "valid values: table, json, quiet");
+        }
+
+        setConfigValue(input.key as keyof Config, input.value as Config[keyof Config]);
+        console.log(`${input.key} = ${input.value}`);
+      }),
+
+    list: procedure
+      .meta({
+        description: "view and manage configuration",
+        default: true,
+      })
+      .query(() => {
+        const config = loadConfig();
+        if (Object.keys(config).length === 0) {
+          console.log("(no configuration set)");
+          return;
+        }
+
+        for (const [key, value] of Object.entries(config)) {
+          if (key === "api_key" && value) {
+            console.log(`${key} = ${(value as string).slice(0, 10)}...`);
+          } else {
+            console.log(`${key} = ${value}`);
+          }
+        }
+      }),
+  }),
+});

package/src/router/cycles.ts

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import {
+  getClient,
+  listCycles,
+  getCurrentCycle,
+  getCycleIssues,
+} from "@bdsqqq/lnr-core";
+import { router, procedure } from "./trpc";
+import { exitWithError, handleApiError } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  formatDate,
+  truncate,
+} from "../lib/output";
+
+const outputOptions = z.object({
+  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 cyclesInput = z.object({
+  team: z.string().describe("team key"),
+}).merge(outputOptions);
+
+const cycleInput = z.object({
+  team: z.string().describe("team key"),
+  current: z.boolean().optional().describe("show current active cycle"),
+  issues: z.boolean().optional().describe("list issues in cycle"),
+}).merge(outputOptions);
+
+export const cyclesRouter = router({
+  cycles: procedure
+    .meta({
+      aliases: { command: ["c"] },
+      description: "list cycles for a team",
+    })
+    .input(cyclesInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+        const cycles = await listCycles(client, input.team);
+
+        if (cycles.length === 0) {
+          exitWithError(`team "${input.team}" not found`);
+        }
+
+        const format = input.json ? "json" : input.quiet ? "quiet" : getOutputFormat(input);
+
+        if (format === "json") {
+          outputJson(cycles);
+          return;
+        }
+
+        if (format === "quiet") {
+          outputQuiet(cycles.map((c) => c.id));
+          return;
+        }
+
+        outputTable(cycles, [
+          { header: "#", value: (c) => String(c.number), width: 4 },
+          { header: "NAME", value: (c) => c.name ?? `Cycle ${c.number}`, width: 20 },
+          { header: "START", value: (c) => formatDate(c.startsAt), width: 12 },
+          { header: "END", value: (c) => formatDate(c.endsAt), width: 12 },
+        ], input);
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+
+  cycle: procedure
+    .meta({
+      description: "show cycle details",
+    })
+    .input(cycleInput)
+    .query(async ({ input }) => {
+      try {
+        if (!input.current) {
+          exitWithError("cycle identifier required", "use --current to show active cycle");
+        }
+
+        const client = getClient();
+        const cycle = await getCurrentCycle(client, input.team);
+
+        if (!cycle) {
+          exitWithError("no active cycle", `team "${input.team}" has no current cycle`);
+        }
+
+        const format = input.json ? "json" : input.quiet ? "quiet" : getOutputFormat(input);
+
+        if (input.issues) {
+          const issues = await getCycleIssues(client, input.team);
+
+          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: 10 },
+            { header: "TITLE", value: (i) => truncate(i.title, 50), width: 50 },
+          ], input);
+          return;
+        }
+
+        if (format === "json") {
+          outputJson(cycle);
+          return;
+        }
+
+        if (format === "quiet") {
+          console.log(cycle.id);
+          return;
+        }
+
+        console.log(`cycle ${cycle.number}: ${cycle.name ?? `Cycle ${cycle.number}`}`);
+        console.log(`  start: ${formatDate(cycle.startsAt)}`);
+        console.log(`  end:   ${formatDate(cycle.endsAt)}`);
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+});

package/src/router/docs.ts

@@ -0,0 +1,153 @@
+import { z } from "zod";
+import {
+  getClient,
+  listDocuments,
+  getDocument,
+  createDocument,
+  updateDocument,
+  deleteDocument,
+} 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 listDocsInput = z.object({
+  project: z.string().optional().describe("filter by project id"),
+  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 docInput = z.object({
+  id: z.string().meta({ positional: true }).describe("document id or 'new'"),
+  title: z.string().optional().describe("document title (required for new)"),
+  content: z.string().optional().describe("document content"),
+  project: z.string().optional().describe("project id to attach document to"),
+  delete: z.boolean().optional().describe("delete the document"),
+  json: z.boolean().optional().describe("output as json"),
+});
+
+export const docsRouter = router({
+  docs: procedure
+    .meta({
+      description: "list documents",
+    })
+    .input(listDocsInput)
+    .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 documents = await listDocuments(client, input.project);
+
+        if (format === "json") {
+          outputJson(documents);
+          return;
+        }
+
+        if (format === "quiet") {
+          outputQuiet(documents.map((d) => d.id));
+          return;
+        }
+
+        outputTable(
+          documents,
+          [
+            { header: "ID", value: (d) => d.id, width: 20 },
+            { header: "TITLE", value: (d) => truncate(d.title, 50), width: 50 },
+          ],
+          outputOpts
+        );
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+
+  doc: procedure
+    .meta({
+      description: "show document details, create with 'new', update, or delete with --delete",
+    })
+    .input(docInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+
+        if (input.id === "new") {
+          if (!input.title) {
+            exitWithError("--title is required", "usage: lnr doc new --title \"...\"");
+          }
+
+          const doc = await createDocument(client, {
+            title: input.title,
+            content: input.content,
+            projectId: input.project,
+          });
+
+          if (doc) {
+            console.log(`created document: ${doc.title}`);
+          } else {
+            exitWithError("failed to create document");
+          }
+          return;
+        }
+
+        if (input.delete) {
+          const success = await deleteDocument(client, input.id);
+
+          if (!success) {
+            exitWithError(`document "${input.id}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+          }
+
+          console.log(`deleted document: ${input.id}`);
+          return;
+        }
+
+        if (input.title || input.content) {
+          const success = await updateDocument(client, input.id, {
+            title: input.title,
+            content: input.content,
+          });
+
+          if (!success) {
+            exitWithError(`document "${input.id}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+          }
+
+          console.log(`updated document: ${input.id}`);
+          return;
+        }
+
+        const format = input.json ? "json" : undefined;
+
+        const doc = await getDocument(client, input.id);
+
+        if (!doc) {
+          exitWithError(`document "${input.id}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+        }
+
+        if (format === "json") {
+          outputJson(doc);
+          return;
+        }
+
+        console.log(`${doc.title}`);
+        if (doc.content) {
+          console.log();
+          console.log(doc.content);
+        }
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+});

package/src/router/index.ts

@@ -0,0 +1,28 @@
+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 { meRouter } from "./me";
+import { projectsRouter } from "./projects";
+import { searchRouter } from "./search";
+import { teamsRouter } from "./teams";
+
+export const appRouter = router({
+  ...authRouter._def.procedures,
+  ...configRouter._def.procedures,
+  ...cyclesRouter._def.procedures,
+  ...docsRouter._def.procedures,
+  ...issuesRouter._def.procedures,
+  ...labelsRouter._def.procedures,
+  ...meRouter._def.procedures,
+  ...projectsRouter._def.procedures,
+  ...searchRouter._def.procedures,
+  ...teamsRouter._def.procedures,
+});
+
+export type AppRouter = typeof appRouter;
+
+export { router, procedure } from "./trpc";