@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/dev-to/icon.js

@@ -0,0 +1,10 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg"
+aria-label="dev.to" role="img"
+viewBox="0 0 512 512"><rect
+width="512" height="512"
+rx="15%"/><path fill="#ffffff" d="M140.47 203.94h-17.44v104.47h17.45c10.155-.545 17.358-8.669 17.47-17.41v-69.65c-.696-10.364-7.796-17.272-17.48-17.41zm45.73 87.25c0 18.81-11.61 47.31-48.36 47.25h-46.4V172.98h47.38c35.44 0 47.36 28.46 47.37 47.28zm100.68-88.66H233.6v38.42h32.57v29.57H233.6v38.41h53.29v29.57h-62.18c-11.16.29-20.44-8.53-20.72-19.69V193.7c-.27-11.15 8.56-20.41 19.71-20.69h63.19zm103.64 115.29c-13.2 30.75-36.85 24.63-47.44 0l-38.53-144.8h32.57l29.71 113.72 29.57-113.72h32.58z"/></svg>`;
+export const DEV_TO_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/dev-to/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/dev-to/manifest.js

@@ -0,0 +1,34 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { DEV_TO_ICON } from './icon.js';
+import { devToTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'dev-to',
+    displayName: 'DEV',
+    shortDescription: 'Publish and browse DEV Community articles, comments, listings, and profiles.',
+    category: 'Social Media',
+    icon: DEV_TO_ICON,
+    auth: {
+        type: 'api_key',
+        tokenField: 'devToApiKey',
+        provider: {
+            in: 'header',
+            name: 'api-key',
+            connectDescription: 'Connect DEV with an API key. Generate one from DEV Settings > Extensions > DEV Community API Keys. Public reads (articles, comments, users, tags, listings) also work without a key.',
+        },
+    },
+    allowedHosts: ['dev.to'],
+    tools: devToTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: {
+        since: '0.0.9',
+        homepage: 'https://dev.to',
+        docsUrl: 'https://developers.forem.com/api/v1',
+        apiDocsUrl: 'https://developers.forem.com/api/v1',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/dev-to/tools/articles.d.ts

@@ -0,0 +1,78 @@
+export declare const devToCreateArticle: import("ai").Tool<{
+    title: string;
+    bodyMarkdown: string;
+    description?: string | undefined;
+    published?: boolean | undefined;
+    tags?: string[] | undefined;
+    series?: string | undefined;
+    organizationId?: number | undefined;
+    devToApiKey?: string | undefined;
+    mainImage?: string | undefined;
+    canonicalUrl?: string | undefined;
+}, any>;
+export declare const devToGetArticle: import("ai").Tool<{
+    id: number;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToGetArticleByPath: import("ai").Tool<{
+    username: string;
+    slug: string;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListArticles: import("ai").Tool<{
+    username?: string | undefined;
+    perPage?: number | undefined;
+    page?: number | undefined;
+    state?: "all" | "rising" | "fresh" | undefined;
+    tags?: string | undefined;
+    collectionId?: number | undefined;
+    tag?: string | undefined;
+    top?: number | undefined;
+    devToApiKey?: string | undefined;
+    tagsExclude?: string | undefined;
+}, any>;
+export declare const devToListLatestArticles: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListUserArticles: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListUserPublishedArticles: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListUserUnpublishedArticles: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListUserAllArticles: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListOrganizationArticles: import("ai").Tool<{
+    username: string;
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToUpdateArticle: import("ai").Tool<{
+    id: number;
+    description?: string | undefined;
+    title?: string | undefined;
+    published?: boolean | undefined;
+    tags?: string[] | undefined;
+    series?: string | undefined;
+    organizationId?: number | undefined;
+    devToApiKey?: string | undefined;
+    bodyMarkdown?: string | undefined;
+    mainImage?: string | undefined;
+    canonicalUrl?: string | undefined;
+}, any>;
+//# sourceMappingURL=articles.d.ts.map

package/dist/toolkits/dev-to/tools/articles.js

@@ -0,0 +1,262 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { devToRequest, toDevToError, requireApiKey } from './client.js';
+const apiKeyField = z.string().optional().describe('Injected by system; do not provide');
+const paginationFields = {
+    page: z.number().int().min(1).optional().describe('Page number for pagination'),
+    perPage: z.number().int().min(1).optional().describe('Number of items per page'),
+};
+export const devToCreateArticle = tool({
+    description: 'Create a new article on DEV Community. Set published=true to publish immediately, or omit/false to save as a draft.',
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        title: z.string().describe('The title of the article'),
+        bodyMarkdown: z.string().describe('The body content of the article in Markdown format'),
+        published: z.boolean().optional().describe('Publish immediately (true) or save as draft (false, default)'),
+        description: z.string().optional().describe('Short description used for preview text and SEO'),
+        mainImage: z.string().optional().describe('URL of the main cover image'),
+        tags: z.array(z.string()).max(4).optional().describe('Array of tag names, maximum 4'),
+        series: z.string().optional().describe('Name of the series this article belongs to'),
+        canonicalUrl: z.string().optional().describe('Canonical URL if crossposted elsewhere'),
+        organizationId: z.number().int().optional().describe('ID of the organization to publish under (must be a member)'),
+    }),
+    execute: async ({ devToApiKey, bodyMarkdown, mainImage, canonicalUrl, organizationId, ...rest }) => {
+        const missing = requireApiKey(devToApiKey);
+        if (missing)
+            return missing;
+        try {
+            const article = { ...rest, body_markdown: bodyMarkdown };
+            if (mainImage !== undefined)
+                article.main_image = mainImage;
+            if (canonicalUrl !== undefined)
+                article.canonical_url = canonicalUrl;
+            if (organizationId !== undefined)
+                article.organization_id = organizationId;
+            return await devToRequest(devToApiKey, 'POST', '/articles', { body: { article } });
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to create article');
+        }
+    },
+});
+export const devToGetArticle = tool({
+    description: 'Get a single published article by its numeric ID, including full body content.',
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        id: z.number().int().describe('The numeric ID of the article'),
+    }),
+    execute: async ({ devToApiKey, id }) => {
+        try {
+            return await devToRequest(devToApiKey, 'GET', `/articles/${id}`);
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to get article');
+        }
+    },
+});
+export const devToGetArticleByPath = tool({
+    description: "Get a single published article by the author's username and the article slug.",
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        username: z.string().describe("The username of the article's author"),
+        slug: z.string().describe('The URL-friendly slug of the article'),
+    }),
+    execute: async ({ devToApiKey, username, slug }) => {
+        try {
+            return await devToRequest(devToApiKey, 'GET', `/articles/${encodeURIComponent(username)}/${encodeURIComponent(slug)}`);
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to get article by path');
+        }
+    },
+});
+export const devToListArticles = tool({
+    description: 'List published articles, optionally filtered by tag(s), username, state (fresh/rising/all), top days, or collection. Omit all filters for the latest feed.',
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        tag: z.string().optional().describe('Filter by a single tag name'),
+        tags: z.string().optional().describe('Filter by multiple tag names (comma-separated)'),
+        tagsExclude: z.string().optional().describe('Exclude articles with these tags (comma-separated)'),
+        username: z.string().optional().describe('Articles from a specific user or organization'),
+        state: z.enum(['fresh', 'rising', 'all']).optional().describe('fresh or rising articles; all with username returns up to 1000'),
+        top: z.number().int().min(1).optional().describe('Top articles from the last N days (combinable with tag)'),
+        collectionId: z.number().int().optional().describe('Articles belonging to a collection/series'),
+        ...paginationFields,
+    }),
+    execute: async ({ devToApiKey, tagsExclude, collectionId, perPage, ...rest }) => {
+        try {
+            const query = { ...rest };
+            if (tagsExclude !== undefined)
+                query.tags_exclude = tagsExclude;
+            if (collectionId !== undefined)
+                query.collection_id = collectionId;
+            if (perPage !== undefined)
+                query.per_page = perPage;
+            return await devToRequest(devToApiKey, 'GET', '/articles', { query });
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to list articles');
+        }
+    },
+});
+export const devToListLatestArticles = tool({
+    description: 'List published articles sorted strictly by descending publish date (no feed personalization).',
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        ...paginationFields,
+    }),
+    execute: async ({ devToApiKey, perPage, ...rest }) => {
+        try {
+            const query = { ...rest };
+            if (perPage !== undefined)
+                query.per_page = perPage;
+            return await devToRequest(devToApiKey, 'GET', '/articles/latest', { query });
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to list latest articles');
+        }
+    },
+});
+export const devToListUserArticles = tool({
+    description: "List the authenticated user's published articles in reverse chronological order.",
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        ...paginationFields,
+    }),
+    execute: async ({ devToApiKey, perPage, ...rest }) => {
+        const missing = requireApiKey(devToApiKey);
+        if (missing)
+            return missing;
+        try {
+            const query = { ...rest };
+            if (perPage !== undefined)
+                query.per_page = perPage;
+            return await devToRequest(devToApiKey, 'GET', '/articles/me', { query });
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to list user articles');
+        }
+    },
+});
+export const devToListUserPublishedArticles = tool({
+    description: "List only the authenticated user's published articles. For drafts, use unpublished/all variants.",
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        ...paginationFields,
+    }),
+    execute: async ({ devToApiKey, perPage, ...rest }) => {
+        const missing = requireApiKey(devToApiKey);
+        if (missing)
+            return missing;
+        try {
+            const query = { ...rest };
+            if (perPage !== undefined)
+                query.per_page = perPage;
+            return await devToRequest(devToApiKey, 'GET', '/articles/me/published', { query });
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to list published articles');
+        }
+    },
+});
+export const devToListUserUnpublishedArticles = tool({
+    description: "List the authenticated user's unpublished (draft) articles.",
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        ...paginationFields,
+    }),
+    execute: async ({ devToApiKey, perPage, ...rest }) => {
+        const missing = requireApiKey(devToApiKey);
+        if (missing)
+            return missing;
+        try {
+            const query = { ...rest };
+            if (perPage !== undefined)
+                query.per_page = perPage;
+            return await devToRequest(devToApiKey, 'GET', '/articles/me/unpublished', { query });
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to list unpublished articles');
+        }
+    },
+});
+export const devToListUserAllArticles = tool({
+    description: 'List all of the authenticated user articles, both published and drafts (drafts first).',
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        ...paginationFields,
+    }),
+    execute: async ({ devToApiKey, perPage, ...rest }) => {
+        const missing = requireApiKey(devToApiKey);
+        if (missing)
+            return missing;
+        try {
+            const query = { ...rest };
+            if (perPage !== undefined)
+                query.per_page = perPage;
+            return await devToRequest(devToApiKey, 'GET', '/articles/me/all', { query });
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to list all user articles');
+        }
+    },
+});
+export const devToListOrganizationArticles = tool({
+    description: 'List articles published by a specific organization.',
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        username: z.string().describe("The organization's username"),
+        ...paginationFields,
+    }),
+    execute: async ({ devToApiKey, username, perPage, ...rest }) => {
+        try {
+            const query = { ...rest };
+            if (perPage !== undefined)
+                query.per_page = perPage;
+            return await devToRequest(devToApiKey, 'GET', `/organizations/${encodeURIComponent(username)}/articles`, {
+                query,
+            });
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to list organization articles');
+        }
+    },
+});
+export const devToUpdateArticle = tool({
+    description: 'Update an existing article owned by the authenticated user. Only provide fields to change.',
+    inputSchema: z.object({
+        devToApiKey: apiKeyField,
+        id: z.number().int().describe('The ID of the article to update'),
+        title: z.string().optional().describe('Updated title'),
+        bodyMarkdown: z.string().optional().describe('Updated body in Markdown (include front matter to change tags/series via markdown)'),
+        published: z.boolean().optional().describe('Set false to revert a published article to draft'),
+        description: z.string().optional().describe('Updated short description'),
+        mainImage: z.string().optional().describe('Updated cover image URL'),
+        tags: z.array(z.string()).max(4).optional().describe('Updated tag names, maximum 4'),
+        series: z.string().optional().describe('Updated series name'),
+        canonicalUrl: z.string().optional().describe('Updated canonical URL'),
+        organizationId: z.number().int().optional().describe('Organization ID to assign the article to'),
+    }),
+    execute: async ({ devToApiKey, id, bodyMarkdown, mainImage, canonicalUrl, organizationId, ...rest }) => {
+        const missing = requireApiKey(devToApiKey);
+        if (missing)
+            return missing;
+        try {
+            const article = { ...rest };
+            if (bodyMarkdown !== undefined)
+                article.body_markdown = bodyMarkdown;
+            if (mainImage !== undefined)
+                article.main_image = mainImage;
+            if (canonicalUrl !== undefined)
+                article.canonical_url = canonicalUrl;
+            if (organizationId !== undefined)
+                article.organization_id = organizationId;
+            return await devToRequest(devToApiKey, 'PUT', `/articles/${id}`, { body: { article } });
+        }
+        catch (error) {
+            return toDevToError(error, 'Failed to update article');
+        }
+    },
+});
+//# sourceMappingURL=articles.js.map

package/dist/toolkits/dev-to/tools/client.d.ts

@@ -0,0 +1,25 @@
+export declare class DevToApiError extends Error {
+    status: number;
+    details: unknown;
+    constructor(message: string, status: number, details: unknown);
+}
+export declare function appendQuery(url: URL, query?: Record<string, unknown>): void;
+export declare function devToRequest(devToApiKey: string | undefined, method: 'GET' | 'POST' | 'PUT', path: string, options?: {
+    query?: Record<string, unknown>;
+    body?: unknown;
+}): Promise<any>;
+export declare function toDevToError(error: unknown, label: string): {
+    error: string;
+    details: unknown;
+    statusCode: number;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+};
+export declare function requireApiKey(devToApiKey: string | undefined): {
+    error: string;
+} | null;
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/dev-to/tools/client.js

@@ -0,0 +1,65 @@
+// @ts-nocheck
+const BASE_URL = 'https://dev.to/api';
+const ACCEPT = 'application/vnd.forem.api-v1+json';
+export class DevToApiError extends Error {
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+    }
+}
+export function appendQuery(url, query) {
+    if (!query)
+        return;
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null)
+            continue;
+        url.searchParams.set(key, String(value));
+    }
+}
+export async function devToRequest(devToApiKey, method, path, options) {
+    const url = new URL(`${BASE_URL}${path}`);
+    appendQuery(url, options?.query);
+    const headers = { Accept: ACCEPT };
+    if (devToApiKey) {
+        headers['api-key'] = devToApiKey;
+    }
+    if (options?.body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const response = await fetch(url.toString(), {
+        method,
+        headers,
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    const text = await response.text();
+    let data = {};
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = { raw: text };
+    }
+    if (!response.ok) {
+        throw new DevToApiError('DEV API request failed', response.status, data);
+    }
+    return data;
+}
+export function toDevToError(error, label) {
+    if (error instanceof DevToApiError) {
+        return { error: label, details: error.details, statusCode: error.status };
+    }
+    return {
+        error: label.replace('Failed', 'Error').replace('failed', 'error'),
+        message: error instanceof Error ? error.message : 'Unknown error',
+    };
+}
+export function requireApiKey(devToApiKey) {
+    if (!devToApiKey) {
+        return { error: 'DEV API key is required. Connect DEV first.' };
+    }
+    return null;
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/dev-to/tools/community.d.ts

@@ -0,0 +1,61 @@
+export declare const devToGetComment: import("ai").Tool<{
+    id: string;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListComments: import("ai").Tool<{
+    articleId?: number | undefined;
+    devToApiKey?: string | undefined;
+    podcastEpisodeId?: number | undefined;
+}, any>;
+export declare const devToGetCurrentUser: import("ai").Tool<{
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToGetUser: import("ai").Tool<{
+    id: string;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToGetOrganization: import("ai").Tool<{
+    username: string;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListOrganizationUsers: import("ai").Tool<{
+    username: string;
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToGetProfileImage: import("ai").Tool<{
+    username: string;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListTags: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListFollowedTags: import("ai").Tool<{
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListFollowers: import("ai").Tool<{
+    sort?: string | undefined;
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListPodcastEpisodes: import("ai").Tool<{
+    username?: string | undefined;
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListReadingList: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+export declare const devToListVideos: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    devToApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=community.d.ts.map