@rnsk/toolkits 0.0.6 → 0.0.8

package/dist/toolkits/reddit/tools/create-post.js

@@ -0,0 +1,59 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditPost, throwIfJsonErrors } from './client.js';
+export const redditCreatePost = tool({
+    description: 'Create a new text (self) or link post in an existing subreddit, optionally applying a flair template ID. Publishes publicly and immediately — confirm subreddit, title, and body with the user before executing. Use redditListSubredditPostFlairs first when the subreddit requires flair.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        subreddit: z.string().describe("Subreddit name without the 'r/' prefix, e.g. 'learnpython'"),
+        title: z.string().max(300).describe('Post title, 300 characters or less'),
+        kind: z
+            .enum(['self', 'link'])
+            .optional()
+            .describe("Post type: 'self' for text posts, 'link' for URL posts. Inferred from text/url when omitted"),
+        text: z.string().optional().describe('Markdown body for a self (text) post'),
+        url: z.string().optional().describe('URL for a link post'),
+        flairId: z
+            .string()
+            .optional()
+            .describe('Flair template ID for the subreddit (from redditListSubredditPostFlairs), not a display name'),
+    }),
+    execute: async ({ redditToken, subreddit, title, kind, text, url, flairId }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            const resolvedKind = kind ?? (text ? 'self' : url ? 'link' : undefined);
+            if (!resolvedKind) {
+                return { error: 'Provide either text (self post) or url (link post), or set kind explicitly.' };
+            }
+            if (resolvedKind === 'self' && !text) {
+                return { error: 'A self post requires text.' };
+            }
+            if (resolvedKind === 'link' && !url) {
+                return { error: 'A link post requires url.' };
+            }
+            const data = await redditPost(redditToken, '/api/submit', {
+                sr: subreddit,
+                kind: resolvedKind,
+                title,
+                text: resolvedKind === 'self' ? text : undefined,
+                url: resolvedKind === 'link' ? url : undefined,
+                flair_template_id: flairId,
+            });
+            throwIfJsonErrors(data, 'Create post');
+            return data;
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to create Reddit post', details: error.details };
+            }
+            return {
+                error: 'Error creating Reddit post',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-post.js.map

package/dist/toolkits/reddit/tools/delete-comment.d.ts

@@ -0,0 +1,29 @@
+export declare const redditDeleteComment: import("ai").Tool<{
+    id: string;
+    redditToken?: string | undefined;
+}, {
+    error: string;
+    success?: undefined;
+    id?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    id: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    success?: undefined;
+    id?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    success?: undefined;
+    id?: undefined;
+    details?: undefined;
+}>;
+//# sourceMappingURL=delete-comment.d.ts.map

package/dist/toolkits/reddit/tools/delete-comment.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditPost } from './client.js';
+export const redditDeleteComment = tool({
+    description: 'Permanently delete a comment authored by the authenticated user. Provide the comment fullname ID (starts with t1_). Deletion is irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe("Comment fullname ID, e.g. 't1_c0s4w1c'"),
+    }),
+    execute: async ({ redditToken, id }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            await redditPost(redditToken, '/api/del', { id });
+            return { success: true, id };
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to delete Reddit comment', details: error.details };
+            }
+            return {
+                error: 'Error deleting Reddit comment',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-comment.js.map

package/dist/toolkits/reddit/tools/delete-post.d.ts

@@ -0,0 +1,29 @@
+export declare const redditDeletePost: import("ai").Tool<{
+    id: string;
+    redditToken?: string | undefined;
+}, {
+    error: string;
+    success?: undefined;
+    id?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    id: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    success?: undefined;
+    id?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    success?: undefined;
+    id?: undefined;
+    details?: undefined;
+}>;
+//# sourceMappingURL=delete-post.d.ts.map

package/dist/toolkits/reddit/tools/delete-post.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditPost } from './client.js';
+export const redditDeletePost = tool({
+    description: 'Permanently delete a post authored by the authenticated user. Provide the post fullname ID (starts with t3_). Only works on the own posts — confirm with the user first.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe("Post fullname ID, e.g. 't3_1abcdef'"),
+    }),
+    execute: async ({ redditToken, id }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            await redditPost(redditToken, '/api/del', { id });
+            return { success: true, id };
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to delete Reddit post', details: error.details };
+            }
+            return {
+                error: 'Error deleting Reddit post',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-post.js.map

package/dist/toolkits/reddit/tools/edit-comment-or-post.d.ts

@@ -0,0 +1,6 @@
+export declare const redditEditCommentOrPost: import("ai").Tool<{
+    text: string;
+    thingId: string;
+    redditToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=edit-comment-or-post.d.ts.map

package/dist/toolkits/reddit/tools/edit-comment-or-post.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditPost, throwIfJsonErrors } from './client.js';
+export const redditEditCommentOrPost = tool({
+    description: 'Edit the body text of the authenticated user\'s own comment or self (text) post. Cannot edit link posts or titles. Provide the fullname ID (t1_ for comments, t3_ for posts).',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        thingId: z.string().describe("Fullname of the comment or self-post, e.g. 't1_c0c0c0c' or 't3_h0h0h0h'"),
+        text: z.string().describe('New raw markdown body text'),
+    }),
+    execute: async ({ redditToken, thingId, text }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            const data = await redditPost(redditToken, '/api/editusertext', {
+                thing_id: thingId,
+                text,
+            });
+            throwIfJsonErrors(data, 'Edit');
+            return data;
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to edit Reddit comment or post', details: error.details };
+            }
+            return {
+                error: 'Error editing Reddit comment or post',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=edit-comment-or-post.js.map

package/dist/toolkits/reddit/tools/get-controversial-posts.d.ts

@@ -0,0 +1,10 @@
+export declare const redditGetControversialPosts: import("ai").Tool<{
+    limit: number;
+    timeFilter: "all" | "year" | "month" | "day" | "hour" | "week";
+    count?: number | undefined;
+    show?: string | undefined;
+    before?: string | undefined;
+    after?: string | undefined;
+    redditToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-controversial-posts.d.ts.map

package/dist/toolkits/reddit/tools/get-controversial-posts.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditGetControversialPosts = tool({
+    description: 'Get controversial posts from across all of Reddit, ranked by controversy within a time window (hour, day, week, month, year, or all-time). Supports pagination via after/before cursors.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        timeFilter: z
+            .enum(['hour', 'day', 'week', 'month', 'year', 'all'])
+            .optional()
+            .default('all')
+            .describe('Time window for ranking controversial posts'),
+        limit: z.number().min(1).max(100).optional().default(25).describe('Max posts to return (max 100)'),
+        after: z.string().optional().describe('Fullname cursor for the next page'),
+        before: z.string().optional().describe('Fullname cursor for the previous page'),
+        count: z.number().min(0).optional().describe('Number of items already seen (pagination)'),
+        show: z.string().optional().describe("Pass 'all' to include normally filtered items"),
+    }),
+    execute: async ({ redditToken, timeFilter = 'all', limit = 25, after, before, count, show }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, '/controversial', {
+                t: timeFilter,
+                limit,
+                after,
+                before,
+                count,
+                show,
+            });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to get controversial posts', details: error.details };
+            }
+            return {
+                error: 'Error getting controversial posts',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-controversial-posts.js.map

package/dist/toolkits/reddit/tools/get-listing-by-sort.d.ts

@@ -0,0 +1,11 @@
+export declare const redditGetListingBySort: import("ai").Tool<{
+    sort: "new" | "hot" | "top" | "rising" | "controversial" | "best";
+    limit: number;
+    count?: number | undefined;
+    show?: string | undefined;
+    before?: string | undefined;
+    after?: string | undefined;
+    redditToken?: string | undefined;
+    timeFilter?: "all" | "year" | "month" | "day" | "hour" | "week" | undefined;
+}, any>;
+//# sourceMappingURL=get-listing-by-sort.d.ts.map

package/dist/toolkits/reddit/tools/get-listing-by-sort.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditGetListingBySort = tool({
+    description: 'Get a listing of posts from the Reddit front page sorted by hot, new, top, rising, controversial, or best. Supports pagination (after/before) and time filtering for top and controversial sorts. For random posts use redditGetRandomPost instead.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        sort: z
+            .enum(['hot', 'new', 'top', 'rising', 'controversial', 'best'])
+            .describe('Sort order for the listing'),
+        timeFilter: z
+            .enum(['hour', 'day', 'week', 'month', 'year', 'all'])
+            .optional()
+            .describe("Time window for 'top' and 'controversial' sorts"),
+        limit: z.number().min(1).max(100).optional().default(25).describe('Max posts to return (max 100)'),
+        after: z.string().optional().describe('Fullname cursor for the next page'),
+        before: z.string().optional().describe('Fullname cursor for the previous page'),
+        count: z.number().min(0).optional().describe('Number of items already seen (pagination)'),
+        show: z.string().optional().describe("Pass 'all' to include normally filtered items"),
+    }),
+    execute: async ({ redditToken, sort, timeFilter, limit = 25, after, before, count, show }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, `/${sort}`, {
+                t: timeFilter,
+                limit,
+                after,
+                before,
+                count,
+                show,
+            });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to get Reddit listing', details: error.details };
+            }
+            return {
+                error: 'Error getting Reddit listing',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-listing-by-sort.js.map

package/dist/toolkits/reddit/tools/get-oauth-scopes.d.ts

@@ -0,0 +1,4 @@
+export declare const redditGetOauthScopes: import("ai").Tool<{
+    redditToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-oauth-scopes.d.ts.map

package/dist/toolkits/reddit/tools/get-oauth-scopes.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditGetOauthScopes = tool({
+    description: 'List all OAuth scopes supported by the Reddit API with their descriptions. Use to understand which permissions are available before requesting broader access.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+    }),
+    execute: async ({ redditToken }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, '/api/v1/scopes');
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to get OAuth scopes', details: error.details };
+            }
+            return {
+                error: 'Error getting OAuth scopes',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-oauth-scopes.js.map

package/dist/toolkits/reddit/tools/get-random-post.d.ts

@@ -0,0 +1,5 @@
+export declare const redditGetRandomPost: import("ai").Tool<{
+    redditToken?: string | undefined;
+    subreddit?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-random-post.d.ts.map

package/dist/toolkits/reddit/tools/get-random-post.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditGetRandomPost = tool({
+    description: 'Get a random public Reddit post, optionally limited to a specific subreddit. Use to discover serendipitous content.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        subreddit: z
+            .string()
+            .optional()
+            .describe("Subreddit name without the 'r/' prefix. Omit for a random post from all of Reddit"),
+    }),
+    execute: async ({ redditToken, subreddit }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, subreddit ? `/r/${subreddit}/random` : '/random');
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to get random post', details: error.details };
+            }
+            return {
+                error: 'Error getting random post',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-random-post.js.map

package/dist/toolkits/reddit/tools/get-subreddit-rules.d.ts

@@ -0,0 +1,5 @@
+export declare const redditGetSubredditRules: import("ai").Tool<{
+    subreddit: string;
+    redditToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-subreddit-rules.d.ts.map

package/dist/toolkits/reddit/tools/get-subreddit-rules.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditGetSubredditRules = tool({
+    description: 'Get the posting rules for a subreddit to verify content meets community guidelines before posting or commenting. Use before redditCreatePost or redditPostComment in an unfamiliar subreddit.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        subreddit: z.string().describe("Subreddit name without the 'r/' prefix, e.g. 'python'"),
+    }),
+    execute: async ({ redditToken, subreddit }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, `/r/${subreddit}/about/rules`, { raw_json: 1 });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to get subreddit rules', details: error.details };
+            }
+            return {
+                error: 'Error getting subreddit rules',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-subreddit-rules.js.map

package/dist/toolkits/reddit/tools/get-user-about.d.ts

@@ -0,0 +1,5 @@
+export declare const redditGetUserAbout: import("ai").Tool<{
+    username: string;
+    redditToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-user-about.d.ts.map

package/dist/toolkits/reddit/tools/get-user-about.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditGetUserAbout = tool({
+    description: 'Get public profile information about a Reddit user, including karma scores and premium status. Use "me" for the authenticated user. Do not include the u/ prefix.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        username: z.string().describe("Reddit username without the 'u/' prefix, or 'me' for the authenticated user"),
+    }),
+    execute: async ({ redditToken, username }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, `/user/${username}/about`);
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to get user information', details: error.details };
+            }
+            return {
+                error: 'Error getting user information',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-user-about.js.map

package/dist/toolkits/reddit/tools/get-user-flair.d.ts

@@ -0,0 +1,8 @@
+export declare const redditGetUserFlair: import("ai").Tool<{
+    subreddit: string;
+    limit?: number | undefined;
+    before?: string | undefined;
+    after?: string | undefined;
+    redditToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-user-flair.d.ts.map

package/dist/toolkits/reddit/tools/get-user-flair.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditGetUserFlair = tool({
+    description: 'List user flair assignments for a subreddit with pagination. Returned flair IDs are scoped to that subreddit and must not be reused elsewhere.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        subreddit: z.string().describe("Subreddit name without the 'r/' prefix, e.g. 'pics'"),
+        limit: z.number().min(1).max(1000).optional().describe('Max flair entries per page (default 25, max 1000)'),
+        after: z.string().optional().describe('User ID anchor for the next page'),
+        before: z.string().optional().describe('User ID anchor for the previous page'),
+    }),
+    execute: async ({ redditToken, subreddit, limit, after, before }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, `/r/${subreddit}/api/flairlist`, { limit, after, before });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to get user flair', details: error.details };
+            }
+            return {
+                error: 'Error getting user flair',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-user-flair.js.map

package/dist/toolkits/reddit/tools/get-user-prefs.d.ts

@@ -0,0 +1,5 @@
+export declare const redditGetUserPrefs: import("ai").Tool<{
+    fields?: string | undefined;
+    redditToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-user-prefs.d.ts.map

package/dist/toolkits/reddit/tools/get-user-prefs.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditGetUserPrefs = tool({
+    description: 'Get preference settings of the authenticated Reddit user. Optionally pass a comma-separated list of fields (e.g. lang,over_18,nightmode) to return only those; omit to return all preferences.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        fields: z
+            .string()
+            .optional()
+            .describe('Comma-separated preference fields to return, e.g. lang,theme_selector,nightmode'),
+    }),
+    execute: async ({ redditToken, fields }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, '/api/v1/me/prefs', { fields });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to get user preferences', details: error.details };
+            }
+            return {
+                error: 'Error getting user preferences',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-user-prefs.js.map