@bdsqqq/lnr-cli 1.6.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bdsqqq/lnr-cli",
-  "version": "1.6.0",
+  "version": "2.0.0",
   "description": "cli for linear issue tracking",
   "type": "module",
   "private": false,
@@ -29,8 +29,7 @@
     "@trpc/server": "^11.8.1",
     "chalk": "^5.6.2",
     "commander": "^14.0.2",
-    "trpc-cli": "^0.12.2",
-    "zod": "^4.3.5"
+    "trpc-cli": "^0.12.2"
   },
   "peerDependencies": {
     "typescript": "^5"

package/src/bench-lnr-overhead.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env bun
+
+/**
+ * measures per-call cost breakdown of lnr e2e subprocess invocations.
+ *
+ * the e2e tests spawn `bun run dev -- <args>` for every assertion (~50 calls).
+ * this script isolates where time goes: bun startup, module loading, API latency.
+ * use it to evaluate whether optimization ideas (compiling, parallelizing, calling
+ * core directly) are worth the complexity.
+ *
+ * run:   bun run packages/cli/src/bench-lnr-overhead.ts
+ * needs: LINEAR_API_KEY set (for API-hitting measurements)
+ *
+ * baseline results (2026-02-07, macOS arm64, bun 1.3.5):
+ *
+ *   bare subprocess (bun --version):        5ms
+ *   bun run dev -- --help (no API):       302ms   ← module loading dominates
+ *   compiled binary --help (no API):      263ms   ← only 38ms faster
+ *   bun run dev -- me (with API):         629ms
+ *   compiled binary me (with API):        533ms
+ *
+ *   API latency (derived):               ~300ms   ← irreducible
+ *   savings from compiling (40 calls):    ~1.5s   ← not worth it
+ *
+ * CI end-to-end (2026-02-07, ubuntu github actions runner):
+ *   readonly tests:   6s (10 tests)
+ *   mutation tests:  42s (32 tests, 40 subprocess calls)
+ *   per-test mean:   ~1.3s (range: 575ms to 4000ms)
+ *
+ * conclusion: the bottleneck is sequential API round-trips (~300ms each
+ * on CI), not subprocess startup. parallelizing independent test groups
+ * is the only approach that meaningfully reduces total time.
+ */
+
+const ITERATIONS = 5;
+const cliDir = import.meta.dir + "/../..";
+const cliPkgDir = import.meta.dir + "/..";
+const BUN = process.execPath;
+
+interface TimingResult {
+  label: string;
+  times: number[];
+  mean: number;
+  min: number;
+  max: number;
+}
+
+function stats(label: string, times: number[]): TimingResult {
+  const mean = times.reduce((a, b) => a + b, 0) / times.length;
+  return { label, times, mean, min: Math.min(...times), max: Math.max(...times) };
+}
+
+function report(r: TimingResult) {
+  console.log(`  ${r.label}: mean=${r.mean.toFixed(0)}ms  min=${r.min.toFixed(0)}ms  max=${r.max.toFixed(0)}ms  (n=${r.times.length})`);
+}
+
+async function timeLnrDev(...args: string[]): Promise<number> {
+  const start = performance.now();
+  const proc = Bun.spawn([BUN, "run", "dev", "--", ...args], {
+    cwd: cliDir,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  await new Response(proc.stdout).text();
+  await proc.exited;
+  return performance.now() - start;
+}
+
+async function timeLnrCompiled(...args: string[]): Promise<number> {
+  const start = performance.now();
+  const proc = Bun.spawn(["/tmp/lnr-bench", ...args], {
+    cwd: cliDir,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  await new Response(proc.stdout).text();
+  await proc.exited;
+  return performance.now() - start;
+}
+
+async function timeBareSubprocess(): Promise<number> {
+  const start = performance.now();
+  const proc = Bun.spawn([BUN, "--version"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  await new Response(proc.stdout).text();
+  await proc.exited;
+  return performance.now() - start;
+}
+
+// --- run ---
+
+console.log("=== lnr subprocess overhead benchmark ===\n");
+
+console.log("1. bare `bun --version` (subprocess overhead floor)");
+const bareTimes: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  bareTimes.push(await timeBareSubprocess());
+}
+report(stats("bun --version", bareTimes));
+
+console.log("\n2. `bun run dev -- --help` (startup + module loading, no API)");
+const helpTimes: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  helpTimes.push(await timeLnrDev("--help"));
+}
+report(stats("lnr --help (dev)", helpTimes));
+
+console.log("\n3. compiling binary...");
+const compileStart = performance.now();
+const compileProc = Bun.spawn([BUN, "build", "./src/cli.ts", "--compile", "--outfile", "/tmp/lnr-bench"], {
+  cwd: cliPkgDir,
+  stdout: "pipe",
+  stderr: "pipe",
+});
+const compileStderr = await new Response(compileProc.stderr).text();
+const compileExit = await compileProc.exited;
+console.log(`   compiled in ${(performance.now() - compileStart).toFixed(0)}ms (exit: ${compileExit})`);
+if (compileExit !== 0) {
+  console.log(`   compile failed: ${compileStderr}`);
+  process.exit(1);
+}
+
+console.log("\n4. `/tmp/lnr-bench --help` (compiled binary, no API)");
+const compiledHelpTimes: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  compiledHelpTimes.push(await timeLnrCompiled("--help"));
+}
+report(stats("lnr --help (compiled)", compiledHelpTimes));
+
+console.log("\n5. `bun run dev -- me` (dev mode, hits Linear API)");
+const meTimes: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  meTimes.push(await timeLnrDev("me"));
+}
+report(stats("lnr me (dev)", meTimes));
+
+console.log("\n6. `/tmp/lnr-bench me` (compiled, hits Linear API)");
+const meCompiledTimes: number[] = [];
+for (let i = 0; i < ITERATIONS; i++) {
+  meCompiledTimes.push(await timeLnrCompiled("me"));
+}
+report(stats("lnr me (compiled)", meCompiledTimes));
+
+const devOverhead = stats("lnr --help (dev)", helpTimes).mean;
+const devWithApi = stats("lnr me (dev)", meTimes).mean;
+const compiledOverhead = stats("lnr --help (compiled)", compiledHelpTimes).mean;
+const compiledWithApi = stats("lnr me (compiled)", meCompiledTimes).mean;
+
+console.log("\n=== derived ===");
+console.log(`  dev startup overhead (no API):     ${devOverhead.toFixed(0)}ms`);
+console.log(`  compiled startup overhead (no API): ${compiledOverhead.toFixed(0)}ms`);
+console.log(`  savings per call (compiled):        ${(devOverhead - compiledOverhead).toFixed(0)}ms`);
+console.log(`  estimated API latency (dev):        ${(devWithApi - devOverhead).toFixed(0)}ms`);
+console.log(`  estimated API latency (compiled):   ${(compiledWithApi - compiledOverhead).toFixed(0)}ms`);
+console.log(`  total lnr calls in mutations e2e:   40`);
+console.log(`  estimated savings (40 calls):        ${((devOverhead - compiledOverhead) * 40 / 1000).toFixed(1)}s`);
+
+console.log("\ndone.");

package/src/e2e-mutations.test.ts

@@ -0,0 +1,378 @@
+/**
+ * ⚠️  DANGER: MUTATION TESTS — creates, updates, deletes Linear data.
+ *
+ * DO NOT RUN WITH YOUR PRODUCTION LINEAR API KEY.
+ * USE A SANDBOX WORKSPACE ONLY.
+ *
+ * run: LINEAR_API_KEY=<SANDBOX_KEY> LNR_E2E_CONFIRM_ORG=<org-name> bun test packages/cli/src/e2e-mutations.test.ts
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { getApiKey, getClient } from "@bdsqqq/lnr-core";
+
+const API_KEY = getApiKey();
+if (!API_KEY) {
+  console.log("skipping e2e mutation tests: no API key found (set LINEAR_API_KEY or add .lnr.json)");
+  process.exit(0);
+}
+
+const client = getClient();
+const org = await client.organization;
+
+const confirmOrg = process.env.LNR_E2E_CONFIRM_ORG;
+
+if (confirmOrg) {
+  if (confirmOrg !== org.name) {
+    console.log(`aborted — org "${confirmOrg}" does not match actual org "${org.name}"`);
+    process.exit(1);
+  }
+  console.log(`testing org: ${org.name}`);
+} else {
+  const rl = require("readline").createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise<string>((resolve) => {
+    rl.question(`\n⚠️  MUTATION TESTS will create, update, and delete data in org: ${org.name}\n   type the org name to confirm: `, resolve);
+  });
+  rl.close();
+
+  if (answer.trim() !== org.name) {
+    console.log("aborted — org name did not match.");
+    process.exit(0);
+  }
+
+  console.log(`testing org: ${org.name}`);
+}
+
+async function cleanupPreviousRuns() {
+  try {
+    console.log("cleaning up previous test runs...");
+
+    const teams = await client.teams();
+    for (const team of teams.nodes.filter((t) => t.name.startsWith("e2e-test-"))) {
+      console.log(`deleting leftover team: ${team.name}`);
+      await client.deleteTeam(team.id);
+    }
+
+    const projects = await client.projects();
+    for (const project of projects.nodes.filter((p) => p.name.startsWith("e2e-project-"))) {
+      console.log(`deleting leftover project: ${project.name}`);
+      await client.deleteProject(project.id);
+    }
+
+    const views = await client.customViews();
+    for (const view of views.nodes.filter((v) => v.name === "Test View" || v.name === "Updated View")) {
+      console.log(`deleting leftover view: ${view.name}`);
+      await client.deleteCustomView(view.id);
+    }
+
+    console.log("cleanup complete");
+  } catch (err) {
+    console.log("cleanup failed, continuing:", err);
+  }
+}
+
+await cleanupPreviousRuns();
+
+const TEST_TEAM_KEY = `E2E${Date.now().toString(36).slice(-4).toUpperCase()}`;
+const TEST_TEAM_NAME = `e2e-test-${Date.now()}`;
+const TEST_PROJECT_NAME = `e2e-project-${Date.now()}`;
+
+let teamId: string;
+let issueId: string;
+let issueIdentifier: string;
+let projectId: string;
+let viewId: string;
+let commentId: string;
+
+async function lnr(...args: string[]): Promise<string> {
+  const proc = Bun.spawn(["bun", "run", "dev", "--", ...args], {
+    cwd: import.meta.dir + "/../..",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    throw new Error(`lnr ${args.join(" ")} failed (${exitCode}):\n${stderr || stdout}`);
+  }
+  return stdout.trim();
+}
+
+describe("e2e: mutations", () => {
+  beforeAll(async () => {
+    console.log(`\n⚠️  MUTATION TESTS — creating test team: ${TEST_TEAM_NAME} (${TEST_TEAM_KEY})`);
+    const result = await client.createTeam({
+      name: TEST_TEAM_NAME,
+      key: TEST_TEAM_KEY,
+    });
+    const team = await result.team;
+    if (!team) throw new Error("failed to create test team");
+    teamId = team.id;
+    console.log(`created team ${teamId}`);
+  }, 30000);
+
+  afterAll(async () => {
+    console.log(`cleaning up: deleting team ${teamId}`);
+    if (teamId) {
+      await client.deleteTeam(teamId);
+      console.log("team deleted");
+    }
+  }, 30000);
+
+  describe("team", () => {
+    test("list teams includes test team", async () => {
+      const out = await lnr("teams");
+      expect(out).toContain(TEST_TEAM_KEY);
+    });
+
+    test("show team by key", async () => {
+      const out = await lnr("team", TEST_TEAM_KEY);
+      expect(out).toContain(TEST_TEAM_NAME);
+    });
+  });
+
+  describe("cycle CRUD", () => {
+    test("create cycle", async () => {
+      const out = await lnr(
+        "cycle",
+        "new",
+        "--team",
+        TEST_TEAM_KEY,
+        "--name",
+        "Test Cycle",
+        "--starts-at",
+        "2026-03-01",
+        "--ends-at",
+        "2026-03-14"
+      );
+      expect(out).toContain("created cycle");
+    });
+
+    test("list cycles", async () => {
+      const out = await lnr("cycles", "--team", TEST_TEAM_KEY);
+      expect(out).toContain("Test Cycle");
+    });
+
+    test("show cycle by number", async () => {
+      const out = await lnr("cycle", "1", "--team", TEST_TEAM_KEY);
+      expect(out).toContain("Test Cycle");
+    });
+
+    test("update cycle name", async () => {
+      const out = await lnr("cycle", "1", "--team", TEST_TEAM_KEY, "--name", "Updated Cycle");
+      expect(out).toContain("updated");
+    });
+
+    test("delete cycle", async () => {
+      const out = await lnr("cycle", "1", "--team", TEST_TEAM_KEY, "--delete");
+      expect(out).toContain("archived");
+    });
+  });
+
+  describe("view CRUD", () => {
+    test("create view", async () => {
+      const out = await lnr("view", "new", "--name", "Test View");
+      expect(out).toContain("created");
+      const json = await lnr("views", "--json");
+      const views = JSON.parse(json);
+      const testView = views.find((v: any) => v.name === "Test View");
+      expect(testView).toBeTruthy();
+      viewId = testView.id;
+    });
+
+    test("list views", async () => {
+      const out = await lnr("views");
+      expect(out).toContain("Test View");
+    });
+
+    test("show view", async () => {
+      const out = await lnr("view", "Test View");
+      expect(out).toContain("Test View");
+    });
+
+    test("update view name", async () => {
+      const out = await lnr("view", "Test View", "--name", "Updated View");
+      expect(out).toContain("updated");
+    });
+
+    test("delete view", async () => {
+      const out = await lnr("view", "Updated View", "--delete");
+      expect(out).toContain("deleted");
+    });
+  });
+
+  describe("issue + comment + reaction", () => {
+    test("create issue", async () => {
+      const out = await lnr("issue", "new", "--team", TEST_TEAM_KEY, "--title", "Test Issue");
+      expect(out).toContain("created");
+      const json = await lnr("issues", "--team", TEST_TEAM_KEY, "--json");
+      const issues = JSON.parse(json);
+      const testIssue = issues.find((i: any) => i.title === "Test Issue");
+      expect(testIssue).toBeTruthy();
+      issueId = testIssue.id;
+      issueIdentifier = testIssue.identifier;
+    });
+
+    test("add comment", async () => {
+      const out = await lnr("issue", issueIdentifier, "--comment", "Test comment body");
+      expect(out).toContain("comment");
+    });
+
+    test("list comments", async () => {
+      const out = await lnr("issue", issueIdentifier, "--comments");
+      expect(out).toContain("Test comment body");
+    });
+
+    test("add reaction to comment", async () => {
+      const json = await lnr("issue", issueIdentifier, "--comments", "--json");
+      const comments = JSON.parse(json);
+      expect(comments.length).toBeGreaterThan(0);
+      commentId = comments[0].id;
+      const out = await lnr("issue", issueIdentifier, "--react", commentId, "--emoji", "thumbsup");
+      expect(out).toContain("reaction");
+    });
+
+    test("subscribe to issue", async () => {
+      const out = await lnr("issue", issueIdentifier, "--subscribe");
+      expect(out.toLowerCase()).toMatch(/subscrib/);
+    });
+
+    test("unsubscribe from issue", async () => {
+      const out = await lnr("issue", issueIdentifier, "--unsubscribe");
+      expect(out.toLowerCase()).toMatch(/unsubscrib/);
+    });
+  });
+
+  describe("issue batch", () => {
+    test("create additional issues for batch", async () => {
+      await lnr("issue", "new", "--team", TEST_TEAM_KEY, "--title", "Batch Issue 1");
+      await lnr("issue", "new", "--team", TEST_TEAM_KEY, "--title", "Batch Issue 2");
+      const out = await lnr("issues", "--team", TEST_TEAM_KEY);
+      expect(out).toContain("Batch Issue 1");
+      expect(out).toContain("Batch Issue 2");
+    }, 15000);
+
+    test("batch update priority", async () => {
+      const json = await lnr("issues", "--team", TEST_TEAM_KEY, "--json");
+      const issues = JSON.parse(json);
+      const batchIssues = issues.filter((i: any) => i.title.startsWith("Batch Issue"));
+      const ids = batchIssues.map((i: any) => i.identifier).join(",");
+      const out = await lnr("issue batch", ids, "--priority", "high");
+      expect(out).toContain("updated");
+    });
+  });
+
+  describe("project + scoped entities", () => {
+    test("create project", async () => {
+      const out = await lnr("project", "new", "--new-name", TEST_PROJECT_NAME, "--team", TEST_TEAM_KEY);
+      expect(out).toContain("created");
+      const json = await lnr("projects", "--json");
+      const projects = JSON.parse(json);
+      const testProject = projects.find((p: any) => p.name === TEST_PROJECT_NAME);
+      expect(testProject).toBeTruthy();
+      projectId = testProject.id;
+    });
+
+    test("show project labels (scoped)", async () => {
+      const out = await lnr("project", TEST_PROJECT_NAME, "--labels");
+      expect(out).toBeDefined();
+    });
+
+    test("show project status (scoped)", async () => {
+      const out = await lnr("project", TEST_PROJECT_NAME, "--show-status");
+      expect(out).toBeDefined();
+    });
+
+    test("show project updates (scoped)", async () => {
+      const out = await lnr("project", TEST_PROJECT_NAME, "--updates");
+      expect(out).toBeDefined();
+    });
+
+    test("subscribe to project", async () => {
+      // may succeed or fail with "already subscribed" — both are valid
+      try {
+        const out = await lnr("project", TEST_PROJECT_NAME, "--subscribe");
+        expect(out.toLowerCase()).toMatch(/subscrib/);
+      } catch (e: any) {
+        expect(e.message).toContain("already have an existing subscription");
+      }
+    });
+
+    test("unsubscribe from project", async () => {
+      // auto-finds subscription, no id required
+      try {
+        const out = await lnr("project", TEST_PROJECT_NAME, "--unsubscribe");
+        expect(out.toLowerCase()).toMatch(/unsubscrib/);
+      } catch (e: any) {
+        // may fail if not subscribed
+        expect(e.message).toMatch(/no subscription found|not subscribed/);
+      }
+    });
+  });
+
+  describe("git automation", () => {
+    test("list git automations (empty ok)", async () => {
+      try {
+        const out = await lnr("git-automations", "--team", TEST_TEAM_KEY);
+        expect(out).toBeDefined();
+      } catch (e: any) {
+        expect(e.message).toContain("no git automation");
+      }
+    });
+
+    test("create git automation state", async () => {
+      const team = await client.team(teamId);
+      const states = await team.states();
+      const inProgressState = states.nodes.find((s) => s.name === "In Progress");
+      if (!inProgressState) {
+        console.log("skipping: no In Progress state found");
+        return;
+      }
+
+      const out = await lnr(
+        "git-automation",
+        "new",
+        "--team",
+        TEST_TEAM_KEY,
+        "--event",
+        "start",
+        "--state",
+        "In Progress"
+      );
+      expect(out).toContain("created");
+    });
+
+    test("list git automations after create", async () => {
+      const out = await lnr("git-automations", "--team", TEST_TEAM_KEY);
+      expect(out).toContain("start");
+    });
+
+    test("delete git automation", async () => {
+      const out = await lnr("git-automation", "start", "--team", TEST_TEAM_KEY, "--delete");
+      expect(out).toContain("deleted");
+    });
+  });
+
+  describe("cleanup", () => {
+    test(
+      "archive all test issues",
+      async () => {
+        const json = await lnr("issues", "--team", TEST_TEAM_KEY, "--json");
+        const issues = JSON.parse(json);
+        for (const issue of issues) {
+          await lnr("issue", issue.identifier, "--archive");
+        }
+        expect(true).toBe(true);
+      },
+      30000
+    );
+
+    test("delete test project", async () => {
+      if (projectId) {
+        const out = await lnr("project", TEST_PROJECT_NAME, "--delete");
+        expect(out).toContain("deleted");
+      }
+    });
+  });
+});

package/src/e2e-readonly.test.ts

@@ -0,0 +1,103 @@
+/**
+ * e2e tests — READ-ONLY operations only.
+ * safe to run with any Linear API key.
+ *
+ * run: LINEAR_API_KEY=xxx bun test packages/cli/src/e2e-readonly.test.ts
+ */
+
+import { describe, test, expect } from "bun:test";
+import { getApiKey, getClient } from "@bdsqqq/lnr-core";
+
+const API_KEY = getApiKey();
+if (!API_KEY) {
+  console.log("skipping e2e tests: no API key found (set LINEAR_API_KEY or add .lnr.json)");
+  process.exit(0);
+}
+
+const client = getClient();
+const org = await client.organization;
+console.log(`testing org: ${org.name}`);
+
+async function lnr(...args: string[]): Promise<string> {
+  const proc = Bun.spawn(["bun", "run", "dev", "--", ...args], {
+    cwd: import.meta.dir + "/../..",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    throw new Error(`lnr ${args.join(" ")} failed (${exitCode}):\n${stderr || stdout}`);
+  }
+  return stdout.trim();
+}
+
+describe("e2e: read-only", () => {
+  test("me command", async () => {
+    const out = await lnr("me");
+    expect(out).toContain("@");
+  });
+
+  test("list teams", async () => {
+    const out = await lnr("teams");
+    expect(out).toBeDefined();
+  });
+
+  test("list projects", async () => {
+    const out = await lnr("projects");
+    expect(out).toBeDefined();
+  });
+
+  test("list users", async () => {
+    const out = await lnr("users");
+    expect(out).toContain("@");
+  });
+
+  test("list views", async () => {
+    try {
+      const out = await lnr("views");
+      expect(out).toBeDefined();
+    } catch {
+      // empty is fine
+    }
+  });
+
+  test("list templates", async () => {
+    try {
+      const out = await lnr("templates");
+      expect(out).toBeDefined();
+    } catch {
+      // empty is fine
+    }
+  });
+
+  test("list notifications", async () => {
+    try {
+      const out = await lnr("notifications");
+      expect(out).toBeDefined();
+    } catch {
+      // empty is fine
+    }
+  });
+
+  test("list agent sessions", async () => {
+    try {
+      const out = await lnr("agent-sessions");
+      expect(out).toBeDefined();
+    } catch {
+      // empty is fine
+    }
+  });
+
+  test("list initiatives (enterprise)", async () => {
+    const out = await lnr("initiatives");
+    expect(out).toBeDefined();
+  });
+
+  test("list roadmaps (enterprise)", async () => {
+    const out = await lnr("roadmaps");
+    expect(out).toBeDefined();
+  });
+});