@rnsk/toolkits 0.0.11 → 0.0.12

package/dist/toolkits/wordpress/tools/list-cms-resources.d.ts

@@ -0,0 +1,45 @@
+export declare const wordpressListCmsResources: import("ai").Tool<{
+    resource: "categories" | "users" | "comments" | "tags" | "media";
+    wordpressToken: string;
+    siteId: number;
+    pageSize?: number | undefined;
+    search?: string | undefined;
+    cursor?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    resource?: undefined;
+    items?: undefined;
+    hasMore?: undefined;
+    nextCursor?: undefined;
+    total?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    resource?: undefined;
+    items?: undefined;
+    hasMore?: undefined;
+    nextCursor?: undefined;
+    total?: undefined;
+    message?: undefined;
+} | {
+    resource: "categories" | "users" | "comments" | "tags" | "media";
+    items: any;
+    hasMore: boolean;
+    nextCursor: null;
+    total: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    resource?: undefined;
+    items?: undefined;
+    hasMore?: undefined;
+    nextCursor?: undefined;
+    total?: undefined;
+}>;
+//# sourceMappingURL=list-cms-resources.d.ts.map

package/dist/toolkits/wordpress/tools/list-cms-resources.js

@@ -0,0 +1,77 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { wpFetch } from './utils.js';
+export const wordpressListCmsResources = tool({
+    description: 'List categories, tags, comments, media, or users for an authorized site through one consistent paginated read tool.',
+    inputSchema: z.object({
+        wordpressToken: z.string().describe('WordPress.com OAuth access token.'),
+        siteId: z.number().describe('Numeric site ID returned by WORDPRESS_COM_LIST_SITES.'),
+        resource: z.enum(['categories', 'tags', 'comments', 'media', 'users']).describe('CMS resource collection to list.'),
+        search: z.string().optional().describe('Limit results to records matching this text where the resource supports search.'),
+        cursor: z.string().optional().describe('Opaque continuation cursor returned by a previous call.'),
+        pageSize: z.number().min(1).max(100).optional().describe('Maximum resources in this page.'),
+    }),
+    execute: async ({ wordpressToken, siteId, resource, search, cursor, pageSize }) => {
+        if (!wordpressToken)
+            return { error: 'WordPress token is required. Connect WordPress.com first.' };
+        try {
+            let path = '';
+            const query = { number: pageSize ?? 20, search, offset: cursor };
+            // WordPress.com REST mapping
+            switch (resource) {
+                case 'categories':
+                    path = `/rest/v1.1/sites/${siteId}/categories`;
+                    break;
+                case 'tags':
+                    path = `/rest/v1.1/sites/${siteId}/tags`;
+                    query.number = pageSize;
+                    break;
+                case 'comments':
+                    path = `/rest/v1.1/sites/${siteId}/comments`;
+                    query.number = pageSize;
+                    query.status = 'all';
+                    if (search)
+                        query.search = search;
+                    break;
+                case 'media':
+                    path = `/rest/v1.1/sites/${siteId}/media`;
+                    query.number = pageSize;
+                    if (search)
+                        query.search = search;
+                    break;
+                case 'users':
+                    path = `/rest/v1.1/sites/${siteId}/users`;
+                    query.number = pageSize;
+                    if (search)
+                        query.search = search;
+                    break;
+                default:
+                    return { error: `Unknown resource ${resource}` };
+            }
+            const res = await wpFetch(path, { wordpressToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: `Failed to list ${resource}`, details: res.data };
+            const data = res.data;
+            const items = data.categories ?? data.tags ?? data.comments ?? data.media ?? data.users ?? data.found ? Object.values(data) : data.users ?? data.media ?? data.comments ?? [];
+            // Fallback generic
+            const normalizedItems = Array.isArray(data) ? data : data.categories ?? data.tags ?? data.media ?? data.comments ?? data.users ?? data.found ?? [];
+            const actualItems = Array.isArray(normalizedItems) ? normalizedItems : [];
+            // Try alternative shape
+            const finalItems = actualItems.length ? actualItems : (Array.isArray(data) ? data : []);
+            // For categories/tags, ensure resource field
+            const enriched = finalItems.map((it) => ({ resource, ...it }));
+            return {
+                resource,
+                items: enriched.length ? enriched : (data.categories ?? data.tags ?? []),
+                hasMore: data.meta?.next_page ? true : false,
+                nextCursor: data.meta?.next_page ?? data.found ? null : null,
+                total: data.found ?? data.total ?? undefined,
+            };
+        }
+        catch (e) {
+            return { error: 'Error listing CMS resources', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-cms-resources.js.map

package/dist/toolkits/wordpress/tools/list-content.d.ts

@@ -0,0 +1,49 @@
+export declare const wordpressListContent: import("ai").Tool<{
+    contentType: "pages" | "posts";
+    wordpressToken: string;
+    siteId: number;
+    pageSize?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    search?: string | undefined;
+    statuses?: string[] | undefined;
+    orderBy?: "date" | "title" | "id" | "modified" | "slug" | "relevance" | undefined;
+    cursor?: string | undefined;
+    authorId?: number | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    items?: undefined;
+    hasMore?: undefined;
+    nextCursor?: undefined;
+    total?: undefined;
+    totalPages?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    items?: undefined;
+    hasMore?: undefined;
+    nextCursor?: undefined;
+    total?: undefined;
+    totalPages?: undefined;
+    message?: undefined;
+} | {
+    items: any;
+    hasMore: boolean;
+    nextCursor: any;
+    total: any;
+    totalPages: number | undefined;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    items?: undefined;
+    hasMore?: undefined;
+    nextCursor?: undefined;
+    total?: undefined;
+    totalPages?: undefined;
+}>;
+//# sourceMappingURL=list-content.d.ts.map

package/dist/toolkits/wordpress/tools/list-content.js

@@ -0,0 +1,71 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { wpFetch } from './utils.js';
+export const wordpressListContent = tool({
+    description: 'List and search editable posts or pages on an authorized site, including drafts, with compact raw and rendered content fields and agent-controlled pagination.',
+    inputSchema: z.object({
+        wordpressToken: z.string().describe('WordPress.com OAuth access token.'),
+        siteId: z.number().describe('Numeric site ID returned by WORDPRESS_COM_LIST_SITES.'),
+        contentType: z.enum(['posts', 'pages']).describe('Content collection to list: posts or pages.'),
+        search: z.string().optional().describe('Limit results to content matching this text.'),
+        statuses: z.array(z.string()).optional().describe('Filter by provider-defined status names such as draft, pending, private, future, or publish.'),
+        authorId: z.number().optional().describe('Limit results to one author ID.'),
+        orderBy: z.enum(['date', 'id', 'modified', 'relevance', 'slug', 'title']).optional().describe('Field used to sort results.'),
+        order: z.enum(['asc', 'desc']).optional().describe('Sort direction.'),
+        cursor: z.string().optional().describe('Opaque continuation cursor returned by a previous call.'),
+        pageSize: z.number().min(1).max(100).optional().describe('Maximum content items in this page.'),
+    }),
+    execute: async ({ wordpressToken, siteId, contentType, search, statuses, authorId, orderBy, order, cursor, pageSize }) => {
+        if (!wordpressToken)
+            return { error: 'WordPress token is required. Connect WordPress.com first.' };
+        try {
+            const path = contentType === 'pages' ? `/rest/v1.1/sites/${siteId}/pages` : `/rest/v1.1/sites/${siteId}/posts`;
+            const query = {
+                number: pageSize ?? 20,
+                search,
+                status: statuses?.join(','),
+                author: authorId,
+                order_by: orderBy,
+                order,
+                offset: cursor,
+                context: 'edit',
+            };
+            const res = await wpFetch(path, { wordpressToken, method: 'GET', query });
+            if (!res.ok)
+                return { error: `Failed to list ${contentType}`, details: res.data };
+            const data = res.data;
+            const itemsRaw = data.posts ?? data.pages ?? data.found ? data.posts ?? data.pages : [];
+            const items = (itemsRaw ?? []).map((p) => ({
+                id: p.ID ?? p.id,
+                type: p.type ?? contentType.slice(0, -1),
+                status: p.status,
+                title: p.title,
+                content: p.content,
+                excerpt: p.excerpt,
+                slug: p.slug,
+                link: p.URL ?? p.link,
+                date: p.date,
+                modified: p.modified,
+                authorId: p.author?.ID ?? p.author_id,
+                parent: p.parent?.ID ?? p.parent ?? 0,
+                categoryIds: p.categories ? Object.keys(p.categories).map(Number) : undefined,
+                tagIds: p.tags ? Object.keys(p.tags).map(Number) : undefined,
+                featuredMediaId: p.featured_image ?? 0,
+                commentStatus: p.discussion?.comment_status,
+                menuOrder: p.menu_order,
+            }));
+            return {
+                items,
+                hasMore: !!data.meta?.next_page || (data.found != null && items.length < data.found),
+                nextCursor: data.meta?.next_page ?? null,
+                total: data.found ?? undefined,
+                totalPages: data.found && pageSize ? Math.ceil(data.found / (pageSize ?? 20)) : undefined,
+            };
+        }
+        catch (e) {
+            return { error: 'Error listing content', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-content.js.map

package/dist/toolkits/wordpress/tools/list-reader-subscriptions.d.ts

@@ -0,0 +1,24 @@
+export declare const wordpressListReaderSubscriptions: import("ai").Tool<{
+    wordpressToken: string;
+}, {
+    error: string;
+    details?: undefined;
+    subscriptions?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    subscriptions?: undefined;
+    message?: undefined;
+} | {
+    subscriptions: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    subscriptions?: undefined;
+}>;
+//# sourceMappingURL=list-reader-subscriptions.d.ts.map

package/dist/toolkits/wordpress/tools/list-reader-subscriptions.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { wpFetch } from './utils.js';
+export const wordpressListReaderSubscriptions = tool({
+    description: 'List feeds and sites followed by the connected WordPress.com account without changing subscriptions.',
+    inputSchema: z.object({
+        wordpressToken: z.string().describe('WordPress.com OAuth access token.'),
+    }),
+    execute: async ({ wordpressToken }) => {
+        if (!wordpressToken)
+            return { error: 'WordPress token is required. Connect WordPress.com first.' };
+        try {
+            const res = await wpFetch('/rest/v1.1/read/following/mine', {
+                wordpressToken,
+                method: 'GET',
+            });
+            if (!res.ok)
+                return { error: 'Failed to list reader subscriptions', details: res.data };
+            const data = res.data;
+            const subs = data.subscriptions ?? data.feeds ?? data.sites ?? [];
+            const normalized = (Array.isArray(subs) ? subs : []).map((s) => ({
+                subscriptionId: String(s.ID ?? s.subscription_id ?? s.feed_ID ?? ''),
+                blogId: String(s.blog_ID ?? s.blog_id ?? s.feed_ID ?? '0'),
+                url: s.URL ?? s.url ?? s.feed_url ?? '',
+                title: s.name ?? s.title ?? '',
+                feedUrl: s.feed_URL ?? s.feed_url ?? '',
+                siteIcon: s.site_icon ?? s.icon ?? '',
+            }));
+            return {
+                subscriptions: normalized.length ? normalized : subs,
+            };
+        }
+        catch (e) {
+            return { error: 'Error listing reader subscriptions', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-reader-subscriptions.js.map

package/dist/toolkits/wordpress/tools/list-sites.d.ts

@@ -0,0 +1,26 @@
+export declare const wordpressListSites: import("ai").Tool<{
+    wordpressToken: string;
+    visibility?: "all" | "visible" | "hidden" | undefined;
+    activity?: "all" | "active" | "inactive" | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    sites?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    sites?: undefined;
+    message?: undefined;
+} | {
+    sites: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    sites?: undefined;
+}>;
+//# sourceMappingURL=list-sites.d.ts.map

package/dist/toolkits/wordpress/tools/list-sites.js

@@ -0,0 +1,69 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { wpFetch } from './utils.js';
+export const wordpressListSites = tool({
+    description: 'List every WordPress.com or Jetpack-connected site authorized by the global OAuth account, returning stable numeric site IDs and concise capability and plan summaries for use with other tools.',
+    inputSchema: z.object({
+        wordpressToken: z.string().describe('WordPress.com OAuth access token.'),
+        activity: z.enum(['all', 'active', 'inactive']).optional().describe('Include all sites or filter by active or inactive status.'),
+        visibility: z.enum(['all', 'visible', 'hidden']).optional().describe("Include all authorized sites or only sites visible or hidden in the user's site list."),
+    }),
+    execute: async ({ wordpressToken, activity, visibility }) => {
+        if (!wordpressToken)
+            return { error: 'WordPress token is required. Connect WordPress.com first.' };
+        try {
+            const res = await wpFetch('/rest/v1.1/me/sites', {
+                wordpressToken,
+                method: 'GET',
+                query: {
+                    site_visibility: visibility,
+                },
+            });
+            if (!res.ok)
+                return { error: 'Failed to list sites', details: res.data };
+            const data = res.data;
+            const sitesRaw = data.sites ?? [];
+            let filtered = sitesRaw;
+            // Activity filter is not a query param; filter locally if needed
+            if (activity && activity !== 'all') {
+                // No direct activity field; keep all
+            }
+            if (visibility && visibility !== 'all') {
+                filtered = filtered.filter((s) => (visibility === 'visible' ? s.visible !== false : s.visible === false));
+            }
+            const sites = filtered.map((s) => ({
+                siteId: s.ID ?? s.site_id,
+                name: s.name,
+                url: s.URL ?? s.url,
+                isPrivate: s.is_private ?? false,
+                visible: s.visible ?? true,
+                jetpack: s.jetpack ?? false,
+                isAtomic: s.is_wpcom_atomic ?? s.is_atomic ?? false,
+                userCanManage: s.user_can_manage ?? s.capabilities?.manage_options ?? false,
+                plan: {
+                    productName: s.plan?.product_name ?? s.plan?.product_name_pretty,
+                    productSlug: s.plan?.product_slug,
+                    isFree: s.plan?.is_free ?? false,
+                },
+                capabilities: {
+                    editPosts: s.capabilities?.edit_posts ?? false,
+                    editPages: s.capabilities?.edit_pages ?? false,
+                    deletePosts: s.capabilities?.delete_posts ?? false,
+                    publishPosts: s.capabilities?.publish_posts ?? false,
+                    uploadFiles: s.capabilities?.upload_files ?? false,
+                    manageCategories: s.capabilities?.manage_categories ?? false,
+                    manageOptions: s.capabilities?.manage_options ?? false,
+                    moderateComments: s.capabilities?.moderate_comments ?? false,
+                    listUsers: s.capabilities?.list_users ?? false,
+                    viewStats: s.capabilities?.view_stats ?? false,
+                },
+            }));
+            return { sites };
+        }
+        catch (e) {
+            return { error: 'Error listing sites', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-sites.js.map

package/dist/toolkits/wordpress/tools/update-draft-post.d.ts

@@ -0,0 +1,51 @@
+export declare const wordpressUpdateDraftPost: import("ai").Tool<{
+    postId: number;
+    wordpressToken: string;
+    siteId: number;
+    title?: string | undefined;
+    content?: string | undefined;
+    categoryIds?: number[] | undefined;
+    excerpt?: string | undefined;
+    tagIds?: number[] | undefined;
+    featuredMediaId?: number | undefined;
+    commentStatus?: "open" | "closed" | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    post?: undefined;
+    updatedFields?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    post?: undefined;
+    updatedFields?: undefined;
+    message?: undefined;
+} | {
+    post: {
+        id: any;
+        status: any;
+        title: any;
+        content: any;
+        excerpt: any;
+        slug: any;
+        link: any;
+        modified: any;
+        authorId: any;
+        categoryIds: number[] | undefined;
+        tagIds: number[] | undefined;
+        featuredMediaId: any;
+        commentStatus: any;
+    };
+    updatedFields: string[];
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    post?: undefined;
+    updatedFields?: undefined;
+}>;
+//# sourceMappingURL=update-draft-post.d.ts.map

package/dist/toolkits/wordpress/tools/update-draft-post.js

@@ -0,0 +1,93 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { wpFetch } from './utils.js';
+export const wordpressUpdateDraftPost = tool({
+    description: 'Update title, body, excerpt, taxonomy, featured media, or comment policy for an existing draft. Provide at least one field to update. The tool refuses to modify a post whose current status is not draft.',
+    inputSchema: z.object({
+        wordpressToken: z.string().describe('WordPress.com OAuth access token.'),
+        siteId: z.number().describe('Numeric site ID returned by WORDPRESS_COM_LIST_SITES.'),
+        postId: z.number().describe('ID of a draft post to update.'),
+        title: z.string().optional().describe('Replacement draft title.'),
+        content: z.string().optional().describe('Replacement draft body as HTML or WordPress block markup.'),
+        excerpt: z.string().optional().describe('Replacement excerpt.'),
+        categoryIds: z.array(z.number()).optional().describe('Replacement category IDs; use an empty list to clear them.'),
+        tagIds: z.array(z.number()).optional().describe('Replacement tag IDs; use an empty list to clear them.'),
+        featuredMediaId: z.number().optional().describe('Replacement featured media ID; use 0 to remove it.'),
+        commentStatus: z.enum(['open', 'closed']).optional().describe('Replacement comment policy.'),
+    }),
+    execute: async ({ wordpressToken, siteId, postId, title, content, excerpt, categoryIds, tagIds, featuredMediaId, commentStatus }) => {
+        if (!wordpressToken)
+            return { error: 'WordPress token is required. Connect WordPress.com first.' };
+        if (title === undefined &&
+            content === undefined &&
+            excerpt === undefined &&
+            categoryIds === undefined &&
+            tagIds === undefined &&
+            featuredMediaId === undefined &&
+            commentStatus === undefined) {
+            return { error: 'Provide at least one field to update: title, content, excerpt, categoryIds, tagIds, featuredMediaId, or commentStatus' };
+        }
+        try {
+            // Verify draft status
+            const getRes = await wpFetch(`/rest/v1.1/sites/${siteId}/posts/${postId}`, {
+                wordpressToken,
+                method: 'GET',
+                query: { context: 'edit' },
+            });
+            if (!getRes.ok)
+                return { error: 'Failed to fetch post for verification', details: getRes.data };
+            const existing = getRes.data;
+            const status = existing.status;
+            if (status && status !== 'draft') {
+                return { error: `Refusing to update post with status '${status}'. Only draft posts can be updated with this tool.`, details: existing };
+            }
+            const body = {};
+            if (title !== undefined)
+                body.title = title;
+            if (content !== undefined)
+                body.content = content;
+            if (excerpt !== undefined)
+                body.excerpt = excerpt;
+            if (categoryIds !== undefined)
+                body.categories = categoryIds;
+            if (tagIds !== undefined)
+                body.tags = tagIds;
+            if (featuredMediaId !== undefined)
+                body.featured_image = featuredMediaId;
+            if (commentStatus !== undefined)
+                body.discussion = { comment_status: commentStatus };
+            const res = await wpFetch(`/rest/v1.1/sites/${siteId}/posts/${postId}`, {
+                wordpressToken,
+                method: 'POST',
+                body,
+            });
+            if (!res.ok)
+                return { error: 'Failed to update draft post', details: res.data };
+            const p = res.data;
+            const updatedFields = Object.keys(body);
+            return {
+                post: {
+                    id: p.ID ?? p.id ?? postId,
+                    status: p.status ?? 'draft',
+                    title: p.title,
+                    content: p.content,
+                    excerpt: p.excerpt,
+                    slug: p.slug,
+                    link: p.URL ?? p.link,
+                    modified: p.modified,
+                    authorId: p.author?.ID,
+                    categoryIds: p.categories ? Object.keys(p.categories).map(Number) : categoryIds,
+                    tagIds: p.tags ? Object.keys(p.tags).map(Number) : tagIds,
+                    featuredMediaId: p.featured_image ?? featuredMediaId,
+                    commentStatus: p.discussion?.comment_status ?? commentStatus,
+                },
+                updatedFields,
+            };
+        }
+        catch (e) {
+            return { error: 'Error updating draft post', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=update-draft-post.js.map

package/dist/toolkits/wordpress/tools/utils.d.ts

@@ -0,0 +1,18 @@
+export declare const WP_API_BASE = "https://public-api.wordpress.com";
+export declare function wpFetch(path: string, { wordpressToken, method, query, body, }: {
+    wordpressToken: string;
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}): Promise<{
+    ok: false;
+    status: number;
+    data: any;
+    error: any;
+} | {
+    ok: true;
+    status: number;
+    data: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/toolkits/wordpress/tools/utils.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+export const WP_API_BASE = 'https://public-api.wordpress.com';
+export async function wpFetch(path, { wordpressToken, method = 'GET', query, body, }) {
+    const url = new URL(`${WP_API_BASE}${path}`);
+    if (query) {
+        Object.entries(query).forEach(([k, v]) => {
+            if (v !== undefined && v !== null && v !== '')
+                url.searchParams.set(k, String(v));
+        });
+    }
+    const headers = {
+        Authorization: `Bearer ${wordpressToken}`,
+        'Content-Type': 'application/json',
+    };
+    const res = await fetch(url.toString(), {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    const text = await res.text();
+    let data;
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = { raw: text };
+    }
+    if (!res.ok) {
+        return { ok: false, status: res.status, data, error: data };
+    }
+    return { ok: true, status: res.status, data };
+}
+//# sourceMappingURL=utils.js.map

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

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