runline 0.11.3 → 0.11.4

package/dist/plugins/googleDocs/src/text.js

@@ -0,0 +1,313 @@
+import { buildLocation, compact, extractDocumentId, hexToRgbF, runBatchUpdate, } from "./shared.js";
+function range(p) {
+    return compact({
+        segmentId: p.segmentId && p.segmentId !== "body" ? p.segmentId : "",
+        startIndex: p.startIndex,
+        endIndex: p.endIndex,
+        tabId: p.tabId,
+    });
+}
+export function registerTextActions(rl) {
+    rl.registerAction("document.insertText", {
+        description: "Insert text at a specific index, or at the end of a segment (body/header/footer/footnote).",
+        inputSchema: {
+            document: { type: "string", required: true },
+            text: { type: "string", required: true },
+            locationKind: {
+                type: "string",
+                required: false,
+                description: "location (default; requires index) | endOfSegmentLocation",
+            },
+            index: {
+                type: "number",
+                required: false,
+                description: "Required for locationKind=location",
+            },
+            segmentId: {
+                type: "string",
+                required: false,
+                description: 'Segment ID, or "body" / empty for the main body',
+            },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const kind = p.locationKind ?? "location";
+            const locObj = buildLocation(kind, p.segmentId, p.index, p.tabId);
+            return runBatchUpdate(ctx, documentId, {
+                insertText: { text: p.text, ...locObj },
+            });
+        },
+    });
+    rl.registerAction("document.replaceAllText", {
+        description: "Replace every occurrence of a text string throughout the document.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            findText: { type: "string", required: true },
+            replaceText: { type: "string", required: true },
+            matchCase: { type: "boolean", required: false },
+            searchByRegex: { type: "boolean", required: false },
+            tabIds: {
+                type: "array",
+                required: false,
+                description: "Optional tab IDs for tabsCriteria.",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, {
+                replaceAllText: {
+                    replaceText: p.replaceText,
+                    containsText: {
+                        text: p.findText,
+                        matchCase: p.matchCase === true,
+                        searchByRegex: p.searchByRegex === true,
+                    },
+                    ...(Array.isArray(p.tabIds)
+                        ? { tabsCriteria: { tabIds: p.tabIds } }
+                        : {}),
+                },
+            });
+        },
+    });
+    rl.registerAction("document.deleteContentRange", {
+        description: "Delete text between two indices in a segment.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            startIndex: { type: "number", required: true },
+            endIndex: { type: "number", required: true },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, {
+                deleteContentRange: { range: range(p) },
+            });
+        },
+    });
+    rl.registerAction("document.createParagraphBullets", {
+        description: "Apply a bullet preset to paragraphs spanning a range. Presets: BULLET_DISC_CIRCLE_SQUARE, BULLET_DIAMONDX_ARROW3D_SQUARE, BULLET_CHECKBOX, NUMBERED_DECIMAL_ALPHA_ROMAN, NUMBERED_DECIMAL_NESTED, etc.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            bulletPreset: { type: "string", required: true },
+            startIndex: { type: "number", required: true },
+            endIndex: { type: "number", required: true },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, {
+                createParagraphBullets: {
+                    bulletPreset: p.bulletPreset,
+                    range: range(p),
+                },
+            });
+        },
+    });
+    rl.registerAction("document.deleteParagraphBullets", {
+        description: "Remove bullets from paragraphs in a range.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            startIndex: { type: "number", required: true },
+            endIndex: { type: "number", required: true },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, {
+                deleteParagraphBullets: { range: range(p) },
+            });
+        },
+    });
+    rl.registerAction("document.insertPerson", {
+        description: "Insert a smart chip person mention at a location or at the end of a segment.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            personProperties: {
+                type: "object",
+                required: true,
+                description: "Docs API PersonProperties object.",
+            },
+            locationKind: {
+                type: "string",
+                required: false,
+                description: "location (default; requires index) | endOfSegmentLocation",
+            },
+            index: { type: "number", required: false },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const kind = p.locationKind ?? "location";
+            return runBatchUpdate(ctx, documentId, {
+                insertPerson: {
+                    personProperties: p.personProperties,
+                    ...buildLocation(kind, p.segmentId, p.index, p.tabId),
+                },
+            });
+        },
+    });
+    rl.registerAction("document.insertRichLink", {
+        description: "Insert a rich link smart chip at a location or at the end of a segment.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            richLinkProperties: {
+                type: "object",
+                required: true,
+                description: "Docs API RichLinkProperties object.",
+            },
+            locationKind: {
+                type: "string",
+                required: false,
+                description: "location (default; requires index) | endOfSegmentLocation",
+            },
+            index: { type: "number", required: false },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const kind = p.locationKind ?? "location";
+            return runBatchUpdate(ctx, documentId, {
+                insertRichLink: {
+                    richLinkProperties: p.richLinkProperties,
+                    ...buildLocation(kind, p.segmentId, p.index, p.tabId),
+                },
+            });
+        },
+    });
+    rl.registerAction("document.insertDate", {
+        description: "Insert a date smart chip at a location or at the end of a segment.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            dateElementProperties: {
+                type: "object",
+                required: false,
+                description: "Optional Docs API DateElementProperties object.",
+            },
+            locationKind: {
+                type: "string",
+                required: false,
+                description: "location (default; requires index) | endOfSegmentLocation",
+            },
+            index: { type: "number", required: false },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const kind = p.locationKind ?? "location";
+            return runBatchUpdate(ctx, documentId, {
+                insertDate: {
+                    ...(p.dateElementProperties
+                        ? { dateElementProperties: p.dateElementProperties }
+                        : {}),
+                    ...buildLocation(kind, p.segmentId, p.index, p.tabId),
+                },
+            });
+        },
+    });
+    rl.registerAction("document.updateTextStyle", {
+        description: "Apply text styling (bold, italic, underline, color, fontSize, fontFamily, link) to a range. Pass `fields` listing which TextStyle properties were set.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            startIndex: { type: "number", required: true },
+            endIndex: { type: "number", required: true },
+            bold: { type: "boolean", required: false },
+            italic: { type: "boolean", required: false },
+            underline: { type: "boolean", required: false },
+            strikethrough: { type: "boolean", required: false },
+            fontSizePt: {
+                type: "number",
+                required: false,
+                description: "Font size in points.",
+            },
+            fontFamily: { type: "string", required: false },
+            foregroundColorHex: {
+                type: "string",
+                required: false,
+                description: "Hex color, e.g. #1A73E8",
+            },
+            backgroundColorHex: { type: "string", required: false },
+            link: {
+                type: "string",
+                required: false,
+                description: "URL for the linked range.",
+            },
+            segmentId: {
+                type: "string",
+                required: false,
+                description: "Header/footer/footnote id; omit for the body.",
+            },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const ts = {};
+            const fields = [];
+            if (p.bold !== undefined) {
+                ts.bold = p.bold;
+                fields.push("bold");
+            }
+            if (p.italic !== undefined) {
+                ts.italic = p.italic;
+                fields.push("italic");
+            }
+            if (p.underline !== undefined) {
+                ts.underline = p.underline;
+                fields.push("underline");
+            }
+            if (p.strikethrough !== undefined) {
+                ts.strikethrough = p.strikethrough;
+                fields.push("strikethrough");
+            }
+            if (p.fontSizePt !== undefined) {
+                ts.fontSize = { magnitude: p.fontSizePt, unit: "PT" };
+                fields.push("fontSize");
+            }
+            if (p.fontFamily) {
+                ts.weightedFontFamily = { fontFamily: p.fontFamily };
+                fields.push("weightedFontFamily");
+            }
+            if (p.foregroundColorHex) {
+                const c = hexToRgbF(p.foregroundColorHex);
+                ts.foregroundColor = { color: { rgbColor: c } };
+                fields.push("foregroundColor");
+            }
+            if (p.backgroundColorHex) {
+                const c = hexToRgbF(p.backgroundColorHex);
+                ts.backgroundColor = { color: { rgbColor: c } };
+                fields.push("backgroundColor");
+            }
+            if (p.link) {
+                ts.link = { url: p.link };
+                fields.push("link");
+            }
+            if (fields.length === 0) {
+                throw new Error("googleDocs.document.updateTextStyle: at least one styling property required");
+            }
+            return runBatchUpdate(ctx, documentId, [
+                {
+                    updateTextStyle: {
+                        range: range(p),
+                        textStyle: ts,
+                        fields: fields.join(","),
+                    },
+                },
+            ]);
+        },
+    });
+}

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { ATTACHMENT_FIELDS, assertAttachmentInScope, assertIssueInScope, gql, key, requireUnscoped } from "./shared.js";
+import { ATTACHMENT_FIELDS, assertAttachmentInScope, assertIssueInScope, gql, key, requireUnscoped, } from "./shared.js";
 export function registerAttachmentActions(rl) {
     rl.registerAction("attachment.list", {
         description: "List issue attachments. Disabled for scoped Linear connections.",
@@ -24,15 +24,27 @@ export function registerAttachmentActions(rl) {
     rl.registerAction("attachment.create", {
         description: "Create an attachment on an issue.",
         inputSchema: t.Object({
-            issueId: t.String({ description: "The issue to associate the attachment with. UUID or issue identifier (e.g., 'LIN-123')" }),
+            issueId: t.String({
+                description: "The issue to associate the attachment with. UUID or issue identifier (e.g., 'LIN-123')",
+            }),
             title: t.String({ description: "The attachment title" }),
-            url: t.String({ description: "Attachment location, also used as a unique identifier. Re-creating with the same url updates the existing record" }),
+            url: t.String({
+                description: "Attachment location, also used as a unique identifier. Re-creating with the same url updates the existing record",
+            }),
             subtitle: t.Optional(t.String({ description: "The attachment subtitle" })),
-            iconUrl: t.Optional(t.String({ description: "An icon url to display with the attachment (jpg or png, max 1MB, ideally 20x20px)" })),
+            iconUrl: t.Optional(t.String({
+                description: "An icon url to display with the attachment (jpg or png, max 1MB, ideally 20x20px)",
+            })),
             commentBody: t.Optional(t.String({ description: "Create a linked comment with markdown body" })),
-            groupBySource: t.Optional(t.Boolean({ description: "Whether attachments for the same source application should be grouped in the Linear UI" })),
-            metadata: t.Optional(t.Object({}, { description: "Attachment metadata object with string and number values (JSONObject)" })),
-            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+            groupBySource: t.Optional(t.Boolean({
+                description: "Whether attachments for the same source application should be grouped in the Linear UI",
+            })),
+            metadata: t.Optional(t.Object({}, {
+                description: "Attachment metadata object with string and number values (JSONObject)",
+            })),
+            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;
@@ -44,11 +56,15 @@ export function registerAttachmentActions(rl) {
     rl.registerAction("attachment.update", {
         description: "Update an attachment. title is required.",
         inputSchema: t.Object({
-            id: t.String({ description: "The identifier of the attachment to update" }),
+            id: t.String({
+                description: "The identifier of the attachment to update",
+            }),
             title: t.String({ description: "The attachment title" }),
             subtitle: t.Optional(t.String({ description: "The attachment subtitle" })),
             iconUrl: t.Optional(t.String({ description: "An icon url to display with the attachment" })),
-            metadata: t.Optional(t.Object({}, { description: "Attachment metadata object with string and number values (JSONObject)" })),
+            metadata: t.Optional(t.Object({}, {
+                description: "Attachment metadata object with string and number values (JSONObject)",
+            })),
         }),
         async execute(input, ctx) {
             const { id, ...fields } = input;
@@ -60,10 +76,14 @@ export function registerAttachmentActions(rl) {
     rl.registerAction("attachment.linkURL", {
         description: "Link any URL to an issue. If a workspace integration matches the URL (Zendesk, GitHub, Slack, etc.) a rich attachment is created; otherwise a basic one.",
         inputSchema: t.Object({
-            issueId: t.String({ description: "The issue for which to link the url. UUID or issue identifier (e.g., 'LIN-123')" }),
+            issueId: t.String({
+                description: "The issue for which to link the url. UUID or issue identifier (e.g., 'LIN-123')",
+            }),
             url: t.String({ description: "The url to link" }),
             title: t.Optional(t.String({ description: "The title to use for the attachment" })),
-            id: t.Optional(t.String({ description: "The id for the attachment (optional UUID override)" })),
+            id: t.Optional(t.String({
+                description: "The id for the attachment (optional UUID override)",
+            })),
         }),
         async execute(input, ctx) {
             const { issueId, url, title, id } = input;
@@ -76,7 +96,11 @@ export function registerAttachmentActions(rl) {
     });
     rl.registerAction("attachment.delete", {
         description: "Delete an attachment.",
-        inputSchema: t.Object({ id: t.String({ description: "The identifier of the attachment to delete" }) }),
+        inputSchema: t.Object({
+            id: t.String({
+                description: "The identifier of the attachment to delete",
+            }),
+        }),
         async execute(input, ctx) {
             const id = input.id;
             await assertAttachmentInScope(ctx, id);

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

@@ -1,14 +1,22 @@
 import * as t from "typebox";
-import { COMMENT_FIELDS, assertCommentInScope, assertIssueInScope, gql, key, requireUnscoped } from "./shared.js";
+import { assertCommentInScope, assertIssueInScope, COMMENT_FIELDS, gql, key, requireUnscoped, } from "./shared.js";
 export function registerCommentActions(rl) {
     rl.registerAction("issue.addComment", {
         description: "Add a comment to an issue. Pass parentId to nest as a reply.",
         inputSchema: t.Object({
-            issueId: t.String({ description: "The issue to associate the comment with. UUID or issue identifier (e.g., 'LIN-123')" }),
+            issueId: t.String({
+                description: "The issue to associate the comment with. UUID or issue identifier (e.g., 'LIN-123')",
+            }),
             body: t.String({ description: "The comment content in markdown format" }),
-            parentId: t.Optional(t.String({ description: "The parent comment under which to nest as a reply" })),
-            doNotSubscribeToIssue: t.Optional(t.Boolean({ description: "Prevent auto-subscription to the issue the comment is created on" })),
-            quotedText: t.Optional(t.String({ description: "The text that this comment references (inline comments)" })),
+            parentId: t.Optional(t.String({
+                description: "The parent comment under which to nest as a reply",
+            })),
+            doNotSubscribeToIssue: t.Optional(t.Boolean({
+                description: "Prevent auto-subscription to the issue the comment is created on",
+            })),
+            quotedText: t.Optional(t.String({
+                description: "The text that this comment references (inline comments)",
+            })),
         }),
         async execute(input, ctx) {
             const fields = input;
@@ -20,7 +28,9 @@ export function registerCommentActions(rl) {
     rl.registerAction("comment.list", {
         description: "List comments. Pass issueId (UUID or identifier like 'LIN-123') to list one issue's comments; without it, lists workspace-wide (unscoped connections only).",
         inputSchema: t.Object({
-            issueId: t.Optional(t.String({ description: "Only list comments on this issue. UUID or issue identifier (e.g., 'LIN-123')" })),
+            issueId: t.Optional(t.String({
+                description: "Only list comments on this issue. UUID or issue identifier (e.g., 'LIN-123')",
+            })),
             limit: t.Optional(t.Number({ description: "Max results (default 50)" })),
         }, { additionalProperties: false }),
         async execute(input, ctx) {
@@ -28,7 +38,7 @@ export function registerCommentActions(rl) {
             if (issueId) {
                 await assertIssueInScope(ctx, issueId);
                 const data = await gql(key(ctx), `query($id: String!, $first: Int) { issue(id: $id) { comments(first: $first) { nodes { ${COMMENT_FIELDS} } pageInfo { hasNextPage endCursor } } } }`, { id: issueId, first: limit });
-                return data.issue?.comments ?? null;
+                return (data.issue?.comments ?? null);
             }
             requireUnscoped(ctx, "comment.list");
             const data = await gql(key(ctx), `query($first: Int) { comments(first: $first) { nodes { ${COMMENT_FIELDS} } pageInfo { hasNextPage endCursor } } }`, { first: limit });
@@ -50,7 +60,9 @@ export function registerCommentActions(rl) {
         inputSchema: t.Object({
             id: t.String({ description: "The identifier of the comment to update" }),
             body: t.Optional(t.String({ description: "The comment content in markdown format" })),
-            quotedText: t.Optional(t.String({ description: "The text that this comment references (inline comments)" })),
+            quotedText: t.Optional(t.String({
+                description: "The text that this comment references (inline comments)",
+            })),
         }),
         async execute(input, ctx) {
             const { id, ...fields } = input;

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { CYCLE_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
+import { bindGetAction, bindListAction, CYCLE_FIELDS, gql, key, requireUnscoped, } from "./shared.js";
 export function registerCycleActions(rl) {
     const listAction = bindListAction(rl);
     const getAction = bindGetAction(rl);
@@ -9,12 +9,20 @@ export function registerCycleActions(rl) {
         description: "Create a cycle for a team.",
         inputSchema: t.Object({
             teamId: t.String({ description: "The team to associate the cycle with" }),
-            startsAt: t.String({ description: "The start time of the cycle (DateTime, ISO 8601)" }),
-            endsAt: t.String({ description: "The end time of the cycle (DateTime, ISO 8601)" }),
+            startsAt: t.String({
+                description: "The start time of the cycle (DateTime, ISO 8601)",
+            }),
+            endsAt: t.String({
+                description: "The end time of the cycle (DateTime, ISO 8601)",
+            }),
             name: t.Optional(t.String({ description: "The custom name of the cycle" })),
             description: t.Optional(t.String({ description: "The description of the cycle" })),
-            completedAt: t.Optional(t.String({ description: "The completion time of the cycle (DateTime). If null, the cycle hasn't been completed" })),
-            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+            completedAt: t.Optional(t.String({
+                description: "The completion time of the cycle (DateTime). If null, the cycle hasn't been completed",
+            })),
+            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) {
             requireUnscoped(ctx, "cycles.*");
@@ -28,9 +36,15 @@ export function registerCycleActions(rl) {
             id: t.String({ description: "The identifier of the cycle to update" }),
             name: t.Optional(t.String({ description: "The custom name of the cycle" })),
             description: t.Optional(t.String({ description: "The description of the cycle" })),
-            startsAt: t.Optional(t.String({ description: "The start time of the cycle (DateTime, ISO 8601)" })),
-            endsAt: t.Optional(t.String({ description: "The end time of the cycle (DateTime, ISO 8601)" })),
-            completedAt: t.Optional(t.String({ description: "The completion time of the cycle (DateTime). If null, the cycle hasn't been completed" })),
+            startsAt: t.Optional(t.String({
+                description: "The start time of the cycle (DateTime, ISO 8601)",
+            })),
+            endsAt: t.Optional(t.String({
+                description: "The end time of the cycle (DateTime, ISO 8601)",
+            })),
+            completedAt: t.Optional(t.String({
+                description: "The completion time of the cycle (DateTime). If null, the cycle hasn't been completed",
+            })),
         }),
         async execute(input, ctx) {
             requireUnscoped(ctx, "cycles.*");

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { INITIATIVE_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
+import { bindGetAction, bindListAction, gql, INITIATIVE_FIELDS, key, requireUnscoped, } from "./shared.js";
 export function registerInitiativeActions(rl) {
     const listAction = bindListAction(rl);
     const getAction = bindGetAction(rl);
@@ -10,15 +10,27 @@ export function registerInitiativeActions(rl) {
         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" })),
+            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" })),
+            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) {
             requireUnscoped(ctx, "initiatives.*");
@@ -29,18 +41,32 @@ export function registerInitiativeActions(rl) {
     rl.registerAction("initiative.update", {
         description: "Update an initiative.",
         inputSchema: t.Object({
-            id: t.String({ description: "The identifier of the initiative to update" }),
+            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" })),
+            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" })),
+            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) {
             requireUnscoped(ctx, "initiatives.*");
@@ -51,7 +77,11 @@ export function registerInitiativeActions(rl) {
     });
     rl.registerAction("initiative.delete", {
         description: "Trash an initiative.",
-        inputSchema: t.Object({ id: t.String({ description: "The identifier of the initiative to delete" }) }),
+        inputSchema: t.Object({
+            id: t.String({
+                description: "The identifier of the initiative to delete",
+            }),
+        }),
         async execute(input, ctx) {
             requireUnscoped(ctx, "initiatives.*");
             const data = await gql(key(ctx), `mutation($id: String!) { initiativeDelete(id: $id) { success } }`, { id: input.id });
@@ -61,10 +91,16 @@ export function registerInitiativeActions(rl) {
     rl.registerAction("initiative.addProject", {
         description: "Associate a project with an initiative. Use this action for project-to-initiative linking; project.update does not accept initiativeId. Verify with initiative.get or the returned initiative.projects list.",
         inputSchema: t.Object({
-            initiativeId: t.String({ description: "The identifier of the initiative" }),
+            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" })),
+            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) {
             requireUnscoped(ctx, "initiatives.*");
@@ -74,7 +110,11 @@ export function registerInitiativeActions(rl) {
     });
     rl.registerAction("initiative.removeProject", {
         description: "Remove a project from an initiative. Pass the link id returned by initiative.addProject, then verify with initiative.get.",
-        inputSchema: t.Object({ id: t.String({ description: "The identifier of the initiativeToProject to delete" }) }),
+        inputSchema: t.Object({
+            id: t.String({
+                description: "The identifier of the initiativeToProject to delete",
+            }),
+        }),
         async execute(input, ctx) {
             requireUnscoped(ctx, "initiatives.*");
             const data = await gql(key(ctx), `mutation($id: String!) { initiativeToProjectDelete(id: $id) { success } }`, { id: input.id });