@bdsqqq/lnr-cli 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@bdsqqq/lnr-cli",
+  "version": "0.1.0",
+  "description": "cli for linear issue tracking",
+  "type": "module",
+  "private": false,
+  "main": "src/cli.ts",
+  "bin": {
+    "lnr": "./src/cli.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bdsqqq/lnr.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "bdsqqq",
+  "scripts": {
+    "dev": "bun run src/cli.ts",
+    "check": "tsc --noEmit",
+    "build": "bun build ./src/cli.ts --compile --outfile lnr"
+  },
+  "dependencies": {
+    "@bdsqqq/lnr-core": "workspace:*",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { registerAuthCommand } from "./commands/auth";
+import { registerIssuesCommand } from "./commands/issues";
+import { registerTeamsCommand } from "./commands/teams";
+import { registerProjectsCommand } from "./commands/projects";
+import { registerCyclesCommand } from "./commands/cycles";
+import { registerMeCommand } from "./commands/me";
+import { registerSearchCommand } from "./commands/search";
+import { registerConfigCommand } from "./commands/config";
+
+const program = new Command();
+
+program
+  .name("lnr")
+  .description("command-line interface for Linear")
+  .version("0.1.0");
+
+registerAuthCommand(program);
+registerIssuesCommand(program);
+registerTeamsCommand(program);
+registerProjectsCommand(program);
+registerCyclesCommand(program);
+registerMeCommand(program);
+registerSearchCommand(program);
+registerConfigCommand(program);
+
+program.parse();

package/src/commands/auth.ts

@@ -0,0 +1,53 @@
+import type { Command } from "commander";
+import {
+  setApiKey,
+  clearApiKey,
+  getApiKey,
+  createClientWithKey,
+  getViewer,
+} from "@bdsqqq/lnr-core";
+import { exitWithError, EXIT_CODES } from "../lib/error";
+
+export function registerAuthCommand(program: Command): void {
+  program
+    .command("auth [api-key]")
+    .description("authenticate with Linear API")
+    .option("--whoami", "show current authenticated user")
+    .option("--logout", "clear stored credentials")
+    .action(async (apiKey: string | undefined, options: { whoami?: boolean; logout?: boolean }) => {
+      if (options.logout) {
+        clearApiKey();
+        console.log("logged out");
+        return;
+      }
+
+      if (options.whoami) {
+        const storedKey = getApiKey();
+        if (!storedKey) {
+          exitWithError("not authenticated", "run: li auth <api-key>", EXIT_CODES.AUTH_ERROR);
+        }
+
+        try {
+          const client = createClientWithKey(storedKey);
+          const viewer = await getViewer(client);
+          console.log(`${viewer.name} <${viewer.email}>`);
+        } catch {
+          exitWithError("invalid api key", "run: li auth <api-key>", EXIT_CODES.AUTH_ERROR);
+        }
+        return;
+      }
+
+      if (!apiKey) {
+        exitWithError("api key required", "usage: li auth <api-key>");
+      }
+
+      try {
+        const client = createClientWithKey(apiKey);
+        const viewer = await getViewer(client);
+        setApiKey(apiKey);
+        console.log(`authenticated as ${viewer.name}`);
+      } catch {
+        exitWithError("invalid api key", "get one from: https://linear.app/settings/account/security", EXIT_CODES.AUTH_ERROR);
+      }
+    });
+}

package/src/commands/config.ts

@@ -0,0 +1,64 @@
+import type { Command } from "commander";
+import {
+  loadConfig,
+  getConfigValue,
+  setConfigValue,
+  type Config,
+} from "@bdsqqq/lnr-core";
+import { exitWithError } from "../lib/error";
+
+const VALID_KEYS: (keyof Config)[] = ["api_key", "default_team", "output_format"];
+
+export function registerConfigCommand(program: Command): void {
+  const configCmd = program
+    .command("config")
+    .description("view and manage configuration");
+
+  configCmd
+    .command("get <key>")
+    .description("get a config value")
+    .action((key: string) => {
+      if (!VALID_KEYS.includes(key as keyof Config)) {
+        exitWithError(`unknown config key: ${key}`, `valid keys: ${VALID_KEYS.join(", ")}`);
+      }
+
+      const value = getConfigValue(key as keyof Config);
+      if (value === undefined) {
+        console.log("(not set)");
+      } else {
+        console.log(value);
+      }
+    });
+
+  configCmd
+    .command("set <key> <value>")
+    .description("set a config value")
+    .action((key: string, value: string) => {
+      if (!VALID_KEYS.includes(key as keyof Config)) {
+        exitWithError(`unknown config key: ${key}`, `valid keys: ${VALID_KEYS.join(", ")}`);
+      }
+
+      if (key === "output_format" && !["table", "json", "quiet"].includes(value)) {
+        exitWithError(`invalid output_format: ${value}`, "valid values: table, json, quiet");
+      }
+
+      setConfigValue(key as keyof Config, value as Config[keyof Config]);
+      console.log(`${key} = ${value}`);
+    });
+
+  configCmd.action(() => {
+    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/commands/cycles.ts

@@ -0,0 +1,134 @@
+import type { Command } from "commander";
+import {
+  getClient,
+  listCycles,
+  getCurrentCycle,
+  getCycleIssues,
+} from "@bdsqqq/lnr-core";
+import { handleApiError, exitWithError } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  formatDate,
+  truncate,
+  type OutputOptions,
+} from "../lib/output";
+
+interface CyclesOptions extends OutputOptions {
+  team?: string;
+  json?: boolean;
+  quiet?: boolean;
+}
+
+interface CycleOptions extends OutputOptions {
+  current?: boolean;
+  team?: string;
+  issues?: boolean;
+  json?: boolean;
+  quiet?: boolean;
+}
+
+export function registerCyclesCommand(program: Command): void {
+  program
+    .command("cycles")
+    .description("list cycles for a team")
+    .requiredOption("--team <key>", "team key (required)")
+    .option("--json", "output as json")
+    .option("--quiet", "output ids only")
+    .option("--verbose", "show detailed output")
+    .action(async (options: CyclesOptions) => {
+      try {
+        const client = getClient();
+        const cycles = await listCycles(client, options.team!);
+
+        if (cycles.length === 0) {
+          exitWithError(`team "${options.team}" not found`);
+        }
+
+        const format = options.json ? "json" : options.quiet ? "quiet" : getOutputFormat(options);
+
+        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 },
+        ], options);
+      } catch (error) {
+        handleApiError(error);
+      }
+    });
+
+  program
+    .command("cycle")
+    .description("show cycle details")
+    .option("--current", "show current active cycle")
+    .requiredOption("--team <key>", "team key (required)")
+    .option("--issues", "list issues in the cycle")
+    .option("--json", "output as json")
+    .option("--quiet", "output ids only")
+    .option("--verbose", "show detailed output")
+    .action(async (options: CycleOptions) => {
+      if (!options.current) {
+        exitWithError("cycle identifier required", "use --current to show active cycle");
+      }
+
+      try {
+        const client = getClient();
+        const cycle = await getCurrentCycle(client, options.team!);
+
+        if (!cycle) {
+          exitWithError("no active cycle", `team "${options.team}" has no current cycle`);
+        }
+
+        const format = options.json ? "json" : options.quiet ? "quiet" : getOutputFormat(options);
+
+        if (options.issues) {
+          const issues = await getCycleIssues(client, options.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 },
+          ], options);
+          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/commands/issues.ts

@@ -0,0 +1,390 @@
+import type { Command } from "commander";
+import {
+  getClient,
+  listIssues,
+  getIssue,
+  createIssue,
+  updateIssue,
+  addComment,
+  priorityFromString,
+  getTeamStates,
+  getTeamLabels,
+  findTeamByKeyOrName,
+  getAvailableTeamKeys,
+  type Issue,
+  type ListIssuesFilter,
+} from "@bdsqqq/lnr-core";
+import { handleApiError, exitWithError, EXIT_CODES } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  formatDate,
+  formatPriority,
+  truncate,
+  type OutputOptions,
+  type TableColumn,
+} from "../lib/output";
+
+interface ListOptions extends OutputOptions {
+  team?: string;
+  state?: string;
+  assignee?: string;
+  label?: string;
+  project?: string;
+  json?: boolean;
+  quiet?: boolean;
+  verbose?: boolean;
+}
+
+interface ShowOptions extends OutputOptions {
+  json?: boolean;
+  open?: boolean;
+}
+
+interface UpdateOptions {
+  state?: string;
+  assignee?: string;
+  priority?: string;
+  label?: string;
+  comment?: string;
+  open?: boolean;
+}
+
+interface CreateOptions {
+  team?: string;
+  title?: string;
+  description?: string;
+  assignee?: string;
+  label?: string;
+  priority?: string;
+}
+
+const issueColumns: TableColumn<Issue>[] = [
+  { header: "ID", value: (i) => i.identifier, width: 10 },
+  { header: "STATE", value: (i) => i.state ?? "-", width: 15 },
+  { header: "TITLE", value: (i) => truncate(i.title, 50), width: 50 },
+  { header: "ASSIGNEE", value: (i) => i.assignee ?? "-", width: 15 },
+  { header: "PRIORITY", value: (i) => formatPriority(i.priority), width: 8 },
+];
+
+async function handleListIssues(options: ListOptions): Promise<void> {
+  try {
+    const client = getClient();
+    const filter: ListIssuesFilter = {
+      team: options.team,
+      state: options.state,
+      assignee: options.assignee,
+      label: options.label,
+      project: options.project,
+    };
+
+    const issues = await listIssues(client, filter);
+    const format = options.json ? "json" : options.quiet ? "quiet" : getOutputFormat(options);
+
+    if (format === "json") {
+      outputJson(issues);
+      return;
+    }
+
+    if (format === "quiet") {
+      outputQuiet(issues.map((i) => i.identifier));
+      return;
+    }
+
+    outputTable(issues, issueColumns, { verbose: options.verbose });
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+async function handleShowIssue(identifier: string, options: ShowOptions): Promise<void> {
+  try {
+    const client = getClient();
+    const issue = await getIssue(client, identifier);
+
+    if (!issue) {
+      exitWithError(`issue ${identifier} not found`, undefined, EXIT_CODES.NOT_FOUND);
+    }
+
+    if (options.open) {
+      const { exec } = await import("child_process");
+      exec(`open "${issue.url}"`);
+      console.log(`opened ${issue.url}`);
+      return;
+    }
+
+    const format = options.json ? "json" : getOutputFormat(options);
+
+    if (format === "json") {
+      outputJson({
+        ...issue,
+        priority: formatPriority(issue.priority),
+        createdAt: formatDate(issue.createdAt),
+        updatedAt: formatDate(issue.updatedAt),
+      });
+      return;
+    }
+
+    console.log(`${issue.identifier}: ${issue.title}`);
+    console.log();
+    console.log(`state:    ${issue.state ?? "-"}`);
+    console.log(`assignee: ${issue.assignee ?? "-"}`);
+    console.log(`priority: ${formatPriority(issue.priority)}`);
+    console.log(`created:  ${formatDate(issue.createdAt)}`);
+    console.log(`updated:  ${formatDate(issue.updatedAt)}`);
+    console.log(`url:      ${issue.url}`);
+
+    if (issue.description) {
+      console.log();
+      console.log(issue.description);
+    }
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+async function handleUpdateIssue(identifier: string, options: UpdateOptions): Promise<void> {
+  try {
+    const client = getClient();
+    const issue = await getIssue(client, identifier);
+
+    if (!issue) {
+      exitWithError(`issue ${identifier} not found`, undefined, EXIT_CODES.NOT_FOUND);
+    }
+
+    if (options.open) {
+      const { exec } = await import("child_process");
+      exec(`open "${issue.url}"`);
+      console.log(`opened ${issue.url}`);
+      return;
+    }
+
+    if (options.comment) {
+      await addComment(client, issue.id, options.comment);
+      console.log(`commented on ${identifier}`);
+      return;
+    }
+
+    const updatePayload: Record<string, unknown> = {};
+
+    if (options.state) {
+      const rawIssue = await (client as unknown as { issue: (id: string) => Promise<{ team?: { id: string } | null } | null> }).issue(identifier);
+      const teamRef = rawIssue && 'team' in rawIssue ? await (rawIssue as unknown as { team: Promise<{ id: string } | null> }).team : null;
+      if (!teamRef) {
+        exitWithError("could not determine team for issue");
+      }
+      const states = await getTeamStates(client, teamRef.id);
+      const targetState = states.find(
+        (s) => s.name.toLowerCase() === options.state!.toLowerCase()
+      );
+      if (!targetState) {
+        const available = states.map((s) => s.name).join(", ");
+        exitWithError(
+          `state "${options.state}" not found`,
+          `available states: ${available}`
+        );
+      }
+      updatePayload.stateId = targetState.id;
+    }
+
+    if (options.assignee) {
+      if (options.assignee === "@me") {
+        const viewer = await client.viewer;
+        updatePayload.assigneeId = viewer.id;
+      } else {
+        const users = await client.users({ filter: { email: { eq: options.assignee } } });
+        const user = users.nodes[0];
+        if (!user) {
+          exitWithError(`user "${options.assignee}" not found`);
+        }
+        updatePayload.assigneeId = user.id;
+      }
+    }
+
+    if (options.priority) {
+      updatePayload.priority = priorityFromString(options.priority);
+    }
+
+    if (options.label) {
+      const isAdd = options.label.startsWith("+");
+      const isRemove = options.label.startsWith("-");
+      const labelName = isAdd || isRemove ? options.label.slice(1) : options.label;
+
+      const rawIssue = await (client as unknown as { issue: (id: string) => Promise<{ team?: { id: string } | null; labels: () => Promise<{ nodes: { id: string }[] }> } | null> }).issue(identifier);
+      const teamRef = rawIssue && 'team' in rawIssue ? await (rawIssue as unknown as { team: Promise<{ id: string } | null> }).team : null;
+      if (!teamRef) {
+        exitWithError("could not determine team for issue");
+      }
+
+      const labels = await getTeamLabels(client, teamRef.id);
+      const targetLabel = labels.find(
+        (l) => l.name.toLowerCase() === labelName.toLowerCase()
+      );
+      if (!targetLabel) {
+        const available = labels.map((l) => l.name).join(", ");
+        exitWithError(`label "${labelName}" not found`, `available labels: ${available}`);
+      }
+
+      const currentLabelsData = rawIssue ? await rawIssue.labels() : { nodes: [] };
+      const currentLabelIds = currentLabelsData.nodes.map((l) => l.id);
+
+      if (isRemove) {
+        updatePayload.labelIds = currentLabelIds.filter((id) => id !== targetLabel.id);
+      } else {
+        if (!currentLabelIds.includes(targetLabel.id)) {
+          updatePayload.labelIds = [...currentLabelIds, targetLabel.id];
+        }
+      }
+    }
+
+    if (Object.keys(updatePayload).length > 0) {
+      await updateIssue(client, issue.id, updatePayload);
+      console.log(`updated ${identifier}`);
+    }
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+async function handleCreateIssue(options: CreateOptions): Promise<void> {
+  if (!options.team) {
+    exitWithError("--team is required", "usage: li issue new --team ENG --title \"...\"");
+  }
+
+  if (!options.title) {
+    exitWithError("--title is required", "usage: li issue new --team ENG --title \"...\"");
+  }
+
+  try {
+    const client = getClient();
+    const team = await findTeamByKeyOrName(client, options.team);
+
+    if (!team) {
+      const available = (await getAvailableTeamKeys(client)).join(", ");
+      exitWithError(`team "${options.team}" not found`, `available teams: ${available}`);
+    }
+
+    const createPayload: {
+      teamId: string;
+      title: string;
+      description?: string;
+      assigneeId?: string;
+      priority?: number;
+      labelIds?: string[];
+    } = {
+      teamId: team.id,
+      title: options.title,
+    };
+
+    if (options.description) {
+      createPayload.description = options.description;
+    }
+
+    if (options.assignee) {
+      if (options.assignee === "@me") {
+        const viewer = await client.viewer;
+        createPayload.assigneeId = viewer.id;
+      } else {
+        const users = await client.users({ filter: { email: { eq: options.assignee } } });
+        const user = users.nodes[0];
+        if (!user) {
+          exitWithError(`user "${options.assignee}" not found`);
+        }
+        createPayload.assigneeId = user.id;
+      }
+    }
+
+    if (options.priority) {
+      createPayload.priority = priorityFromString(options.priority);
+    }
+
+    if (options.label) {
+      const labels = await getTeamLabels(client, team.id);
+      const targetLabel = labels.find(
+        (l) => l.name.toLowerCase() === options.label!.toLowerCase()
+      );
+      if (!targetLabel) {
+        const available = labels.map((l) => l.name).join(", ");
+        exitWithError(`label "${options.label}" not found`, `available labels: ${available}`);
+      }
+      createPayload.labelIds = [targetLabel.id];
+    }
+
+    const issue = await createIssue(client, createPayload);
+    if (issue) {
+      console.log(`created ${issue.identifier}: ${issue.title}`);
+    } else {
+      console.log("created issue");
+    }
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+export function registerIssuesCommand(program: Command): void {
+  program
+    .command("issues")
+    .description("list issues")
+    .option("--team <key>", "filter by team key")
+    .option("--state <state>", "filter by state name")
+    .option("--assignee <email>", "filter by assignee (@me for self)")
+    .option("--label <label>", "filter by label")
+    .option("--project <project>", "filter by project name")
+    .option("--json", "output as JSON")
+    .option("--quiet", "output issue IDs only")
+    .option("--verbose", "show table headers")
+    .action(async (options: ListOptions) => {
+      await handleListIssues(options);
+    });
+
+  program
+    .command("issue <id>")
+    .description("show or update an issue, or create with 'new'")
+    .option("--json", "output as JSON")
+    .option("--open", "open issue in browser")
+    .option("--state <state>", "update state")
+    .option("--assignee <email>", "update assignee (@me for self)")
+    .option("--priority <priority>", "update priority (urgent, high, medium, low)")
+    .option("--label <label>", "add (+label) or remove (-label) a label")
+    .option("--comment <text>", "add a comment")
+    .option("--team <key>", "team for new issue")
+    .option("--title <title>", "title for new issue")
+    .option("--description <description>", "description for new issue")
+    .action(async (id: string, options: ShowOptions & UpdateOptions & CreateOptions) => {
+      if (id === "new") {
+        await handleCreateIssue(options);
+        return;
+      }
+
+      const hasUpdate =
+        options.state || options.assignee || options.priority || options.label || options.comment;
+
+      if (hasUpdate) {
+        await handleUpdateIssue(id, options);
+      } else {
+        await handleShowIssue(id, options);
+      }
+    });
+
+  program
+    .command("i")
+    .description("alias for issues")
+    .option("--team <key>", "filter by team key")
+    .option("--state <state>", "filter by state name")
+    .option("--assignee <email>", "filter by assignee (@me for self)")
+    .option("--label <label>", "filter by label")
+    .option("--project <project>", "filter by project name")
+    .option("--json", "output as JSON")
+    .option("--quiet", "output issue IDs only")
+    .option("--verbose", "show table headers")
+    .argument("[subcommand]", "subcommand (new)")
+    .action(async (subcommand: string | undefined, options: ListOptions & CreateOptions) => {
+      if (subcommand === "new") {
+        await handleCreateIssue(options);
+        return;
+      }
+      await handleListIssues(options);
+    });
+}

package/src/commands/me.ts

@@ -0,0 +1,110 @@
+import type { Command } from "commander";
+import {
+  getClient,
+  getViewer,
+  getMyIssues,
+  getMyCreatedIssues,
+} from "@bdsqqq/lnr-core";
+import { handleApiError } from "../lib/error";
+import {
+  getOutputFormat,
+  outputJson,
+  outputQuiet,
+  outputTable,
+  formatPriority,
+  truncate,
+  type OutputOptions,
+} from "../lib/output";
+
+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);
+
+      try {
+        const client = getClient();
+
+        if (options.issues) {
+          const issues = await getMyIssues(client);
+
+          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, 40), width: 40 },
+            { header: "STATE", value: (i) => i.state ?? "-", width: 16 },
+            { header: "PRIORITY", value: (i) => formatPriority(i.priority), width: 10 },
+          ]);
+          return;
+        }
+
+        if (options.created) {
+          const issues = await getMyCreatedIssues(client);
+
+          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, 40), width: 40 },
+            { header: "STATE", value: (i) => i.state ?? "-", width: 16 },
+            { header: "PRIORITY", value: (i) => formatPriority(i.priority), width: 10 },
+          ]);
+          return;
+        }
+
+        const viewer = await getViewer(client);
+
+        if (format === "json") {
+          outputJson(viewer);
+          return;
+        }
+
+        if (format === "quiet") {
+          console.log(viewer.id);
+          return;
+        }
+
+        console.log(`${viewer.name}`);
+        console.log(`email: ${viewer.email}`);
+        if (viewer.displayName && viewer.displayName !== viewer.name) {
+          console.log(`display name: ${viewer.displayName}`);
+        }
+        console.log(`admin: ${viewer.admin ? "yes" : "no"}`);
+      } catch (error) {
+        handleApiError(error);
+      }
+    });
+}

package/src/commands/projects.ts

@@ -0,0 +1,214 @@
+import type { Command } from "commander";
+import {
+  getClient,
+  listProjects,
+  getProject,
+  getProjectIssues,
+  createProject,
+  deleteProject,
+  findTeamByKeyOrName,
+  getAvailableTeamKeys,
+} from "@bdsqqq/lnr-core";
+import { handleApiError, exitWithError, EXIT_CODES } from "../lib/error";
+import {
+  outputJson,
+  outputQuiet,
+  outputTable,
+  getOutputFormat,
+  formatDate,
+  truncate,
+  type OutputOptions,
+} from "../lib/output";
+
+interface CreateProjectOptions {
+  name?: string;
+  team?: string;
+  description?: string;
+}
+
+async function handleCreateProject(options: CreateProjectOptions): Promise<void> {
+  if (!options.name) {
+    exitWithError("--name is required", "usage: li project new --name \"...\"");
+  }
+
+  try {
+    const client = getClient();
+    let teamIds: string[] = [];
+
+    if (options.team) {
+      const team = await findTeamByKeyOrName(client, options.team);
+      if (!team) {
+        const available = (await getAvailableTeamKeys(client)).join(", ");
+        exitWithError(`team "${options.team}" not found`, `available teams: ${available}`, EXIT_CODES.NOT_FOUND);
+      }
+      teamIds = [team.id];
+    }
+
+    const project = await createProject(client, {
+      name: options.name,
+      description: options.description,
+      teamIds,
+    });
+
+    if (project) {
+      console.log(`created project: ${project.name}`);
+    } else {
+      console.log("created project");
+    }
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+async function handleDeleteProject(name: string): Promise<void> {
+  try {
+    const client = getClient();
+    const success = await deleteProject(client, name);
+
+    if (!success) {
+      exitWithError(`project "${name}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+    }
+
+    console.log(`deleted project: ${name}`);
+  } catch (error) {
+    handleApiError(error);
+  }
+}
+
+export function registerProjectsCommand(program: Command): void {
+  program
+    .command("projects")
+    .description("list projects")
+    .option("--team <team>", "filter by team")
+    .option("--status <status>", "filter by status (active, completed, canceled, paused)")
+    .option("--json", "output as json")
+    .option("--quiet", "output ids only")
+    .option("--verbose", "show detailed output")
+    .action(async (options: { team?: string; status?: string; json?: boolean; quiet?: boolean; verbose?: boolean }) => {
+      try {
+        const client = getClient();
+
+        const outputOpts: OutputOptions = {
+          format: options.json ? "json" : options.quiet ? "quiet" : undefined,
+          verbose: options.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        const projects = await listProjects(client, { team: options.team, status: options.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);
+      }
+    });
+
+  program
+    .command("project <name>")
+    .description("show project details, create with 'new', or delete with --delete")
+    .option("--issues", "list issues in project")
+    .option("--json", "output as json")
+    .option("--quiet", "output ids only")
+    .option("--verbose", "show detailed output")
+    .option("--delete", "delete/archive the project")
+    .option("--name <name>", "name for new project")
+    .option("--team <team>", "team for new project")
+    .option("--description <description>", "description for new project")
+    .action(async (name: string, options: { issues?: boolean; json?: boolean; quiet?: boolean; verbose?: boolean; delete?: boolean; name?: string; team?: string; description?: string }) => {
+      if (name === "new") {
+        await handleCreateProject(options);
+        return;
+      }
+
+      if (options.delete) {
+        await handleDeleteProject(name);
+        return;
+      }
+
+      try {
+        const client = getClient();
+
+        const outputOpts: OutputOptions = {
+          format: options.json ? "json" : options.quiet ? "quiet" : undefined,
+          verbose: options.verbose,
+        };
+        const format = getOutputFormat(outputOpts);
+
+        const project = await getProject(client, name);
+
+        if (!project) {
+          exitWithError(`project "${name}" not found`, undefined, EXIT_CODES.NOT_FOUND);
+        }
+
+        if (options.issues) {
+          const issues = await getProjectIssues(client, 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);
+      }
+    });
+
+  program
+    .command("p")
+    .description("alias for projects")
+    .option("--team <team>", "filter by team")
+    .option("--status <status>", "filter by status")
+    .option("--json", "output as json")
+    .option("--quiet", "output ids only")
+    .option("--verbose", "show detailed output")
+    .action(async (options: { team?: string; status?: string; json?: boolean; quiet?: boolean; verbose?: boolean }) => {
+      await program.commands.find((c) => c.name() === "projects")?.parseAsync(["projects", ...process.argv.slice(3)], { from: "user" });
+    });
+}

package/src/commands/search.ts

@@ -0,0 +1,52 @@
+import type { Command } from "commander";
+import { getClient, searchIssues } from "@bdsqqq/lnr-core";
+import { handleApiError } from "../lib/error";
+import {
+  getOutputFormat,
+  outputJson,
+  outputQuiet,
+  outputTable,
+  truncate,
+  type OutputOptions,
+} from "../lib/output";
+
+interface SearchOptions extends OutputOptions {
+  team?: string;
+  json?: boolean;
+  quiet?: boolean;
+}
+
+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);
+
+      try {
+        const client = getClient();
+        const issues = await searchIssues(client, query, { team: options.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: 12 },
+          { header: "TITLE", value: (i) => truncate(i.title, 50), width: 50 },
+          { header: "STATE", value: (i) => i.state ?? "-", width: 16 },
+        ]);
+      } catch (error) {
+        handleApiError(error);
+      }
+    });
+}

package/src/commands/teams.ts

@@ -0,0 +1,115 @@
+import type { Command } from "commander";
+import {
+  getClient,
+  listTeams,
+  getTeam,
+  getTeamMembers,
+  getAvailableTeamKeys,
+} from "@bdsqqq/lnr-core";
+import { handleApiError, exitWithError, EXIT_CODES } from "../lib/error";
+import {
+  getOutputFormat,
+  outputJson,
+  outputQuiet,
+  outputTable,
+  type OutputOptions,
+} from "../lib/output";
+
+interface TeamListOptions extends OutputOptions {
+  json?: boolean;
+  quiet?: boolean;
+}
+
+interface TeamShowOptions extends OutputOptions {
+  members?: boolean;
+  json?: boolean;
+}
+
+export function registerTeamsCommand(program: Command): void {
+  program
+    .command("teams")
+    .alias("t")
+    .description("list teams")
+    .option("--json", "output as json")
+    .option("--quiet", "output ids only")
+    .action(async (options: TeamListOptions) => {
+      const format = options.json ? "json" : options.quiet ? "quiet" : getOutputFormat(options);
+
+      try {
+        const client = getClient();
+        const teams = await listTeams(client);
+
+        if (format === "json") {
+          outputJson(teams);
+          return;
+        }
+
+        if (format === "quiet") {
+          outputQuiet(teams.map((t) => t.key));
+          return;
+        }
+
+        outputTable(teams, [
+          { header: "KEY", value: (t) => t.key, width: 8 },
+          { header: "NAME", value: (t) => t.name, width: 24 },
+          { header: "DESCRIPTION", value: (t) => t.description ?? "-", width: 40 },
+        ]);
+      } catch (error) {
+        handleApiError(error);
+      }
+    });
+
+  program
+    .command("team <key>")
+    .description("show team details")
+    .option("--members", "show team members")
+    .option("--json", "output as json")
+    .action(async (key: string, options: TeamShowOptions) => {
+      const format = options.json ? "json" : getOutputFormat(options);
+
+      try {
+        const client = getClient();
+        const team = await getTeam(client, key);
+
+        if (!team) {
+          const availableKeys = (await getAvailableTeamKeys(client)).join(", ");
+          exitWithError(
+            `team "${key}" not found`,
+            `available teams: ${availableKeys}`,
+            EXIT_CODES.NOT_FOUND
+          );
+        }
+
+        if (options.members) {
+          const members = await getTeamMembers(client, key);
+
+          if (format === "json") {
+            outputJson(members);
+            return;
+          }
+
+          console.log(`${team.name} (${team.key}) members:\n`);
+          outputTable(members, [
+            { header: "NAME", value: (m) => m.name, width: 24 },
+            { header: "EMAIL", value: (m) => m.email ?? "-", width: 32 },
+            { header: "ACTIVE", value: (m) => (m.active ? "yes" : "no"), width: 8 },
+          ]);
+          return;
+        }
+
+        if (format === "json") {
+          outputJson(team);
+          return;
+        }
+
+        console.log(`${team.name} (${team.key})`);
+        if (team.description) {
+          console.log(team.description);
+        }
+        console.log(`timezone: ${team.timezone ?? "-"}`);
+        console.log(`private: ${team.private ? "yes" : "no"}`);
+      } catch (error) {
+        handleApiError(error);
+      }
+    });
+}

package/src/lib/error.ts

@@ -0,0 +1,43 @@
+import chalk from "chalk";
+
+export const EXIT_CODES = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  AUTH_ERROR: 2,
+  NOT_FOUND: 3,
+  RATE_LIMITED: 4,
+} as const;
+
+export function exitWithError(
+  message: string,
+  hint?: string,
+  code: number = EXIT_CODES.GENERAL_ERROR
+): never {
+  console.error(chalk.red(`error: ${message}`));
+  if (hint) {
+    console.error(chalk.dim(`  ${hint}`));
+  }
+  process.exit(code);
+}
+
+export function handleApiError(error: unknown): never {
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+
+    if (msg.includes("unauthorized") || msg.includes("authentication")) {
+      exitWithError("not authenticated", "run: li auth <api-key>", EXIT_CODES.AUTH_ERROR);
+    }
+
+    if (msg.includes("not found")) {
+      exitWithError(msg, undefined, EXIT_CODES.NOT_FOUND);
+    }
+
+    if (msg.includes("rate limit")) {
+      exitWithError("rate limited, retry in 30s", undefined, EXIT_CODES.RATE_LIMITED);
+    }
+
+    exitWithError(msg);
+  }
+
+  exitWithError("unknown error occurred");
+}

package/src/lib/output.ts

@@ -0,0 +1,99 @@
+import chalk from "chalk";
+import { getConfigValue } from "@bdsqqq/lnr-core";
+
+export type OutputFormat = "table" | "json" | "quiet";
+
+export interface OutputOptions {
+  format?: OutputFormat;
+  verbose?: boolean;
+}
+
+export function getOutputFormat(options: OutputOptions): OutputFormat {
+  if (options.format) {
+    return options.format;
+  }
+  return getConfigValue("output_format") ?? "table";
+}
+
+export function outputJson(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function outputQuiet(ids: string[]): void {
+  for (const id of ids) {
+    console.log(id);
+  }
+}
+
+export interface TableColumn<T> {
+  header: string;
+  value: (item: T) => string;
+  width?: number;
+}
+
+export function outputTable<T>(
+  items: T[],
+  columns: TableColumn<T>[],
+  options: OutputOptions = {}
+): void {
+  if (items.length === 0) {
+    console.log(chalk.dim("no results"));
+    return;
+  }
+
+  const widths: number[] = columns.map((col) => {
+    const headerLen = col.header.length;
+    const maxValueLen = Math.max(
+      ...items.map((item) => col.value(item).length)
+    );
+    return col.width ?? Math.max(headerLen, maxValueLen);
+  });
+
+  if (options.verbose) {
+    const headerLine = columns
+      .map((col, i) => col.header.padEnd(widths[i] ?? 10))
+      .join("  ");
+    console.log(chalk.dim(headerLine));
+    console.log(chalk.dim("-".repeat(headerLine.length)));
+  }
+
+  for (const item of items) {
+    const line = columns
+      .map((col, i) => {
+        const val = col.value(item);
+        const w = widths[i] ?? 10;
+        return val.slice(0, w).padEnd(w);
+      })
+      .join("  ");
+    console.log(line);
+  }
+}
+
+export function truncate(str: string, maxLen: number): string {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "…";
+}
+
+export function formatDate(date: Date | string | undefined | null): string {
+  if (!date) return "-";
+  const d = typeof date === "string" ? new Date(date) : date;
+  const result = d.toISOString().split("T")[0];
+  return result ?? "-";
+}
+
+export function formatPriority(priority: number | undefined): string {
+  switch (priority) {
+    case 0:
+      return "-";
+    case 1:
+      return "urgent";
+    case 2:
+      return "high";
+    case 3:
+      return "medium";
+    case 4:
+      return "low";
+    default:
+      return "-";
+  }
+}