@alasano/pi-linear 0.0.1

package/extensions/tools/issue-labels.ts

@@ -0,0 +1,273 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { withLinearAuth, linearGraphQL, resolveTeamId } from '../client';
+import { PaginationParams, FilterParam, RawInputParam, TeamConvenienceParams } from '../params';
+import { ISSUE_LABEL_SELECTION } from '../selections';
+import type { JsonObject } from '../types';
+import { compactObject, asObject, asString, mergeFilters } from '../util';
+
+export function issueLabelTools() {
+  return [
+    defineTool({
+      name: 'linear_list_issue_labels',
+      label: 'Linear List Issue Labels',
+      description: 'List issue labels. Supports full issueLabels query args.',
+      parameters: Type.Object({
+        ...TeamConvenienceParams,
+        ...PaginationParams,
+        ...FilterParam,
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const resolvedTeamId =
+            params.teamId || params.teamKey
+              ? await resolveTeamId(
+                  apiKey,
+                  { teamId: params.teamId, teamKey: params.teamKey },
+                  signal,
+                )
+              : undefined;
+
+          const convenienceFilter = resolvedTeamId
+            ? ({ team: { id: { eq: resolvedTeamId } } } as JsonObject)
+            : undefined;
+
+          const filter = mergeFilters(asObject(params.filter), convenienceFilter);
+
+          const variables = compactObject({
+            after: params.after,
+            before: params.before,
+            filter,
+            first: params.first ?? 50,
+            includeArchived: params.includeArchived,
+            last: params.last,
+            orderBy: params.orderBy,
+          });
+
+          const data = await linearGraphQL<{
+            issueLabels: { nodes: Array<JsonObject> };
+          }>(
+            apiKey,
+            `query ListIssueLabels(
+              $after: String
+              $before: String
+              $filter: IssueLabelFilter
+              $first: Int
+              $includeArchived: Boolean
+              $last: Int
+              $orderBy: PaginationOrderBy
+            ) {
+              issueLabels(
+                after: $after
+                before: $before
+                filter: $filter
+                first: $first
+                includeArchived: $includeArchived
+                last: $last
+                orderBy: $orderBy
+              ) {
+                nodes {
+                  ${ISSUE_LABEL_SELECTION}
+                }
+              }
+            }`,
+            variables,
+            signal,
+          );
+
+          const labels = data.issueLabels.nodes;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ labels }, null, 2) }],
+            details: { labels },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_create_issue_label',
+      label: 'Linear Create Issue Label',
+      description:
+        'Create an issue label via issueLabelCreate. Supports top-level fields and raw input.',
+      parameters: Type.Object({
+        name: Type.Optional(Type.String()),
+        color: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String()),
+        id: Type.Optional(Type.String()),
+        isGroup: Type.Optional(Type.Boolean()),
+        parentId: Type.Optional(Type.String()),
+        retiredAt: Type.Optional(Type.String()),
+        ...TeamConvenienceParams,
+        replaceTeamLabels: Type.Optional(Type.Boolean()),
+        ...RawInputParam,
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const rawInput = asObject(params.input) || {};
+          const teamId =
+            params.teamId || params.teamKey || asString(rawInput.teamId)
+              ? await resolveTeamId(
+                  apiKey,
+                  {
+                    teamId: params.teamId || asString(rawInput.teamId),
+                    teamKey: params.teamKey,
+                  },
+                  signal,
+                )
+              : undefined;
+
+          const input = {
+            ...rawInput,
+            ...compactObject({
+              name: params.name,
+              color: params.color,
+              description: params.description,
+              id: params.id,
+              isGroup: params.isGroup,
+              parentId: params.parentId,
+              retiredAt: params.retiredAt,
+              teamId,
+            }),
+          };
+
+          if (!asString(input.name)) {
+            throw new Error('Issue label name is required (name).');
+          }
+
+          const data = await linearGraphQL<{
+            issueLabelCreate: {
+              success: boolean;
+              issueLabel?: JsonObject | null;
+            };
+          }>(
+            apiKey,
+            `mutation CreateIssueLabel($input: IssueLabelCreateInput!, $replaceTeamLabels: Boolean) {
+              issueLabelCreate(input: $input, replaceTeamLabels: $replaceTeamLabels) {
+                success
+                issueLabel {
+                  ${ISSUE_LABEL_SELECTION}
+                }
+              }
+            }`,
+            {
+              input,
+              replaceTeamLabels: params.replaceTeamLabels,
+            },
+            signal,
+          );
+
+          const label = data.issueLabelCreate.issueLabel;
+          if (!data.issueLabelCreate.success || !label) {
+            throw new Error('Linear issueLabelCreate did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ label }, null, 2) }],
+            details: { label },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_update_issue_label',
+      label: 'Linear Update Issue Label',
+      description: 'Update an issue label by id.',
+      parameters: Type.Object({
+        id: Type.String(),
+        name: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String()),
+        color: Type.Optional(Type.String()),
+        parentId: Type.Optional(Type.String()),
+        isGroup: Type.Optional(Type.Boolean()),
+        retiredAt: Type.Optional(Type.String()),
+        replaceTeamLabels: Type.Optional(Type.Boolean()),
+        ...RawInputParam,
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const rawInput = asObject(params.input) || {};
+          const input = {
+            ...rawInput,
+            ...compactObject({
+              name: params.name,
+              description: params.description,
+              color: params.color,
+              parentId: params.parentId,
+              isGroup: params.isGroup,
+              retiredAt: params.retiredAt,
+            }),
+          };
+
+          if (Object.keys(input).length === 0) {
+            throw new Error('No update fields were provided.');
+          }
+
+          const data = await linearGraphQL<{
+            issueLabelUpdate: {
+              success: boolean;
+              issueLabel?: JsonObject | null;
+            };
+          }>(
+            apiKey,
+            `mutation UpdateIssueLabel($id: String!, $input: IssueLabelUpdateInput!, $replaceTeamLabels: Boolean) {
+              issueLabelUpdate(id: $id, input: $input, replaceTeamLabels: $replaceTeamLabels) {
+                success
+                issueLabel {
+                  ${ISSUE_LABEL_SELECTION}
+                }
+              }
+            }`,
+            {
+              id: params.id,
+              input,
+              replaceTeamLabels: params.replaceTeamLabels,
+            },
+            signal,
+          );
+
+          const label = data.issueLabelUpdate.issueLabel;
+          if (!data.issueLabelUpdate.success || !label) {
+            throw new Error('Linear issueLabelUpdate did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ label }, null, 2) }],
+            details: { label },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_delete_issue_label',
+      label: 'Linear Delete Issue Label',
+      description: 'Delete an issue label by id.',
+      parameters: Type.Object({
+        id: Type.String(),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{
+            issueLabelDelete: { success: boolean };
+          }>(
+            apiKey,
+            `mutation DeleteIssueLabel($id: String!) {
+              issueLabelDelete(id: $id) {
+                success
+              }
+            }`,
+            { id: params.id },
+            signal,
+          );
+
+          if (!data.issueLabelDelete.success) {
+            throw new Error('Linear issueLabelDelete did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true }, null, 2) }],
+            details: { success: true },
+          };
+        });
+      },
+    }),
+  ];
+}

package/extensions/tools/issue-relations.ts

@@ -0,0 +1,207 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { withLinearAuth, linearGraphQL } from '../client';
+import { PaginationParams } from '../params';
+import { ISSUE_RELATION_SELECTION } from '../selections';
+import type { JsonObject } from '../types';
+import { compactObject } from '../util';
+
+export function issueRelationTools() {
+  return [
+    defineTool({
+      name: 'linear_list_issue_relations',
+      label: 'Linear List Issue Relations',
+      description: 'List issue relations. Supports pagination.',
+      parameters: Type.Object({
+        ...PaginationParams,
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const variables = compactObject({
+            after: params.after,
+            before: params.before,
+            first: params.first ?? 20,
+            includeArchived: params.includeArchived,
+            last: params.last,
+            orderBy: params.orderBy,
+          });
+
+          const data = await linearGraphQL<{
+            issueRelations: { nodes: Array<JsonObject> };
+          }>(
+            apiKey,
+            `query ListIssueRelations(
+              $after: String
+              $before: String
+              $first: Int
+              $includeArchived: Boolean
+              $last: Int
+              $orderBy: PaginationOrderBy
+            ) {
+              issueRelations(
+                after: $after
+                before: $before
+                first: $first
+                includeArchived: $includeArchived
+                last: $last
+                orderBy: $orderBy
+              ) {
+                nodes {
+                  ${ISSUE_RELATION_SELECTION}
+                }
+              }
+            }`,
+            variables,
+            signal,
+          );
+
+          const issueRelations = data.issueRelations.nodes;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ issueRelations }, null, 2) }],
+            details: { issueRelations },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_create_issue_relation',
+      label: 'Linear Create Issue Relation',
+      description: 'Create a relation between two issues.',
+      parameters: Type.Object({
+        issueId: Type.String({
+          description: 'Issue identifier (e.g. ENG-123) or UUID.',
+        }),
+        relatedIssueId: Type.String({
+          description: 'Related issue identifier (e.g. ENG-456) or UUID.',
+        }),
+        type: Type.String({
+          description: 'Relation type: blocks, duplicate, related, or similar.',
+        }),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const input = {
+            issueId: params.issueId,
+            relatedIssueId: params.relatedIssueId,
+            type: params.type,
+          };
+
+          const data = await linearGraphQL<{
+            issueRelationCreate: {
+              success: boolean;
+              issueRelation?: JsonObject | null;
+            };
+          }>(
+            apiKey,
+            `mutation CreateIssueRelation($input: IssueRelationCreateInput!) {
+              issueRelationCreate(input: $input) {
+                success
+                issueRelation {
+                  ${ISSUE_RELATION_SELECTION}
+                }
+              }
+            }`,
+            { input },
+            signal,
+          );
+
+          const issueRelation = data.issueRelationCreate.issueRelation;
+          if (!data.issueRelationCreate.success || !issueRelation) {
+            throw new Error('Linear issueRelationCreate did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ issueRelation }, null, 2) }],
+            details: { issueRelation },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_update_issue_relation',
+      label: 'Linear Update Issue Relation',
+      description: 'Update an issue relation by id.',
+      parameters: Type.Object({
+        id: Type.String(),
+        type: Type.Optional(Type.String()),
+        issueId: Type.Optional(Type.String()),
+        relatedIssueId: Type.Optional(Type.String()),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const input = compactObject({
+            type: params.type,
+            issueId: params.issueId,
+            relatedIssueId: params.relatedIssueId,
+          });
+
+          if (Object.keys(input).length === 0) {
+            throw new Error('No update fields were provided.');
+          }
+
+          const data = await linearGraphQL<{
+            issueRelationUpdate: {
+              success: boolean;
+              issueRelation?: JsonObject | null;
+            };
+          }>(
+            apiKey,
+            `mutation UpdateIssueRelation($id: String!, $input: IssueRelationUpdateInput!) {
+              issueRelationUpdate(id: $id, input: $input) {
+                success
+                issueRelation {
+                  ${ISSUE_RELATION_SELECTION}
+                }
+              }
+            }`,
+            { id: params.id, input },
+            signal,
+          );
+
+          const issueRelation = data.issueRelationUpdate.issueRelation;
+          if (!data.issueRelationUpdate.success || !issueRelation) {
+            throw new Error('Linear issueRelationUpdate did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ issueRelation }, null, 2) }],
+            details: { issueRelation },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_delete_issue_relation',
+      label: 'Linear Delete Issue Relation',
+      description: 'Delete an issue relation by id.',
+      parameters: Type.Object({
+        id: Type.String(),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{
+            issueRelationDelete: { success: boolean };
+          }>(
+            apiKey,
+            `mutation DeleteIssueRelation($id: String!) {
+              issueRelationDelete(id: $id) {
+                success
+              }
+            }`,
+            { id: params.id },
+            signal,
+          );
+
+          if (!data.issueRelationDelete.success) {
+            throw new Error('Linear issueRelationDelete did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true }, null, 2) }],
+            details: { success: true },
+          };
+        });
+      },
+    }),
+  ];
+}

package/extensions/tools/issue-statuses.ts

@@ -0,0 +1,72 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { withLinearAuth, linearGraphQL } from '../client';
+import { PaginationParams, FilterParam } from '../params';
+import { WORKFLOW_STATE_SELECTION } from '../selections';
+import type { JsonObject } from '../types';
+import { compactObject, asObject } from '../util';
+
+export function issueStatusTools() {
+  return [
+    defineTool({
+      name: 'linear_list_issue_statuses',
+      label: 'Linear List Issue Statuses',
+      description:
+        'List workflow states (issue statuses). Supports full workflowStates query args.',
+      parameters: Type.Object({
+        ...PaginationParams,
+        ...FilterParam,
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const variables = compactObject({
+            after: params.after,
+            before: params.before,
+            filter: asObject(params.filter),
+            first: params.first ?? 50,
+            includeArchived: params.includeArchived,
+            last: params.last,
+            orderBy: params.orderBy,
+          });
+
+          const data = await linearGraphQL<{
+            workflowStates: { nodes: Array<JsonObject> };
+          }>(
+            apiKey,
+            `query ListIssueStatuses(
+              $after: String
+              $before: String
+              $filter: WorkflowStateFilter
+              $first: Int
+              $includeArchived: Boolean
+              $last: Int
+              $orderBy: PaginationOrderBy
+            ) {
+              workflowStates(
+                after: $after
+                before: $before
+                filter: $filter
+                first: $first
+                includeArchived: $includeArchived
+                last: $last
+                orderBy: $orderBy
+              ) {
+                nodes {
+                  ${WORKFLOW_STATE_SELECTION}
+                }
+              }
+            }`,
+            variables,
+            signal,
+          );
+
+          const states = data.workflowStates.nodes;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ states }, null, 2) }],
+            details: { states },
+          };
+        });
+      },
+    }),
+  ];
+}