@rnsk/toolkits 0.0.8 → 0.0.10

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

@@ -0,0 +1,181 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { jira, buildSearchJql } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const jiraAnalyseExpression = tool({
+    description: "Analyses Jira expressions for syntax validation, type checking, and complexity analysis. Use when you need to validate Jira expression syntax before using it in automation rules, custom fields, or workflows.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        check: z.enum(["syntax", "type", "complexity"]).optional().describe("Type of check to perform on the expression."),
+        expressions: z.array(z.string()).describe("The list of Jira expressions to analyse. Each expression will be checked according to the specified check type."),
+        contextVariables: z.record(z.any()).optional().describe("Context variables and their types. The type checker assumes that common context variables (such as 'issue' or 'project') are available in context and sets their type. Use this property to override the default types or provide details of new variables."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, check, expressions, contextVariables }) => {
+        const queryParams = undefined;
+        const body = { expressions: expressions, check: check, contextVariables: contextVariables };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/expression/analyse`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraCreateJqlAutocompletedata = tool({
+    description: "Retrieves JQL autocomplete reference data including reserved words, field names, and function names. Use when building JQL query editors or validating JQL syntax.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        projectIds: z.array(z.string()).optional().describe("List of project IDs used to filter the visible field details returned. Only fields visible in these projects will be included."),
+        includeCollapsedFields: z.boolean().optional().describe("Include collapsed fields for fields that have non-unique names. Set to true to include fields with duplicate names."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, projectIds, includeCollapsedFields }) => {
+        const queryParams = undefined;
+        const body = { projectIds: projectIds, includeCollapsedFields: includeCollapsedFields };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/jql/autocompletedata`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraEvaluateJiraExpression = tool({
+    description: "Tool to evaluate Jira expressions using the enhanced search API. Use when you need to extract or transform data from Jira using Jira expression language. Useful for complex data queries, transformations, and building custom objects from Jira data.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        expand: z.string().optional().describe("Use expand to include additional information in the response. This parameter accepts 'meta.complexity' that returns information about the expression complexity, such as the number of expensive operations used and how close the expression is to reaching the complexity limit. Useful when designing and debugging your expressions."),
+        context: z.record(z.any()).optional().describe("Context in which the Jira expression is evaluated."),
+        expression: z.string().describe("The Jira expression to evaluate. Jira expressions allow you to extract and transform data from Jira. For example: 'issue.key' returns the issue key, 'issue.issueType.name' returns the issue type name, or complex expressions like '{ key: issue.key, type: issue.issueType.name, links: issue.links.map(link => link.linkedIssue.id) }' to build custom objects."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, expand, context, expression }) => {
+        const queryParams = undefined;
+        const body = { expression: expression, context: context, expand: expand };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/expression/evaluate`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraGetJqlAutocompletedata = tool({
+    description: "Tool to retrieve JQL autocomplete reference data. Use when you need to discover available JQL fields, functions, and reserved words for building queries.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+    }),
+    execute: async ({ jiraToken, jiraCloudId }) => {
+        const queryParams = undefined;
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/jql/autocompletedata`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraGetJqlAutocompletedataSuggestions = tool({
+    description: "Tool to get JQL field auto-complete suggestions. Use when building JQL queries to discover valid field values or predicate options.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        fieldName: z.string().optional().describe("The name of the field for which to get suggestions."),
+        fieldValue: z.string().optional().describe("The partial field item name entered by the user to filter suggestions."),
+        predicateName: z.string().optional().describe("The name of the CHANGED operator predicate for which suggestions are generated. Valid values: 'by', 'from', 'to'."),
+        predicateValue: z.string().optional().describe("The partial predicate item name entered by the user to filter suggestions."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, fieldName, fieldValue, predicateName, predicateValue }) => {
+        const queryParams = { fieldName: fieldName, fieldValue: fieldValue, predicateName: predicateName, predicateValue: predicateValue };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/jql/autocompletedata/suggestions`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraParseJqlQueries = tool({
+    description: "Parse and validate JQL queries, returning their abstract syntax tree structure along with any errors or warnings. Use when you need to validate JQL syntax or understand query structure before execution.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        queries: z.array(z.string()).min(1).describe("A list of JQL queries to parse. Each query string must be non-empty and will be validated according to the validation parameter."),
+        validation: z.enum(["strict", "warn", "none"]).optional().describe("How to validate the JQL queries and treat the validation results. 'strict': Returns all errors; if validation fails, the query structure is not returned. 'warn': Returns all errors; if validation fails but the JQL query is correctly formed, the query structure is returned. 'none': No validation is performed; if JQL query is correctly formed, the query structure is returned."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, queries, validation }) => {
+        const queryParams = undefined;
+        const body = { queries: queries, validation: validation };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/jql/parse`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraSearchApproximateCount = tool({
+    description: "Count issues matching a JQL query using approximate count endpoint. Use when you need a fast count of issues without retrieving full issue details. The JQL query must be bounded (include at least one search restriction).",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        jql: z.string().describe("A JQL (Jira Query Language) expression to search for issues. For performance reasons, this parameter requires a bounded query - a query with a search restriction (e.g., 'project = KAN', 'assignee = currentUser()', 'status = Done'). Unbounded queries like empty strings or queries with only 'ORDER BY' clauses are not allowed."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, jql }) => {
+        const queryParams = undefined;
+        const body = { jql: jql };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/search/approximate-count`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraSearchForIssuesUsingJqlGet = tool({
+    description: "This action retrieves Jira issues based on a specified JQL query. It allows for pagination as well as selection of specific fields to include in the result.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        jql: z.string().optional().describe("Jira Query Language (JQL) string for searching issues. REQUIRED if 'next_page_token' is not provided. Provide this parameter to start a search. To continue a paginated search with a raw Jira token, provide both the original JQL and 'next_page_token'; tokens returned by this action already include that context. IMPORTANT: JQL must include at least one search restriction (filter condition such as project, status, assignee, issuetype, labels, created, updated, etc.). Unbounded queries containing only ORDER BY clauses (e.g., 'order by created DESC') are rejected by the API. Always include a filter like 'project = X' or 'status = Open'. NOTE: This action uses Jira's enhanced search API which has stricter JQL syntax requirements than the Jira UI."),
+        expand: z.string().optional().describe("Comma-separated list of entities to expand within issues (e.g., 'renderedFields', 'changelog')."),
+        fields: z.array(z.string()).optional().describe("Specific issue fields to retrieve (e.g., 'summary', 'customfield_10010', '*all', '*navigable'). Defaults if omitted."),
+        failFast: z.boolean().optional().describe("Fail early on certain errors during search."),
+        properties: z.array(z.string()).optional().describe("List of issue property keys (key-value metadata) to retrieve."),
+        maxResults: z.number().int().min(1).optional().describe("Maximum issues to retrieve per page. Must be at least 1. Note: Jira Cloud typically limits results to 100 per request for performance reasons."),
+        fieldsByKeys: z.boolean().optional().describe("Set to 'True' to identify fields by keys (e.g., 'customfield_10000') instead of IDs."),
+        nextPageToken: z.string().optional().describe("Pagination token from a previous enhanced search response. Use the token returned by this action to continue without resending JQL. If you pass a raw Jira nextPageToken, also pass the original JQL."),
+        reconcileIssues: z.array(z.number().int()).optional().describe("List of issue IDs to enable read-after-write reconciliation during search."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, jql, expand, fields, failFast, properties, maxResults, fieldsByKeys, nextPageToken, reconcileIssues }) => {
+        const queryParams = { jql: jql, expand: expand, fields: fields, properties: properties, maxResults: maxResults, fieldsByKeys: fieldsByKeys, nextPageToken: nextPageToken, reconcileIssues: reconcileIssues, failFast: failFast };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/search/jql`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraSearchForIssuesUsingJqlPost = tool({
+    description: "This action performs the enhanced JQL issue search that supports eventual consistency and token-based pagination. Use it when you need stable results immediately after creating or updating issues, or when paginating large result sets. IMPORTANT: This action only works with Jira Cloud. For Jira Server or Data Center instances, use JIRA_SEARCH_FOR_ISSUES_USING_JQL_GET instead.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        jql: z.string().optional().describe("The JQL (Jira Query Language) query string to use for the search. Must be bounded (for example, include a restriction like 'project = KAN'); unbounded queries such as empty JQL or only 'order by ...' are not accepted. Provide either this 'jql' (for the first page) or 'nextPageToken' (to continue pagination). Use only valid JQL field names (e.g., 'project', 'assignee', 'status', 'created', 'updated', 'reporter', 'priority', 'issuetype', 'summary', 'description', 'key', 'labels', 'component', 'fixVersion', 'resolution', 'sprint', 'timespent', 'worklogDate', 'worklogAuthor', 'worklogComment'). Note that some fields like 'worklogDate' require time-tracking to be enabled in the Jira instance."),
+        expand: z.string().optional().describe("A comma-separated list of entities to expand in the response (e.g., 'names', 'schema', 'transitions', 'changelog')."),
+        fields: z.array(z.string()).optional().describe("A list of fields to return for each issue (e.g., 'summary', 'status', 'assignee', '*navigable')."),
+        maxResults: z.number().int().min(1).max(5000).optional().describe("The maximum number of issues to return per page (1-5000). In practice, values above 100 may be ignored by the API; total results per JQL query are capped at ~10,000 regardless of pagination."),
+        properties: z.array(z.string()).optional().describe("A list of issue property keys to return for each issue."),
+        fieldsByKeys: z.boolean().optional().describe("If true, treats values in 'fields' as keys (e.g., 'customfield_10000')."),
+        nextPageToken: z.string().optional().describe("Opaque token received from a previous response to continue pagination. Tokens returned by this action include the original search context and can be passed alone. Raw Jira nextPageToken values require the original JQL too. IMPORTANT: Tokens are short-lived and expire quickly. They must be used immediately within the same search session. If you receive a 'token is invalid or expired' error, restart the search from the beginning with a fresh JQL query (do not reuse old tokens)."),
+        reconcileIssues: z.array(z.number().int()).optional().describe("List of issue IDs to reconcile for read-after-write consistency (maximum 50)."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, jql, expand, fields, maxResults, properties, fieldsByKeys, nextPageToken, reconcileIssues }) => {
+        const queryParams = undefined;
+        const body = { jql: jql, expand: expand, fields: fields, maxResults: maxResults, properties: properties, fieldsByKeys: fieldsByKeys, nextPageToken: nextPageToken, reconcileIssues: reconcileIssues };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/search/jql`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraSearchIssues = tool({
+    description: "This action performs advanced searches for Jira issues using either structured filters or raw JQL queries. It supports various search criteria including project, assignee, status, priority, and date ranges.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        jql: z.string().optional().describe("Raw JQL (Jira Query Language) query for advanced users. Takes precedence over filters. Can be a complete JQL query with filters and/or ORDER BY clause, or just an ORDER BY clause. CRITICAL JQL SYNTAX RULES - Every comparison needs field + operator + value: (1) WRONG: '(\"val1\" OR \"val2\")' - bare values without field reference cause 'Expecting operator' errors. (2) RIGHT: 'status = \"val1\" OR status = \"val2\"' - each value has field and operator. (3) BETTER: 'status IN (\"val1\", \"val2\", \"val3\")' - use IN for multiple values on same field. (4) Text search uses ~: 'summary ~ \"keyword\"' or 'text ~ \"keyword\"'. (5) Valid operators: =, !=, <, >, <=, >=, ~, !~, IN, NOT IN, IS, IS NOT. COMMON MISTAKE: Do NOT pass ('value1' OR 'value2') - this is invalid. Instead use: field IN ('value1', 'value2') or field = 'value1' OR field = 'value2'."),
+        fields: z.array(z.string()).optional().describe("List of fields to return for each issue (for example: summary, status, assignee). If omitted, a sensible default set is requested to populate common fields."),
+        labels: z.array(z.string()).optional().describe("Filter by labels (all labels must match)."),
+        assignee: z.string().optional().describe("Filter by assignee. Can be account ID (e.g., '712020:abc...'), email (e.g., 'john@company.com'), display name (e.g., 'John Doe'), or 'unassigned'."),
+        maxResults: z.number().int().optional().describe("Maximum number of issues to return per page. Capped at 100 per page; total results per JQL query capped at ~10,000. Use next_page_token to paginate."),
+        projectKey: z.string().optional().describe("Filter by project key (e.g., 'PROJ')."),
+        textSearch: z.string().optional().describe("Search in summary and description text."),
+        createdAfter: z.string().optional().describe("Filter issues created after this date. Supports YYYY-MM-DD format or relative dates like '-30m' (last 30 minutes), '-7d' (last 7 days), '-1w' (last week), '-1M' (last month)."),
+        updatedAfter: z.string().optional().describe("Filter issues updated after this date. Supports YYYY-MM-DD format or relative dates like '-30m' (last 30 minutes), '-7d' (last 7 days), '-1w' (last week), '-1M' (last month)."),
+        createdBefore: z.string().optional().describe("Filter issues created before this date (YYYY-MM-DD format)."),
+        updatedBefore: z.string().optional().describe("Filter issues updated before this date (YYYY-MM-DD format)."),
+        nextPageToken: z.string().optional().describe("Cursor token used to fetch the next page when using enhanced search. Tokens returned by this action include the original search context and can be passed alone. Raw Jira nextPageToken values require the same JQL or filters used for the original search."),
+        sprintIdOrName: z.string().optional().describe("Filter by sprint. Can be sprint ID (e.g., '123') or name (e.g., 'Sprint 1', 'Release Sprint')."),
+        statusIdOrName: z.string().optional().describe("Filter by status. Can be either a status ID (e.g., '10001') or name (e.g., 'To Do', 'In Progress', 'Done')."),
+        preservedOrderBy: z.string().optional().describe("Internal: preserved ORDER BY clause from ORDER-BY-only JQL input"),
+        priorityIdOrName: z.string().optional().describe("Filter by priority. Can be either a priority ID (e.g., '1', '2') or name (e.g., 'High', 'Medium', 'Low')."),
+        issueTypeIdOrName: z.string().optional().describe("Filter by issue type. Can be either an issue type ID (e.g., '10001') or name (e.g., 'Bug', 'Task', 'Story')."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, jql, fields, labels, assignee, maxResults, projectKey, textSearch, createdAfter, updatedAfter, createdBefore, updatedBefore, nextPageToken, sprintIdOrName, statusIdOrName, preservedOrderBy, priorityIdOrName, issueTypeIdOrName }) => {
+        if (nextPageToken) {
+            return jira(jiraToken, { cloudId: jiraCloudId, path: '/search/jql', method: 'POST', body: { jql, nextPageToken } });
+        }
+        const built = jql ?? buildSearchJql({ projectKey, assignee, statusIdOrName, priorityIdOrName, issueTypeIdOrName, labels, textSearch, createdAfter, updatedAfter, createdBefore, updatedBefore, sprintIdOrName, preservedOrderBy });
+        if (!built)
+            return { error: "Provide at least one filter: jql, projectKey, assignee, status, textSearch, dates, etc." };
+        const body = { jql: built };
+        if (fields)
+            body.fields = fields;
+        if (maxResults !== undefined)
+            body.maxResults = maxResults;
+        return jira(jiraToken, { cloudId: jiraCloudId, path: '/search/jql', method: 'POST', body });
+    },
+});
+//# sourceMappingURL=search.js.map

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

@@ -0,0 +1,114 @@
+export declare const jiraAddUserToGroup: import("ai").Tool<{
+    accountId: string;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    groupId?: string | undefined;
+    groupName?: string | undefined;
+}, any>;
+export declare const jiraCreateGroup: import("ai").Tool<{
+    name: string;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+}, any>;
+export declare const jiraFindUsers: import("ai").Tool<{
+    query?: string | undefined;
+    maxResults?: number | undefined;
+    active?: boolean | undefined;
+    accountId?: string | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    startAt?: number | undefined;
+}, any>;
+export declare const jiraFindUsers2: import("ai").Tool<{
+    query?: string | undefined;
+    maxResults?: number | undefined;
+    username?: string | undefined;
+    property?: string | undefined;
+    accountId?: string | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    startAt?: number | undefined;
+}, any>;
+export declare const jiraFindUsersForPicker: import("ai").Tool<{
+    query: string;
+    maxResults?: number | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    avatarSize?: string | undefined;
+    showAvatar?: boolean | undefined;
+    excludeAccountIds?: string[] | undefined;
+    excludeConnectUsers?: boolean | undefined;
+}, any>;
+export declare const jiraGetAllGroups: import("ai").Tool<{
+    maxResults?: number | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    startAt?: number | undefined;
+}, any>;
+export declare const jiraGetAllUsers: import("ai").Tool<{
+    maxResults?: number | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    startAt?: number | undefined;
+}, any>;
+export declare const jiraGetCurrentUser: import("ai").Tool<{
+    expand?: string | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+}, any>;
+export declare const jiraGetGroup: import("ai").Tool<{
+    expand?: string | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    groupId?: string | undefined;
+    groupName?: string | undefined;
+}, any>;
+export declare const jiraGetMypreferencesLocale: import("ai").Tool<{
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+}, any>;
+export declare const jiraGetUserGroups: import("ai").Tool<{
+    accountId: string;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+}, any>;
+export declare const jiraListGroupsPicker: import("ai").Tool<{
+    query?: string | undefined;
+    maxResults?: number | undefined;
+    exclude?: string[] | undefined;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    excludeId?: string[] | undefined;
+    caseInsensitive?: boolean | undefined;
+}, any>;
+export declare const jiraRemoveUserFromGroup: import("ai").Tool<{
+    accountId: string;
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+    groupId?: string | undefined;
+    groupName?: string | undefined;
+}, any>;
+export declare const jiraWhoAmI: import("ai").Tool<{
+    jiraToken?: string | undefined;
+    jiraCloudId?: string | undefined;
+}, {
+    error: string;
+    sites?: undefined;
+    accountId?: undefined;
+    message?: undefined;
+} | {
+    sites: {
+        id: any;
+        name: any;
+        url: any;
+    }[];
+    accountId: null;
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    sites?: undefined;
+    accountId?: undefined;
+}>;
+//# sourceMappingURL=users.d.ts.map

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

@@ -0,0 +1,221 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { jira } from './client.js';
+import { ATLASSIAN_API } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const jiraAddUserToGroup = tool({
+    description: "This action adds a user to a Jira group. The user is identified by their Atlassian account ID, and the group is identified by either its name or 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.'),
+        groupId: z.string().optional().describe("The ID of the group to add the user to. Either group_name or group_id must be provided."),
+        accountId: z.string().describe("The Atlassian account ID of the user to add to the group."),
+        groupName: z.string().optional().describe("The name of the group to add the user to. Either group_name or group_id must be provided. Must be an exact match; prefer group_id for precision."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, groupId, accountId, groupName }) => {
+        const queryParams = { groupname: groupName, groupId: groupId };
+        const body = { accountId: accountId };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/group/user`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraCreateGroup = tool({
+    description: "This action creates a new group in Jira. Groups are used to organize users and manage permissions across projects and issues.",
+    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("The name of the group to create. Must be unique within the Jira instance."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, name }) => {
+        const queryParams = undefined;
+        const body = { name: name };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/group`, method: 'POST', query: queryParams, body });
+    },
+});
+export const jiraFindUsers = tool({
+    description: "This action allows you to search for Jira users using various parameters like email or display name. It returns a list of users that match the search criteria for further operations.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        query: z.string().optional().describe("A query string that is matched against user attributes. This can be used to search by display name or email address. For example, 'john@company.com' to find a user by email. At least one of 'query' or 'account_id' must be provided. Plain-text only — JQL-style functions like currentUser() are unsupported and return no results. Email fields in results may be redacted due to privacy settings; use display_name for disambiguation when email is unavailable."),
+        active: z.boolean().optional().describe("Filter users by active status. When true, only active users are returned. When false, only inactive users are returned. If not provided, the search returns active users."),
+        startAt: z.number().int().optional().describe("The 0-based index of the first item to return in the page of results. Used for pagination."),
+        accountId: z.string().optional().describe("The account ID to search for. Use this to get user details when you already have the account ID. At least one of 'query' or 'account_id' must be provided."),
+        maxResults: z.number().int().optional().describe("The maximum number of items to return per page. Defaults to 50. Maximum allowed is typically 1000."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, query, active, startAt, accountId, maxResults }) => {
+        const queryParams = { query: query, accountId: accountId, active: active, startAt: startAt, maxResults: maxResults };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/user/search`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraFindUsers2 = tool({
+    description: "Tool to find users in Jira by query string, account ID, or property search. Use when you need to search for users to assign to issues, add as watchers, or perform other user-related operations.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        query: z.string().optional().describe("A query string that is matched against user attributes (displayName, and emailAddress) to find relevant users. The string can match the prefix of the attribute's value. For example, 'john' matches a user with a displayName of 'John Smith' and a user with an emailAddress of 'johnson@example.com'. Required, unless accountId or property is specified."),
+        startAt: z.number().int().min(0).optional().describe("The index of the first item to return in a page of filtered results (page offset)."),
+        property: z.string().optional().describe("A query string used to search properties. Property keys are specified by path, so property keys containing dot (.) or equals (=) characters cannot be used. The query string cannot be specified using a JSON object. Example: To search for the value of 'nested' from {\"something\":{\"nested\":1,\"other\":2}} use 'thepropertykey.something.nested=1'. Required, unless accountId or query is specified."),
+        username: z.string().optional().describe("This parameter is no longer available. See the deprecation notice for details."),
+        accountId: z.string().optional().describe("A query string that is matched exactly against a user accountId. Required, unless query or property is specified."),
+        maxResults: z.number().int().min(1).max(1000).optional().describe("The maximum number of items to return per page."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, query, startAt, property, username, accountId, maxResults }) => {
+        const queryParams = { query: query, accountId: accountId, startAt: startAt, maxResults: maxResults, property: property, username: username };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/user/search`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraFindUsersForPicker = tool({
+    description: "Find users for picker components by matching query against user attributes like display name and email.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        query: z.string().describe("A query string that is matched against user attributes, such as 'displayName', and 'emailAddress', to find relevant users. The string can match the prefix of the attribute's value. For example, *query=john* matches a user with a 'displayName' of *John Smith* and a user with an 'emailAddress' of *johnson@example.com*."),
+        avatarSize: z.string().optional().describe("The size of the avatar to return. Only used when 'show_avatar' is true."),
+        maxResults: z.number().int().min(1).optional().describe("The maximum number of items to return. The total number of matched users is returned in 'total'. Defaults to 50."),
+        showAvatar: z.boolean().optional().describe("Include the URI to the user's avatar. Defaults to false."),
+        excludeAccountIds: z.array(z.string()).optional().describe("A list of account IDs to exclude from the search results. Cannot be provided with 'exclude'."),
+        excludeConnectUsers: z.boolean().optional().describe("Exclude Connect app users from the search results. Defaults to false."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, query, avatarSize, maxResults, showAvatar, excludeAccountIds, excludeConnectUsers }) => {
+        const queryParams = { query: query, maxResults: maxResults, showAvatar: showAvatar, avatarSize: avatarSize, excludeAccountIds: excludeAccountIds, excludeConnectUsers: excludeConnectUsers };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/user/picker`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraGetAllGroups = tool({
+    description: "This action retrieves a single page of groups from the Jira instance. Use 'start_at' and 'max_results' to page through results; the response includes 'has_next_page' and 'next_start_at' to drive pagination.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        startAt: z.number().int().min(0).optional().describe("The 0-based index of the first item to return in the page of results. Defaults to 0. To paginate, use 'next_start_at' from the response (or increment 'start_at' by 'max_results'); stop when 'has_next_page' is false."),
+        maxResults: z.number().int().min(1).optional().describe("The maximum number of items to return per page. Defaults to 50. The Jira instance might have its own maximum limit for this value. A single page is returned per call; use 'has_next_page'/'next_start_at' to fetch more."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, startAt, maxResults }) => {
+        const perPage = maxResults ?? 50;
+        const start = startAt ?? 0;
+        const res = await jira(jiraToken, { cloudId: jiraCloudId, path: "/groups/picker", query: { startAt: start, maxResults: perPage } });
+        if (res?.error)
+            return res;
+        const list = Array.isArray(res?.values) ? res.values : [];
+        const isLast = res?.isLast ?? list.length < perPage;
+        return { groups: list, total: res?.total ?? list.length, startAt: start, maxResults: perPage, isLast, hasNextPage: !isLast, nextStartAt: isLast ? null : start + perPage };
+    },
+});
+export const jiraGetAllUsers = tool({
+    description: "This action retrieves a single page of users from the Jira instance. Use 'start_at' and 'max_results' to page through results; the response includes 'has_next_page' and 'next_start_at' to drive pagination.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        startAt: z.number().int().min(0).optional().describe("The 0-based index of the first item to return in the page of results. Defaults to 0. To paginate, increment 'start_at' by 'max_results' each request (or use 'next_start_at' from the response); stop when 'has_next_page' is false."),
+        maxResults: z.number().int().min(1).optional().describe("The maximum number of items to return per page. Defaults to 50. The Jira instance might have its own maximum limit for this value. A single page is returned per call; use 'has_next_page'/'next_start_at' from the response to fetch subsequent pages."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, startAt, maxResults }) => {
+        const perPage = maxResults ?? 50;
+        const start = startAt ?? 0;
+        const users = await jira(jiraToken, { cloudId: jiraCloudId, path: "/users/search", query: { startAt: start, maxResults: perPage } });
+        if (users?.error)
+            return users;
+        const list = Array.isArray(users) ? users : [];
+        const isLast = list.length < perPage;
+        return { users: list, startAt: start, maxResults: perPage, isLast, hasNextPage: !isLast, nextStartAt: isLast ? null : start + perPage };
+    },
+});
+export const jiraGetCurrentUser = tool({
+    description: "This action retrieves detailed information about the currently authenticated Jira user. It provides data such as the user's display name, email address, groups, and application roles.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        expand: z.string().optional().describe("Comma-separated list of user properties to expand, e.g., 'groups', 'applicationRoles'. Omitting this parameter returns only the base user profile without group membership or role data."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, expand }) => {
+        const queryParams = { expand: expand };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/myself`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraGetGroup = tool({
+    description: "This action retrieves information about a specific Jira group. You can fetch the group by its name or unique ID, and optionally expand to include the list of users in the group.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        expand: z.string().optional().describe("Additional properties to expand in the response. Use 'users' to include group members. Useful for verifying membership state after group modification operations."),
+        groupId: z.string().optional().describe("The unique ID of the group to retrieve. Either group_name or group_id must be provided."),
+        groupName: z.string().optional().describe("The name of the group to retrieve. Either group_name or group_id must be provided."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, expand, groupId, groupName }) => {
+        const queryParams = { groupname: groupName, groupId: groupId, expand: expand };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/group`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraGetMypreferencesLocale = tool({
+    description: "Tool to retrieve the locale preference of the currently authenticated Jira user. Use when you need to know the user's language and regional settings.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+    }),
+    execute: async ({ jiraToken, jiraCloudId }) => {
+        const queryParams = undefined;
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/mypreferences/locale`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraGetUserGroups = tool({
+    description: "Retrieves all groups for a specific Jira user by account ID. Use this action when you need to check group membership for a particular user, verify permissions, or audit user access. Essential for understanding which groups a user belongs to before performing group-related operations.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        accountId: z.string().describe("The Atlassian account ID of the user whose groups you want to retrieve."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, accountId }) => {
+        const queryParams = { accountId: accountId };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/user/groups`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraListGroupsPicker = tool({
+    description: "This action searches and lists groups using Jira's picker endpoint, which is optimized for autocomplete and search scenarios. It allows filtering by name and excluding specific groups.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+        query: z.string().optional().describe("The string to find in group names. Use this to search for groups matching a specific text."),
+        exclude: z.array(z.string()).optional().describe("A list of group names to exclude from the result. As a group's name can change, use of 'exclude_id' is recommended to identify a group. This parameter cannot be used with 'exclude_id' parameter."),
+        excludeId: z.array(z.string()).optional().describe("A list of group IDs to exclude from the result. This parameter cannot be used with the 'exclude' parameter."),
+        maxResults: z.number().int().min(1).optional().describe("The maximum number of groups to return. The maximum number of groups that can be returned is limited by the system property 'jira.ajax.autocomplete.limit'."),
+        caseInsensitive: z.boolean().optional().describe("Whether the search for groups should be case insensitive. Defaults to false if not specified."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, query, exclude, excludeId, maxResults, caseInsensitive }) => {
+        const queryParams = { query: query, exclude: exclude, excludeId: excludeId, maxResults: maxResults, caseInsensitive: caseInsensitive };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/groups/picker`, method: 'GET', query: queryParams });
+    },
+});
+export const jiraRemoveUserFromGroup = tool({
+    description: "This action removes a user from a Jira group. The user is identified by their Atlassian account ID, and the group is identified by either its name or 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.'),
+        groupId: z.string().optional().describe("The ID of the group to remove the user from. Either group_name or group_id must be provided."),
+        accountId: z.string().describe("The Atlassian account ID of the user to remove from the group. System and app accounts cannot be modified; attempting removal returns a 400 'User not modifiable' error."),
+        groupName: z.string().optional().describe("The name of the group to remove the user from. Either group_name or group_id must be provided."),
+    }),
+    execute: async ({ jiraToken, jiraCloudId, groupId, accountId, groupName }) => {
+        const queryParams = { groupname: groupName, groupId: groupId, accountId: accountId };
+        return jira(jiraToken, { cloudId: jiraCloudId, api: 'api/3', path: `/group/user`, method: 'DELETE', query: queryParams });
+    },
+});
+export const jiraWhoAmI = tool({
+    description: "Return the Atlassian (Jira) sites accessible to the connection. Identity is workspace-level.",
+    inputSchema: z.object({
+        jiraToken: tokenField,
+        jiraCloudId: z.string().optional().describe('Optional Jira Cloud site ID. If omitted, your first accessible site is used automatically.'),
+    }),
+    execute: async ({ jiraToken, jiraCloudId }) => {
+        try {
+            const response = await fetch(`${ATLASSIAN_API}/oauth/token/accessible-resources`, { headers: { Authorization: `Bearer ${jiraToken}`, Accept: "application/json" } });
+            if (!response.ok)
+                return { error: `Failed to list accessible sites with status ${response.status}` };
+            const sites = await response.json();
+            return { sites: (Array.isArray(sites) ? sites : []).map((s) => ({ id: s.id, name: s.name, url: s.url })), accountId: null };
+        }
+        catch (error) {
+            return { error: "Error listing accessible Jira sites", message: error instanceof Error ? error.message : "Unknown error" };
+        }
+    },
+});
+//# sourceMappingURL=users.js.map

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

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

package/dist/toolkits/neo4j/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg viewBox="0 0 128 128" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M63.333 32.567c-5.2.866-9.566 3-12.833 6.266-3.867 3.867-5.833 8.5-6.5 15.367-.3 3.133-.467 15.467-.2 15.467.067 0 .7-.234 1.4-.534 1.633-.7 5.167-.7 7-.033l1.4.5.167-8.033c.166-8.567.366-9.867 1.966-13.067 1.1-2.133 3.767-4.633 6.034-5.667 2.6-1.2 6.4-1.666 9.333-1.2 6.267 1.034 10 4.434 11.567 10.5.633 2.434.666 3.7.666 17.1v14.434H93.4L93.233 67.9c-.1-14.9-.166-15.9-.866-18.567-1.9-7.4-6.5-12.766-12.934-15.2-3.433-1.3-6.7-1.8-11.2-1.766-2.233.033-4.433.133-4.9.2z" fill="#000"/><path d="M22.733 57.2c-2.866 1.433-4.4 4-4.4 7.467 0 1.1.2 2.5.467 3.133.633 1.567 2.433 3.467 4 4.3 1.9 1 5.5 1 7.367.033l1.366-.7 4.267 2.9 4.267 2.934V81.7L35.8 84.633l-4.3 2.934-1.1-.667c-1.6-.933-4.7-1.133-6.6-.4-2 .767-4.067 2.6-4.833 4.333-.834 1.767-.834 5.234 0 7 .7 1.567 2.333 3.3 3.8 4.067.6.3 2.033.6 3.233.7 2.8.2 5.167-.733 6.867-2.733 1.366-1.6 2.266-4.4 2.033-6.334l-.167-1.366 4.3-2.9 4.3-2.9 1.534.7c2.333 1 5.8.766 8-.567 2.4-1.5 3.6-3.633 3.733-6.633.1-2.1 0-2.567-.833-4.2-2.167-4.134-7-5.7-11.134-3.634l-1.233.6-4.233-2.9-4.234-2.9-.1-2.333c-.066-2.8-.866-4.6-2.833-6.233-2.5-2.134-6.233-2.567-9.267-1.067z" fill="#018BFF"/></svg>`;
+export const NEO4J_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/neo4j/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/neo4j/manifest.js

@@ -0,0 +1,33 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { NEO4J_ICON } from './icon.js';
+import { neo4jTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'neo4j',
+    displayName: 'Neo4j',
+    shortDescription: 'Aura instances, snapshots, projects, users, IP filters, agents, and GDS sessions.',
+    category: 'Data & Analytics',
+    icon: NEO4J_ICON,
+    auth: {
+        type: 'basic_auth',
+        tokenField: 'neo4jCredentials',
+        provider: {
+            connectDescription: 'Connect Neo4j with Aura API client credentials. Create them in the Aura Console under Account Settings > Client credentials (Aura API). Paste as "clientId:clientSecret". Tools exchange them for a short-lived bearer token automatically.',
+        },
+    },
+    allowedHosts: ['api.neo4j.io'],
+    tools: neo4jTools.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://neo4j.com',
+        docsUrl: 'https://neo4j.com/docs/aura/api/authentication/',
+        apiDocsUrl: 'https://neo4j.com/docs/aura/platform/api/specification/',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/neo4j/tools/analytics.d.ts

@@ -0,0 +1,21 @@
+export declare const neo4jEstimateGdsSessionSize: import("ai").Tool<{
+    nodeCount: number;
+    relationshipCount: number;
+    neo4jCredentials?: string | undefined;
+    nodeLabelCount?: number | undefined;
+    nodePropertyCount?: number | undefined;
+    relationshipPropertyCount?: number | undefined;
+    algorithmCategories?: string[] | undefined;
+}, any>;
+export declare const neo4jListGdsSessions: import("ai").Tool<{
+    instanceId?: string | undefined;
+    neo4jCredentials?: string | undefined;
+    tenantId?: string | undefined;
+    organizationId?: string | undefined;
+}, any>;
+export declare const neo4jAggregateDirectors: import("ai").Tool<{
+    instanceId: string;
+    graphQlEndpoint: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=analytics.d.ts.map