@bdsqqq/lnr-cli 1.6.0 → 2.0.0

package/src/router/agent-sessions.ts

@@ -0,0 +1,253 @@
+import "../lib/arktype-config";
+import { type } from "arktype";
+import {
+  getClient,
+  listAgentSessions,
+  getAgentSession,
+  updateAgentSession,
+  getAgentSessionActivities,
+  type AgentSession,
+  type AgentActivity,
+} 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 listAgentSessionsInput = type({
+  "json?": type("boolean").describe("output as json"),
+  "quiet?": type("boolean").describe("output ids only"),
+  "verbose?": type("boolean").describe("show all columns"),
+  "status?": type("string").describe("filter by status (active, pending, complete, error, stale)"),
+});
+
+export const agentSessionInput = type({
+  id: type("string").configure({ positional: true }).describe("agent session id"),
+  "json?": type("boolean").describe("output as json"),
+  "quiet?": type("boolean").describe("output id only"),
+  "verbose?": type("boolean").describe("show all fields"),
+  "externalLink?": type("string").describe("set external link url"),
+  "activities?": type("boolean").describe("show session activities"),
+});
+
+const sessionColumns: TableColumn<AgentSession>[] = [
+  { header: "STATUS", value: (s) => s.status, width: 14 },
+  { header: "TYPE", value: (s) => s.type, width: 14 },
+  { header: "ISSUE", value: (s) => s.issueIdentifier ?? "-", width: 12 },
+  { header: "CREATOR", value: (s) => s.creatorName ?? "-", width: 16 },
+  {
+    header: "DATE",
+    value: (s) => s.createdAt.toISOString().split("T")[0] ?? "",
+    width: 12,
+  },
+];
+
+const verboseSessionColumns: TableColumn<AgentSession>[] = [
+  ...sessionColumns,
+  { header: "APP USER", value: (s) => s.appUserName ?? "-", width: 16 },
+  {
+    header: "STARTED",
+    value: (s) =>
+      s.startedAt ? s.startedAt.toISOString().split("T")[0] ?? "-" : "-",
+    width: 12,
+  },
+  {
+    header: "ENDED",
+    value: (s) =>
+      s.endedAt ? s.endedAt.toISOString().split("T")[0] ?? "-" : "-",
+    width: 12,
+  },
+  { header: "ID", value: (s) => s.id, width: 36 },
+];
+
+const activityColumns: TableColumn<AgentActivity>[] = [
+  { header: "TYPE", value: (a) => a.type, width: 12 },
+  {
+    header: "CONTENT",
+    value: (a) => {
+      if (a.content.action) {
+        return `${a.content.action}: ${a.content.parameter ?? ""}`.slice(0, 40);
+      }
+      return (a.content.body ?? "").slice(0, 40);
+    },
+    width: 42,
+  },
+  { header: "USER", value: (a) => a.userName ?? "-", width: 16 },
+  {
+    header: "DATE",
+    value: (a) => a.createdAt.toISOString().split("T")[0] ?? "",
+    width: 12,
+  },
+];
+
+const verboseActivityColumns: TableColumn<AgentActivity>[] = [
+  ...activityColumns,
+  { header: "SIGNAL", value: (a) => a.signal ?? "-", width: 10 },
+  { header: "EPHEMERAL", value: (a) => (a.ephemeral ? "yes" : "no"), width: 10 },
+  { header: "ID", value: (a) => a.id, width: 36 },
+];
+
+export const agentSessionsRouter = router({
+  "agent-sessions": procedure
+    .meta({
+      aliases: { command: ["as"] },
+      description: "list agent sessions (experimental)",
+    })
+    .input(listAgentSessionsInput)
+    .query(async ({ input }) => {
+      try {
+        const client = getClient();
+        const sessions = await listAgentSessions(client, {
+          status: input.status,
+        });
+
+        const outputOpts: OutputOptions = {
+          format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+          verbose: input.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        if (format === "json") {
+          outputJson(sessions);
+          return;
+        }
+
+        if (format === "quiet") {
+          outputQuiet(sessions.map((s) => s.id));
+          return;
+        }
+
+        const columns = input.verbose ? verboseSessionColumns : sessionColumns;
+        outputTable(sessions, columns, outputOpts);
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+
+  "agent-session": procedure
+    .meta({ description: "show agent session details (experimental)" })
+    .input(agentSessionInput)
+    .mutation(async ({ input }) => {
+      try {
+        const client = getClient();
+
+        if (input.externalLink !== undefined) {
+          const success = await updateAgentSession(client, input.id, {
+            externalLink: input.externalLink,
+          });
+          if (!success) {
+            exitWithError(
+              `failed to update agent session "${input.id}"`,
+              "check the session id and permissions",
+              EXIT_CODES.GENERAL_ERROR
+            );
+          }
+          console.log("updated");
+          return;
+        }
+
+        if (input.activities) {
+          const activities = await getAgentSessionActivities(client, input.id);
+
+          const outputOpts: OutputOptions = {
+            format: input.json ? "json" : input.quiet ? "quiet" : undefined,
+            verbose: input.verbose,
+          };
+          const format = getOutputFormat(outputOpts);
+
+          if (format === "json") {
+            outputJson(activities);
+            return;
+          }
+
+          if (format === "quiet") {
+            outputQuiet(activities.map((a) => a.id));
+            return;
+          }
+
+          const columns = input.verbose
+            ? verboseActivityColumns
+            : activityColumns;
+          outputTable(activities, columns, outputOpts);
+          return;
+        }
+
+        const session = await getAgentSession(client, input.id);
+
+        if (!session) {
+          exitWithError(
+            `agent session "${input.id}" not found`,
+            "try: lnr agent-sessions",
+            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(session);
+          return;
+        }
+
+        if (format === "quiet") {
+          console.log(session.id);
+          return;
+        }
+
+        console.log(`status: ${session.status}`);
+        console.log(`type: ${session.type}`);
+        console.log(`created: ${session.createdAt.toISOString()}`);
+        if (session.issueIdentifier) {
+          console.log(`issue: ${session.issueIdentifier}`);
+        }
+        if (session.creatorName) {
+          console.log(`creator: ${session.creatorName}`);
+        }
+        if (session.appUserName) {
+          console.log(`app user: ${session.appUserName}`);
+        }
+        if (session.summary) {
+          console.log(`summary: ${session.summary}`);
+        }
+        if (session.externalLink) {
+          console.log(`external link: ${session.externalLink}`);
+        }
+        if (session.startedAt) {
+          console.log(`started: ${session.startedAt.toISOString()}`);
+        }
+        if (session.endedAt) {
+          console.log(`ended: ${session.endedAt.toISOString()}`);
+        }
+        if (input.verbose) {
+          console.log(`id: ${session.id}`);
+          if (session.issueId) {
+            console.log(`issue id: ${session.issueId}`);
+          }
+          if (session.commentId) {
+            console.log(`comment id: ${session.commentId}`);
+          }
+          if (session.dismissedAt) {
+            console.log(`dismissed: ${session.dismissedAt.toISOString()}`);
+          }
+          if (session.archivedAt) {
+            console.log(`archived: ${session.archivedAt.toISOString()}`);
+          }
+          if (session.plan) {
+            console.log(`plan: ${JSON.stringify(session.plan)}`);
+          }
+        }
+      } catch (error) {
+        handleApiError(error);
+      }
+    }),
+});

package/src/router/auth.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import "../lib/arktype-config";
+import { type } from "arktype";
 import {
   setApiKey,
   clearApiKey,
@@ -9,10 +10,10 @@ import {
 import { router, procedure } from "./trpc";
 import { exitWithError, EXIT_CODES } from "../lib/error";
 
-const authInput = z.object({
-  apiKey: z.string().optional().meta({ positional: true }).describe("Linear API key"),
-  whoami: z.boolean().optional().describe("show current authenticated user"),
-  logout: z.boolean().optional().describe("clear stored credentials"),
+export const authInput = type({
+  "apiKey?": type("string").configure({ positional: true }).describe("Linear API key"),
+  "whoami?": type("boolean").describe("show current authenticated user"),
+  "logout?": type("boolean").describe("clear stored credentials"),
 });
 
 export const authRouter = router({

package/src/router/config.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import "../lib/arktype-config";
+import { type } from "arktype";
 import {
   loadConfig,
   getConfigValue,
@@ -8,13 +9,13 @@ import {
 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"),
+export const getInput = type({
+  key: type("'api_key' | 'default_team' | 'output_format'").configure({ 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 setInput = type({
+  key: type("'api_key' | 'default_team' | 'output_format'").configure({ positional: true }).describe("config key to set"),
+  value: type("string").configure({ positional: true }).describe("value to set"),
 });
 
 export const configRouter = router({

package/src/router/contract.test.ts

@@ -0,0 +1,364 @@
+/**
+ * contract tests: CLI input → core function parameters
+ *
+ * these tests verify the transformation from CLI flags to API request payloads.
+ */
+
+import { describe, test, expect } from "bun:test";
+import { type } from "arktype";
+
+// import schemas directly from router files
+import { listIssuesInput, issueInput } from "../generated/issue";
+import { listProjectsInput, projectInput } from "../generated/project";
+import { listTeamsInput, teamInput } from "../router/teams";
+import { listCyclesInput, cycleInput } from "../router/cycles";
+import { listDocsInput, docInput } from "../generated/doc";
+import { listLabelsInput, labelInput } from "../generated/label";
+import { meInput } from "../router/me";
+import { searchInput } from "../router/search";
+import { authInput } from "../router/auth";
+import { getInput as configGetInput, setInput as configSetInput } from "../router/config";
+
+/**
+ * unified validation helper that works with both zod and arktype schemas.
+ * provides consistent safeParse-like interface during migration.
+ */
+function safeParse<T>(schema: unknown, data: unknown): { success: boolean; data?: T; error?: unknown } {
+  // zod schema check
+  if (typeof schema === "object" && schema !== null && "safeParse" in schema) {
+    const zodResult = (schema as { safeParse: (d: unknown) => { success: boolean; data?: T; error?: unknown } }).safeParse(data);
+    return zodResult;
+  }
+  // arktype schema (callable)
+  if (typeof schema === "function") {
+    const result = (schema as (d: unknown) => unknown)(data);
+    if (result instanceof type.errors) {
+      return { success: false, error: result };
+    }
+    return { success: true, data: result as T };
+  }
+  throw new Error("unknown schema type");
+}
+
+// operation inference - mirrors router logic
+function inferOperation(command: string, input: Record<string, unknown>): "create" | "update" | "delete" | "show" {
+  const positionalNewCommands = ["issue", "project", "doc", "label"];
+  if (positionalNewCommands.includes(command)) {
+    const positional = input.idOrNew ?? input.name ?? input.id;
+    if (positional === "new") return "create";
+  }
+  if (input.delete || input.archive) return "delete";
+  const mutationFlags = [
+    "state", "assignee", "priority", "label", "comment",
+    "editComment", "replyTo", "deleteComment", "react", "unreact",
+    "parent", "blocks", "blockedBy", "relatesTo", "title",
+    "content", "projectName"
+  ];
+  for (const flag of mutationFlags) {
+    if (input[flag] !== undefined) return "update";
+  }
+  return "show";
+}
+
+describe("projects", () => {
+  describe("projects", () => {
+    test("valid input parses", () => {
+      const result = safeParse(listProjectsInput, {});
+      expect(result.success).toBe(true);
+    });
+
+    test("infers SHOW with no mutation flags", () => {
+      expect(inferOperation("projects", {})).toBe("show");
+    });
+
+  });
+
+  describe("project", () => {
+    test("valid input parses", () => {
+      const result = safeParse(projectInput, {"name":"test-value"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(projectInput, {});
+      expect(result.success).toBe(false);
+    });
+
+    test("infers CREATE when name='new'", () => {
+      expect(inferOperation("project", { name: "new" })).toBe("create");
+    });
+
+    test("infers DELETE when --delete", () => {
+      expect(inferOperation("project", {"name":"test-value","delete":true})).toBe("delete");
+    });
+
+    test("infers SHOW with no mutation flags", () => {
+      expect(inferOperation("project", {"name":"test-value"})).toBe("show");
+    });
+
+  });
+
+});
+
+describe("search", () => {
+  describe("search", () => {
+    test("valid input parses", () => {
+      const result = safeParse(searchInput, {"query":"test-value"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(searchInput, {});
+      expect(result.success).toBe(false);
+    });
+
+  });
+
+});
+
+describe("cycles", () => {
+  describe("cycles", () => {
+    test("valid input parses", () => {
+      const result = safeParse(listCyclesInput, {"team":"test-value"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(listCyclesInput, {});
+      expect(result.success).toBe(false);
+    });
+
+  });
+
+  describe("cycle", () => {
+    test("valid input parses", () => {
+      const result = safeParse(cycleInput, {"nameOrNumber":"1","team":"test-value"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(cycleInput, {});
+      expect(result.success).toBe(false);
+    });
+
+    test("infers CREATE when nameOrNumber='new'", () => {
+      const result = safeParse(cycleInput, {"nameOrNumber":"new","team":"ENG"});
+      expect(result.success).toBe(true);
+    });
+
+    test("infers DELETE when --delete", () => {
+      const result = safeParse(cycleInput, {"nameOrNumber":"1","team":"ENG","delete":true});
+      expect(result.success).toBe(true);
+    });
+
+    test("infers SHOW with no mutation flags", () => {
+      const result = safeParse(cycleInput, {"nameOrNumber":"Sprint 1","team":"ENG"});
+      expect(result.success).toBe(true);
+    });
+
+  });
+
+});
+
+describe("docs", () => {
+  describe("docs", () => {
+    test("valid input parses", () => {
+      const result = safeParse(listDocsInput, {});
+      expect(result.success).toBe(true);
+    });
+
+    test("infers SHOW with no mutation flags", () => {
+      expect(inferOperation("docs", {})).toBe("show");
+    });
+
+  });
+
+  describe("doc", () => {
+    test("valid input parses", () => {
+      const result = safeParse(docInput, {"id":"test-value"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(docInput, {});
+      expect(result.success).toBe(false);
+    });
+
+    test("infers CREATE when id='new'", () => {
+      expect(inferOperation("doc", { id: "new" })).toBe("create");
+    });
+
+    test("infers DELETE when --delete", () => {
+      expect(inferOperation("doc", {"id":"test-value","delete":true})).toBe("delete");
+    });
+
+    test("infers SHOW with no mutation flags", () => {
+      expect(inferOperation("doc", {"id":"test-value"})).toBe("show");
+    });
+
+  });
+
+});
+
+describe("teams", () => {
+  describe("teams", () => {
+    test("valid input parses", () => {
+      const result = safeParse(listTeamsInput, {});
+      expect(result.success).toBe(true);
+    });
+
+  });
+
+  describe("team", () => {
+    test("valid input parses", () => {
+      const result = safeParse(teamInput, {"key":"test-value"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(teamInput, {});
+      expect(result.success).toBe(false);
+    });
+
+  });
+
+});
+
+describe("config", () => {
+  describe("get", () => {
+    test("valid input parses", () => {
+      const result = safeParse(configGetInput, {"key":"api_key"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(configGetInput, {});
+      expect(result.success).toBe(false);
+    });
+
+  });
+
+  describe("set", () => {
+    test("valid input parses", () => {
+      const result = safeParse(configSetInput, {"key":"api_key","value":"test-value"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(configSetInput, {});
+      expect(result.success).toBe(false);
+    });
+
+  });
+
+});
+
+describe("me", () => {
+  describe("me", () => {
+    test("valid input parses", () => {
+      const result = safeParse(meInput, {});
+      expect(result.success).toBe(true);
+    });
+
+  });
+
+});
+
+describe("labels", () => {
+  describe("labels", () => {
+    test("valid input parses", () => {
+      const result = safeParse(listLabelsInput, {});
+      expect(result.success).toBe(true);
+    });
+
+    test("infers SHOW with no mutation flags", () => {
+      expect(inferOperation("labels", {})).toBe("show");
+    });
+
+  });
+
+  describe("label", () => {
+    test("valid input parses", () => {
+      const result = safeParse(labelInput, {"id":"test-value"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(labelInput, {});
+      expect(result.success).toBe(false);
+    });
+
+    test("infers CREATE when id='new'", () => {
+      expect(inferOperation("label", { id: "new" })).toBe("create");
+    });
+
+    test("infers DELETE when --delete", () => {
+      expect(inferOperation("label", {"id":"test-value","delete":true})).toBe("delete");
+    });
+
+    test("infers SHOW with no mutation flags", () => {
+      expect(inferOperation("label", {"id":"test-value"})).toBe("show");
+    });
+
+  });
+
+});
+
+describe("auth", () => {
+  describe("auth", () => {
+    test("valid input parses", () => {
+      const result = safeParse(authInput, {});
+      expect(result.success).toBe(true);
+    });
+
+  });
+
+});
+
+describe("issues", () => {
+  describe("issues", () => {
+    test("valid input parses", () => {
+      const result = safeParse(listIssuesInput, {});
+      expect(result.success).toBe(true);
+    });
+
+    test("infers UPDATE when --state", () => {
+      expect(inferOperation("issues", {"state":"test"})).toBe("update");
+    });
+
+    test("infers SHOW with no mutation flags", () => {
+      expect(inferOperation("issues", {})).toBe("show");
+    });
+
+  });
+
+  describe("issue", () => {
+    test("valid input parses", () => {
+      const result = safeParse(issueInput, {"idOrNew":"test-value"});
+      expect(result.success).toBe(true);
+    });
+
+    test("rejects missing required flags", () => {
+      const result = safeParse(issueInput, {});
+      expect(result.success).toBe(false);
+    });
+
+    test("infers CREATE when idOrNew='new'", () => {
+      expect(inferOperation("issue", { idOrNew: "new" })).toBe("create");
+    });
+
+    test("infers DELETE when --archive", () => {
+      expect(inferOperation("issue", {"idOrNew":"test-value","archive":true})).toBe("delete");
+    });
+
+    test("infers UPDATE when --state", () => {
+      expect(inferOperation("issue", {"idOrNew":"test-value","state":"test"})).toBe("update");
+    });
+
+    test("infers SHOW with no mutation flags", () => {
+      expect(inferOperation("issue", {"idOrNew":"test-value"})).toBe("show");
+    });
+
+  });
+
+});