@rnsk/toolkits 0.0.6 → 0.0.8

package/dist/toolkits/google-search-console/tools/get-site.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeSiteUrl, webmastersRequest } from './utils.js';
+export const getSite = tool({
+    description: 'Retrieve metadata for a site property in Google Search Console.',
+    inputSchema: z.object({
+        googleSearchConsoleToken: z.string().describe('The Google Search Console access token'),
+        site_url: z.string().describe('The Search Console property URL to retrieve'),
+    }),
+    execute: async ({ googleSearchConsoleToken, site_url }) => {
+        try {
+            const result = await webmastersRequest(googleSearchConsoleToken, `/sites/${encodeSiteUrl(site_url)}`);
+            if (!result.ok) {
+                return { error: 'Failed to get site', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting site',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-site.js.map

package/dist/toolkits/google-search-console/tools/get-sitemap.d.ts

@@ -0,0 +1,6 @@
+export declare const getSitemap: import("ai").Tool<{
+    googleSearchConsoleToken: string;
+    site_url: string;
+    feedpath: string;
+}, any>;
+//# sourceMappingURL=get-sitemap.d.ts.map

package/dist/toolkits/google-search-console/tools/get-sitemap.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeFeedpath, encodeSiteUrl, webmastersRequest } from './utils.js';
+export const getSitemap = tool({
+    description: 'Retrieve information about a specific sitemap submitted for a site.',
+    inputSchema: z.object({
+        googleSearchConsoleToken: z.string().describe('The Google Search Console access token'),
+        site_url: z.string().describe('The site URL including protocol (e.g. https://www.example.com/)'),
+        feedpath: z.string().describe('The URL of the sitemap (e.g. https://www.example.com/sitemap.xml)'),
+    }),
+    execute: async ({ googleSearchConsoleToken, site_url, feedpath }) => {
+        try {
+            const result = await webmastersRequest(googleSearchConsoleToken, `/sites/${encodeSiteUrl(site_url)}/sitemaps/${encodeFeedpath(feedpath)}`);
+            if (!result.ok) {
+                return { error: 'Failed to get sitemap', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting sitemap',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-sitemap.js.map

package/dist/toolkits/google-search-console/tools/index.d.ts

@@ -0,0 +1,178 @@
+import { addSite } from './add-site.js';
+import { deleteSite } from './delete-site.js';
+import { getSite } from './get-site.js';
+import { getSitemap } from './get-sitemap.js';
+import { inspectUrl } from './inspect-url.js';
+import { listSitemaps } from './list-sitemaps.js';
+import { listSites } from './list-sites.js';
+import { searchAnalyticsQuery } from './search-analytics-query.js';
+import { submitSitemap } from './submit-sitemap.js';
+export { addSite, deleteSite, getSite, getSitemap, inspectUrl, listSitemaps, listSites, searchAnalyticsQuery, submitSitemap, };
+export declare const googleSearchConsoleTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSearchConsoleToken: string;
+        site_url: string;
+    }, {
+        error: string;
+        details: any;
+        statusCode: number;
+        success?: undefined;
+        site_url?: undefined;
+        data?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        site_url: string;
+        data: any;
+        error?: undefined;
+        details?: undefined;
+        statusCode?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        statusCode?: undefined;
+        success?: undefined;
+        site_url?: undefined;
+        data?: undefined;
+    }>;
+    requiredAuth: "googleSearchConsoleToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSearchConsoleToken: string;
+        site_url: string;
+    }, {
+        error: string;
+        details: any;
+        statusCode: number;
+        success?: undefined;
+        site_url?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        site_url: string;
+        error?: undefined;
+        details?: undefined;
+        statusCode?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        statusCode?: undefined;
+        success?: undefined;
+        site_url?: undefined;
+    }>;
+    requiredAuth: "googleSearchConsoleToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSearchConsoleToken: string;
+        site_url: string;
+    }, any>;
+    requiredAuth: "googleSearchConsoleToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSearchConsoleToken: string;
+        site_url: string;
+        feedpath: string;
+    }, any>;
+    requiredAuth: "googleSearchConsoleToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSearchConsoleToken: string;
+        site_url: string;
+        inspection_url: string;
+        language_code?: string | undefined;
+    }, any>;
+    requiredAuth: "googleSearchConsoleToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSearchConsoleToken: string;
+        site_url: string;
+        sitemap_index?: string | undefined;
+    }, any>;
+    requiredAuth: "googleSearchConsoleToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSearchConsoleToken: string;
+    }, any>;
+    requiredAuth: "googleSearchConsoleToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSearchConsoleToken: string;
+        site_url: string;
+        start_date: string;
+        end_date: string;
+        dimensions?: string[] | undefined;
+        search_type?: "video" | "web" | "image" | "news" | "discover" | "googleNews" | undefined;
+        aggregation_type?: "auto" | "byPage" | "byProperty" | undefined;
+        row_limit?: number | undefined;
+        start_row?: number | undefined;
+        data_state?: "all" | "final" | undefined;
+        dimension_filter_groups?: Record<string, unknown>[] | undefined;
+    }, any>;
+    requiredAuth: "googleSearchConsoleToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSearchConsoleToken: string;
+        site_url: string;
+        feedpath: string;
+    }, {
+        error: string;
+        details: any;
+        statusCode: number;
+        success?: undefined;
+        site_url?: undefined;
+        feedpath?: undefined;
+        data?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        site_url: string;
+        feedpath: string;
+        data: any;
+        error?: undefined;
+        details?: undefined;
+        statusCode?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        statusCode?: undefined;
+        success?: undefined;
+        site_url?: undefined;
+        feedpath?: undefined;
+        data?: undefined;
+    }>;
+    requiredAuth: "googleSearchConsoleToken";
+    scope: "write";
+})[];
+//# sourceMappingURL=index.d.ts.map

package/dist/toolkits/google-search-console/tools/index.js

@@ -0,0 +1,77 @@
+// @ts-nocheck
+import { addSite } from './add-site.js';
+import { deleteSite } from './delete-site.js';
+import { getSite } from './get-site.js';
+import { getSitemap } from './get-sitemap.js';
+import { inspectUrl } from './inspect-url.js';
+import { listSitemaps } from './list-sitemaps.js';
+import { listSites } from './list-sites.js';
+import { searchAnalyticsQuery } from './search-analytics-query.js';
+import { submitSitemap } from './submit-sitemap.js';
+export { addSite, deleteSite, getSite, getSitemap, inspectUrl, listSitemaps, listSites, searchAnalyticsQuery, submitSitemap, };
+export const googleSearchConsoleTools = [
+    {
+        name: 'googleSearchConsoleAddSite',
+        description: 'Adds a site to the set of the user\'s sites in Google Search Console. This action registers a new property (site) in Google Search Console for the authenticated user. After adding the site, you will need to verify own...',
+        tool: addSite,
+        requiredAuth: 'googleSearchConsoleToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleSearchConsoleDeleteSite',
+        description: 'Removes a site from the user\'s Google Search Console sites. This action permanently removes a site property from the authenticated user\'s Search Console account. The site URL must be URL-encoded. Use this when you n...',
+        tool: deleteSite,
+        requiredAuth: 'googleSearchConsoleToken',
+        scope: 'delete',
+    },
+    {
+        name: 'googleSearchConsoleGetSite',
+        description: 'Retrieves information about a specific Search Console site. Use when you need to get site details including permission level for a specific property.',
+        tool: getSite,
+        requiredAuth: 'googleSearchConsoleToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSearchConsoleGetSitemap',
+        description: 'Retrieves sitemap metadata (submitted/indexed counts, errors, warnings, last-submission timestamps) for a specific sitemap in Search Console. Returns metadata only, not raw XML content. Note: numeric fields like `erro...',
+        tool: getSitemap,
+        requiredAuth: 'googleSearchConsoleToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSearchConsoleInspectUrl',
+        description: 'Inspects a URL for indexing issues and status in Google Search Console. Results may reflect cached data lagging real changes by several days. High-volume use can trigger 429 quota errors; limit to priority URLs.',
+        tool: inspectUrl,
+        requiredAuth: 'googleSearchConsoleToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSearchConsoleListSitemaps',
+        description: 'Lists all sitemaps for a site in Google Search Console. Response fields `errors`, `warnings`, `contents.submitted`, and `contents.indexed` may be returned as strings; cast to integers before numeric operations. Evalua...',
+        tool: listSitemaps,
+        requiredAuth: 'googleSearchConsoleToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSearchConsoleListSites',
+        description: 'Lists all verified sites (properties) owned by the authenticated user in Google Search Console. Response contains a siteEntry array — always iterate it, never assume a single object. Each entry includes permissionLeve...',
+        tool: listSites,
+        requiredAuth: 'googleSearchConsoleToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSearchConsoleSearchAnalyticsQuery',
+        description: 'Queries Google Search Console for search analytics data including clicks, impressions, CTR, and position metrics. Only returns URLs with at least one impression; missing rows do not confirm non-indexing. Position is a...',
+        tool: searchAnalyticsQuery,
+        requiredAuth: 'googleSearchConsoleToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSearchConsoleSubmitSitemap',
+        description: 'Submits a sitemap to Google Search Console for indexing. This action registers or resubmits a sitemap for a verified property in Google Search Console. The sitemap file must be accessible at the specified URL and prop...',
+        tool: submitSitemap,
+        requiredAuth: 'googleSearchConsoleToken',
+        scope: 'write',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/google-search-console/tools/inspect-url.d.ts

@@ -0,0 +1,7 @@
+export declare const inspectUrl: import("ai").Tool<{
+    googleSearchConsoleToken: string;
+    site_url: string;
+    inspection_url: string;
+    language_code?: string | undefined;
+}, any>;
+//# sourceMappingURL=inspect-url.d.ts.map

package/dist/toolkits/google-search-console/tools/inspect-url.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { searchConsoleRequest } from './utils.js';
+export const inspectUrl = tool({
+    description: 'Inspect a URL using the Google Search Console URL Inspection API. Returns indexing status and crawl details.',
+    inputSchema: z.object({
+        googleSearchConsoleToken: z.string().describe('The Google Search Console access token'),
+        site_url: z.string().describe('The Search Console property URL that owns the page'),
+        inspection_url: z.string().describe('The fully-qualified URL to inspect'),
+        language_code: z
+            .string()
+            .optional()
+            .describe('IETF BCP-47 language code for localizing results (e.g. en-US)'),
+    }),
+    execute: async ({ googleSearchConsoleToken, site_url, inspection_url, language_code }) => {
+        try {
+            const body = {
+                siteUrl: site_url,
+                inspectionUrl: inspection_url,
+            };
+            if (language_code)
+                body.languageCode = language_code;
+            const result = await searchConsoleRequest(googleSearchConsoleToken, '/urlInspection/index:inspect', {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to inspect URL', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error inspecting URL',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=inspect-url.js.map

package/dist/toolkits/google-search-console/tools/list-sitemaps.d.ts

@@ -0,0 +1,6 @@
+export declare const listSitemaps: import("ai").Tool<{
+    googleSearchConsoleToken: string;
+    site_url: string;
+    sitemap_index?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-sitemaps.d.ts.map

package/dist/toolkits/google-search-console/tools/list-sitemaps.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeSiteUrl, webmastersRequest } from './utils.js';
+export const listSitemaps = tool({
+    description: 'List sitemaps submitted for a site in Google Search Console.',
+    inputSchema: z.object({
+        googleSearchConsoleToken: z.string().describe('The Google Search Console access token'),
+        site_url: z.string().describe('The site URL including protocol'),
+        sitemap_index: z
+            .string()
+            .optional()
+            .describe('Optional sitemap index URL to list child sitemaps from'),
+    }),
+    execute: async ({ googleSearchConsoleToken, site_url, sitemap_index }) => {
+        try {
+            const result = await webmastersRequest(googleSearchConsoleToken, `/sites/${encodeSiteUrl(site_url)}/sitemaps`, { query: { sitemapIndex: sitemap_index } });
+            if (!result.ok) {
+                return { error: 'Failed to list sitemaps', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing sitemaps',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-sitemaps.js.map

package/dist/toolkits/google-search-console/tools/list-sites.d.ts

@@ -0,0 +1,4 @@
+export declare const listSites: import("ai").Tool<{
+    googleSearchConsoleToken: string;
+}, any>;
+//# sourceMappingURL=list-sites.d.ts.map

package/dist/toolkits/google-search-console/tools/list-sites.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { webmastersRequest } from './utils.js';
+export const listSites = tool({
+    description: 'List all site properties accessible to the authenticated user in Google Search Console.',
+    inputSchema: z.object({
+        googleSearchConsoleToken: z.string().describe('The Google Search Console access token'),
+    }),
+    execute: async ({ googleSearchConsoleToken }) => {
+        try {
+            const result = await webmastersRequest(googleSearchConsoleToken, '/sites');
+            if (!result.ok) {
+                return { error: 'Failed to list sites', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing sites',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-sites.js.map

package/dist/toolkits/google-search-console/tools/search-analytics-query.d.ts

@@ -0,0 +1,14 @@
+export declare const searchAnalyticsQuery: import("ai").Tool<{
+    googleSearchConsoleToken: string;
+    site_url: string;
+    start_date: string;
+    end_date: string;
+    dimensions?: string[] | undefined;
+    search_type?: "video" | "web" | "image" | "news" | "discover" | "googleNews" | undefined;
+    aggregation_type?: "auto" | "byPage" | "byProperty" | undefined;
+    row_limit?: number | undefined;
+    start_row?: number | undefined;
+    data_state?: "all" | "final" | undefined;
+    dimension_filter_groups?: Record<string, unknown>[] | undefined;
+}, any>;
+//# sourceMappingURL=search-analytics-query.d.ts.map

package/dist/toolkits/google-search-console/tools/search-analytics-query.js

@@ -0,0 +1,73 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeSiteUrl, webmastersRequest } from './utils.js';
+export const searchAnalyticsQuery = tool({
+    description: 'Query Google Search Console search analytics data for a site over a date range with optional dimensions and filters.',
+    inputSchema: z.object({
+        googleSearchConsoleToken: z.string().describe('The Google Search Console access token'),
+        site_url: z.string().describe('The site URL including protocol or domain property'),
+        start_date: z.string().describe('Start date in YYYY-MM-DD format'),
+        end_date: z.string().describe('End date in YYYY-MM-DD format'),
+        dimensions: z
+            .array(z.string())
+            .optional()
+            .describe('Dimensions to group by (e.g. query, page, country, device, date)'),
+        search_type: z
+            .enum(['web', 'image', 'video', 'news', 'discover', 'googleNews'])
+            .optional()
+            .describe('Search type filter'),
+        aggregation_type: z
+            .enum(['auto', 'byPage', 'byProperty'])
+            .optional()
+            .describe('How data is aggregated'),
+        row_limit: z.number().min(1).max(25000).optional().describe('Maximum rows to return (1-25000)'),
+        start_row: z.number().min(0).optional().describe('First row for pagination'),
+        data_state: z.enum(['final', 'all']).optional().describe('Data state to return'),
+        dimension_filter_groups: z
+            .array(z.record(z.unknown()))
+            .optional()
+            .describe('Optional dimension filter groups'),
+    }),
+    execute: async ({ googleSearchConsoleToken, site_url, start_date, end_date, dimensions, search_type, aggregation_type, row_limit, start_row, data_state, dimension_filter_groups, }) => {
+        try {
+            const body = {
+                startDate: start_date,
+                endDate: end_date,
+            };
+            if (dimensions)
+                body.dimensions = dimensions;
+            if (search_type)
+                body.type = search_type;
+            if (aggregation_type)
+                body.aggregationType = aggregation_type;
+            if (row_limit !== undefined)
+                body.rowLimit = row_limit;
+            if (start_row !== undefined)
+                body.startRow = start_row;
+            if (data_state)
+                body.dataState = data_state;
+            if (dimension_filter_groups)
+                body.dimensionFilterGroups = dimension_filter_groups;
+            const result = await webmastersRequest(googleSearchConsoleToken, `/sites/${encodeSiteUrl(site_url)}/searchAnalytics/query`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok) {
+                return {
+                    error: 'Failed to query search analytics',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error querying search analytics',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-analytics-query.js.map

package/dist/toolkits/google-search-console/tools/submit-sitemap.d.ts

@@ -0,0 +1,33 @@
+export declare const submitSitemap: import("ai").Tool<{
+    googleSearchConsoleToken: string;
+    site_url: string;
+    feedpath: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    success?: undefined;
+    site_url?: undefined;
+    feedpath?: undefined;
+    data?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    site_url: string;
+    feedpath: string;
+    data: any;
+    error?: undefined;
+    details?: undefined;
+    statusCode?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    success?: undefined;
+    site_url?: undefined;
+    feedpath?: undefined;
+    data?: undefined;
+}>;
+//# sourceMappingURL=submit-sitemap.d.ts.map

package/dist/toolkits/google-search-console/tools/submit-sitemap.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeFeedpath, encodeSiteUrl, webmastersRequest } from './utils.js';
+export const submitSitemap = tool({
+    description: 'Submit a sitemap URL to Google Search Console for a site property.',
+    inputSchema: z.object({
+        googleSearchConsoleToken: z.string().describe('The Google Search Console access token'),
+        site_url: z.string().describe('The site URL as registered in Search Console'),
+        feedpath: z.string().describe('The full URL of the sitemap to submit'),
+    }),
+    execute: async ({ googleSearchConsoleToken, site_url, feedpath }) => {
+        try {
+            const result = await webmastersRequest(googleSearchConsoleToken, `/sites/${encodeSiteUrl(site_url)}/sitemaps/${encodeFeedpath(feedpath)}`, { method: 'PUT' });
+            if (!result.ok) {
+                return { error: 'Failed to submit sitemap', details: result.data, statusCode: result.status };
+            }
+            return { success: true, site_url, feedpath, data: result.data };
+        }
+        catch (error) {
+            return {
+                error: 'Error submitting sitemap',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=submit-sitemap.js.map

package/dist/toolkits/google-search-console/tools/utils.d.ts

@@ -0,0 +1,24 @@
+export declare const WEBMASTERS_BASE = "https://www.googleapis.com/webmasters/v3";
+export declare const SEARCH_CONSOLE_BASE = "https://searchconsole.googleapis.com/v1";
+export declare function encodeSiteUrl(siteUrl: string): string;
+export declare function encodeFeedpath(feedpath: string): string;
+export declare function buildQueryString(params: Record<string, unknown>): string;
+export declare function webmastersRequest(googleSearchConsoleToken: string, path: string, options?: {
+    method?: string;
+    body?: unknown;
+    query?: Record<string, unknown>;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data: any;
+}>;
+export declare function searchConsoleRequest(googleSearchConsoleToken: string, path: string, options?: {
+    method?: string;
+    body?: unknown;
+    query?: Record<string, unknown>;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data: any;
+}>;
+//# sourceMappingURL=utils.d.ts.map