@alasano/pi-linear 0.0.1

package/extensions/tools/projects.ts

@@ -0,0 +1,365 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { withLinearAuth, linearGraphQL } from '../client';
+import { PaginationParams, FilterParam, SortParam, RawInputParam } from '../params';
+import { PROJECT_SELECTION } from '../selections';
+import type { JsonObject } from '../types';
+import { compactObject, asObject, asObjectArray, asString } from '../util';
+
+export function projectTools() {
+  return [
+    defineTool({
+      name: 'linear_list_projects',
+      label: 'Linear List Projects',
+      description: 'List projects. Supports full projects query args and raw filter/sort.',
+      parameters: Type.Object({
+        ...PaginationParams,
+        ...FilterParam,
+        ...SortParam,
+      }),
+      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,
+            sort: asObjectArray(params.sort),
+          });
+
+          const data = await linearGraphQL<{
+            projects: { nodes: Array<JsonObject> };
+          }>(
+            apiKey,
+            `query ListProjects(
+              $after: String
+              $before: String
+              $filter: ProjectFilter
+              $first: Int
+              $includeArchived: Boolean
+              $last: Int
+              $orderBy: PaginationOrderBy
+              $sort: [ProjectSortInput!]
+            ) {
+              projects(
+                after: $after
+                before: $before
+                filter: $filter
+                first: $first
+                includeArchived: $includeArchived
+                last: $last
+                orderBy: $orderBy
+                sort: $sort
+              ) {
+                nodes {
+                  ${PROJECT_SELECTION}
+                }
+              }
+            }`,
+            variables,
+            signal,
+          );
+
+          const projects = data.projects.nodes;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ projects }, null, 2) }],
+            details: { projects },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_get_project',
+      label: 'Linear Get Project',
+      description: 'Get a specific project by id.',
+      parameters: Type.Object({
+        projectId: Type.String({ description: 'Project id.' }),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{ project: JsonObject | null }>(
+            apiKey,
+            `query GetProject($id: String!) {
+              project(id: $id) {
+                ${PROJECT_SELECTION}
+              }
+            }`,
+            { id: params.projectId },
+            signal,
+          );
+
+          const project = data.project;
+          return {
+            content: [
+              { type: 'text', text: JSON.stringify({ project: project ?? null }, null, 2) },
+            ],
+            details: { project: project ?? null },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_save_project',
+      label: 'Linear Save Project',
+      description:
+        'Create or update a project. If projectId/id is provided, uses projectUpdate; otherwise uses projectCreate.',
+      parameters: Type.Object({
+        projectId: Type.Optional(Type.String({ description: 'Project id for update mode.' })),
+        id: Type.Optional(Type.String({ description: 'ProjectCreateInput.id' })),
+        name: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String()),
+        content: Type.Optional(Type.String()),
+        color: Type.Optional(Type.String()),
+        icon: Type.Optional(Type.String()),
+        convertedFromIssueId: Type.Optional(Type.String()),
+        labelIds: Type.Optional(Type.Array(Type.String())),
+        lastAppliedTemplateId: Type.Optional(Type.String()),
+        leadId: Type.Optional(Type.String()),
+        memberIds: Type.Optional(Type.Array(Type.String())),
+        priority: Type.Optional(Type.Number()),
+        prioritySortOrder: Type.Optional(Type.Number()),
+        sortOrder: Type.Optional(Type.Number()),
+        startDate: Type.Optional(Type.String()),
+        startDateResolution: Type.Optional(Type.String()),
+        statusId: Type.Optional(Type.String()),
+        targetDate: Type.Optional(Type.String()),
+        targetDateResolution: Type.Optional(Type.String()),
+        teamIds: Type.Optional(Type.Array(Type.String())),
+        templateId: Type.Optional(Type.String()),
+        useDefaultTemplate: Type.Optional(Type.Boolean()),
+        canceledAt: Type.Optional(Type.String()),
+        completedAt: Type.Optional(Type.String()),
+        frequencyResolution: Type.Optional(Type.String()),
+        projectUpdateRemindersPausedUntilAt: Type.Optional(Type.String()),
+        slackIssueComments: Type.Optional(Type.Boolean()),
+        slackIssueStatuses: Type.Optional(Type.Boolean()),
+        slackNewIssue: Type.Optional(Type.Boolean()),
+        trashed: Type.Optional(Type.Boolean()),
+        updateReminderFrequency: Type.Optional(Type.Number()),
+        updateReminderFrequencyInWeeks: Type.Optional(Type.Number()),
+        updateRemindersDay: Type.Optional(Type.String()),
+        updateRemindersHour: Type.Optional(Type.Integer()),
+        slackChannelName: 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.projectId) || asString(rawInput.id);
+
+          const input = {
+            ...rawInput,
+            ...compactObject({
+              canceledAt: params.canceledAt,
+              color: params.color,
+              completedAt: params.completedAt,
+              content: params.content,
+              convertedFromIssueId: params.convertedFromIssueId,
+              description: params.description,
+              frequencyResolution: params.frequencyResolution,
+              icon: params.icon,
+              id: params.id,
+              labelIds: params.labelIds,
+              lastAppliedTemplateId: params.lastAppliedTemplateId,
+              leadId: params.leadId,
+              memberIds: params.memberIds,
+              name: params.name,
+              priority: params.priority,
+              prioritySortOrder: params.prioritySortOrder,
+              projectUpdateRemindersPausedUntilAt: params.projectUpdateRemindersPausedUntilAt,
+              slackIssueComments: params.slackIssueComments,
+              slackIssueStatuses: params.slackIssueStatuses,
+              slackNewIssue: params.slackNewIssue,
+              sortOrder: params.sortOrder,
+              startDate: params.startDate,
+              startDateResolution: params.startDateResolution,
+              statusId: params.statusId,
+              targetDate: params.targetDate,
+              targetDateResolution: params.targetDateResolution,
+              teamIds: params.teamIds,
+              templateId: params.templateId,
+              trashed: params.trashed,
+              updateReminderFrequency: params.updateReminderFrequency,
+              updateReminderFrequencyInWeeks: params.updateReminderFrequencyInWeeks,
+              updateRemindersDay: params.updateRemindersDay,
+              updateRemindersHour: params.updateRemindersHour,
+              useDefaultTemplate: params.useDefaultTemplate,
+            }),
+          };
+
+          if (updateId) {
+            if (Object.keys(input).length === 0) {
+              throw new Error('No project update fields were provided.');
+            }
+
+            const data = await linearGraphQL<{
+              projectUpdate: { success: boolean; project?: JsonObject | null };
+            }>(
+              apiKey,
+              `mutation UpdateProject($id: String!, $input: ProjectUpdateInput!) {
+                projectUpdate(id: $id, input: $input) {
+                  success
+                  project {
+                    ${PROJECT_SELECTION}
+                  }
+                }
+              }`,
+              { id: updateId, input },
+              signal,
+            );
+
+            if (!data.projectUpdate.success || !data.projectUpdate.project) {
+              throw new Error('Linear projectUpdate did not succeed.');
+            }
+
+            const project = data.projectUpdate.project;
+            return {
+              content: [{ type: 'text', text: JSON.stringify({ project }, null, 2) }],
+              details: { project },
+            };
+          }
+
+          if (!asString(input.name)) {
+            throw new Error('Project name is required for projectCreate (name).');
+          }
+
+          if (!Array.isArray(input.teamIds) || input.teamIds.length === 0) {
+            throw new Error('teamIds is required for projectCreate and must be a non-empty array.');
+          }
+
+          const data = await linearGraphQL<{
+            projectCreate: { success: boolean; project?: JsonObject | null };
+          }>(
+            apiKey,
+            `mutation CreateProject($input: ProjectCreateInput!, $slackChannelName: String) {
+              projectCreate(input: $input, slackChannelName: $slackChannelName) {
+                success
+                project {
+                  ${PROJECT_SELECTION}
+                }
+              }
+            }`,
+            {
+              input,
+              slackChannelName: params.slackChannelName,
+            },
+            signal,
+          );
+
+          if (!data.projectCreate.success || !data.projectCreate.project) {
+            throw new Error('Linear projectCreate did not succeed.');
+          }
+
+          const project = data.projectCreate.project;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ project }, null, 2) }],
+            details: { project },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_delete_project',
+      label: 'Linear Delete Project',
+      description: 'Delete a project by id.',
+      parameters: Type.Object({
+        projectId: Type.String(),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{
+            projectDelete: { success: boolean };
+          }>(
+            apiKey,
+            `mutation DeleteProject($id: String!) {
+              projectDelete(id: $id) {
+                success
+              }
+            }`,
+            { id: params.projectId },
+            signal,
+          );
+
+          if (!data.projectDelete.success) {
+            throw new Error('Linear projectDelete did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true }, null, 2) }],
+            details: { success: true },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_archive_project',
+      label: 'Linear Archive Project',
+      description: 'Archive a project by id. Use trash=true to trash instead.',
+      parameters: Type.Object({
+        projectId: Type.String(),
+        trash: Type.Optional(Type.Boolean()),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{
+            projectArchive: { success: boolean };
+          }>(
+            apiKey,
+            `mutation ArchiveProject($id: String!, $trash: Boolean) {
+              projectArchive(id: $id, trash: $trash) {
+                success
+              }
+            }`,
+            { id: params.projectId, trash: params.trash },
+            signal,
+          );
+
+          if (!data.projectArchive.success) {
+            throw new Error('Linear projectArchive did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true }, null, 2) }],
+            details: { success: true },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_unarchive_project',
+      label: 'Linear Unarchive Project',
+      description: 'Unarchive a project by id.',
+      parameters: Type.Object({
+        projectId: Type.String(),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{
+            projectUnarchive: { success: boolean };
+          }>(
+            apiKey,
+            `mutation UnarchiveProject($id: String!) {
+              projectUnarchive(id: $id) {
+                success
+              }
+            }`,
+            { id: params.projectId },
+            signal,
+          );
+
+          if (!data.projectUnarchive.success) {
+            throw new Error('Linear projectUnarchive did not succeed.');
+          }
+
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true }, null, 2) }],
+            details: { success: true },
+          };
+        });
+      },
+    }),
+  ];
+}

package/extensions/tools/teams.ts

@@ -0,0 +1,107 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { withLinearAuth, linearGraphQL } from '../client';
+import { PaginationParams, FilterParam } from '../params';
+import { TEAM_SELECTION } from '../selections';
+import type { LinearTeam, JsonObject } from '../types';
+import { compactObject, asObject } from '../util';
+
+export function teamTools() {
+  return [
+    defineTool({
+      name: 'linear_list_teams',
+      label: 'Linear List Teams',
+      description:
+        'List Linear teams and states. Supports full teams query args: after, before, filter, first, includeArchived, last, orderBy.',
+      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,
+            includeArchived: params.includeArchived,
+            last: params.last,
+            orderBy: params.orderBy,
+          });
+
+          const data = await linearGraphQL<{ teams: { nodes: LinearTeam[] } }>(
+            apiKey,
+            `query ListTeams(
+              $after: String
+              $before: String
+              $filter: TeamFilter
+              $first: Int
+              $includeArchived: Boolean
+              $last: Int
+              $orderBy: PaginationOrderBy
+            ) {
+              teams(
+                after: $after
+                before: $before
+                filter: $filter
+                first: $first
+                includeArchived: $includeArchived
+                last: $last
+                orderBy: $orderBy
+              ) {
+                nodes {
+                  id
+                  key
+                  name
+                  states(first: 50) {
+                    nodes {
+                      id
+                      name
+                      type
+                    }
+                  }
+                }
+              }
+            }`,
+            variables,
+            signal,
+          );
+
+          const teams = data.teams.nodes;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ teams }, null, 2) }],
+            details: { teams },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_get_team',
+      label: 'Linear Get Team',
+      description: 'Get a specific team by id.',
+      parameters: Type.Object({
+        teamId: Type.String(),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{ team: JsonObject | null }>(
+            apiKey,
+            `query GetTeam($id: String!) {
+              team(id: $id) {
+                ${TEAM_SELECTION}
+              }
+            }`,
+            { id: params.teamId },
+            signal,
+          );
+
+          const team = data.team;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ team }, null, 2) }],
+            details: { team },
+          };
+        });
+      },
+    }),
+  ];
+}

package/extensions/tools/users.ts

@@ -0,0 +1,107 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { withLinearAuth, linearGraphQL } from '../client';
+import { PaginationParams, FilterParam, SortParam } from '../params';
+import { USER_SELECTION } from '../selections';
+import type { JsonObject } from '../types';
+import { compactObject, asObject, asObjectArray } from '../util';
+
+export function userTools() {
+  return [
+    defineTool({
+      name: 'linear_list_users',
+      label: 'Linear List Users',
+      description: 'List users. Supports full users query args.',
+      parameters: Type.Object({
+        ...PaginationParams,
+        ...FilterParam,
+        ...SortParam,
+        includeDisabled: Type.Optional(Type.Boolean()),
+      }),
+      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,
+            includeDisabled: params.includeDisabled,
+            last: params.last,
+            orderBy: params.orderBy,
+            sort: asObjectArray(params.sort),
+          });
+
+          const data = await linearGraphQL<{
+            users: { nodes: Array<JsonObject> };
+          }>(
+            apiKey,
+            `query ListUsers(
+              $after: String
+              $before: String
+              $filter: UserFilter
+              $first: Int
+              $includeArchived: Boolean
+              $includeDisabled: Boolean
+              $last: Int
+              $orderBy: PaginationOrderBy
+              $sort: [UserSortInput!]
+            ) {
+              users(
+                after: $after
+                before: $before
+                filter: $filter
+                first: $first
+                includeArchived: $includeArchived
+                includeDisabled: $includeDisabled
+                last: $last
+                orderBy: $orderBy
+                sort: $sort
+              ) {
+                nodes {
+                  ${USER_SELECTION}
+                }
+              }
+            }`,
+            variables,
+            signal,
+          );
+
+          const users = data.users.nodes;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ users }, null, 2) }],
+            details: { users },
+          };
+        });
+      },
+    }),
+    defineTool({
+      name: 'linear_get_user',
+      label: 'Linear Get User',
+      description: 'Get a specific user by id.',
+      parameters: Type.Object({
+        userId: Type.String(),
+      }),
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        return withLinearAuth(ctx, signal, async (apiKey) => {
+          const data = await linearGraphQL<{ user: JsonObject | null }>(
+            apiKey,
+            `query GetUser($id: String!) {
+              user(id: $id) {
+                ${USER_SELECTION}
+              }
+            }`,
+            { id: params.userId },
+            signal,
+          );
+
+          const user = data.user;
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ user }, null, 2) }],
+            details: { user },
+          };
+        });
+      },
+    }),
+  ];
+}

package/extensions/tools/workspaces.ts

@@ -0,0 +1,33 @@
+import { defineTool } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import { switchWorkspace, type WorkspaceCredentials } from '../client';
+
+export function workspaceTools(creds: WorkspaceCredentials) {
+  const names = Object.keys(creds.workspaces);
+  if (names.length < 2) return [];
+
+  return [
+    defineTool({
+      name: 'linear_switch_workspace',
+      label: 'Linear Switch Workspace',
+      description: `Switch active Linear workspace. Available: ${names.join(', ')}. Currently active: ${creds.activeWorkspace || 'none'}.`,
+      parameters: Type.Object({
+        name: Type.String({
+          description: `Workspace name to switch to. One of: ${names.join(', ')}`,
+        }),
+      }),
+      async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+        const updated = await switchWorkspace(params.name);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ active: updated.activeWorkspace }, null, 2),
+            },
+          ],
+          details: { active: updated.activeWorkspace },
+        };
+      },
+    }),
+  ];
+}

package/extensions/types.ts

@@ -0,0 +1,31 @@
+export type JsonObject = Record<string, unknown>;
+
+export type LinearGraphQLError = {
+  message: string;
+};
+
+export type LinearIssue = {
+  id: string;
+  identifier: string;
+  number?: number | null;
+  title: string;
+  description?: string | null;
+  priority?: number | null;
+  url?: string | null;
+  branchName?: string | null;
+  dueDate?: string | null;
+  createdAt?: string;
+  updatedAt?: string;
+  state?: { id: string; name: string; type?: string | null } | null;
+  team?: { id: string; key: string; name: string } | null;
+  assignee?: { id: string; name?: string | null; email?: string | null } | null;
+};
+
+export type LinearTeam = {
+  id: string;
+  key: string;
+  name: string;
+  states?: {
+    nodes: Array<{ id: string; name: string; type?: string | null }>;
+  };
+};

package/extensions/util.ts

@@ -0,0 +1,38 @@
+import { Type } from '@sinclair/typebox';
+import type { JsonObject } from './types';
+
+export function asString(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+export function asObject(value: unknown): JsonObject | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  return value as JsonObject;
+}
+
+export function asObjectArray(value: unknown): JsonObject[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const mapped = value.map(asObject).filter((item): item is JsonObject => Boolean(item));
+  return mapped.length ? mapped : [];
+}
+
+export function compactObject<T extends Record<string, unknown>>(input: T): Partial<T> {
+  const output: Partial<T> = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== undefined) {
+      output[key as keyof T] = value as T[keyof T];
+    }
+  }
+  return output;
+}
+
+export function mergeFilters(base?: JsonObject, extra?: JsonObject): JsonObject | undefined {
+  if (base && extra) {
+    return { and: [base, extra] };
+  }
+  return base || extra;
+}
+
+export const GenericObjectSchema = Type.Record(Type.String(), Type.Any());