@alasano/pi-linear 0.0.1

package/extensions/tools/milestones.ts

@@ -0,0 +1,250 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { withLinearAuth, linearGraphQL } from '../client';
+import { PaginationParams, FilterParam, RawInputParam } from '../params';
+import { MILESTONE_SELECTION } from '../selections';
+import type { JsonObject } from '../types';
+import { compactObject, asObject, asString, GenericObjectSchema } from '../util';
+
+export function milestoneTools() {
+  return [
+    defineTool({
+      name: 'linear_list_milestones',
+      label: 'Linear List Milestones',
+      description: 'List project milestones. Supports full projectMilestones 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 ?? 20,
+            includeArchived: params.includeArchived,
+            last: params.last,
+            orderBy: params.orderBy,
+          });
+
+          const data = await linearGraphQL<{
+            projectMilestones: { nodes: Array<JsonObject> };
+          }>(
+            apiKey,
+            `query ListMilestones(
+              $after: String
+              $before: String
+              $filter: ProjectMilestoneFilter
+              $first: Int
+              $includeArchived: Boolean
+              $last: Int
+              $orderBy: PaginationOrderBy
+            ) {
+              projectMilestones(
+                after: $after
+                before: $before
+                filter: $filter
+                first: $first
+                includeArchived: $includeArchived
+                last: $last
+                orderBy: $orderBy
+              ) {
+                nodes {
+                  ${MILESTONE_SELECTION}
+                }
+              }
+            }`,
+            variables,
+            signal,
+          );
+
+          const milestones = data.projectMilestones.nodes;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ milestones }, null, 2) }],
+            details: { milestones },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_get_milestone',
+      label: 'Linear Get Milestone',
+      description: 'Get a specific project milestone by id.',
+      parameters: Type.Object({
+        milestoneId: Type.String(),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{
+            projectMilestone: JsonObject | null;
+          }>(
+            apiKey,
+            `query GetMilestone($id: String!) {
+              projectMilestone(id: $id) {
+                ${MILESTONE_SELECTION}
+              }
+            }`,
+            { id: params.milestoneId },
+            signal,
+          );
+
+          const milestone = data.projectMilestone;
+          return {
+            content: [
+              { type: 'text', text: JSON.stringify({ milestone: milestone ?? null }, null, 2) },
+            ],
+            details: { milestone: milestone ?? null },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_save_milestone',
+      label: 'Linear Save Milestone',
+      description:
+        'Create or update a project milestone. If milestoneId is provided, uses projectMilestoneUpdate; otherwise uses projectMilestoneCreate.',
+      parameters: Type.Object({
+        milestoneId: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String()),
+        descriptionData: Type.Optional(GenericObjectSchema),
+        id: Type.Optional(Type.String()),
+        name: Type.Optional(Type.String()),
+        projectId: Type.Optional(Type.String()),
+        sortOrder: Type.Optional(Type.Number()),
+        targetDate: Type.Optional(Type.String()),
+        ...RawInputParam,
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const rawInput = asObject(params.input) || {};
+          const updateId = asString(params.milestoneId);
+
+          const input = {
+            ...rawInput,
+            ...compactObject({
+              description: params.description,
+              descriptionData: asObject(params.descriptionData),
+              id: params.id,
+              name: params.name,
+              projectId: params.projectId,
+              sortOrder: params.sortOrder,
+              targetDate: params.targetDate,
+            }),
+          };
+
+          if (updateId) {
+            if (Object.keys(input).length === 0) {
+              throw new Error('No milestone update fields were provided.');
+            }
+
+            const data = await linearGraphQL<{
+              projectMilestoneUpdate: {
+                success: boolean;
+                projectMilestone?: JsonObject | null;
+              };
+            }>(
+              apiKey,
+              `mutation UpdateMilestone($id: String!, $input: ProjectMilestoneUpdateInput!) {
+                projectMilestoneUpdate(id: $id, input: $input) {
+                  success
+                  projectMilestone {
+                    ${MILESTONE_SELECTION}
+                  }
+                }
+              }`,
+              { id: updateId, input },
+              signal,
+            );
+
+            if (
+              !data.projectMilestoneUpdate.success ||
+              !data.projectMilestoneUpdate.projectMilestone
+            ) {
+              throw new Error('Linear projectMilestoneUpdate did not succeed.');
+            }
+
+            const milestone = data.projectMilestoneUpdate.projectMilestone;
+            return {
+              content: [{ type: 'text', text: JSON.stringify({ milestone }, null, 2) }],
+              details: { milestone },
+            };
+          }
+
+          if (!asString(input.name)) {
+            throw new Error('Milestone name is required for projectMilestoneCreate (name).');
+          }
+
+          if (!asString(input.projectId)) {
+            throw new Error('projectId is required for projectMilestoneCreate.');
+          }
+
+          const data = await linearGraphQL<{
+            projectMilestoneCreate: {
+              success: boolean;
+              projectMilestone?: JsonObject | null;
+            };
+          }>(
+            apiKey,
+            `mutation CreateMilestone($input: ProjectMilestoneCreateInput!) {
+              projectMilestoneCreate(input: $input) {
+                success
+                projectMilestone {
+                  ${MILESTONE_SELECTION}
+                }
+              }
+            }`,
+            { input },
+            signal,
+          );
+
+          if (
+            !data.projectMilestoneCreate.success ||
+            !data.projectMilestoneCreate.projectMilestone
+          ) {
+            throw new Error('Linear projectMilestoneCreate did not succeed.');
+          }
+
+          const milestone = data.projectMilestoneCreate.projectMilestone;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ milestone }, null, 2) }],
+            details: { milestone },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_delete_milestone',
+      label: 'Linear Delete Milestone',
+      description: 'Delete a project milestone by id.',
+      parameters: Type.Object({
+        milestoneId: Type.String(),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{
+            projectMilestoneDelete: { success: boolean };
+          }>(
+            apiKey,
+            `mutation DeleteMilestone($id: String!) {
+              projectMilestoneDelete(id: $id) {
+                success
+              }
+            }`,
+            { id: params.milestoneId },
+            signal,
+          );
+
+          if (!data.projectMilestoneDelete.success) {
+            throw new Error('Linear projectMilestoneDelete did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true }, null, 2) }],
+            details: { success: true },
+          };
+        });
+      },
+    }),
+  ];
+}

package/extensions/tools/project-labels.ts

@@ -0,0 +1,227 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { withLinearAuth, linearGraphQL } from '../client';
+import { PaginationParams, FilterParam, RawInputParam } from '../params';
+import { PROJECT_LABEL_SELECTION } from '../selections';
+import type { JsonObject } from '../types';
+import { compactObject, asObject, asString } from '../util';
+
+export function projectLabelTools() {
+  return [
+    defineTool({
+      name: 'linear_list_project_labels',
+      label: 'Linear List Project Labels',
+      description: 'List project labels. Supports full projectLabels 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<{
+            projectLabels: { nodes: Array<JsonObject> };
+          }>(
+            apiKey,
+            `query ListProjectLabels(
+              $after: String
+              $before: String
+              $filter: ProjectLabelFilter
+              $first: Int
+              $includeArchived: Boolean
+              $last: Int
+              $orderBy: PaginationOrderBy
+            ) {
+              projectLabels(
+                after: $after
+                before: $before
+                filter: $filter
+                first: $first
+                includeArchived: $includeArchived
+                last: $last
+                orderBy: $orderBy
+              ) {
+                nodes {
+                  ${PROJECT_LABEL_SELECTION}
+                }
+              }
+            }`,
+            variables,
+            signal,
+          );
+
+          const labels = data.projectLabels.nodes;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ labels }, null, 2) }],
+            details: { labels },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_create_project_label',
+      label: 'Linear Create Project Label',
+      description: 'Create a project label.',
+      parameters: Type.Object({
+        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()),
+        ...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,
+            }),
+          };
+
+          if (!asString(input.name)) {
+            throw new Error('Project label name is required (name).');
+          }
+
+          const data = await linearGraphQL<{
+            projectLabelCreate: {
+              success: boolean;
+              projectLabel?: JsonObject | null;
+            };
+          }>(
+            apiKey,
+            `mutation CreateProjectLabel($input: ProjectLabelCreateInput!) {
+              projectLabelCreate(input: $input) {
+                success
+                projectLabel {
+                  ${PROJECT_LABEL_SELECTION}
+                }
+              }
+            }`,
+            { input },
+            signal,
+          );
+
+          const label = data.projectLabelCreate.projectLabel;
+          if (!data.projectLabelCreate.success || !label) {
+            throw new Error('Linear projectLabelCreate did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ label }, null, 2) }],
+            details: { label },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_update_project_label',
+      label: 'Linear Update Project Label',
+      description: 'Update a project 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()),
+        ...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,
+            }),
+          };
+
+          if (Object.keys(input).length === 0) {
+            throw new Error('No update fields were provided.');
+          }
+
+          const data = await linearGraphQL<{
+            projectLabelUpdate: {
+              success: boolean;
+              projectLabel?: JsonObject | null;
+            };
+          }>(
+            apiKey,
+            `mutation UpdateProjectLabel($id: String!, $input: ProjectLabelUpdateInput!) {
+              projectLabelUpdate(id: $id, input: $input) {
+                success
+                projectLabel {
+                  ${PROJECT_LABEL_SELECTION}
+                }
+              }
+            }`,
+            { id: params.id, input },
+            signal,
+          );
+
+          const label = data.projectLabelUpdate.projectLabel;
+          if (!data.projectLabelUpdate.success || !label) {
+            throw new Error('Linear projectLabelUpdate did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ label }, null, 2) }],
+            details: { label },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_delete_project_label',
+      label: 'Linear Delete Project Label',
+      description: 'Delete a project 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<{
+            projectLabelDelete: { success: boolean };
+          }>(
+            apiKey,
+            `mutation DeleteProjectLabel($id: String!) {
+              projectLabelDelete(id: $id) {
+                success
+              }
+            }`,
+            { id: params.id },
+            signal,
+          );
+
+          if (!data.projectLabelDelete.success) {
+            throw new Error('Linear projectLabelDelete did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true }, null, 2) }],
+            details: { success: true },
+          };
+        });
+      },
+    }),
+  ];
+}

package/extensions/tools/project-relations.ts

@@ -0,0 +1,219 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { withLinearAuth, linearGraphQL } from '../client';
+import { PaginationParams } from '../params';
+import { PROJECT_RELATION_SELECTION } from '../selections';
+import type { JsonObject } from '../types';
+import { compactObject } from '../util';
+
+export function projectRelationTools() {
+  return [
+    defineTool({
+      name: 'linear_list_project_relations',
+      label: 'Linear List Project Relations',
+      description: 'List project 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<{
+            projectRelations: { nodes: Array<JsonObject> };
+          }>(
+            apiKey,
+            `query ListProjectRelations(
+              $after: String
+              $before: String
+              $first: Int
+              $includeArchived: Boolean
+              $last: Int
+              $orderBy: PaginationOrderBy
+            ) {
+              projectRelations(
+                after: $after
+                before: $before
+                first: $first
+                includeArchived: $includeArchived
+                last: $last
+                orderBy: $orderBy
+              ) {
+                nodes {
+                  ${PROJECT_RELATION_SELECTION}
+                }
+              }
+            }`,
+            variables,
+            signal,
+          );
+
+          const projectRelations = data.projectRelations.nodes;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ projectRelations }, null, 2) }],
+            details: { projectRelations },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_create_project_relation',
+      label: 'Linear Create Project Relation',
+      description: 'Create a relation between two projects.',
+      parameters: Type.Object({
+        projectId: Type.String(),
+        relatedProjectId: Type.String(),
+        type: Type.String({ description: 'Relation type.' }),
+        anchorType: Type.String({ description: 'Anchor type for the project.' }),
+        relatedAnchorType: Type.String({
+          description: 'Anchor type for the related project.',
+        }),
+        projectMilestoneId: Type.Optional(Type.String()),
+        relatedProjectMilestoneId: Type.Optional(Type.String()),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const input = compactObject({
+            projectId: params.projectId,
+            relatedProjectId: params.relatedProjectId,
+            type: params.type,
+            anchorType: params.anchorType,
+            relatedAnchorType: params.relatedAnchorType,
+            projectMilestoneId: params.projectMilestoneId,
+            relatedProjectMilestoneId: params.relatedProjectMilestoneId,
+          });
+
+          const data = await linearGraphQL<{
+            projectRelationCreate: {
+              success: boolean;
+              projectRelation?: JsonObject | null;
+            };
+          }>(
+            apiKey,
+            `mutation CreateProjectRelation($input: ProjectRelationCreateInput!) {
+              projectRelationCreate(input: $input) {
+                success
+                projectRelation {
+                  ${PROJECT_RELATION_SELECTION}
+                }
+              }
+            }`,
+            { input },
+            signal,
+          );
+
+          const projectRelation = data.projectRelationCreate.projectRelation;
+          if (!data.projectRelationCreate.success || !projectRelation) {
+            throw new Error('Linear projectRelationCreate did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ projectRelation }, null, 2) }],
+            details: { projectRelation },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_update_project_relation',
+      label: 'Linear Update Project Relation',
+      description: 'Update a project relation by id.',
+      parameters: Type.Object({
+        id: Type.String(),
+        type: Type.Optional(Type.String()),
+        projectId: Type.Optional(Type.String()),
+        relatedProjectId: Type.Optional(Type.String()),
+        anchorType: Type.Optional(Type.String()),
+        relatedAnchorType: Type.Optional(Type.String()),
+        projectMilestoneId: Type.Optional(Type.String()),
+        relatedProjectMilestoneId: Type.Optional(Type.String()),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const input = compactObject({
+            type: params.type,
+            projectId: params.projectId,
+            relatedProjectId: params.relatedProjectId,
+            anchorType: params.anchorType,
+            relatedAnchorType: params.relatedAnchorType,
+            projectMilestoneId: params.projectMilestoneId,
+            relatedProjectMilestoneId: params.relatedProjectMilestoneId,
+          });
+
+          if (Object.keys(input).length === 0) {
+            throw new Error('No update fields were provided.');
+          }
+
+          const data = await linearGraphQL<{
+            projectRelationUpdate: {
+              success: boolean;
+              projectRelation?: JsonObject | null;
+            };
+          }>(
+            apiKey,
+            `mutation UpdateProjectRelation($id: String!, $input: ProjectRelationUpdateInput!) {
+              projectRelationUpdate(id: $id, input: $input) {
+                success
+                projectRelation {
+                  ${PROJECT_RELATION_SELECTION}
+                }
+              }
+            }`,
+            { id: params.id, input },
+            signal,
+          );
+
+          const projectRelation = data.projectRelationUpdate.projectRelation;
+          if (!data.projectRelationUpdate.success || !projectRelation) {
+            throw new Error('Linear projectRelationUpdate did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ projectRelation }, null, 2) }],
+            details: { projectRelation },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_delete_project_relation',
+      label: 'Linear Delete Project Relation',
+      description: 'Delete a project 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<{
+            projectRelationDelete: { success: boolean };
+          }>(
+            apiKey,
+            `mutation DeleteProjectRelation($id: String!) {
+              projectRelationDelete(id: $id) {
+                success
+              }
+            }`,
+            { id: params.id },
+            signal,
+          );
+
+          if (!data.projectRelationDelete.success) {
+            throw new Error('Linear projectRelationDelete did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true }, null, 2) }],
+            details: { success: true },
+          };
+        });
+      },
+    }),
+  ];
+}