@bdsqqq/lnr-core 0.1.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@bdsqqq/lnr-core",
+  "version": "0.1.0",
+  "description": "core business logic for linear-cli",
+  "type": "module",
+  "private": false,
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bdsqqq/lnr.git",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "author": "bdsqqq",
+  "scripts": {
+    "check": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@linear/sdk": "^68.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/src/client.ts

@@ -0,0 +1,33 @@
+import { LinearClient } from "@linear/sdk";
+import { getApiKey } from "./config";
+
+let clientInstance: LinearClient | null = null;
+
+export class NotAuthenticatedError extends Error {
+  constructor() {
+    super("not authenticated");
+    this.name = "NotAuthenticatedError";
+  }
+}
+
+export function getClient(): LinearClient {
+  if (clientInstance) {
+    return clientInstance;
+  }
+
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new NotAuthenticatedError();
+  }
+
+  clientInstance = new LinearClient({ apiKey });
+  return clientInstance;
+}
+
+export function createClientWithKey(apiKey: string): LinearClient {
+  return new LinearClient({ apiKey });
+}
+
+export function resetClient(): void {
+  clientInstance = null;
+}

package/src/config.test.ts

@@ -0,0 +1,44 @@
+import { describe, test, expect, afterEach, beforeAll } from "bun:test";
+import {
+  loadConfig,
+  saveConfig,
+  getConfigValue,
+  setConfigValue,
+  type Config,
+} from "./config";
+
+describe("config core", () => {
+  let originalConfig: Config;
+
+  beforeAll(() => {
+    originalConfig = loadConfig();
+  });
+
+  afterEach(() => {
+    saveConfig(originalConfig);
+  });
+
+  test("loadConfig returns object", () => {
+    const config = loadConfig();
+    expect(typeof config).toBe("object");
+  });
+
+  test("setConfigValue and getConfigValue work", () => {
+    const testValue = "TEST_TEAM_VALUE";
+    setConfigValue("default_team", testValue);
+    expect(getConfigValue("default_team")).toBe(testValue);
+  });
+
+  test("saveConfig and loadConfig roundtrip", () => {
+    const testConfig: Config = {
+      api_key: "test_key",
+      default_team: "TEST",
+      output_format: "json",
+    };
+    saveConfig(testConfig);
+    const loaded = loadConfig();
+    expect(loaded.api_key).toBe(testConfig.api_key);
+    expect(loaded.default_team).toBe(testConfig.default_team);
+    expect(loaded.output_format).toBe(testConfig.output_format);
+  });
+});

package/src/config.ts

@@ -0,0 +1,65 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+
+export interface Config {
+  api_key?: string;
+  default_team?: string;
+  output_format?: "table" | "json" | "quiet";
+}
+
+const CONFIG_DIR = join(homedir(), ".linear-cli");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+export function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function loadConfig(): Config {
+  ensureConfigDir();
+  if (!existsSync(CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(config: Config): void {
+  ensureConfigDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+export function getApiKey(): string | undefined {
+  return loadConfig().api_key;
+}
+
+export function setApiKey(key: string): void {
+  const config = loadConfig();
+  config.api_key = key;
+  saveConfig(config);
+}
+
+export function clearApiKey(): void {
+  const config = loadConfig();
+  delete config.api_key;
+  saveConfig(config);
+}
+
+export function getConfigValue<K extends keyof Config>(key: K): Config[K] {
+  return loadConfig()[key];
+}
+
+export function setConfigValue<K extends keyof Config>(
+  key: K,
+  value: Config[K]
+): void {
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+}

package/src/cycles.test.ts

@@ -0,0 +1,45 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { LinearClient } from "@linear/sdk";
+import { getApiKey } from "./config";
+import { listCycles, getCurrentCycle } from "./cycles";
+import { getAvailableTeamKeys } from "./teams";
+
+function getTestClient(): LinearClient {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("no api key configured - run: li auth <api-key>");
+  }
+  return new LinearClient({ apiKey });
+}
+
+describe("cycles core", () => {
+  let client: LinearClient;
+  let teamKey: string;
+
+  beforeAll(async () => {
+    client = getTestClient();
+    const keys = await getAvailableTeamKeys(client);
+    teamKey = keys.includes("BDSQ") ? "BDSQ" : keys[0] ?? "UNKNOWN";
+  });
+
+  test("listCycles returns cycle array", async () => {
+    const cycles = await listCycles(client, teamKey);
+    expect(Array.isArray(cycles)).toBe(true);
+    if (cycles.length > 0) {
+      expect(cycles[0]).toHaveProperty("id");
+      expect(cycles[0]).toHaveProperty("number");
+      expect(cycles[0]).toHaveProperty("startsAt");
+      expect(cycles[0]).toHaveProperty("endsAt");
+    }
+  });
+
+  test("listCycles returns empty for invalid team", async () => {
+    const cycles = await listCycles(client, "INVALID_KEY_XYZ");
+    expect(cycles).toEqual([]);
+  });
+
+  test("getCurrentCycle returns null for invalid team", async () => {
+    const cycle = await getCurrentCycle(client, "INVALID_KEY_XYZ");
+    expect(cycle).toBeNull();
+  });
+});

package/src/cycles.ts

@@ -0,0 +1,93 @@
+import type { LinearClient } from "@linear/sdk";
+import type { Cycle, Issue } from "./types";
+
+export async function listCycles(
+  client: LinearClient,
+  teamKey: string
+): Promise<Cycle[]> {
+  try {
+    const team = await client.team(teamKey);
+
+    if (!team) {
+      return [];
+    }
+
+    const cyclesConnection = await team.cycles();
+    return cyclesConnection.nodes.map((c) => ({
+      id: c.id,
+      number: c.number,
+      name: c.name,
+      startsAt: c.startsAt,
+      endsAt: c.endsAt,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export async function getCurrentCycle(
+  client: LinearClient,
+  teamKey: string
+): Promise<Cycle | null> {
+  try {
+    const team = await client.team(teamKey);
+
+    if (!team) {
+      return null;
+    }
+
+    const activeCycle = await team.activeCycle;
+
+    if (!activeCycle) {
+      return null;
+    }
+
+    return {
+      id: activeCycle.id,
+      number: activeCycle.number,
+      name: activeCycle.name,
+      startsAt: activeCycle.startsAt,
+      endsAt: activeCycle.endsAt,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function getCycleIssues(
+  client: LinearClient,
+  teamKey: string
+): Promise<Issue[]> {
+  try {
+    const team = await client.team(teamKey);
+
+    if (!team) {
+      return [];
+    }
+
+    const activeCycle = await team.activeCycle;
+
+    if (!activeCycle) {
+      return [];
+    }
+
+    const issuesConnection = await activeCycle.issues();
+
+    return Promise.all(
+      issuesConnection.nodes.map(async (i) => ({
+        id: i.id,
+        identifier: i.identifier,
+        title: i.title,
+        description: i.description,
+        state: (await i.state)?.name ?? null,
+        assignee: (await i.assignee)?.name ?? null,
+        priority: i.priority,
+        createdAt: i.createdAt,
+        updatedAt: i.updatedAt,
+        url: i.url,
+      }))
+    );
+  } catch {
+    return [];
+  }
+}

package/src/index.ts

@@ -0,0 +1,73 @@
+// types
+export type {
+  Issue,
+  Project,
+  Team,
+  TeamMember,
+  Cycle,
+  User,
+  ListIssuesFilter,
+  CreateIssueInput,
+  UpdateIssueInput,
+  CreateProjectInput,
+} from "./types";
+
+// client
+export {
+  getClient,
+  createClientWithKey,
+  resetClient,
+  NotAuthenticatedError,
+} from "./client";
+
+// config
+export {
+  loadConfig,
+  saveConfig,
+  getApiKey,
+  setApiKey,
+  clearApiKey,
+  getConfigValue,
+  setConfigValue,
+  ensureConfigDir,
+  type Config,
+} from "./config";
+
+// issues
+export {
+  listIssues,
+  getIssue,
+  createIssue,
+  updateIssue,
+  addComment,
+  priorityFromString,
+  getTeamStates,
+  getTeamLabels,
+} from "./issues";
+
+// projects
+export {
+  listProjects,
+  getProject,
+  getProjectIssues,
+  createProject,
+  deleteProject,
+} from "./projects";
+
+// teams
+export {
+  listTeams,
+  getTeam,
+  getTeamMembers,
+  findTeamByKeyOrName,
+  getAvailableTeamKeys,
+} from "./teams";
+
+// cycles
+export { listCycles, getCurrentCycle, getCycleIssues } from "./cycles";
+
+// me
+export { getViewer, getMyIssues, getMyCreatedIssues } from "./me";
+
+// search
+export { searchIssues } from "./search";

package/src/issues.test.ts

@@ -0,0 +1,66 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { LinearClient } from "@linear/sdk";
+import { getApiKey } from "./config";
+import { listIssues, getIssue, createIssue, priorityFromString } from "./issues";
+
+const TEST_PREFIX = "[TEST-CLI]";
+
+function getTestClient(): LinearClient {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("no api key configured - run: li auth <api-key>");
+  }
+  return new LinearClient({ apiKey });
+}
+
+async function getFirstTeamKey(): Promise<string> {
+  const client = getTestClient();
+  const teams = await client.teams();
+  const bdsq = teams.nodes.find((t) => t.key === "BDSQ");
+  if (bdsq) return bdsq.key;
+  const first = teams.nodes[0];
+  if (!first) throw new Error("no teams found");
+  return first.key;
+}
+
+describe("issues core", () => {
+  let client: LinearClient;
+  let teamKey: string;
+
+  beforeAll(async () => {
+    client = getTestClient();
+    teamKey = await getFirstTeamKey();
+  });
+
+  test("priorityFromString converts priority names", () => {
+    expect(priorityFromString("urgent")).toBe(1);
+    expect(priorityFromString("high")).toBe(2);
+    expect(priorityFromString("medium")).toBe(3);
+    expect(priorityFromString("low")).toBe(4);
+    expect(priorityFromString("none")).toBe(0);
+    expect(priorityFromString("unknown")).toBe(0);
+  });
+
+  test("listIssues returns issue array", async () => {
+    const issues = await listIssues(client);
+    expect(Array.isArray(issues)).toBe(true);
+    if (issues.length > 0) {
+      expect(issues[0]).toHaveProperty("id");
+      expect(issues[0]).toHaveProperty("identifier");
+      expect(issues[0]).toHaveProperty("title");
+    }
+  });
+
+  test("listIssues filters by team", async () => {
+    const issues = await listIssues(client, { team: teamKey });
+    expect(Array.isArray(issues)).toBe(true);
+    for (const issue of issues) {
+      expect(issue.identifier.startsWith(teamKey + "-")).toBe(true);
+    }
+  });
+
+  test("getIssue returns null for nonexistent issue", async () => {
+    const issue = await getIssue(client, "NONEXISTENT-99999");
+    expect(issue).toBeNull();
+  });
+});

package/src/issues.ts

@@ -0,0 +1,182 @@
+import type { LinearClient } from "@linear/sdk";
+import type { Issue, ListIssuesFilter, CreateIssueInput, UpdateIssueInput } from "./types";
+
+export function priorityFromString(priority: string): number {
+  switch (priority.toLowerCase()) {
+    case "urgent":
+      return 1;
+    case "high":
+      return 2;
+    case "medium":
+      return 3;
+    case "low":
+      return 4;
+    case "none":
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+export async function listIssues(
+  client: LinearClient,
+  filter: ListIssuesFilter = {}
+): Promise<Issue[]> {
+  const apiFilter: Record<string, unknown> = {};
+
+  if (filter.team) {
+    apiFilter.team = { key: { eq: filter.team } };
+  }
+
+  if (filter.state) {
+    apiFilter.state = { name: { eqIgnoreCase: filter.state } };
+  }
+
+  if (filter.assignee) {
+    if (filter.assignee === "@me") {
+      const viewer = await client.viewer;
+      apiFilter.assignee = { id: { eq: viewer.id } };
+    } else {
+      apiFilter.assignee = { email: { eq: filter.assignee } };
+    }
+  }
+
+  if (filter.label) {
+    apiFilter.labels = { some: { name: { eqIgnoreCase: filter.label } } };
+  }
+
+  if (filter.project) {
+    apiFilter.project = { name: { eqIgnoreCase: filter.project } };
+  }
+
+  const issues = await client.issues({ filter: apiFilter });
+  const nodes = issues.nodes;
+
+  return Promise.all(
+    nodes.map(async (n) => ({
+      id: n.id,
+      identifier: n.identifier,
+      title: n.title,
+      description: n.description,
+      state: (await n.state)?.name ?? null,
+      assignee: (await n.assignee)?.name ?? null,
+      priority: n.priority,
+      createdAt: n.createdAt,
+      updatedAt: n.updatedAt,
+      url: n.url,
+    }))
+  );
+}
+
+export async function getIssue(
+  client: LinearClient,
+  identifier: string
+): Promise<Issue | null> {
+  try {
+    const issue = await client.issue(identifier);
+
+    if (!issue) {
+      return null;
+    }
+
+    const state = await issue.state;
+    const assignee = await issue.assignee;
+
+    return {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description,
+      state: state?.name ?? null,
+      assignee: assignee?.name ?? null,
+      priority: issue.priority,
+      createdAt: issue.createdAt,
+      updatedAt: issue.updatedAt,
+      url: issue.url,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function createIssue(
+  client: LinearClient,
+  input: CreateIssueInput
+): Promise<Issue | null> {
+  const result = await client.createIssue(input);
+
+  if (!result.success) {
+    return null;
+  }
+
+  const issueData = (result as unknown as { _issue?: { id: string } })._issue;
+  if (!issueData?.id) {
+    return null;
+  }
+
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const createdIssue = await client.issue(issueData.id);
+      if (createdIssue) {
+        const state = await createdIssue.state;
+        const assignee = await createdIssue.assignee;
+        return {
+          id: createdIssue.id,
+          identifier: createdIssue.identifier,
+          title: createdIssue.title,
+          description: createdIssue.description,
+          state: state?.name ?? null,
+          assignee: assignee?.name ?? null,
+          priority: createdIssue.priority,
+          createdAt: createdIssue.createdAt,
+          updatedAt: createdIssue.updatedAt,
+          url: createdIssue.url,
+        };
+      }
+    } catch {
+      if (attempt < 2) await new Promise((r) => setTimeout(r, 300));
+    }
+  }
+
+  return null;
+}
+
+export async function updateIssue(
+  client: LinearClient,
+  issueId: string,
+  input: UpdateIssueInput
+): Promise<boolean> {
+  const result = await client.updateIssue(issueId, input);
+  return result.success;
+}
+
+export async function addComment(
+  client: LinearClient,
+  issueId: string,
+  body: string
+): Promise<boolean> {
+  const result = await client.createComment({ issueId, body });
+  return result.success;
+}
+
+export async function getTeamStates(
+  client: LinearClient,
+  teamId: string
+): Promise<Array<{ id: string; name: string }>> {
+  const team = await client.team(teamId);
+  if (!team) return [];
+
+  const states = await team.states();
+  return states.nodes.map((s) => ({ id: s.id, name: s.name }));
+}
+
+export async function getTeamLabels(
+  client: LinearClient,
+  teamId: string
+): Promise<Array<{ id: string; name: string }>> {
+  const team = await client.team(teamId);
+  if (!team) return [];
+
+  const labels = await team.labels();
+  return labels.nodes.map((l) => ({ id: l.id, name: l.name }));
+}

package/src/me.test.ts

@@ -0,0 +1,49 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { LinearClient } from "@linear/sdk";
+import { getApiKey } from "./config";
+import { getViewer, getMyIssues, getMyCreatedIssues } from "./me";
+
+function getTestClient(): LinearClient {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("no api key configured - run: li auth <api-key>");
+  }
+  return new LinearClient({ apiKey });
+}
+
+describe("me core", () => {
+  let client: LinearClient;
+
+  beforeAll(() => {
+    client = getTestClient();
+  });
+
+  test("getViewer returns current user", async () => {
+    const viewer = await getViewer(client);
+    expect(viewer).toHaveProperty("id");
+    expect(viewer).toHaveProperty("name");
+    expect(viewer).toHaveProperty("email");
+    expect(viewer).toHaveProperty("active");
+    expect(viewer).toHaveProperty("admin");
+  });
+
+  test("getMyIssues returns issue array", async () => {
+    const issues = await getMyIssues(client);
+    expect(Array.isArray(issues)).toBe(true);
+    if (issues.length > 0) {
+      expect(issues[0]).toHaveProperty("id");
+      expect(issues[0]).toHaveProperty("identifier");
+      expect(issues[0]).toHaveProperty("title");
+    }
+  });
+
+  test("getMyCreatedIssues returns issue array", async () => {
+    const issues = await getMyCreatedIssues(client);
+    expect(Array.isArray(issues)).toBe(true);
+    if (issues.length > 0) {
+      expect(issues[0]).toHaveProperty("id");
+      expect(issues[0]).toHaveProperty("identifier");
+      expect(issues[0]).toHaveProperty("title");
+    }
+  });
+});

package/src/me.ts

@@ -0,0 +1,61 @@
+import type { LinearClient } from "@linear/sdk";
+import type { User, Issue } from "./types";
+
+export async function getViewer(client: LinearClient): Promise<User> {
+  const viewer = await client.viewer;
+
+  return {
+    id: viewer.id,
+    name: viewer.name,
+    email: viewer.email,
+    displayName: viewer.displayName,
+    active: viewer.active,
+    admin: viewer.admin,
+  };
+}
+
+export async function getMyIssues(client: LinearClient): Promise<Issue[]> {
+  const viewer = await client.viewer;
+  const issuesConnection = await viewer.assignedIssues({
+    filter: { state: { type: { nin: ["completed", "canceled"] } } },
+  });
+
+  return Promise.all(
+    issuesConnection.nodes.map(async (i) => ({
+      id: i.id,
+      identifier: i.identifier,
+      title: i.title,
+      description: i.description,
+      state: (await i.state)?.name ?? null,
+      assignee: (await i.assignee)?.name ?? null,
+      priority: i.priority,
+      createdAt: i.createdAt,
+      updatedAt: i.updatedAt,
+      url: i.url,
+    }))
+  );
+}
+
+export async function getMyCreatedIssues(
+  client: LinearClient
+): Promise<Issue[]> {
+  const viewer = await client.viewer;
+  const issuesConnection = await viewer.createdIssues({
+    filter: { state: { type: { nin: ["completed", "canceled"] } } },
+  });
+
+  return Promise.all(
+    issuesConnection.nodes.map(async (i) => ({
+      id: i.id,
+      identifier: i.identifier,
+      title: i.title,
+      description: i.description,
+      state: (await i.state)?.name ?? null,
+      assignee: (await i.assignee)?.name ?? null,
+      priority: i.priority,
+      createdAt: i.createdAt,
+      updatedAt: i.updatedAt,
+      url: i.url,
+    }))
+  );
+}

package/src/projects.test.ts

@@ -0,0 +1,42 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { LinearClient } from "@linear/sdk";
+import { getApiKey } from "./config";
+import { listProjects, getProject, createProject, deleteProject } from "./projects";
+
+const TEST_PREFIX = "[TEST-CLI]";
+
+function getTestClient(): LinearClient {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("no api key configured - run: li auth <api-key>");
+  }
+  return new LinearClient({ apiKey });
+}
+
+describe("projects core", () => {
+  let client: LinearClient;
+
+  beforeAll(() => {
+    client = getTestClient();
+  });
+
+  test("listProjects returns project array", async () => {
+    const projects = await listProjects(client);
+    expect(Array.isArray(projects)).toBe(true);
+    if (projects.length > 0) {
+      expect(projects[0]).toHaveProperty("id");
+      expect(projects[0]).toHaveProperty("name");
+      expect(projects[0]).toHaveProperty("state");
+    }
+  });
+
+  test("getProject returns null for nonexistent project", async () => {
+    const project = await getProject(client, "NONEXISTENT_PROJECT_XYZ_123");
+    expect(project).toBeNull();
+  });
+
+  test("deleteProject returns false for nonexistent project", async () => {
+    const result = await deleteProject(client, "NONEXISTENT_PROJECT_XYZ_123");
+    expect(result).toBe(false);
+  });
+});

package/src/projects.ts

@@ -0,0 +1,147 @@
+import type { LinearClient } from "@linear/sdk";
+import type { Issue, Project, CreateProjectInput } from "./types";
+
+export async function listProjects(
+  client: LinearClient,
+  options: { team?: string; status?: string } = {}
+): Promise<Project[]> {
+  let projectsConnection = await client.projects();
+
+  if (options.team) {
+    const teams = await client.teams();
+    const team = teams.nodes.find(
+      (t) =>
+        t.key.toLowerCase() === options.team!.toLowerCase() ||
+        t.name.toLowerCase() === options.team!.toLowerCase()
+    );
+    if (!team) {
+      return [];
+    }
+    projectsConnection = await team.projects();
+  }
+
+  let nodes = projectsConnection.nodes;
+
+  if (options.status) {
+    const statusLower = options.status.toLowerCase();
+    nodes = nodes.filter((p) => {
+      const state = p.state?.toLowerCase() ?? "";
+      return state === statusLower || state.includes(statusLower);
+    });
+  }
+
+  return nodes.map((p) => ({
+    id: p.id,
+    name: p.name,
+    description: p.description,
+    state: p.state,
+    progress: p.progress,
+    targetDate: p.targetDate,
+    startDate: p.startDate,
+    createdAt: p.createdAt,
+  }));
+}
+
+export async function getProject(
+  client: LinearClient,
+  nameOrId: string
+): Promise<Project | null> {
+  const projects = await client.projects();
+  const project = projects.nodes.find(
+    (p) => p.name.toLowerCase() === nameOrId.toLowerCase() || p.id === nameOrId
+  );
+
+  if (!project) {
+    return null;
+  }
+
+  return {
+    id: project.id,
+    name: project.name,
+    description: project.description,
+    state: project.state,
+    progress: project.progress,
+    targetDate: project.targetDate,
+    startDate: project.startDate,
+    createdAt: project.createdAt,
+  };
+}
+
+export async function getProjectIssues(
+  client: LinearClient,
+  nameOrId: string
+): Promise<Issue[]> {
+  const projects = await client.projects();
+  const project = projects.nodes.find(
+    (p) => p.name.toLowerCase() === nameOrId.toLowerCase() || p.id === nameOrId
+  );
+
+  if (!project) {
+    return [];
+  }
+
+  const issues = await project.issues();
+
+  return Promise.all(
+    issues.nodes.map(async (i) => ({
+      id: i.id,
+      identifier: i.identifier,
+      title: i.title,
+      description: i.description,
+      state: (await i.state)?.name ?? null,
+      assignee: (await i.assignee)?.name ?? null,
+      priority: i.priority,
+      createdAt: i.createdAt,
+      updatedAt: i.updatedAt,
+      url: i.url,
+    }))
+  );
+}
+
+export async function createProject(
+  client: LinearClient,
+  input: CreateProjectInput
+): Promise<Project | null> {
+  const result = await client.createProject({
+    name: input.name,
+    description: input.description,
+    teamIds: input.teamIds ?? [],
+  });
+
+  if (!result.success) {
+    return null;
+  }
+
+  const projectData = await result.project;
+  if (!projectData) {
+    return null;
+  }
+
+  return {
+    id: projectData.id,
+    name: projectData.name,
+    description: projectData.description,
+    state: projectData.state,
+    progress: projectData.progress,
+    targetDate: projectData.targetDate,
+    startDate: projectData.startDate,
+    createdAt: projectData.createdAt,
+  };
+}
+
+export async function deleteProject(
+  client: LinearClient,
+  nameOrId: string
+): Promise<boolean> {
+  const projects = await client.projects();
+  const project = projects.nodes.find(
+    (p) => p.name.toLowerCase() === nameOrId.toLowerCase() || p.id === nameOrId
+  );
+
+  if (!project) {
+    return false;
+  }
+
+  const result = await client.deleteProject(project.id);
+  return result.success;
+}

package/src/search.test.ts

@@ -0,0 +1,38 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { LinearClient } from "@linear/sdk";
+import { getApiKey } from "./config";
+import { searchIssues } from "./search";
+
+function getTestClient(): LinearClient {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("no api key configured - run: li auth <api-key>");
+  }
+  return new LinearClient({ apiKey });
+}
+
+describe("search core", () => {
+  let client: LinearClient;
+
+  beforeAll(() => {
+    client = getTestClient();
+  });
+
+  test("searchIssues returns issue array", async () => {
+    const issues = await searchIssues(client, "issue");
+    expect(Array.isArray(issues)).toBe(true);
+    if (issues.length > 0) {
+      expect(issues[0]).toHaveProperty("id");
+      expect(issues[0]).toHaveProperty("identifier");
+      expect(issues[0]).toHaveProperty("title");
+    }
+  });
+
+  test("searchIssues filters by team", async () => {
+    const issues = await searchIssues(client, "issue", { team: "BDSQ" });
+    expect(Array.isArray(issues)).toBe(true);
+    for (const issue of issues) {
+      expect(issue.identifier.startsWith("BDSQ-")).toBe(true);
+    }
+  });
+});

package/src/search.ts

@@ -0,0 +1,33 @@
+import type { LinearClient } from "@linear/sdk";
+import type { Issue } from "./types";
+
+export async function searchIssues(
+  client: LinearClient,
+  query: string,
+  options: { team?: string } = {}
+): Promise<Issue[]> {
+  const searchResults = await client.searchIssues(query);
+  let issues = searchResults.nodes;
+
+  if (options.team) {
+    const teamKey = options.team.toUpperCase();
+    issues = issues.filter((issue) =>
+      issue.identifier.startsWith(teamKey + "-")
+    );
+  }
+
+  return Promise.all(
+    issues.map(async (i) => ({
+      id: i.id,
+      identifier: i.identifier,
+      title: i.title,
+      description: i.description,
+      state: (await i.state)?.name ?? null,
+      assignee: (await i.assignee)?.name ?? null,
+      priority: i.priority,
+      createdAt: i.createdAt,
+      updatedAt: i.updatedAt,
+      url: i.url,
+    }))
+  );
+}

package/src/teams.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { LinearClient } from "@linear/sdk";
+import { getApiKey } from "./config";
+import { listTeams, getTeam, getTeamMembers, getAvailableTeamKeys } from "./teams";
+
+function getTestClient(): LinearClient {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("no api key configured - run: li auth <api-key>");
+  }
+  return new LinearClient({ apiKey });
+}
+
+describe("teams core", () => {
+  let client: LinearClient;
+  let teamKey: string;
+
+  beforeAll(async () => {
+    client = getTestClient();
+    const keys = await getAvailableTeamKeys(client);
+    teamKey = keys.includes("BDSQ") ? "BDSQ" : keys[0] ?? "UNKNOWN";
+  });
+
+  test("listTeams returns team array", async () => {
+    const teams = await listTeams(client);
+    expect(Array.isArray(teams)).toBe(true);
+    expect(teams.length).toBeGreaterThan(0);
+    expect(teams[0]).toHaveProperty("id");
+    expect(teams[0]).toHaveProperty("key");
+    expect(teams[0]).toHaveProperty("name");
+  });
+
+  test("getTeam returns team by key", async () => {
+    const team = await getTeam(client, teamKey);
+    expect(team).not.toBeNull();
+    expect(team?.key).toBe(teamKey);
+  });
+
+  test("getTeam returns null for invalid key", async () => {
+    const team = await getTeam(client, "INVALID_KEY_XYZ");
+    expect(team).toBeNull();
+  });
+
+  test("getTeamMembers returns members array", async () => {
+    const members = await getTeamMembers(client, teamKey);
+    expect(Array.isArray(members)).toBe(true);
+    if (members.length > 0) {
+      expect(members[0]).toHaveProperty("id");
+      expect(members[0]).toHaveProperty("name");
+      expect(members[0]).toHaveProperty("email");
+    }
+  });
+
+  test("getAvailableTeamKeys returns string array", async () => {
+    const keys = await getAvailableTeamKeys(client);
+    expect(Array.isArray(keys)).toBe(true);
+    expect(keys.length).toBeGreaterThan(0);
+    expect(typeof keys[0]).toBe("string");
+  });
+});

package/src/teams.ts

@@ -0,0 +1,92 @@
+import type { LinearClient } from "@linear/sdk";
+import type { Team, TeamMember } from "./types";
+
+export async function listTeams(client: LinearClient): Promise<Team[]> {
+  const teamsConnection = await client.teams();
+  return teamsConnection.nodes.map((t) => ({
+    id: t.id,
+    key: t.key,
+    name: t.name,
+    description: t.description,
+    private: t.private,
+    timezone: t.timezone,
+  }));
+}
+
+export async function getTeam(
+  client: LinearClient,
+  key: string
+): Promise<Team | null> {
+  const teamsConnection = await client.teams({
+    filter: { key: { eq: key.toUpperCase() } },
+  });
+  const team = teamsConnection.nodes[0];
+
+  if (!team) {
+    return null;
+  }
+
+  return {
+    id: team.id,
+    key: team.key,
+    name: team.name,
+    description: team.description,
+    private: team.private,
+    timezone: team.timezone,
+  };
+}
+
+export async function getTeamMembers(
+  client: LinearClient,
+  key: string
+): Promise<TeamMember[]> {
+  const teamsConnection = await client.teams({
+    filter: { key: { eq: key.toUpperCase() } },
+  });
+  const team = teamsConnection.nodes[0];
+
+  if (!team) {
+    return [];
+  }
+
+  const membersConnection = await team.members();
+  return membersConnection.nodes.map((m) => ({
+    id: m.id,
+    name: m.name,
+    email: m.email,
+    displayName: m.displayName,
+    active: m.active,
+  }));
+}
+
+export async function findTeamByKeyOrName(
+  client: LinearClient,
+  keyOrName: string
+): Promise<Team | null> {
+  const teams = await client.teams();
+  const team = teams.nodes.find(
+    (t) =>
+      t.key.toLowerCase() === keyOrName.toLowerCase() ||
+      t.name.toLowerCase() === keyOrName.toLowerCase()
+  );
+
+  if (!team) {
+    return null;
+  }
+
+  return {
+    id: team.id,
+    key: team.key,
+    name: team.name,
+    description: team.description,
+    private: team.private,
+    timezone: team.timezone,
+  };
+}
+
+export async function getAvailableTeamKeys(
+  client: LinearClient
+): Promise<string[]> {
+  const teams = await client.teams();
+  return teams.nodes.map((t) => t.key);
+}

package/src/types.ts

@@ -0,0 +1,87 @@
+export interface Issue {
+  id: string;
+  identifier: string;
+  title: string;
+  description?: string | null;
+  state?: string | null;
+  assignee?: string | null;
+  priority?: number;
+  createdAt: Date;
+  updatedAt: Date;
+  url: string;
+}
+
+export interface Project {
+  id: string;
+  name: string;
+  description?: string | null;
+  state?: string | null;
+  progress?: number | null;
+  targetDate?: Date | null;
+  startDate?: Date | null;
+  createdAt: Date;
+}
+
+export interface Team {
+  id: string;
+  key: string;
+  name: string;
+  description?: string | null;
+  private: boolean;
+  timezone?: string | null;
+}
+
+export interface TeamMember {
+  id: string;
+  name: string;
+  email?: string | null;
+  displayName?: string | null;
+  active: boolean;
+}
+
+export interface Cycle {
+  id: string;
+  number: number;
+  name?: string | null;
+  startsAt: Date;
+  endsAt: Date;
+}
+
+export interface User {
+  id: string;
+  name: string;
+  email?: string | null;
+  displayName?: string | null;
+  active: boolean;
+  admin: boolean;
+}
+
+export interface ListIssuesFilter {
+  team?: string;
+  state?: string;
+  assignee?: string;
+  label?: string;
+  project?: string;
+}
+
+export interface CreateIssueInput {
+  teamId: string;
+  title: string;
+  description?: string;
+  assigneeId?: string;
+  priority?: number;
+  labelIds?: string[];
+}
+
+export interface UpdateIssueInput {
+  stateId?: string;
+  assigneeId?: string;
+  priority?: number;
+  labelIds?: string[];
+}
+
+export interface CreateProjectInput {
+  name: string;
+  description?: string;
+  teamIds?: string[];
+}