runline 0.8.0 → 0.8.1

package/dist/plugins/linear/src/initiatives.js

@@ -0,0 +1,79 @@
+import * as t from "typebox";
+import { INITIATIVE_FIELDS, bindGetAction, bindListAction, gql, key } from "./shared.js";
+export function registerInitiativeActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("initiative.list", "List initiatives.", "initiatives", "InitiativeFilter", INITIATIVE_FIELDS);
+    getAction("initiative.get", "Get an initiative by ID or slug.", "initiative", INITIATIVE_FIELDS);
+    rl.registerAction("initiative.create", {
+        description: "Create an initiative. Status: Planned | Active | Completed.",
+        inputSchema: t.Object({
+            name: t.String({ description: "The name of the initiative" }),
+            description: t.Optional(t.String({ description: "The description of the initiative" })),
+            content: t.Optional(t.String({ description: "The initiative's content in markdown format" })),
+            icon: t.Optional(t.String({ description: "The initiative's icon" })),
+            color: t.Optional(t.String({ description: "The initiative's color (hex)" })),
+            ownerId: t.Optional(t.String({ description: "The owner of the initiative" })),
+            status: t.Optional(t.String({ description: "The initiative's status (InitiativeStatus: Planned | Active | Completed)" })),
+            targetDate: t.Optional(t.String({ description: "The estimated completion date of the initiative (TimelessDate, YYYY-MM-DD)" })),
+            targetDateResolution: t.Optional(t.String({ description: "The resolution of the initiative's estimated completion date (DateResolutionType)" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order of the initiative within the workspace (Float)" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($input: InitiativeCreateInput!) { initiativeCreate(input: $input) { success initiative { ${INITIATIVE_FIELDS} } } }`, { input: input });
+            return data.initiativeCreate?.initiative;
+        },
+    });
+    rl.registerAction("initiative.update", {
+        description: "Update an initiative.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the initiative to update" }),
+            name: t.Optional(t.String({ description: "The name of the initiative" })),
+            description: t.Optional(t.String({ description: "The description of the initiative" })),
+            content: t.Optional(t.String({ description: "The initiative's content in markdown format" })),
+            icon: t.Optional(t.String({ description: "The initiative's icon" })),
+            color: t.Optional(t.String({ description: "The initiative's color (hex)" })),
+            ownerId: t.Optional(t.String({ description: "The owner of the initiative" })),
+            status: t.Optional(t.String({ description: "The initiative's status (InitiativeStatus: Planned | Active | Completed)" })),
+            targetDate: t.Optional(t.String({ description: "The estimated completion date (TimelessDate, YYYY-MM-DD). Set to null to clear" })),
+            targetDateResolution: t.Optional(t.String({ description: "The resolution of the initiative's estimated completion date (DateResolutionType)" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order of the initiative within the workspace (Float)" })),
+            trashed: t.Optional(t.Boolean({ description: "Whether the initiative has been trashed. Set to true to trash, or null to restore" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: InitiativeUpdateInput!) { initiativeUpdate(id: $id, input: $input) { success initiative { ${INITIATIVE_FIELDS} } } }`, { id, input: fields });
+            return data.initiativeUpdate?.initiative;
+        },
+    });
+    rl.registerAction("initiative.delete", {
+        description: "Trash an initiative.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the initiative to delete" }) }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { initiativeDelete(id: $id) { success } }`, { id: input.id });
+            return data.initiativeDelete;
+        },
+    });
+    rl.registerAction("initiative.addProject", {
+        description: "Associate a project with an initiative. A project can only appear once in an initiative hierarchy.",
+        inputSchema: t.Object({
+            initiativeId: t.String({ description: "The identifier of the initiative" }),
+            projectId: t.String({ description: "The identifier of the project" }),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project within the initiative (Float)" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($input: InitiativeToProjectCreateInput!) { initiativeToProjectCreate(input: $input) { success initiativeToProject { id } } }`, { input: input });
+            return data.initiativeToProjectCreate;
+        },
+    });
+    rl.registerAction("initiative.removeProject", {
+        description: "Remove a project from an initiative. Pass the link id returned by initiative.addProject.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the initiativeToProject to delete" }) }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { initiativeToProjectDelete(id: $id) { success } }`, { id: input.id });
+            return data.initiativeToProjectDelete;
+        },
+    });
+}

package/dist/plugins/linear/src/issues.js

@@ -0,0 +1,245 @@
+import * as t from "typebox";
+import { COMMENT_FIELDS, ISSUE_FIELDS, ISSUE_LITE, LIST_INPUT_SCHEMA, buildConnArgs, gql, key, } from "./shared.js";
+export function registerIssueActions(rl) {
+    rl.registerAction("issue.create", {
+        description: "Create an issue. teamId is required; title is required unless a template is applied.",
+        inputSchema: t.Object({
+            teamId: t.String({ description: "The identifier of the team associated with the issue" }),
+            title: t.String({ description: "The title of the issue" }),
+            description: t.Optional(t.String({ description: "The issue description in markdown format" })),
+            assigneeId: t.Optional(t.String({ description: "The identifier of the user to assign the issue to" })),
+            priority: t.Optional(t.Number({ description: "Priority. 0=No priority, 1=Urgent, 2=High, 3=Medium, 4=Low" })),
+            stateId: t.Optional(t.String({ description: "The team workflow state of the issue" })),
+            labelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the issue labels associated with this ticket" })),
+            parentId: t.Optional(t.String({ description: "The identifier of the parent issue. UUID or issue identifier (e.g., 'LIN-123')" })),
+            projectId: t.Optional(t.String({ description: "The project associated with the issue" })),
+            projectMilestoneId: t.Optional(t.String({ description: "The project milestone associated with the issue" })),
+            cycleId: t.Optional(t.String({ description: "The cycle associated with the issue" })),
+            estimate: t.Optional(t.Number({ description: "The estimated complexity of the issue (Int)" })),
+            dueDate: t.Optional(t.String({ description: "The date at which the issue is due (TimelessDate, YYYY-MM-DD)" })),
+            subscriberIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the users subscribing to this ticket" })),
+            templateId: t.Optional(t.String({ description: "The identifier of a template the issue should be created from" })),
+            useDefaultTemplate: t.Optional(t.Boolean({ description: "Apply the team's default template based on the user's membership" })),
+            sortOrder: t.Optional(t.Number({ description: "The position of the issue related to other issues (Float)" })),
+            subIssueSortOrder: t.Optional(t.Number({ description: "The position of the issue in its parent's sub-issue list (Float)" })),
+            releaseIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the releases to associate with this issue" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            const fields = input;
+            const data = await gql(key(ctx), `mutation($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { ${ISSUE_FIELDS} } } }`, { input: fields });
+            return data.issueCreate?.issue;
+        },
+    });
+    rl.registerAction("issue.get", {
+        description: "Get an issue by ID or identifier (e.g. 'THE-154')",
+        inputSchema: t.Object({ issueId: t.String() }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `query($id: String!) { issue(id: $id) { ${ISSUE_FIELDS} } }`, { id: input.issueId });
+            return data.issue;
+        },
+    });
+    rl.registerAction("issue.list", {
+        description: "List issues. Pass `filter` for state/label/project/etc. Default hides archived.",
+        inputSchema: t.Object({
+            ...LIST_INPUT_SCHEMA,
+            teamId: t.Optional(t.String({ description: "Convenience: filter by team" })),
+            assigneeId: t.Optional(t.String({ description: "Convenience: filter by assignee" })),
+        }),
+        async execute(input, ctx) {
+            const opts = (input ?? {});
+            // Merge convenience filters into `filter`
+            const merged = { ...(opts.filter ?? {}) };
+            if (opts.teamId)
+                merged.team = { id: { eq: opts.teamId } };
+            if (opts.assigneeId)
+                merged.assignee = { id: { eq: opts.assigneeId } };
+            const filter = Object.keys(merged).length > 0 ? merged : undefined;
+            const { argsDecl, argsCall, vars } = buildConnArgs({ ...opts, filter }, "IssueFilter");
+            const data = await gql(key(ctx), `query${argsDecl} { issues${argsCall} { nodes { ${ISSUE_LITE} } pageInfo { hasNextPage endCursor } } }`, vars);
+            const conn = data.issues;
+            return { nodes: conn.nodes, pageInfo: conn.pageInfo };
+        },
+    });
+    rl.registerAction("issue.update", {
+        description: "Update an issue. All fields optional; only provided fields are updated.",
+        inputSchema: t.Object({
+            issueId: t.String({ description: "The identifier of the issue to update" }),
+            title: t.Optional(t.String({ description: "The issue title" })),
+            description: t.Optional(t.String({ description: "The issue description in markdown format" })),
+            assigneeId: t.Optional(t.String({ description: "The identifier of the user to assign the issue to" })),
+            stateId: t.Optional(t.String({ description: "The team workflow state of the issue" })),
+            priority: t.Optional(t.Number({ description: "Priority. 0=No priority, 1=Urgent, 2=High, 3=Medium, 4=Low" })),
+            labelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the issue labels associated with this ticket (replaces all)" })),
+            addedLabelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of issue labels to be added to this issue" })),
+            removedLabelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of issue labels to be removed from this issue" })),
+            projectId: t.Optional(t.String({ description: "The project associated with the issue" })),
+            projectMilestoneId: t.Optional(t.String({ description: "The project milestone associated with the issue" })),
+            cycleId: t.Optional(t.String({ description: "The cycle associated with the issue" })),
+            parentId: t.Optional(t.String({ description: "The identifier of the parent issue. UUID or issue identifier (e.g., 'LIN-123')" })),
+            teamId: t.Optional(t.String({ description: "The identifier of the team associated with the issue (move issue to a different team)" })),
+            estimate: t.Optional(t.Number({ description: "The estimated complexity of the issue (Int)" })),
+            dueDate: t.Optional(t.String({ description: "The date at which the issue is due (TimelessDate, YYYY-MM-DD)" })),
+            subscriberIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the users subscribing to this ticket" })),
+            sortOrder: t.Optional(t.Number({ description: "The position of the issue related to other issues (Float)" })),
+            subIssueSortOrder: t.Optional(t.Number({ description: "The position of the issue in its parent's sub-issue list (Float)" })),
+            snoozedUntilAt: t.Optional(t.String({ description: "The time until which the issue will be snoozed in Triage view (DateTime)" })),
+            releaseIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the releases associated with this issue (replaces all)" })),
+            addedReleaseIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of releases to be added to this issue" })),
+            removedReleaseIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of releases to be removed from this issue" })),
+            trashed: t.Optional(t.Boolean({ description: "Whether the issue has been trashed" })),
+        }),
+        async execute(input, ctx) {
+            const { issueId, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: IssueUpdateInput!) { issueUpdate(id: $id, input: $input) { success issue { ${ISSUE_FIELDS} } } }`, { id: issueId, input: fields });
+            return data.issueUpdate?.issue;
+        },
+    });
+    rl.registerAction("issue.delete", {
+        description: "Trash (soft-delete) an issue. Pass permanentlyDelete=true to bypass 30d grace period (admin only).",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            permanentlyDelete: t.Optional(t.Boolean()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, permanentlyDelete } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $perm: Boolean) { issueDelete(id: $id, permanentlyDelete: $perm) { success } }`, { id: issueId, perm: permanentlyDelete ?? null });
+            return data.issueDelete;
+        },
+    });
+    rl.registerAction("issue.archive", {
+        description: "Archive an issue.",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            trash: t.Optional(t.Boolean()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, trash } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $trash: Boolean) { issueArchive(id: $id, trash: $trash) { success } }`, { id: issueId, trash: trash ?? null });
+            return data.issueArchive;
+        },
+    });
+    rl.registerAction("issue.unarchive", {
+        description: "Unarchive an issue.",
+        inputSchema: t.Object({ issueId: t.String() }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { issueUnarchive(id: $id) { success } }`, { id: input.issueId });
+            return data.issueUnarchive;
+        },
+    });
+    rl.registerAction("issue.search", {
+        description: "Search issues by text query using full-text and vector search. Rate-limited to 30 req/min.",
+        inputSchema: t.Object({
+            term: t.String({ description: "Search string to look for" }),
+            limit: t.Optional(t.Number({ description: "Max results (forward pagination, default 50)" })),
+            filter: t.Optional(t.Object({}, { description: "Optional IssueFilter" })),
+            includeComments: t.Optional(t.Boolean({ description: "Should associated comments be searched (default false)" })),
+            includeArchived: t.Optional(t.Boolean({ description: "Should archived resources be included (default false)" })),
+            teamId: t.Optional(t.String({ description: "UUID of a team to boost in search results" })),
+            orderBy: t.Optional(t.String({ description: "PaginationOrderBy: createdAt | updatedAt" })),
+            after: t.Optional(t.String({ description: "Cursor for forward pagination" })),
+            before: t.Optional(t.String({ description: "Cursor for backward pagination" })),
+        }),
+        async execute(input, ctx) {
+            const opts = input;
+            const data = await gql(key(ctx), `query($term: String!, $first: Int, $filter: IssueFilter, $includeComments: Boolean, $includeArchived: Boolean, $teamId: String, $orderBy: PaginationOrderBy, $after: String, $before: String) {
+          searchIssues(term: $term, first: $first, filter: $filter, includeComments: $includeComments, includeArchived: $includeArchived, teamId: $teamId, orderBy: $orderBy, after: $after, before: $before) {
+            nodes { ${ISSUE_LITE} }
+            totalCount
+            pageInfo { hasNextPage endCursor }
+          }
+        }`, {
+                term: opts.term,
+                first: opts.limit ?? 50,
+                filter: opts.filter ?? null,
+                includeComments: opts.includeComments ?? null,
+                includeArchived: opts.includeArchived ?? null,
+                teamId: opts.teamId ?? null,
+                orderBy: opts.orderBy ?? null,
+                after: opts.after ?? null,
+                before: opts.before ?? null,
+            });
+            return data.searchIssues;
+        },
+    });
+    rl.registerAction("issue.addLabel", {
+        description: "Add a single label to an issue.",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            labelId: t.String(),
+        }),
+        async execute(input, ctx) {
+            const { issueId, labelId } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $labelId: String!) { issueAddLabel(id: $id, labelId: $labelId) { success } }`, { id: issueId, labelId });
+            return data.issueAddLabel;
+        },
+    });
+    rl.registerAction("issue.removeLabel", {
+        description: "Remove a single label from an issue.",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            labelId: t.String(),
+        }),
+        async execute(input, ctx) {
+            const { issueId, labelId } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $labelId: String!) { issueRemoveLabel(id: $id, labelId: $labelId) { success } }`, { id: issueId, labelId });
+            return data.issueRemoveLabel;
+        },
+    });
+    rl.registerAction("issue.subscribe", {
+        description: "Subscribe a user to issue notifications (defaults to current user).",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            userId: t.Optional(t.String()),
+            userEmail: t.Optional(t.String()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, userId, userEmail } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $userId: String, $userEmail: String) {
+          issueSubscribe(id: $id, userId: $userId, userEmail: $userEmail) { success }
+        }`, { id: issueId, userId: userId ?? null, userEmail: userEmail ?? null });
+            return data.issueSubscribe;
+        },
+    });
+    rl.registerAction("issue.unsubscribe", {
+        description: "Unsubscribe a user from issue notifications (defaults to current user).",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            userId: t.Optional(t.String()),
+            userEmail: t.Optional(t.String()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, userId, userEmail } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $userId: String, $userEmail: String) {
+          issueUnsubscribe(id: $id, userId: $userId, userEmail: $userEmail) { success }
+        }`, { id: issueId, userId: userId ?? null, userEmail: userEmail ?? null });
+            return data.issueUnsubscribe;
+        },
+    });
+    rl.registerAction("issue.addLink", {
+        description: "Create a relation between two issues.",
+        inputSchema: t.Object({
+            issueId: t.String({ description: "The identifier of the issue that is related to another issue. UUID or issue identifier (e.g., 'LIN-123')" }),
+            relatedIssueId: t.String({ description: "The identifier of the related issue. UUID or issue identifier (e.g., 'LIN-123')" }),
+            type: t.String({ description: "IssueRelationType: blocks | duplicate | related | similar" }),
+        }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($input: IssueRelationCreateInput!) { issueRelationCreate(input: $input) { success issueRelation { id type } } }`, { input: input });
+            return data.issueRelationCreate;
+        },
+    });
+    rl.registerAction("issue.listComments", {
+        description: "List comments on an issue.",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            limit: t.Optional(t.Number()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, limit } = input;
+            const data = await gql(key(ctx), `query($id: String!, $first: Int) {
+          issue(id: $id) { comments(first: $first) { nodes { ${COMMENT_FIELDS} } } }
+        }`, { id: issueId, first: limit ?? 50 });
+            return data.issue?.comments?.nodes;
+        },
+    });
+}

package/dist/plugins/linear/src/labels.js

@@ -0,0 +1,69 @@
+import * as t from "typebox";
+import { LABEL_FIELDS, bindGetAction, bindListAction, gql, key } from "./shared.js";
+export function registerLabelActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("label.list", "List labels (workspace + team-scoped).", "issueLabels", "IssueLabelFilter", LABEL_FIELDS);
+    getAction("label.get", "Get a label by ID.", "issueLabel", LABEL_FIELDS);
+    rl.registerAction("label.create", {
+        description: "Create a label. Omit teamId for a workspace-level label.",
+        inputSchema: t.Object({
+            name: t.String({ description: "The name of the label" }),
+            teamId: t.Optional(t.String({ description: "The team associated with the label. If omitted, the label is workspace-scoped" })),
+            color: t.Optional(t.String({ description: "The color of the label (hex)" })),
+            description: t.Optional(t.String({ description: "The description of the label" })),
+            parentId: t.Optional(t.String({ description: "The identifier of the parent label (group label)" })),
+            isGroup: t.Optional(t.Boolean({ description: "Whether the label is a group" })),
+            retiredAt: t.Optional(t.String({ description: "The time at which the label was retired (DateTime). Set to null to restore a retired label" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+            replaceTeamLabels: t.Optional(t.Boolean({ description: "Replace all team-specific labels with the same name with this newly created workspace label (default false)" })),
+        }),
+        async execute(input, ctx) {
+            const { replaceTeamLabels, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($input: IssueLabelCreateInput!, $replaceTeamLabels: Boolean) { issueLabelCreate(input: $input, replaceTeamLabels: $replaceTeamLabels) { success issueLabel { ${LABEL_FIELDS} } } }`, { input: fields, replaceTeamLabels: replaceTeamLabels ?? null });
+            return data.issueLabelCreate?.issueLabel;
+        },
+    });
+    rl.registerAction("label.update", {
+        description: "Update a label.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the label to update" }),
+            name: t.Optional(t.String({ description: "The name of the label" })),
+            color: t.Optional(t.String({ description: "The color of the label (hex)" })),
+            description: t.Optional(t.String({ description: "The description of the label" })),
+            parentId: t.Optional(t.String({ description: "The identifier of the parent label" })),
+            isGroup: t.Optional(t.Boolean({ description: "Whether the label is a group" })),
+            retiredAt: t.Optional(t.String({ description: "The time at which the label was retired (DateTime). Set to null to restore a retired label" })),
+            replaceTeamLabels: t.Optional(t.Boolean({ description: "Replace all team-specific labels with the same name with this updated workspace label (default false)" })),
+        }),
+        async execute(input, ctx) {
+            const { id, replaceTeamLabels, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: IssueLabelUpdateInput!, $replaceTeamLabels: Boolean) { issueLabelUpdate(id: $id, input: $input, replaceTeamLabels: $replaceTeamLabels) { success issueLabel { ${LABEL_FIELDS} } } }`, { id, input: fields, replaceTeamLabels: replaceTeamLabels ?? null });
+            return data.issueLabelUpdate?.issueLabel;
+        },
+    });
+    rl.registerAction("label.delete", {
+        description: "Delete a label.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the label to delete" }) }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { issueLabelDelete(id: $id) { success } }`, { id: input.id });
+            return data.issueLabelDelete;
+        },
+    });
+    rl.registerAction("label.retire", {
+        description: "Retire a label. Retired labels remain visible but cannot be applied to new issues.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the label to retire" }) }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { issueLabelRetire(id: $id) { success issueLabel { ${LABEL_FIELDS} } } }`, { id: input.id });
+            return data.issueLabelRetire?.issueLabel;
+        },
+    });
+    rl.registerAction("label.restore", {
+        description: "Restore a previously retired label.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the label to restore" }) }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { issueLabelRestore(id: $id) { success issueLabel { ${LABEL_FIELDS} } } }`, { id: input.id });
+            return data.issueLabelRestore?.issueLabel;
+        },
+    });
+}

package/dist/plugins/linear/src/organization.js

@@ -0,0 +1,12 @@
+import * as t from "typebox";
+import { ORG_FIELDS, gql, key } from "./shared.js";
+export function registerOrganizationActions(rl) {
+    rl.registerAction("org.get", {
+        description: "Get the authenticated workspace.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            const data = await gql(key(ctx), `query { organization { ${ORG_FIELDS} } }`);
+            return data.organization;
+        },
+    });
+}

package/dist/plugins/linear/src/projects.js

@@ -0,0 +1,189 @@
+import * as t from "typebox";
+import { MILESTONE_FIELDS, PROJECT_FIELDS, PROJECT_UPDATE_FIELDS, bindGetAction, bindListAction, gql, key, } from "./shared.js";
+export function registerProjectActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("project.list", "List projects.", "projects", "ProjectFilter", PROJECT_FIELDS);
+    getAction("project.get", "Get a project by ID or slug.", "project", PROJECT_FIELDS);
+    rl.registerAction("project.create", {
+        description: "Create a project. teamIds is required.",
+        inputSchema: t.Object({
+            name: t.String({ description: "The name of the project" }),
+            teamIds: t.Array(t.Unknown(), { description: "The identifiers of the teams this project is associated with" }),
+            description: t.Optional(t.String({ description: "The description for the project" })),
+            content: t.Optional(t.String({ description: "The project content as markdown" })),
+            icon: t.Optional(t.String({ description: "The icon of the project" })),
+            color: t.Optional(t.String({ description: "The color of the project (hex)" })),
+            priority: t.Optional(t.Number({ description: "The priority of the project. 0=No priority, 1=Urgent, 2=High, 3=Medium, 4=Low" })),
+            leadId: t.Optional(t.String({ description: "The identifier of the project lead" })),
+            memberIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the members of this project" })),
+            startDate: t.Optional(t.String({ description: "The planned start date of the project (TimelessDate, YYYY-MM-DD)" })),
+            startDateResolution: t.Optional(t.String({ description: "The resolution of the project's start date (DateResolutionType)" })),
+            targetDate: t.Optional(t.String({ description: "The planned target date of the project (TimelessDate, YYYY-MM-DD)" })),
+            targetDateResolution: t.Optional(t.String({ description: "The resolution of the project's estimated completion date (DateResolutionType)" })),
+            statusId: t.Optional(t.String({ description: "The ID of the project status" })),
+            labelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the project labels associated with this project" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project in shared views (Float)" })),
+            templateId: t.Optional(t.String({ description: "The ID of a project template to apply when creating the project" })),
+            useDefaultTemplate: t.Optional(t.Boolean({ description: "Apply the default project template of the first team provided. Ignored if templateId is set" })),
+            convertedFromIssueId: t.Optional(t.String({ description: "The ID of the issue that was converted into this project" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+            slackChannelName: t.Optional(t.String({ description: "The full name for the Slack channel to create (including prefix). Creates and connects a Slack channel if provided" })),
+        }),
+        async execute(input, ctx) {
+            const { slackChannelName, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($input: ProjectCreateInput!, $slackChannelName: String) { projectCreate(input: $input, slackChannelName: $slackChannelName) { success project { ${PROJECT_FIELDS} } } }`, { input: fields, slackChannelName: slackChannelName ?? null });
+            return data.projectCreate?.project;
+        },
+    });
+    rl.registerAction("project.update", {
+        description: "Update a project.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the project to update (UUID or slug)" }),
+            name: t.Optional(t.String({ description: "The name of the project" })),
+            description: t.Optional(t.String({ description: "The description for the project" })),
+            content: t.Optional(t.String({ description: "The project content as markdown" })),
+            icon: t.Optional(t.String({ description: "The icon of the project" })),
+            color: t.Optional(t.String({ description: "The color of the project (hex)" })),
+            priority: t.Optional(t.Number({ description: "The priority of the project. 0=No, 1=Urgent, 2=High, 3=Medium, 4=Low" })),
+            leadId: t.Optional(t.String({ description: "The identifier of the project lead" })),
+            memberIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the members of this project" })),
+            startDate: t.Optional(t.String({ description: "The planned start date (TimelessDate, YYYY-MM-DD)" })),
+            startDateResolution: t.Optional(t.String({ description: "The resolution of the project's start date (DateResolutionType)" })),
+            targetDate: t.Optional(t.String({ description: "The planned target date (TimelessDate, YYYY-MM-DD)" })),
+            targetDateResolution: t.Optional(t.String({ description: "The resolution of the project's estimated completion date (DateResolutionType)" })),
+            statusId: t.Optional(t.String({ description: "The ID of the project status" })),
+            labelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the project labels associated with this project" })),
+            teamIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the teams this project is associated with" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project in shared views (Float)" })),
+            completedAt: t.Optional(t.String({ description: "The time at which the project was completed (DateTime)" })),
+            canceledAt: t.Optional(t.String({ description: "The time at which the project was canceled (DateTime)" })),
+            trashed: t.Optional(t.Boolean({ description: "Whether the project has been trashed. Set to true to trash, or null to restore" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: ProjectUpdateInput!) { projectUpdate(id: $id, input: $input) { success project { ${PROJECT_FIELDS} } } }`, { id, input: fields });
+            return data.projectUpdate?.project;
+        },
+    });
+    rl.registerAction("project.delete", {
+        description: "Trash (soft-delete) a project. Restorable via project.unarchive.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the project to delete" }), }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { projectDelete(id: $id) { success } }`, { id: input.id });
+            return data.projectDelete;
+        },
+    });
+    rl.registerAction("project.unarchive", {
+        description: "Restore a previously trashed or archived project.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the project to restore (UUID or slug)" }), }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { projectUnarchive(id: $id) { success } }`, { id: input.id });
+            return data.projectUnarchive;
+        },
+    });
+    rl.registerAction("project.search", {
+        description: "Search projects by text. Rate-limited to 30 req/min.",
+        inputSchema: t.Object({
+            term: t.String({ description: "Search string to look for" }),
+            limit: t.Optional(t.Number({ description: "Max results (forward pagination, default 50)" })),
+            includeComments: t.Optional(t.Boolean({ description: "Should associated comments be searched (default false)" })),
+            teamId: t.Optional(t.String({ description: "UUID of a team to boost in search results" })),
+        }),
+        async execute(input, ctx) {
+            const opts = input;
+            const data = await gql(key(ctx), `query($term: String!, $first: Int, $includeComments: Boolean, $teamId: String) {
+          searchProjects(term: $term, first: $first, includeComments: $includeComments, teamId: $teamId) {
+            nodes { ${PROJECT_FIELDS} }
+            totalCount
+          }
+        }`, {
+                term: opts.term,
+                first: opts.limit ?? 50,
+                includeComments: opts.includeComments ?? null,
+                teamId: opts.teamId ?? null,
+            });
+            return data.searchProjects;
+        },
+    });
+    // Project milestones
+    listAction("milestone.list", "List project milestones.", "projectMilestones", "ProjectMilestoneFilter", MILESTONE_FIELDS);
+    getAction("milestone.get", "Get a project milestone by ID.", "projectMilestone", MILESTONE_FIELDS);
+    rl.registerAction("milestone.create", {
+        description: "Create a project milestone.",
+        inputSchema: t.Object({
+            projectId: t.String({ description: "Related project for the project milestone" }),
+            name: t.String({ description: "The name of the project milestone" }),
+            description: t.Optional(t.String({ description: "The description of the project milestone in markdown format" })),
+            targetDate: t.Optional(t.String({ description: "The planned target date of the project milestone (TimelessDate, YYYY-MM-DD)" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project milestone within a project (Float)" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($input: ProjectMilestoneCreateInput!) { projectMilestoneCreate(input: $input) { success projectMilestone { ${MILESTONE_FIELDS} } } }`, { input: input });
+            return data.projectMilestoneCreate?.projectMilestone;
+        },
+    });
+    rl.registerAction("milestone.update", {
+        description: "Update a project milestone.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the project milestone to update" }),
+            name: t.Optional(t.String({ description: "The name of the project milestone" })),
+            description: t.Optional(t.String({ description: "The description of the project milestone in markdown format" })),
+            targetDate: t.Optional(t.String({ description: "The planned target date (TimelessDate, YYYY-MM-DD)" })),
+            projectId: t.Optional(t.String({ description: "Related project for the project milestone (move to another project)" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project milestone within a project (Float)" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: ProjectMilestoneUpdateInput!) { projectMilestoneUpdate(id: $id, input: $input) { success projectMilestone { ${MILESTONE_FIELDS} } } }`, { id, input: fields });
+            return data.projectMilestoneUpdate?.projectMilestone;
+        },
+    });
+    rl.registerAction("milestone.delete", {
+        description: "Delete a project milestone.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the project milestone to delete" }), }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { projectMilestoneDelete(id: $id) { success } }`, { id: input.id });
+            return data.projectMilestoneDelete;
+        },
+    });
+    // Project updates
+    listAction("projectUpdate.list", "List project updates.", "projectUpdates", "ProjectUpdateFilter", PROJECT_UPDATE_FIELDS);
+    rl.registerAction("projectUpdate.create", {
+        description: "Post a status update on a project.",
+        inputSchema: t.Object({
+            projectId: t.String({ description: "The project to associate the project update with" }),
+            body: t.Optional(t.String({ description: "The content of the project update in markdown format" })),
+            health: t.Optional(t.String({ description: "The health of the project at the time of the update (ProjectUpdateHealthType: onTrack | atRisk | offTrack)" })),
+            isDiffHidden: t.Optional(t.Boolean({ description: "Whether the diff between the current update and the previous one should be hidden" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($input: ProjectUpdateCreateInput!) { projectUpdateCreate(input: $input) { success projectUpdate { ${PROJECT_UPDATE_FIELDS} } } }`, { input: input });
+            return data.projectUpdateCreate?.projectUpdate;
+        },
+    });
+    rl.registerAction("projectUpdate.update", {
+        description: "Update a project status update.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the project update to update" }),
+            body: t.Optional(t.String({ description: "The content of the project update in markdown format" })),
+            health: t.Optional(t.String({ description: "The health of the project at the time of the update (ProjectUpdateHealthType: onTrack | atRisk | offTrack)" })),
+            isDiffHidden: t.Optional(t.Boolean({ description: "Whether the diff between the current update and the previous one should be hidden" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: ProjectUpdateUpdateInput!) { projectUpdateUpdate(id: $id, input: $input) { success projectUpdate { ${PROJECT_UPDATE_FIELDS} } } }`, { id, input: fields });
+            return data.projectUpdateUpdate?.projectUpdate;
+        },
+    });
+    rl.registerAction("projectUpdate.archive", {
+        description: "Archive a project status update.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the project update to archive" }), }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { projectUpdateArchive(id: $id) { success } }`, { id: input.id });
+            return data.projectUpdateArchive;
+        },
+    });
+}