@bdsqqq/lnr-core 1.1.1 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bdsqqq/lnr-core",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "core business logic for lnr",
   "type": "module",
   "private": false,

package/src/client.ts

@@ -10,16 +10,20 @@ export class NotAuthenticatedError extends Error {
   }
 }
 
-export function getClient(): LinearClient {
-  if (clientInstance) {
-    return clientInstance;
-  }
-
-  const apiKey = getApiKey();
+export function getClient(apiKeyOverride?: string): LinearClient {
+  const apiKey = apiKeyOverride ?? getApiKey();
   if (!apiKey) {
     throw new NotAuthenticatedError();
   }
 
+  if (apiKeyOverride) {
+    return new LinearClient({ apiKey });
+  }
+
+  if (clientInstance) {
+    return clientInstance;
+  }
+
   clientInstance = new LinearClient({ apiKey });
   return clientInstance;
 }

package/src/comments.test.ts

@@ -0,0 +1,119 @@
+import { describe, test, expect } from "bun:test";
+import { aggregateReactions, extractSyncMeta } from "./comments";
+
+describe("aggregateReactions", () => {
+  test("empty array → empty", () => {
+    expect(aggregateReactions([])).toEqual([]);
+  });
+
+  test("single reaction → count 1", () => {
+    expect(aggregateReactions([{ emoji: "👍" }])).toEqual([
+      { emoji: "👍", count: 1 },
+    ]);
+  });
+
+  test("duplicates aggregate", () => {
+    const result = aggregateReactions([
+      { emoji: "👍" },
+      { emoji: "👍" },
+      { emoji: "👍" },
+    ]);
+    expect(result).toEqual([{ emoji: "👍", count: 3 }]);
+  });
+
+  test("different emojis get separate entries", () => {
+    const result = aggregateReactions([
+      { emoji: "👍" },
+      { emoji: "👎" },
+      { emoji: "👍" },
+    ]);
+    expect(result).toContainEqual({ emoji: "👍", count: 2 });
+    expect(result).toContainEqual({ emoji: "👎", count: 1 });
+    expect(result).toHaveLength(2);
+  });
+});
+
+describe("extractSyncMeta", () => {
+  test("slack with valid metadata", () => {
+    const result = extractSyncMeta("slack", {
+      channelName: "frontend",
+      messageUrl: "https://slack.com/msg/123",
+    });
+    expect(result).toEqual({
+      type: "slack",
+      channelName: "frontend",
+      messageUrl: "https://slack.com/msg/123",
+    });
+  });
+
+  test("slack with missing metadata", () => {
+    expect(extractSyncMeta("slack", null)).toEqual({
+      type: "slack",
+      channelName: undefined,
+      messageUrl: undefined,
+    });
+  });
+
+  test("slack with partial metadata", () => {
+    expect(extractSyncMeta("slack", { channelName: "general" })).toEqual({
+      type: "slack",
+      channelName: "general",
+      messageUrl: undefined,
+    });
+  });
+
+  test("github extracts owner/repo/number", () => {
+    const result = extractSyncMeta("github", {
+      owner: "bdsqqq",
+      repo: "lnr",
+      number: 42,
+    });
+    expect(result).toEqual({
+      type: "github",
+      owner: "bdsqqq",
+      repo: "lnr",
+      number: 42,
+    });
+  });
+
+  test("github partial (only repo)", () => {
+    expect(extractSyncMeta("github", { repo: "lnr" })).toEqual({
+      type: "github",
+      owner: undefined,
+      repo: "lnr",
+      number: undefined,
+    });
+  });
+
+  test("jira extracts issueKey/projectId", () => {
+    const result = extractSyncMeta("jira", {
+      issueKey: "PROJ-123",
+      projectId: "proj-id",
+    });
+    expect(result).toEqual({
+      type: "jira",
+      issueKey: "PROJ-123",
+      projectId: "proj-id",
+    });
+  });
+
+  test("unknown service → { type: 'unknown' }", () => {
+    expect(extractSyncMeta("notion", { some: "data" })).toEqual({
+      type: "unknown",
+    });
+  });
+
+  test("case insensitive", () => {
+    expect(extractSyncMeta("SLACK", { channelName: "test" })).toEqual({
+      type: "slack",
+      channelName: "test",
+      messageUrl: undefined,
+    });
+    expect(extractSyncMeta("GitHub", { owner: "x" })).toEqual({
+      type: "github",
+      owner: "x",
+      repo: undefined,
+      number: undefined,
+    });
+  });
+});

package/src/comments.ts

@@ -0,0 +1,193 @@
+import type { LinearClient, ExternalEntityInfo } from "@linear/sdk";
+
+/** aggregated reaction count for display (e.g., 👍 x 3) */
+export interface CommentReaction {
+  emoji: string;
+  count: number;
+}
+
+/** slack-specific sync metadata */
+export interface SlackSyncMeta {
+  type: "slack";
+  channelName?: string;
+  messageUrl?: string;
+}
+
+/** github-specific sync metadata */
+export interface GithubSyncMeta {
+  type: "github";
+  owner?: string;
+  repo?: string;
+  number?: number;
+}
+
+/** jira-specific sync metadata */
+export interface JiraSyncMeta {
+  type: "jira";
+  issueKey?: string;
+  projectId?: string;
+}
+
+/** generic sync metadata for unknown services */
+export interface GenericSyncMeta {
+  type: "unknown";
+}
+
+export type SyncMeta = SlackSyncMeta | GithubSyncMeta | JiraSyncMeta | GenericSyncMeta;
+
+/** external service sync info — extracted from linear's ExternalEntityInfo */
+export interface CommentSyncInfo {
+  service: string;
+  meta: SyncMeta;
+}
+
+export interface CommentsResult {
+  comments: Comment[];
+  error?: string;
+}
+
+export interface Comment {
+  id: string;
+  body: string;
+  createdAt: Date;
+  updatedAt: Date;
+  /** linear user who authored the comment, null if external */
+  user: string | null;
+  /** parent comment id for threading, null if root */
+  parentId: string | null;
+  url: string;
+  reactions: CommentReaction[];
+  /** external services this comment syncs with (slack channels, etc.) */
+  syncedWith: CommentSyncInfo[];
+  /** bot that created this comment (linear integrations) */
+  botActor?: string | null;
+  /** external user (e.g., slack user) who authored the comment */
+  externalUser?: string | null;
+}
+
+export function aggregateReactions(reactions: readonly { emoji: string }[]): CommentReaction[] {
+  const counts = new Map<string, number>();
+  for (const r of reactions) {
+    counts.set(r.emoji, (counts.get(r.emoji) ?? 0) + 1);
+  }
+  return Array.from(counts.entries()).map(([emoji, count]) => ({ emoji, count }));
+}
+
+export function extractSyncMeta(service: string, metadata: unknown): SyncMeta {
+  const svc = service.toLowerCase();
+  const isObject = typeof metadata === "object" && metadata !== null;
+
+  if (svc === "slack") {
+    const channelName =
+      isObject && "channelName" in metadata && typeof metadata.channelName === "string"
+        ? metadata.channelName
+        : undefined;
+    const messageUrl =
+      isObject && "messageUrl" in metadata && typeof metadata.messageUrl === "string"
+        ? metadata.messageUrl
+        : undefined;
+    return { type: "slack", channelName, messageUrl } satisfies SyncMeta;
+  }
+
+  if (svc === "github") {
+    const owner =
+      isObject && "owner" in metadata && typeof metadata.owner === "string"
+        ? metadata.owner
+        : undefined;
+    const repo =
+      isObject && "repo" in metadata && typeof metadata.repo === "string"
+        ? metadata.repo
+        : undefined;
+    const number =
+      isObject && "number" in metadata && typeof metadata.number === "number"
+        ? metadata.number
+        : undefined;
+    return { type: "github", owner, repo, number } satisfies SyncMeta;
+  }
+
+  if (svc === "jira") {
+    const issueKey =
+      isObject && "issueKey" in metadata && typeof metadata.issueKey === "string"
+        ? metadata.issueKey
+        : undefined;
+    const projectId =
+      isObject && "projectId" in metadata && typeof metadata.projectId === "string"
+        ? metadata.projectId
+        : undefined;
+    return { type: "jira", issueKey, projectId } satisfies SyncMeta;
+  }
+
+  return { type: "unknown" } satisfies SyncMeta;
+}
+
+function extractSyncInfo(syncedWith?: ExternalEntityInfo[]): CommentSyncInfo[] {
+  if (!syncedWith) return [];
+  return syncedWith.map((s) => ({
+    service: s.service,
+    meta: extractSyncMeta(s.service, s.metadata),
+  }));
+}
+
+export async function getIssueComments(
+  client: LinearClient,
+  issueId: string
+): Promise<CommentsResult> {
+  try {
+    const issue = await client.issue(issueId);
+    if (!issue) return { comments: [] };
+
+    const commentsData = await issue.comments();
+    const comments = await Promise.all(
+      commentsData.nodes.map(async (c) => {
+        const user = await c.user;
+        const externalUser = c.externalUserId ? await c.externalUser : null;
+        const botActor = c.botActor;
+
+        return {
+          id: c.id,
+          body: c.body,
+          createdAt: c.createdAt,
+          updatedAt: c.updatedAt,
+          user: user?.name ?? null,
+          parentId: c.parentId ?? null,
+          url: c.url,
+          reactions: aggregateReactions(c.reactions ?? []),
+          syncedWith: extractSyncInfo(c.syncedWith),
+          botActor: botActor?.name ?? null,
+          externalUser: externalUser?.name ?? null,
+        };
+      })
+    );
+    return { comments };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { comments: [], error: message };
+  }
+}
+
+export async function updateComment(
+  client: LinearClient,
+  commentId: string,
+  body: string
+): Promise<boolean> {
+  const result = await client.updateComment(commentId, { body });
+  return result.success;
+}
+
+export async function replyToComment(
+  client: LinearClient,
+  issueId: string,
+  parentId: string,
+  body: string
+): Promise<boolean> {
+  const result = await client.createComment({ issueId, body, parentId });
+  return result.success;
+}
+
+export async function deleteComment(
+  client: LinearClient,
+  commentId: string
+): Promise<boolean> {
+  const result = await client.deleteComment(commentId);
+  return result.success;
+}

package/src/config.test.ts

@@ -1,9 +1,12 @@
-import { describe, test, expect, afterEach, beforeAll } from "bun:test";
+import { describe, test, expect, afterEach, beforeAll, afterAll } from "bun:test";
 import {
   loadConfig,
   saveConfig,
   getConfigValue,
   setConfigValue,
+  getApiKey,
+  listConfig,
+  getConfigPath,
   type Config,
 } from "./config";
 
@@ -41,4 +44,73 @@ describe("config core", () => {
     expect(loaded.default_team).toBe(testConfig.default_team);
     expect(loaded.output_format).toBe(testConfig.output_format);
   });
+
+  test("listConfig returns full config", () => {
+    const testConfig: Config = {
+      api_key: "list_test_key",
+      default_team: "LIST_TEST",
+    };
+    saveConfig(testConfig);
+    const listed = listConfig();
+    expect(listed.api_key).toBe(testConfig.api_key);
+    expect(listed.default_team).toBe(testConfig.default_team);
+  });
+
+  test("getConfigPath returns path string", () => {
+    const path = getConfigPath();
+    expect(typeof path).toBe("string");
+    expect(path).toContain(".lnr");
+    expect(path).toContain("config.json");
+  });
+});
+
+describe("getApiKey precedence", () => {
+  let originalConfig: Config;
+  let originalEnv: string | undefined;
+
+  beforeAll(() => {
+    originalConfig = loadConfig();
+    originalEnv = process.env.LINEAR_API_KEY;
+  });
+
+  afterEach(() => {
+    saveConfig(originalConfig);
+    if (originalEnv !== undefined) {
+      process.env.LINEAR_API_KEY = originalEnv;
+    } else {
+      delete process.env.LINEAR_API_KEY;
+    }
+  });
+
+  afterAll(() => {
+    if (originalEnv !== undefined) {
+      process.env.LINEAR_API_KEY = originalEnv;
+    } else {
+      delete process.env.LINEAR_API_KEY;
+    }
+  });
+
+  test("getApiKey returns config value when env not set", () => {
+    delete process.env.LINEAR_API_KEY;
+    saveConfig({ api_key: "config_key_123" });
+    expect(getApiKey()).toBe("config_key_123");
+  });
+
+  test("getApiKey returns env var when set", () => {
+    saveConfig({ api_key: "config_key_123" });
+    process.env.LINEAR_API_KEY = "env_key_456";
+    expect(getApiKey()).toBe("env_key_456");
+  });
+
+  test("getApiKey prefers env over config", () => {
+    saveConfig({ api_key: "should_not_return" });
+    process.env.LINEAR_API_KEY = "should_return";
+    expect(getApiKey()).toBe("should_return");
+  });
+
+  test("getApiKey returns undefined when neither set", () => {
+    delete process.env.LINEAR_API_KEY;
+    saveConfig({});
+    expect(getApiKey()).toBeUndefined();
+  });
 });

package/src/config.ts

@@ -36,7 +36,15 @@ export function saveConfig(config: Config): void {
 }
 
 export function getApiKey(): string | undefined {
-  return loadConfig().api_key;
+  return process.env.LINEAR_API_KEY ?? loadConfig().api_key;
+}
+
+export function listConfig(): Config {
+  return loadConfig();
+}
+
+export function getConfigPath(): string {
+  return CONFIG_PATH;
 }
 
 export function setApiKey(key: string): void {

package/src/documents.ts

@@ -0,0 +1,110 @@
+import type { LinearClient } from "@linear/sdk";
+
+export interface Document {
+  id: string;
+  title: string;
+  content: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+  url: string;
+  project: string | null;
+}
+
+export async function listDocuments(
+  client: LinearClient,
+  projectId?: string
+): Promise<Document[]> {
+  try {
+    const filter = projectId
+      ? { project: { id: { eq: projectId } } }
+      : undefined;
+
+    const documentsConnection = await client.documents({ filter });
+    const nodes = documentsConnection.nodes;
+
+    return Promise.all(
+      nodes.map(async (d) => ({
+        id: d.id,
+        title: d.title,
+        content: d.content ?? null,
+        createdAt: d.createdAt,
+        updatedAt: d.updatedAt,
+        url: d.url,
+        project: (await d.project)?.name ?? null,
+      }))
+    );
+  } catch {
+    return [];
+  }
+}
+
+export async function getDocument(
+  client: LinearClient,
+  id: string
+): Promise<Document | null> {
+  try {
+    const doc = await client.document(id);
+    if (!doc) {
+      return null;
+    }
+
+    return {
+      id: doc.id,
+      title: doc.title,
+      content: doc.content ?? null,
+      createdAt: doc.createdAt,
+      updatedAt: doc.updatedAt,
+      url: doc.url,
+      project: (await doc.project)?.name ?? null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function createDocument(
+  client: LinearClient,
+  input: { title: string; content?: string; projectId?: string }
+): Promise<Document | null> {
+  const result = await client.createDocument({
+    title: input.title,
+    content: input.content,
+    projectId: input.projectId,
+  });
+
+  if (!result.success) {
+    return null;
+  }
+
+  const doc = await result.document;
+  if (!doc) {
+    return null;
+  }
+
+  return {
+    id: doc.id,
+    title: doc.title,
+    content: doc.content ?? null,
+    createdAt: doc.createdAt,
+    updatedAt: doc.updatedAt,
+    url: doc.url,
+    project: (await doc.project)?.name ?? null,
+  };
+}
+
+export async function updateDocument(
+  client: LinearClient,
+  id: string,
+  input: { title?: string; content?: string }
+): Promise<boolean> {
+  const result = await client.updateDocument(id, input);
+  return result.success;
+}
+
+export async function deleteDocument(
+  client: LinearClient,
+  id: string
+): Promise<boolean> {
+  const result = await client.deleteDocument(id);
+  return result.success;
+}

package/src/index.ts

@@ -30,6 +30,8 @@ export {
   getConfigValue,
   setConfigValue,
   ensureConfigDir,
+  listConfig,
+  getConfigPath,
   type Config,
 } from "./config";
 
@@ -43,6 +45,8 @@ export {
   priorityFromString,
   getTeamStates,
   getTeamLabels,
+  archiveIssue,
+  getSubIssues,
 } from "./issues";
 
 // projects
@@ -67,7 +71,53 @@ export {
 export { listCycles, getCurrentCycle, getCycleIssues } from "./cycles";
 
 // me
-export { getViewer, getMyIssues, getMyCreatedIssues } from "./me";
+export { getViewer, getMyIssues, getMyCreatedIssues, getMyActivity } from "./me";
+export type { Activity } from "./types";
 
 // search
 export { searchIssues } from "./search";
+
+// relations
+export { createIssueRelation } from "./relations";
+
+// documents
+export type { Document } from "./documents";
+export {
+  listDocuments,
+  getDocument,
+  createDocument,
+  updateDocument,
+  deleteDocument,
+} from "./documents";
+
+// labels
+export type { Label } from "./labels";
+export {
+  listLabels,
+  getLabel,
+  createLabel,
+  updateLabel,
+  deleteLabel,
+} from "./labels";
+
+// comments
+export type {
+  Comment,
+  CommentReaction,
+  CommentSyncInfo,
+  CommentsResult,
+  SyncMeta,
+  SlackSyncMeta,
+  GithubSyncMeta,
+  JiraSyncMeta,
+  GenericSyncMeta,
+} from "./comments";
+export {
+  getIssueComments,
+  updateComment,
+  replyToComment,
+  deleteComment,
+} from "./comments";
+
+// reactions
+export { createReaction, deleteReaction } from "./reactions";

package/src/issues.ts

@@ -64,6 +64,7 @@ export async function listIssues(
       createdAt: n.createdAt,
       updatedAt: n.updatedAt,
       url: n.url,
+      parentId: (await n.parent)?.id ?? null,
     }))
   );
 }
@@ -81,6 +82,7 @@ export async function getIssue(
 
     const state = await issue.state;
     const assignee = await issue.assignee;
+    const parent = await issue.parent;
 
     return {
       id: issue.id,
@@ -93,6 +95,7 @@ export async function getIssue(
       createdAt: issue.createdAt,
       updatedAt: issue.updatedAt,
       url: issue.url,
+      parentId: parent?.id ?? null,
     };
   } catch {
     return null;
@@ -180,3 +183,36 @@ export async function getTeamLabels(
   const labels = await team.labels();
   return labels.nodes.map((l) => ({ id: l.id, name: l.name }));
 }
+
+export async function archiveIssue(
+  client: LinearClient,
+  issueId: string
+): Promise<boolean> {
+  const result = await client.archiveIssue(issueId);
+  return result.success;
+}
+
+export async function getSubIssues(
+  client: LinearClient,
+  parentIdentifier: string
+): Promise<Issue[]> {
+  const parent = await client.issue(parentIdentifier);
+  if (!parent) return [];
+
+  const children = await parent.children();
+  return Promise.all(
+    children.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,
+      parentId: parent.id,
+    }))
+  );
+}

package/src/labels.ts

@@ -0,0 +1,97 @@
+import type { LinearClient } from "@linear/sdk";
+
+export interface Label {
+  id: string;
+  name: string;
+  color: string;
+  description: string | null;
+}
+
+export async function listLabels(
+  client: LinearClient,
+  teamId?: string
+): Promise<Label[]> {
+  if (teamId) {
+    const team = await client.team(teamId);
+    if (!team) {
+      return [];
+    }
+    const labelsConnection = await team.labels();
+    return labelsConnection.nodes.map((l) => ({
+      id: l.id,
+      name: l.name,
+      color: l.color,
+      description: l.description ?? null,
+    }));
+  }
+
+  const labelsConnection = await client.issueLabels();
+  return labelsConnection.nodes.map((l) => ({
+    id: l.id,
+    name: l.name,
+    color: l.color,
+    description: l.description ?? null,
+  }));
+}
+
+export async function getLabel(
+  client: LinearClient,
+  id: string
+): Promise<Label | null> {
+  try {
+    const label = await client.issueLabel(id);
+    return {
+      id: label.id,
+      name: label.name,
+      color: label.color,
+      description: label.description ?? null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function createLabel(
+  client: LinearClient,
+  input: { name: string; teamId?: string; color?: string; description?: string }
+): Promise<Label | null> {
+  const payload = await client.createIssueLabel({
+    name: input.name,
+    teamId: input.teamId,
+    color: input.color,
+    description: input.description,
+  });
+
+  if (!payload.success) {
+    return null;
+  }
+
+  const label = await payload.issueLabel;
+  if (!label) {
+    return null;
+  }
+
+  return {
+    id: label.id,
+    name: label.name,
+    color: label.color,
+    description: label.description ?? null,
+  };
+}
+
+export async function updateLabel(
+  client: LinearClient,
+  id: string,
+  input: { name?: string; color?: string; description?: string }
+): Promise<boolean> {
+  const payload = await client.updateIssueLabel(id, input);
+  return payload.success;
+}
+
+export async function deleteLabel(
+  client: LinearClient,
+  id: string
+): Promise<boolean> {
+  const payload = await client.deleteIssueLabel(id);
+  return payload.success;
+}

package/src/me.ts

@@ -1,5 +1,5 @@
-import type { LinearClient } from "@linear/sdk";
-import type { User, Issue } from "./types";
+import { LinearClient, PaginationOrderBy } from "@linear/sdk";
+import type { User, Issue, Activity } from "./types";
 
 export async function getViewer(client: LinearClient): Promise<User> {
   const viewer = await client.viewer;
@@ -59,3 +59,37 @@ export async function getMyCreatedIssues(
     }))
   );
 }
+
+export async function getMyActivity(
+  client: LinearClient,
+  limit = 20
+): Promise<Activity[]> {
+  const viewer = await client.viewer;
+  const assignedConnection = await viewer.assignedIssues({
+    first: limit * 2,
+    orderBy: PaginationOrderBy.UpdatedAt,
+  });
+  const createdConnection = await viewer.createdIssues({
+    first: limit * 2,
+    orderBy: PaginationOrderBy.UpdatedAt,
+  });
+
+  const issueMap = new Map<string, Activity>();
+
+  for (const i of [...assignedConnection.nodes, ...createdConnection.nodes]) {
+    if (!issueMap.has(i.id)) {
+      issueMap.set(i.id, {
+        id: i.id,
+        identifier: i.identifier,
+        title: i.title,
+        state: (await i.state)?.name ?? null,
+        updatedAt: i.updatedAt,
+        url: i.url,
+      });
+    }
+  }
+
+  return [...issueMap.values()]
+    .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
+    .slice(0, limit);
+}

package/src/reactions.ts

@@ -0,0 +1,18 @@
+import type { LinearClient } from "@linear/sdk";
+
+export async function createReaction(
+  client: LinearClient,
+  commentId: string,
+  emoji: string
+): Promise<boolean> {
+  const result = await client.createReaction({ commentId, emoji });
+  return result.success;
+}
+
+export async function deleteReaction(
+  client: LinearClient,
+  reactionId: string
+): Promise<boolean> {
+  const result = await client.deleteReaction(reactionId);
+  return result.success;
+}

package/src/relations.ts

@@ -0,0 +1,17 @@
+import { IssueRelationType, type LinearClient } from "@linear/sdk";
+
+export async function createIssueRelation(
+  client: LinearClient,
+  issueId: string,
+  relatedIssueId: string,
+  type: "blocks" | "related"
+): Promise<boolean> {
+  const relationType =
+    type === "blocks" ? IssueRelationType.Blocks : IssueRelationType.Related;
+  const result = await client.createIssueRelation({
+    issueId,
+    relatedIssueId,
+    type: relationType,
+  });
+  return result.success;
+}

package/src/types.ts

@@ -9,6 +9,7 @@ export interface Issue {
   createdAt: Date;
   updatedAt: Date;
   url: string;
+  parentId?: string | null;
 }
 
 export interface Project {
@@ -71,6 +72,7 @@ export interface CreateIssueInput {
   assigneeId?: string;
   priority?: number;
   labelIds?: string[];
+  parentId?: string;
 }
 
 export interface UpdateIssueInput {
@@ -78,6 +80,7 @@ export interface UpdateIssueInput {
   assigneeId?: string;
   priority?: number;
   labelIds?: string[];
+  parentId?: string;
 }
 
 export interface CreateProjectInput {
@@ -85,3 +88,12 @@ export interface CreateProjectInput {
   description?: string;
   teamIds?: string[];
 }
+
+export interface Activity {
+  id: string;
+  identifier: string;
+  title: string;
+  state?: string | null;
+  updatedAt: Date;
+  url: string;
+}