@rnsk/toolkits 0.0.7 → 0.0.9

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

@@ -0,0 +1,155 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackSearchAll = tool({
+    description: 'Unified workspace search across messages and files in one call. Read the files section explicitly for document hits. Results are index-based (minutes stale); use history tools for real-time. Honor Retry-After on 429.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        query: z.string().describe('Query with Slack modifiers, e.g. "error report in:#channel from:@user has:file"'),
+        sort: z.string().optional().describe('score (relevance) or timestamp'),
+        sortDir: z.string().optional().describe('asc or desc'),
+        count: z.number().optional().describe('Results per page (default 20, max 100)'),
+        page: z.number().optional().describe('Page number (default 1)'),
+        highlight: z.boolean().optional().describe('Wrap search terms with highlight markers'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, sortDir, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'search.all', {
+                ...rest,
+                sort_dir: sortDir,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to search');
+        }
+    },
+});
+export const slackSearchMessages = tool({
+    description: 'Workspace-wide message search with query modifiers (in:#channel, from:@user, before:/after:/on: dates), sorting, and pagination. Combine with autoPaginate+count for full collection.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        query: z.string().describe('Search query, e.g. "bug report from:@jane in:#support after:2025-01-01"'),
+        sort: z.string().optional().describe('score or timestamp'),
+        sortDir: z.string().optional().describe('asc or desc'),
+        count: z.number().optional().describe('Per page (max 100), or total desired with autoPaginate'),
+        page: z.number().optional().describe('Manual page number (not with cursor/autoPaginate)'),
+        cursor: z.string().optional().describe('Cursor pagination ("*" for first call; preferred over page)'),
+        highlight: z.boolean().optional().describe('Highlight search terms in results'),
+        autoPaginate: z.boolean().optional().describe('Auto-collect pages until count total messages is reached'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, sortDir, autoPaginate, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            if (autoPaginate) {
+                const total = rest.count ?? 100;
+                const collected = [];
+                let cursor = rest.cursor;
+                let query = rest.query;
+                while (collected.length < total) {
+                    const data = await slackApi(slackToken, 'search.messages', {
+                        query,
+                        sort: rest.sort,
+                        sort_dir: sortDir,
+                        count: Math.min(100, total - collected.length),
+                        cursor,
+                        highlight: rest.highlight,
+                        team_id: teamId,
+                    });
+                    const matches = data?.messages?.matches ?? [];
+                    collected.push(...matches);
+                    cursor = data?.messages?.paging?.next_cursor || data?.response_metadata?.next_cursor;
+                    if (!cursor || matches.length === 0)
+                        break;
+                }
+                return { ok: true, query, messages: { total: collected.length, matches: collected.slice(0, total) } };
+            }
+            return await slackApi(slackToken, 'search.messages', {
+                ...rest,
+                sort_dir: sortDir,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to search messages');
+        }
+    },
+});
+export const slackAssistantSearch = tool({
+    description: 'Real-time search across messages, files, channels, and users (keyword or natural-language/semantic). Resolve named entities to IDs first via contentTypes; confirm with the user on multiple matches.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        query: z.string().describe('Keyword or natural-language question'),
+        contentTypes: z.string().optional().describe('Comma-separated: messages,files,channels,users (default messages)'),
+        channelTypes: z.string().optional().describe('Comma-separated: public_channel,private_channel,mpim,im'),
+        limit: z.number().min(1).max(20).optional().describe('Results per page (max 20, default 20)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        sort: z.string().optional().describe('score or timestamp'),
+        sortDir: z.string().optional().describe('asc or desc'),
+        before: z.number().optional().describe('Unix timestamp: only results before this date'),
+        after: z.number().optional().describe('Unix timestamp: only results after this date'),
+        modifiers: z.string().optional().describe("Extra filters, e.g. 'has:pin before:yesterday is:thread'"),
+        termClauses: z.array(z.string()).optional().describe('Conjunctive search term clauses (all must match)'),
+        highlight: z.boolean().optional().describe('Highlight matching terms'),
+        includeBots: z.boolean().optional().describe('Include bot messages'),
+        includeDeletedUsers: z.boolean().optional().describe('Include deleted users'),
+        includeMessageBlocks: z.boolean().optional().describe('Return Block Kit blocks'),
+        includeContextMessages: z.boolean().optional().describe('Include surrounding messages'),
+        includeArchivedChannels: z.boolean().optional().describe('Include archived channels'),
+        disableSemanticSearch: z.boolean().optional().describe('Force keyword-only search (no Slack AI)'),
+        contextChannelId: z.string().optional().describe('Channel context hint (not a strict filter)'),
+        actionToken: z.string().optional().describe('Event action token (required for bot tokens)'),
+    }),
+    execute: async ({ slackToken, contentTypes, channelTypes, sortDir, termClauses, includeBots, includeDeletedUsers, includeMessageBlocks, includeContextMessages, includeArchivedChannels, disableSemanticSearch, contextChannelId, actionToken, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'assistant.search.context', {
+                ...rest,
+                content_types: contentTypes,
+                channel_types: channelTypes,
+                sort_dir: sortDir,
+                term_clauses: termClauses,
+                include_bots: includeBots,
+                include_deleted_users: includeDeletedUsers,
+                include_message_blocks: includeMessageBlocks,
+                include_context_messages: includeContextMessages,
+                include_archived_channels: includeArchivedChannels,
+                disable_semantic_search: disableSemanticSearch,
+                context_channel_id: contextChannelId,
+                action_token: actionToken,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to search');
+        }
+    },
+});
+export const slackGetSearchInfo = tool({
+    description: 'Check whether AI-powered semantic search is enabled on the workspace. When false, pass disableSemanticSearch=true to slackAssistantSearch for keyword-only search.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'assistant.search.info', {});
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get search info');
+        }
+    },
+});
+//# sourceMappingURL=search.js.map

package/dist/toolkits/slack/tools/slack-lists.d.ts

@@ -0,0 +1,65 @@
+export declare const slackCreateList: import("ai").Tool<{
+    name: string;
+    slackToken?: string | undefined;
+    descriptionBlocks?: string | Record<string, any> | Record<string, any>[] | undefined;
+    schema?: Record<string, any>[] | undefined;
+    todoMode?: boolean | undefined;
+    copyFromListId?: string | undefined;
+    includeCopiedListRecords?: boolean | undefined;
+}, any>;
+export declare const slackCreateListItem: import("ai").Tool<{
+    listId: string;
+    slackToken?: string | undefined;
+    initialFields?: Record<string, any>[] | undefined;
+    parentItemId?: string | undefined;
+    duplicatedItemId?: string | undefined;
+}, any>;
+export declare const slackGetListItem: import("ai").Tool<{
+    id: string;
+    listId: string;
+    slackToken?: string | undefined;
+    includeIsSubscribed?: boolean | undefined;
+}, any>;
+export declare const slackListListItems: import("ai").Tool<{
+    listId: string;
+    limit?: number | undefined;
+    archived?: boolean | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackUpdateList: import("ai").Tool<{
+    id: string;
+    name?: string | undefined;
+    slackToken?: string | undefined;
+    descriptionBlocks?: string | Record<string, any> | Record<string, any>[] | undefined;
+    todoMode?: boolean | undefined;
+}, any>;
+export declare const slackUpdateListItem: import("ai").Tool<{
+    listId: string;
+    cells: Record<string, any>[];
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackDeleteListItem: import("ai").Tool<{
+    id: string;
+    listId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackDeleteListItems: import("ai").Tool<{
+    ids: string[];
+    listId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetListAccess: import("ai").Tool<{
+    listId: string;
+    accessLevel: string;
+    slackToken?: string | undefined;
+    userIds?: string[] | undefined;
+    channelIds?: string[] | undefined;
+}, any>;
+export declare const slackDeleteListAccess: import("ai").Tool<{
+    listId: string;
+    slackToken?: string | undefined;
+    userIds?: string[] | undefined;
+    channelIds?: string[] | undefined;
+}, any>;
+//# sourceMappingURL=slack-lists.d.ts.map

package/dist/toolkits/slack/tools/slack-lists.js

@@ -0,0 +1,282 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+function toRichText(value) {
+    if (typeof value === 'string') {
+        return [
+            {
+                type: 'rich_text',
+                elements: [{ type: 'rich_text_section', elements: [{ type: 'text', text: value }] }],
+            },
+        ];
+    }
+    return value;
+}
+export const slackCreateList = tool({
+    description: 'Create a Slack List with a name, optional rich-text description, typed columns, or by copying another List (with optional rows), or in to-do task mode. Returns the list_id. Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        name: z.string().describe('List title, e.g. Sprint Tasks'),
+        descriptionBlocks: z.union([z.string(), z.record(z.any()), z.array(z.record(z.any()))]).optional().describe('Description (plain string auto-wrapped to rich_text, or blocks)'),
+        schema: z.array(z.record(z.any())).optional().describe('Column definitions (name, type, options)'),
+        todoMode: z.boolean().optional().describe('Add built-in task-tracking columns'),
+        copyFromListId: z.string().optional().describe('Copy column structure from this List ID'),
+        includeCopiedListRecords: z.boolean().optional().describe('Also copy rows (requires copyFromListId)'),
+    }),
+    execute: async ({ slackToken, name, descriptionBlocks, schema, todoMode, copyFromListId, includeCopiedListRecords }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'slackLists.create', {
+                name,
+                description_blocks: descriptionBlocks,
+                schema,
+                todo_mode: todoMode,
+                copy_from_list_id: copyFromListId,
+                include_copied_list_records: includeCopiedListRecords,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to create Slack List');
+        }
+    },
+});
+export const slackCreateListItem = tool({
+    description: 'Add a row to a Slack List with initial cell values. Text cells accept plain strings (auto-wrapped to rich_text); selects take choice values like ["todo"]. Copy a row via duplicatedItemId or nest via parentItemId. Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        listId: z.string().describe('List ID, e.g. F0123456789'),
+        initialFields: z.array(z.record(z.any())).optional().describe('Cells: {column_id, text|select|user|date|number|checkbox,...}'),
+        parentItemId: z.string().optional().describe('Create as a subtask of this row ID'),
+        duplicatedItemId: z.string().optional().describe('Copy this existing row ID'),
+    }),
+    execute: async ({ slackToken, listId, initialFields, parentItemId, duplicatedItemId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            const fields = (initialFields ?? []).map((cell) => {
+                if (cell && typeof cell.text === 'string' && !cell.rich_text) {
+                    const { text, ...rest } = cell;
+                    return { ...rest, rich_text: toRichText(text) };
+                }
+                return cell;
+            });
+            return await slackApi(slackToken, 'slackLists.items.create', {
+                list_id: listId,
+                initial_fields: fields.length ? fields : undefined,
+                parent_item_id: parentItemId,
+                duplicated_item_id: duplicatedItemId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to create Slack List item');
+        }
+    },
+});
+export const slackGetListItem = tool({
+    description: 'Read one List row with column_id-keyed typed values and parent List metadata. Optionally include subscription status. Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        listId: z.string().describe('List ID holding the row'),
+        id: z.string().describe('Row ID, e.g. Rec0123456789'),
+        includeIsSubscribed: z.boolean().optional().describe('Include whether the caller is subscribed to the row'),
+    }),
+    execute: async ({ slackToken, listId, id, includeIsSubscribed }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'slackLists.items.info', {
+                list_id: listId,
+                id,
+                include_is_subscribed: includeIsSubscribed,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get Slack List item');
+        }
+    },
+});
+export const slackListListItems = tool({
+    description: 'List rows in a Slack List. You must paginate on response_metadata.next_cursor until empty or rows are silently truncated. Set archived=true for archived rows. Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        listId: z.string().describe('List ID to read rows from'),
+        limit: z.number().optional().describe('Rows per page (e.g. 100)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        archived: z.boolean().optional().describe('List archived rows instead of active ones'),
+    }),
+    execute: async ({ slackToken, listId, limit, cursor, archived }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'slackLists.items.list', {
+                list_id: listId,
+                limit,
+                cursor,
+                archived,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list Slack List items');
+        }
+    },
+});
+export const slackUpdateList = tool({
+    description: 'Edit a List name, description, or to-do mode. Identify the List by id (not list_id). Description strings are auto-wrapped to rich_text. Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('List ID, e.g. F0123456789'),
+        name: z.string().optional().describe('New title (omit to keep)'),
+        descriptionBlocks: z.union([z.string(), z.record(z.any()), z.array(z.record(z.any()))]).optional().describe('New description'),
+        todoMode: z.boolean().optional().describe('Toggle to-do task mode'),
+    }),
+    execute: async ({ slackToken, id, name, descriptionBlocks, todoMode }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'slackLists.update', {
+                id,
+                name,
+                description_blocks: descriptionBlocks,
+                todo_mode: todoMode,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to update Slack List');
+        }
+    },
+});
+export const slackUpdateListItem = tool({
+    description: 'Update cells of EXISTING List rows (row_id must match ^Rec[A-Z0-9]{8,}$). Text cells accept plain strings; selects take choice values. To add rows use slackCreateListItem. Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        listId: z.string().describe('List ID containing the rows'),
+        cells: z.array(z.record(z.any())).describe('Cells: {row_id, column_id, text|select|user|date|number|checkbox,...}'),
+    }),
+    execute: async ({ slackToken, listId, cells }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            const normalized = (cells ?? []).map((cell) => {
+                if (cell && typeof cell.text === 'string' && !cell.rich_text) {
+                    const { text, ...rest } = cell;
+                    return { ...rest, rich_text: toRichText(text) };
+                }
+                return cell;
+            });
+            return await slackApi(slackToken, 'slackLists.items.update', {
+                list_id: listId,
+                cells: normalized,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to update Slack List item');
+        }
+    },
+});
+export const slackDeleteListItem = tool({
+    description: 'Permanently delete one List row by List ID and row ID. Cannot be undone — confirm with the user first. Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        listId: z.string().describe('List ID holding the row'),
+        id: z.string().describe('Row ID, e.g. Rec0123456789'),
+    }),
+    execute: async ({ slackToken, listId, id }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'slackLists.items.delete', { list_id: listId, id });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete Slack List item');
+        }
+    },
+});
+export const slackDeleteListItems = tool({
+    description: 'Delete multiple List rows in one all-or-nothing call. On failure treat the whole batch as not deleted and retry it entirely. Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        listId: z.string().describe('List ID to delete rows from'),
+        ids: z.array(z.string()).describe('Row IDs, e.g. ["Rec0123456789","Rec9876543210"]'),
+    }),
+    execute: async ({ slackToken, listId, ids }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'slackLists.items.deleteMultiple', { list_id: listId, ids });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete Slack List items');
+        }
+    },
+});
+export const slackSetListAccess = tool({
+    description: 'Share a List with channels or users at read/write/owner level. Provide exactly one of channelIds or userIds (owner requires userIds). Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        listId: z.string().describe('List ID to share'),
+        accessLevel: z.string().describe("One of 'read', 'write', or 'owner' (owner is user-only)"),
+        channelIds: z.array(z.string()).optional().describe('Channel IDs to share with'),
+        userIds: z.array(z.string()).optional().describe('User IDs to share with'),
+    }),
+    execute: async ({ slackToken, listId, accessLevel, channelIds, userIds }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            if ((channelIds && userIds) || (!channelIds && !userIds)) {
+                return { error: 'Provide exactly one of channelIds or userIds.' };
+            }
+            if (accessLevel === 'owner' && !userIds) {
+                return { error: "The 'owner' level requires userIds (not channelIds)." };
+            }
+            return await slackApi(slackToken, 'slackLists.access.set', {
+                list_id: listId,
+                access_level: accessLevel,
+                channel_ids: channelIds,
+                user_ids: userIds,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set Slack List access');
+        }
+    },
+});
+export const slackDeleteListAccess = tool({
+    description: 'Revoke List sharing for channels or users. Provide exactly one of channelIds or userIds. Requires a user token.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        listId: z.string().describe('List ID to revoke access on'),
+        channelIds: z.array(z.string()).optional().describe('Channel IDs to revoke'),
+        userIds: z.array(z.string()).optional().describe('User IDs to revoke'),
+    }),
+    execute: async ({ slackToken, listId, channelIds, userIds }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            if ((channelIds && userIds) || (!channelIds && !userIds)) {
+                return { error: 'Provide exactly one of channelIds or userIds.' };
+            }
+            return await slackApi(slackToken, 'slackLists.access.delete', {
+                list_id: listId,
+                channel_ids: channelIds,
+                user_ids: userIds,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete Slack List access');
+        }
+    },
+});
+//# sourceMappingURL=slack-lists.js.map

package/dist/toolkits/slack/tools/teams.d.ts

@@ -0,0 +1,75 @@
+export declare const slackGetTeamInfo: import("ai").Tool<{
+    team?: string | undefined;
+    domain?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetTeamProfile: import("ai").Tool<{
+    teamId?: string | undefined;
+    visibility?: "all" | "visible" | "hidden" | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackListAuthTeams: import("ai").Tool<{
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    includeIcon?: boolean | undefined;
+}, any>;
+export declare const slackListAvailableWorkspaces: import("ai").Tool<{
+    user: string;
+    slackToken?: string | undefined;
+}, {
+    error: string;
+} | {
+    ok: boolean;
+    available_workspaces: any;
+    total_count: any;
+}>;
+export declare const slackCreateEnterpriseTeam: import("ai").Tool<{
+    teamName: string;
+    teamDomain: string;
+    slackToken?: string | undefined;
+    teamDescription?: string | undefined;
+    teamDiscoverability?: "open" | "closed" | "unlisted" | "invite_only" | undefined;
+}, any>;
+export declare const slackListEnterpriseTeams: import("ai").Tool<{
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackListWorkspaceAdmins: import("ai").Tool<{
+    teamId: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackListWorkspaceOwners: import("ai").Tool<{
+    teamId: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetWorkspaceSettings: import("ai").Tool<{
+    teamId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetWorkspaceName: import("ai").Tool<{
+    teamId: string;
+    name: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetWorkspaceDescription: import("ai").Tool<{
+    description: string;
+    teamId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetWorkspaceIcon: import("ai").Tool<{
+    teamId: string;
+    imageUrl: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetWorkspaceDefaultChannels: import("ai").Tool<{
+    teamId: string;
+    channelIds: string | string[];
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=teams.d.ts.map