@rnsk/toolkits 0.0.9 → 0.0.11

package/dist/toolkits/hugging-face/tools/users.js

@@ -0,0 +1,132 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hfApi, hfRedirect, HOSTS } from './client.js';
+import { repoIdOf as _r, uiPrefix as _u } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+function repoIdOf(namespace, repo, repoId) { return _r(namespace, repo, repoId); }
+function uiPrefix(repoType) { return _u(repoType); }
+export const huggingFaceDeleteNotifications = tool({
+    description: "Tool to delete notifications from Hugging Face. Use when you need to remove notifications either by specific discussion IDs or by applying filters to delete multiple notifications at once. Supports targeted deletion (via discussion_ids) or bulk deletion (via applyToAll with filter parameters).",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        p: z.number().int().min(0).optional().describe("Page number for pagination when filtering notifications. Defaults to 0 (first page)."),
+        mention: z.enum(["all", "participating", "mentions"]).optional().describe("Enum for mention filter."),
+        paperId: z.string().optional().describe("Filter notifications by paper ID. Use this to delete notifications related to a specific paper. Only applies when applyToAll is true."),
+        repoName: z.string().optional().describe("Filter notifications by repository name. Use this to delete notifications from a specific repository. Format should be 'namespace/repo-name'. Only applies when applyToAll is true."),
+        repoType: z.enum(["dataset", "model", "space", "bucket"]).optional().describe("Enum for repository type filter."),
+        articleId: z.string().optional().describe("Filter notifications by article ID. Use this to delete notifications related to a specific article. Only applies when applyToAll is true."),
+        lastUpdate: z.string().optional().describe("Filter notifications by last update timestamp. Use this to delete notifications updated before or after a specific time. Only applies when applyToAll is true."),
+        postAuthor: z.string().optional().describe("Filter notifications by the username of the post author. Use this to delete notifications from a specific user. Only applies when applyToAll is true."),
+        readStatus: z.enum(["all", "unread"]).optional().describe("Enum for read status filter."),
+        applyToAll: z.boolean().optional().describe("When true, applies the deletion to all notifications matching the filter criteria (readStatus, repoType, repoName, etc.). Use with caution as this will delete multiple notifications at once. Required when not using discussion_ids."),
+        discussionIds: z.array(z.string()).optional().describe("Array of specific discussion IDs to delete. Each ID must be exactly 24 hexadecimal characters. Use this for targeted deletion of specific notifications. If provided, other filter parameters are ignored."),
+    }),
+    execute: async ({ huggingFaceToken, p, mention, paperId, repoName, repoType, articleId, lastUpdate, postAuthor, readStatus, applyToAll, discussionIds }) => {
+        const queryParams = undefined;
+        const body = { p: p, mention: mention, paper_id: paperId, repo_name: repoName, repo_type: repoType, article_id: articleId, last_update: lastUpdate, post_author: postAuthor, read_status: readStatus, apply_to_all: applyToAll, discussion_ids: discussionIds };
+        return hfApi(huggingFaceToken, { method: 'DELETE', url: `${HOSTS.HUB}/api/notifications`, queryParams, body });
+    },
+});
+export const huggingFaceGetOrganizationsAvatar = tool({
+    description: "Tool to retrieve the avatar URL for a Hugging Face organization. Use when you need to get the avatar image URL for a specific organization.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        name: z.string().describe("The name of the organization. For example, 'huggingface' or 'meta-llama'."),
+        redirect: z.string().optional().describe("If provided, redirect to the avatar URL instead of returning it as JSON. Set to any value to enable redirection."),
+    }),
+    execute: async ({ huggingFaceToken, name, redirect }) => {
+        const queryParams = { redirect: redirect };
+        return hfRedirect(huggingFaceToken, { url: `${HOSTS.HUB}/api/organizations/${encodeURIComponent(name)}/avatar`, queryParams });
+    },
+});
+export const huggingFaceGetOrganizationsMembers = tool({
+    description: "Tool to retrieve a list of members for a Hugging Face organization. Use when you need to discover who belongs to an organization, with optional filtering by search terms, email, and pagination support.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        name: z.string().describe("Name of the organization to retrieve members from. This is the organization's username or slug on Hugging Face."),
+        email: z.string().optional().describe("Filter members by email address. This may require admin permissions depending on the organization's settings."),
+        limit: z.number().int().min(1).max(1000).optional().describe("Maximum number of members to return. Defaults to 500."),
+        cursor: z.string().optional().describe("Pagination cursor for fetching the next page of results. Use the cursor from the previous response to get more members."),
+        search: z.string().optional().describe("Search query to filter members by username or full name. Use this to find specific members within the organization."),
+    }),
+    execute: async ({ huggingFaceToken, name, email, limit, cursor, search }) => {
+        const queryParams = { email: email, limit: limit, cursor: cursor, search: search };
+        return hfApi(huggingFaceToken, { method: 'GET', url: `${HOSTS.HUB}/api/organizations/${encodeURIComponent(name)}/members`, queryParams });
+    },
+});
+export const huggingFaceGetOrganizationsSocials = tool({
+    description: "Tool to retrieve an organization's social media handles from Hugging Face. Use when you need to find an organization's GitHub, LinkedIn, or Twitter/X profiles. Only returns handles that the organization has publicly shared on their Hugging Face profile.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        name: z.string().describe("The name of the organization to retrieve social media handles for. This is the organization's username on Hugging Face."),
+    }),
+    execute: async ({ huggingFaceToken, name }) => {
+        const queryParams = undefined;
+        return hfApi(huggingFaceToken, { method: 'GET', url: `${HOSTS.HUB}/api/organizations/${encodeURIComponent(name)}/socials`, queryParams });
+    },
+});
+export const huggingFaceGetUsersAvatar = tool({
+    description: "Tool to retrieve the avatar URL for a Hugging Face user. Use when you need to get the avatar image URL for a specific user.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        redirect: z.string().optional().describe("If provided, redirect to the avatar URL instead of returning it as JSON. Set to any value to enable redirection."),
+        username: z.string().describe("The username of the user whose avatar URL to retrieve. For example, 'julien-c' or 'lysandre'."),
+    }),
+    execute: async ({ huggingFaceToken, redirect, username }) => {
+        const queryParams = { redirect: redirect };
+        return hfRedirect(huggingFaceToken, { url: `${HOSTS.HUB}/api/users/${encodeURIComponent(username)}/avatar`, queryParams });
+    },
+});
+export const huggingFaceGetUsersOverview = tool({
+    description: "Tool to retrieve a comprehensive overview of a Hugging Face user's profile. Use when you need to get user statistics, organizations, activity counts, and profile information.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        username: z.string().describe("Username of the Hugging Face user to retrieve overview for. This is the user's handle on Hugging Face."),
+    }),
+    execute: async ({ huggingFaceToken, username }) => {
+        const queryParams = undefined;
+        return hfApi(huggingFaceToken, { method: 'GET', url: `${HOSTS.HUB}/api/users/${encodeURIComponent(username)}/overview`, queryParams });
+    },
+});
+export const huggingFaceGetUsersSocials = tool({
+    description: "Tool to retrieve a user's social media handles from Hugging Face. Use when you need to find a user's GitHub, LinkedIn, Twitter/X, or Bluesky profiles. Only returns handles that the user has publicly shared on their Hugging Face profile.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        username: z.string().describe("The username of the Hugging Face user to retrieve social media handles for. This is the user's username on Hugging Face."),
+    }),
+    execute: async ({ huggingFaceToken, username }) => {
+        const queryParams = undefined;
+        return hfApi(huggingFaceToken, { method: 'GET', url: `${HOSTS.HUB}/api/users/${encodeURIComponent(username)}/socials`, queryParams });
+    },
+});
+export const huggingFaceGetWhoami = tool({
+    description: "Tool to get information about the authenticated Hugging Face user including username, email, organizations, and token details. Use when you need to identify the current user from an access token or retrieve user profile information.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+    }),
+    execute: async ({ huggingFaceToken }) => {
+        const queryParams = undefined;
+        return hfApi(huggingFaceToken, { method: 'GET', url: `${HOSTS.HUB}/api/whoami`, queryParams });
+    },
+});
+export const huggingFaceListNotifications = tool({
+    description: "Tool to list notifications for the authenticated Hugging Face user. Use when you need to retrieve user notifications, optionally filtered by read status, repository type, author, or other criteria.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        p: z.number().int().min(0).optional().describe("Page number for pagination. Defaults to 0."),
+        mention: z.enum(["all", "participating", "mentions"]).optional().describe("Enum for mention filter."),
+        paperId: z.string().optional().describe("Filter notifications by paper ID."),
+        repoName: z.string().optional().describe("Filter notifications by repository name."),
+        repoType: z.enum(["dataset", "model", "space", "bucket"]).optional().describe("Enum for repository type filter."),
+        articleId: z.string().optional().describe("Filter notifications by article ID."),
+        lastUpdate: z.string().optional().describe("Filter notifications by last update timestamp."),
+        postAuthor: z.string().optional().describe("Filter notifications by the author of the post."),
+        readStatus: z.enum(["all", "unread"]).optional().describe("Enum for notification read status filter."),
+    }),
+    execute: async ({ huggingFaceToken, p, mention, paperId, repoName, repoType, articleId, lastUpdate, postAuthor, readStatus }) => {
+        const queryParams = { p: p, mention: mention, paper_id: paperId, repo_name: repoName, repo_type: repoType, article_id: articleId, last_update: lastUpdate, post_author: postAuthor, read_status: readStatus };
+        return hfApi(huggingFaceToken, { method: 'GET', url: `${HOSTS.HUB}/api/notifications`, queryParams });
+    },
+});
+//# sourceMappingURL=users.js.map

package/dist/toolkits/hugging-face/tools/webhooks.d.ts

@@ -0,0 +1,35 @@
+export declare const huggingFaceCreateWebhook: import("ai").Tool<{
+    url: string;
+    domains: string[];
+    watched: Record<string, any>[];
+    secret?: string | undefined;
+    huggingFaceToken?: string | undefined;
+    jobSourceId?: string | undefined;
+}, any>;
+export declare const huggingFaceDeleteSettingsWebhooks: import("ai").Tool<{
+    webhookId: string;
+    huggingFaceToken?: string | undefined;
+}, any>;
+export declare const huggingFaceGetSettingsWebhooks: import("ai").Tool<{
+    webhookId: string;
+    huggingFaceToken?: string | undefined;
+}, any>;
+export declare const huggingFaceListSettingsWebhooks: import("ai").Tool<{
+    huggingFaceToken?: string | undefined;
+}, any>;
+export declare const huggingFaceUpdateSettingsWebhooks: import("ai").Tool<{
+    webhookId: string;
+    domains: string[];
+    watched: Record<string, any>[];
+    url?: string | undefined;
+    job?: Record<string, any> | undefined;
+    secret?: string | undefined;
+    huggingFaceToken?: string | undefined;
+    jobSourceId?: string | undefined;
+}, any>;
+export declare const huggingFaceUpdateWebhookStatus: import("ai").Tool<{
+    action: "enable" | "disable";
+    webhookId: string;
+    huggingFaceToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/toolkits/hugging-face/tools/webhooks.js

@@ -0,0 +1,87 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hfApi, HOSTS } from './client.js';
+import { repoIdOf as _r, uiPrefix as _u } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+function repoIdOf(namespace, repo, repoId) { return _r(namespace, repo, repoId); }
+function uiPrefix(repoType) { return _u(repoType); }
+export const huggingFaceCreateWebhook = tool({
+    description: "Tool to create a webhook on Hugging Face that triggers on repository or discussion events. Use when you need to receive notifications for changes to specific models, datasets, or spaces.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        url: z.string().describe("The webhook URL endpoint that will receive POST requests when events occur. Must be a valid HTTP/HTTPS URL."),
+        secret: z.string().optional().describe("Optional secret string used to sign webhook payloads for verification. Must contain only printable ASCII characters (spaces and characters from 0x20 to 0x7F)."),
+        domains: z.array(z.string()).min(1).describe("List of event domains to monitor. At least one domain must be specified. Use 'repo' for repository events or 'discussion' for discussion events."),
+        watched: z.array(z.record(z.any())).min(1).describe("List of repositories to watch for changes. At least one repository must be specified. Events from these repositories will trigger webhook calls."),
+        jobSourceId: z.string().optional().describe("Optional job source identifier for associating the webhook with a specific job source."),
+    }),
+    execute: async ({ huggingFaceToken, url, secret, domains, watched, jobSourceId }) => {
+        const queryParams = undefined;
+        const body = { url: url, secret: secret, domains: domains, watched: watched, job_source_id: jobSourceId };
+        return hfApi(huggingFaceToken, { method: 'POST', url: `${HOSTS.HUB}/api/settings/webhooks`, queryParams, body });
+    },
+});
+export const huggingFaceDeleteSettingsWebhooks = tool({
+    description: "Tool to delete a webhook from Hugging Face settings. Use when you need to remove a webhook configuration that is no longer needed.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        webhookId: z.string().min(24).max(24).describe("The unique identifier of the webhook to delete. Must be a 24-character hexadecimal string."),
+    }),
+    execute: async ({ huggingFaceToken, webhookId }) => {
+        const queryParams = undefined;
+        return hfApi(huggingFaceToken, { method: 'DELETE', url: `${HOSTS.HUB}/api/settings/webhooks/${encodeURIComponent(webhookId)}`, queryParams });
+    },
+});
+export const huggingFaceGetSettingsWebhooks = tool({
+    description: "Tool to retrieve a specific webhook configuration from Hugging Face settings. Use when you need to inspect webhook details, verify webhook status, or check webhook configuration for a given webhook ID.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        webhookId: z.string().min(24).max(24).describe("The unique identifier of the webhook to retrieve. Must be a 24-character hexadecimal string."),
+    }),
+    execute: async ({ huggingFaceToken, webhookId }) => {
+        const queryParams = undefined;
+        return hfApi(huggingFaceToken, { method: 'GET', url: `${HOSTS.HUB}/api/settings/webhooks/${encodeURIComponent(webhookId)}`, queryParams });
+    },
+});
+export const huggingFaceListSettingsWebhooks = tool({
+    description: "Tool to list all webhooks configured in Hugging Face settings. Use when you need to retrieve webhook configurations for the authenticated user's account.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+    }),
+    execute: async ({ huggingFaceToken }) => {
+        const queryParams = undefined;
+        return hfApi(huggingFaceToken, { method: 'GET', url: `${HOSTS.HUB}/api/settings/webhooks`, queryParams });
+    },
+});
+export const huggingFaceUpdateSettingsWebhooks = tool({
+    description: "Tool to update an existing webhook in Hugging Face settings. Use when you need to modify webhook configuration such as watched entities, event domains, target URL, or job settings.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        job: z.record(z.any()).optional().describe("Model for webhook job configuration to execute when webhook triggers."),
+        url: z.string().optional().describe("URL endpoint where webhook POST requests will be sent when events occur. Must be a valid HTTP/HTTPS URL."),
+        secret: z.string().optional().describe("Secret string used to sign webhook requests for verification. Must contain only printable ASCII characters."),
+        domains: z.array(z.string()).min(1).describe("List of event domains that trigger the webhook. At least one domain is required. 'repo' for repository events, 'discussion' for discussion events."),
+        watched: z.array(z.record(z.any())).min(1).describe("List of entities to watch (users, organizations, or repositories). At least one item is required. Events from these entities will trigger the webhook."),
+        webhookId: z.string().min(24).max(24).describe("The unique identifier of the webhook to update (24-character hexadecimal string). Get this from the list webhooks action."),
+        jobSourceId: z.string().optional().describe("Source identifier for the job. Used to track the origin of the job execution."),
+    }),
+    execute: async ({ huggingFaceToken, job, url, secret, domains, watched, webhookId, jobSourceId }) => {
+        const queryParams = undefined;
+        const body = { job: job, url: url, secret: secret, domains: domains, watched: watched, job_source_id: jobSourceId };
+        return hfApi(huggingFaceToken, { method: 'PUT', url: `${HOSTS.HUB}/api/settings/webhooks/${encodeURIComponent(webhookId)}`, queryParams, body });
+    },
+});
+export const huggingFaceUpdateWebhookStatus = tool({
+    description: "Tool to enable or disable a webhook on Hugging Face. Use when you need to temporarily deactivate a webhook without deleting it, or reactivate a previously disabled webhook.",
+    inputSchema: z.object({
+        huggingFaceToken: tokenField,
+        action: z.enum(["enable", "disable"]).describe("The action to perform on the webhook: 'enable' to activate the webhook or 'disable' to deactivate it."),
+        webhookId: z.string().min(24).max(24).describe("The unique identifier of the webhook to enable or disable. Must be a 24-character hexadecimal string."),
+    }),
+    execute: async ({ huggingFaceToken, action, webhookId }) => {
+        const queryParams = undefined;
+        return hfApi(huggingFaceToken, { method: 'POST', url: `${HOSTS.HUB}/api/settings/webhooks/${encodeURIComponent(webhookId)}/${encodeURIComponent(action)}`, queryParams });
+    },
+});
+//# sourceMappingURL=webhooks.js.map

package/dist/toolkits/jira/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const JIRA_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/jira/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128"><defs><linearGradient id="jira-original-a" gradientUnits="userSpaceOnUse" x1="22.034" y1="9.773" x2="17.118" y2="14.842" gradientTransform="scale(4)"><stop offset=".176" stop-color="#0052cc"/><stop offset="1" stop-color="#2684ff"/></linearGradient><linearGradient id="jira-original-b" gradientUnits="userSpaceOnUse" x1="16.641" y1="15.564" x2="10.957" y2="21.094" gradientTransform="scale(4)"><stop offset=".176" stop-color="#0052cc"/><stop offset="1" stop-color="#2684ff"/></linearGradient></defs><path d="M108.023 16H61.805c0 11.52 9.324 20.848 20.847 20.848h8.5v8.226c0 11.52 9.328 20.848 20.848 20.848V19.977A3.98 3.98 0 00108.023 16zm0 0" fill="#2684ff"/><path d="M85.121 39.04H38.902c0 11.519 9.325 20.847 20.844 20.847h8.504v8.226c0 11.52 9.328 20.848 20.848 20.848V43.016a3.983 3.983 0 00-3.977-3.977zm0 0" fill="url(#jira-original-a)"/><path d="M62.219 62.078H16c0 11.524 9.324 20.848 20.848 20.848h8.5v8.23c0 11.52 9.328 20.844 20.847 20.844V66.059a3.984 3.984 0 00-3.976-3.98zm0 0" fill="url(#jira-original-b)"/></svg>`;
+export const JIRA_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/jira/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/jira/manifest.js

@@ -0,0 +1,53 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { JIRA_ICON } from './icon.js';
+import { jiraTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'jira',
+    displayName: 'Jira',
+    shortDescription: 'Issues, projects, boards, sprints, users, JQL search, and workflows.',
+    category: 'Productivity & Project Management',
+    icon: JIRA_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'jiraToken',
+        provider: {
+            slug: 'jira',
+            env: { clientId: 'JIRA_CLIENT_ID', clientSecret: 'JIRA_CLIENT_SECRET' },
+            authorizeUrl: 'https://auth.atlassian.com/authorize',
+            tokenUrl: 'https://auth.atlassian.com/oauth/token',
+            scopes: [
+                'read:jira-user',
+                'read:jira-work',
+                'write:jira-work',
+                'manage:jira-project',
+                'manage:jira-configuration',
+                'read:board-scope:jira-software',
+                'write:board-scope:jira-software',
+                'read:sprint:jira-software',
+                'write:sprint:jira-software',
+            ],
+            scopeSeparator: ' ',
+            exchangeStyle: 'json',
+            extraAuthParams: { audience: 'api.atlassian.com', prompt: 'consent' },
+            connectDescription: 'Connect Jira to manage issues, projects, boards, sprints, users, and workflows. Your Cloud site is detected automatically.',
+            callbackPath: '/api/auth/jira/callback',
+            stateCookie: 'jira_oauth_state',
+        },
+    },
+    allowedHosts: ['api.atlassian.com'],
+    tools: jiraTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.9',
+        homepage: 'https://www.atlassian.com/software/jira',
+        docsUrl: 'https://developer.atlassian.com/cloud/jira/platform/rest/v3/',
+        apiDocsUrl: 'https://developer.atlassian.com/cloud/jira/platform/rest/v3/',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/jira/tools/boards.d.ts

@@ -0,0 +1,52 @@
+export declare const jiraCreateBoard: import("ai").Tool<{
+    type: "kanban" | "scrum" | "agility";
+    name: string;
+    filterId?: number | undefined;
+    location?: Record<string, any> | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+}, any>;
+export declare const jiraCreateSprint: import("ai").Tool<{
+    name: string;
+    originBoardId: number;
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    additionalProperties?: Record<string, any> | undefined;
+    goal?: string | undefined;
+}, any>;
+export declare const jiraGetSprint: import("ai").Tool<{
+    sprintId: number;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+}, any>;
+export declare const jiraListBoards: import("ai").Tool<{
+    type?: "kanban" | "scrum" | undefined;
+    maxResults?: number | undefined;
+    name?: string | undefined;
+    orderBy?: string | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    startAt?: number | undefined;
+    includePrivate?: boolean | undefined;
+    projectKeyOrId?: string | undefined;
+}, any>;
+export declare const jiraListSprints: import("ai").Tool<{
+    boardId: number;
+    maxResults?: number | undefined;
+    state?: string | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    startAt?: number | undefined;
+}, any>;
+export declare const jiraMoveIssueToSprint: import("ai").Tool<{
+    issues: string[];
+    sprintId: number;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    rankAfterIssue?: string | undefined;
+    rankBeforeIssue?: string | undefined;
+    rankCustomFieldId?: number | undefined;
+}, any>;
+//# sourceMappingURL=boards.d.ts.map

package/dist/toolkits/jira/tools/boards.js

@@ -0,0 +1,104 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { jira } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const jiraCreateBoard = tool({
+    description: "Creates a new Jira board (kanban, scrum, or agility) with optional filter and location configuration. Use this action when you need to set up a new board for a project or create a personal board for tracking work. The board will organize and visualize issues based on the specified filter or project context.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        name: z.string().describe("Name for the new board. Choose a clear, descriptive name that helps users identify the board's purpose."),
+        type: z.enum(["kanban", "scrum", "agility"]).describe("Type of board to create. 'kanban' for continuous flow boards, 'scrum' for sprint-based boards, 'agility' for basic agile boards."),
+        filterId: z.number().int().optional().describe("ID of an existing Jira filter to use as the board's issue source. The filter defines which issues appear on the board. Use JIRA_LIST_FILTERS or JIRA_GET_FILTER_FAVOURITE to find filter IDs."),
+        location: z.record(z.any()).optional().describe("Location configuration for the board."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, name, type, filterId, location }) => {
+        const queryParams = undefined;
+        const body = { name: name, type: type, filterId: filterId, location: location };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'agile/1.0', path: `/board`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraCreateSprint = tool({
+    description: "This action allows the creation of a new sprint within a specified Jira board. Users can set optional start and end dates, as well as define a primary goal for the sprint.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        goal: z.string().optional().describe("Primary objective or goal for the sprint."),
+        name: z.string().max(30).describe("Name for the new sprint. Must be 30 characters or less."),
+        endDate: z.string().optional().describe("Intended end date and time for the sprint (ISO 8601 format)."),
+        startDate: z.string().optional().describe("Intended start date and time for the sprint (ISO 8601 format)."),
+        originBoardId: z.number().int().describe("Identifier of the Jira board for the new sprint. You can find board IDs using the JIRA_LIST_BOARDS action."),
+        additionalProperties: z.record(z.any()).optional().describe("Additional properties to include in the sprint creation request. Use this for any extra fields supported by the Jira API that are not covered by the standard parameters. Provide as a dictionary with field names and their values. Note: Jira Cloud has strict schema validation and may reject unknown properties with a 400 error. This field is primarily useful for Jira Server/Data Center deployments or future API additions. Use with caution."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, goal, name, endDate, startDate, originBoardId, additionalProperties }) => {
+        const queryParams = undefined;
+        const body = { name: name, originBoardId: originBoardId, startDate: startDate, endDate: endDate, goal: goal };
+        if (additionalProperties && typeof additionalProperties === "object")
+            Object.assign(body, additionalProperties);
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'agile/1.0', path: `/sprint`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraGetSprint = tool({
+    description: "Retrieves detailed information about a specific sprint by its ID. Use this action when you need to fetch a single sprint's details directly by ID, such as checking sprint status, dates, goal, or metadata. For finding sprint IDs, use JIRA_LIST_SPRINTS first.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        sprintId: z.number().int().describe("The unique identifier of the sprint to retrieve. Use JIRA_LIST_SPRINTS to find sprint IDs for a board."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, sprintId }) => {
+        const queryParams = undefined;
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'agile/1.0', path: `/sprint/${encodeURIComponent(sprintId)}`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraListBoards = tool({
+    description: "Retrieves a list of Jira boards based on specified criteria.      Supports pagination via start_at and max_results. The response also includes convenience fields nextStartAt, hasNextPage, and nextPageToken to help iterate through pages.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        name: z.string().optional().describe("Filters results to boards whose name contains the string (case-insensitive). Board names do not necessarily correspond to project keys; enumerate all boards to confirm the correct match."),
+        type: z.enum(["scrum", "kanban"]).optional().describe("Filters results to boards of the specified type. Valid values: 'scrum', 'kanban'. Other types (e.g., 'simple') are not filterable server-side; filter those from the response."),
+        orderBy: z.string().optional().describe("Field to order boards by (e.g., 'name', '-name' for descending). Refer to Jira API docs for all sortable fields."),
+        startAt: z.number().int().min(0).optional().describe("Index of the first board to return (0-based) for pagination."),
+        maxResults: z.number().int().optional().describe("Maximum number of boards to return per page."),
+        includePrivate: z.boolean().optional().describe("Include private boards in the results."),
+        projectKeyOrId: z.string().optional().describe("Filters results to boards for the specified project. Must be a project KEY (e.g., 'KAN', 'PROJ') or numeric project ID (e.g., '10000'). Do NOT use the project name (e.g., 'My Project') - use the short key instead."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, name, type, orderBy, startAt, maxResults, includePrivate, projectKeyOrId }) => {
+        const queryParams = { name: name, type: type, projectKeyOrId: projectKeyOrId, startAt: startAt, maxResults: maxResults, orderBy: orderBy, includePrivate: includePrivate };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'agile/1.0', path: `/board`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraListSprints = tool({
+    description: "Retrieves and lists sprints associated with a specified Jira board.      Users can filter results based on the state of the sprints, allowing for better management and visibility.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        state: z.string().optional().describe("Filters sprints by state. Accepts single value ('active') or comma-separated values ('active,closed'). Valid states: 'future', 'active', 'closed'. Returns all states if omitted."),
+        boardId: z.number().int().describe("Unique identifier of the Jira board. Must be a Scrum board ID; Kanban boards do not support sprints and will return no results. Use JIRA_LIST_BOARDS to identify the correct board."),
+        startAt: z.number().int().min(0).optional().describe("0-based starting index for pagination. Increment by 'max_results' each iteration; stop when response field 'isLast' is true."),
+        maxResults: z.number().int().min(1).max(50).optional().describe("Maximum number of sprints per page."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, state, boardId, startAt, maxResults }) => {
+        const queryParams = { state: state, startAt: startAt, maxResults: maxResults };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'agile/1.0', path: `/board/${encodeURIComponent(boardId)}/sprint`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraMoveIssueToSprint = tool({
+    description: "This action takes multiple issues and moves them to a specified sprint in Jira.      It ensures that the issues are successfully added to the targeted sprint based on the provided sprint ID.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        issues: z.array(z.string()).describe("A list of issue keys (e.g., 'PROJ-123') to be moved to the specified sprint."),
+        sprintId: z.number().int().describe("Unique identifier for the target sprint. Must belong to the same board/project as the issues being moved."),
+        rankAfterIssue: z.string().optional().describe("The issue key or ID to rank the moved issues after. If specified, the moved issues will be placed immediately after this issue in the sprint backlog."),
+        rankBeforeIssue: z.string().optional().describe("The issue key or ID to rank the moved issues before. If specified, the moved issues will be placed immediately before this issue in the sprint backlog."),
+        rankCustomFieldId: z.number().int().optional().describe("The ID of the rank custom field to use for ordering. This is typically the 'Rank' field ID in your Jira instance. Only needed if you have multiple rank fields."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, issues, sprintId, rankAfterIssue, rankBeforeIssue, rankCustomFieldId }) => {
+        const queryParams = undefined;
+        const body = { issues: issues, rankBeforeIssue: rankBeforeIssue, rankAfterIssue: rankAfterIssue, rankCustomFieldId: rankCustomFieldId };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'agile/1.0', path: `/sprint/${encodeURIComponent(sprintId)}/issue`, method: 'POST', query: queryParams, body });
+    },
+});
+//# sourceMappingURL=boards.js.map

package/dist/toolkits/jira/tools/client.d.ts

@@ -0,0 +1,23 @@
+declare const ATLASSIAN_API = "https://api.atlassian.com";
+export declare function getCloudId(token: any, hint: any): Promise<any>;
+export declare function jira(token: any, { cloudId, api, path, method, query, body, headers }: {
+    cloudId: any;
+    api?: string | undefined;
+    path: any;
+    method?: string | undefined;
+    query: any;
+    body: any;
+    headers?: {} | undefined;
+}): Promise<any>;
+export declare function mdToAdf(input: any): any;
+export declare function findAccountId(token: any, cloudId: any, nameOrEmail: any): Promise<any>;
+export declare function resolveAssignee(token: any, cloudId: any, accountId: any, nameOrEmail: any): Promise<any>;
+export declare function getTransitionId(token: any, cloudId: any, issueIdOrKey: any, idOrName: any): Promise<string | null>;
+export declare function uploadAttachment(token: any, cloudId: any, issueKey: any, { fileName, fileContent, mimeType }: {
+    fileName: any;
+    fileContent: any;
+    mimeType: any;
+}): Promise<any>;
+export declare function buildSearchJql(f: any): string;
+export { ATLASSIAN_API };
+//# sourceMappingURL=client.d.ts.map