@rnsk/toolkits 0.0.1 → 0.0.2

package/dist/toolkits/github/tools/Repos/list-repos.d.ts

@@ -0,0 +1,22 @@
+export declare const listRepos: import("ai").Tool<{
+    sort: "created" | "updated" | "full_name" | "pushed";
+    page: number;
+    perPage: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    repos?: undefined;
+    total?: undefined;
+} | {
+    repos: {
+        name: string;
+        full_name: string;
+        description: string | null;
+        visibility: string;
+        html_url: string;
+        private: boolean;
+    }[];
+    total: number;
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-repos.d.ts.map

package/dist/toolkits/github/tools/Repos/list-repos.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listRepos = tool({
+    description: 'List repositories for the authenticated GitHub user. Returns repo name, full_name, description, visibility, and URL. Use when the user asks to see their repos, list their repositories, or browse their GitHub repos.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        perPage: z.number().min(1).max(100).optional().default(30).describe('Number of repos per page (max 100)'),
+        page: z.number().min(1).optional().default(1).describe('Page number'),
+        sort: z.enum(['created', 'updated', 'pushed', 'full_name']).optional().default('updated').describe('Sort order'),
+    }),
+    execute: async ({ githubToken, perPage = 30, page = 1, sort = 'updated' }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        const { data } = await octokit.rest.repos.listForAuthenticatedUser({
+            per_page: perPage,
+            page,
+            sort,
+        });
+        return {
+            repos: data.map((repo) => ({
+                name: repo.name,
+                full_name: repo.full_name,
+                description: repo.description ?? null,
+                visibility: repo.visibility ?? 'unknown',
+                html_url: repo.html_url,
+                private: repo.private,
+            })),
+            total: data.length,
+        };
+    },
+});
+//# sourceMappingURL=list-repos.js.map

package/dist/toolkits/github/tools/Repos/star-repo.d.ts

@@ -0,0 +1,13 @@
+export declare const starRepo: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    action: "star" | "unstar";
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=star-repo.d.ts.map

package/dist/toolkits/github/tools/Repos/star-repo.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const starRepo = tool({
+    description: 'Star or unstar a GitHub repository.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner'),
+        repo: z.string().describe('Repository name'),
+        action: z.enum(['star', 'unstar']).describe('Action to perform'),
+    }),
+    execute: async ({ githubToken, owner, repo, action }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            if (action === 'star') {
+                await octokit.rest.activity.starRepoForAuthenticatedUser({
+                    owner,
+                    repo,
+                });
+                return { message: `Starred ${owner}/${repo}` };
+            }
+            else {
+                await octokit.rest.activity.unstarRepoForAuthenticatedUser({
+                    owner,
+                    repo,
+                });
+                return { message: `Unstarred ${owner}/${repo}` };
+            }
+        }
+        catch (error) {
+            return { error: `Failed to ${action} repo: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=star-repo.js.map

package/dist/toolkits/github/tools/Repos/watch-repo.d.ts

@@ -0,0 +1,18 @@
+export declare const watchRepo: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    subscribed?: boolean | undefined;
+    ignored?: boolean | undefined;
+}, {
+    error: string;
+    subscribed?: undefined;
+    ignored?: undefined;
+    message?: undefined;
+} | {
+    subscribed: boolean;
+    ignored: boolean;
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=watch-repo.d.ts.map

package/dist/toolkits/github/tools/Repos/watch-repo.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const watchRepo = tool({
+    description: 'Set subscription status (watch/unwatch) for a repository.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner'),
+        repo: z.string().describe('Repository name'),
+        ignored: z.boolean().optional().describe('If true, ignore notifications'),
+        subscribed: z.boolean().optional().describe('If true, subscribe to notifications'),
+    }),
+    execute: async ({ githubToken, owner, repo, ignored = false, subscribed = true }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.activity.setRepoSubscription({
+                owner,
+                repo,
+                ignored,
+                subscribed,
+            });
+            return {
+                subscribed: data.subscribed,
+                ignored: data.ignored,
+                message: `Updated watch status for ${owner}/${repo}`,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update watch status: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=watch-repo.js.map

package/dist/toolkits/github/tools/Search/search-code.d.ts

@@ -0,0 +1,14 @@
+export declare const searchCode: import("ai").Tool<{
+    q: string;
+    sort?: "indexed" | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+}, {
+    total_count: number;
+    incomplete_results: boolean;
+    items: import("@octokit/openapi-types").components["schemas"]["code-search-result-item"][];
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=search-code.d.ts.map

package/dist/toolkits/github/tools/Search/search-code.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const searchCode = tool({
+    description: 'Search code. Searches for query terms inside of a file.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        q: z.string().describe('The query contains one or more search keywords and qualifiers. Qualifiers allow you to limit your search to specific areas of GitHub.'),
+        sort: z.enum(['indexed']).optional().describe('Sorts the results of your query.'),
+        order: z.enum(['desc', 'asc']).optional().describe('Determines whether the first search result returned is the highest number of matches (desc) or lowest number of matches (asc).'),
+        per_page: z.number().optional().describe('Results per page (max 100).'),
+    }),
+    execute: async ({ githubToken, q, sort, order, per_page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.search.code({
+                q,
+                sort,
+                order,
+                per_page,
+            });
+            return data;
+        }
+        catch (error) {
+            return { error: `Failed to search code: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=search-code.js.map

package/dist/toolkits/github/tools/Search/search-commits.d.ts

@@ -0,0 +1,14 @@
+export declare const searchCommits: import("ai").Tool<{
+    q: string;
+    sort?: "author-date" | "committer-date" | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+}, {
+    total_count: number;
+    incomplete_results: boolean;
+    items: import("@octokit/openapi-types").components["schemas"]["commit-search-result-item"][];
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=search-commits.d.ts.map

package/dist/toolkits/github/tools/Search/search-commits.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const searchCommits = tool({
+    description: 'Search commits. Find commits via various criteria on the default branch (usually master).',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        q: z.string().describe('The query contains one or more search keywords and qualifiers. Qualifiers allow you to limit your search to specific areas of GitHub.'),
+        sort: z.enum(['author-date', 'committer-date']).optional().describe('Sorts the results of your query.'),
+        order: z.enum(['desc', 'asc']).optional().describe('Determines whether the first search result returned is the highest number of matches (desc) or lowest number of matches (asc).'),
+        per_page: z.number().optional().describe('Results per page (max 100).'),
+    }),
+    execute: async ({ githubToken, q, sort, order, per_page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.search.commits({
+                q,
+                sort,
+                order,
+                per_page,
+            });
+            return data;
+        }
+        catch (error) {
+            return { error: `Failed to search commits: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=search-commits.js.map

package/dist/toolkits/github/tools/Search/search-issues.d.ts

@@ -0,0 +1,23 @@
+export declare const searchIssues: import("ai").Tool<{
+    q: string;
+    perPage: number;
+    order: "asc" | "desc";
+    sort?: "created" | "updated" | "comments" | "reactions" | "reactions-+1" | "reactions--1" | "reactions-smile" | "reactions-thinking_face" | "reactions-heart" | "reactions-tada" | undefined;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    items?: undefined;
+} | {
+    total_count: number;
+    items: {
+        number: number;
+        title: string;
+        state: string;
+        html_url: string;
+        user: string | undefined;
+        pull_request: boolean;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=search-issues.d.ts.map

package/dist/toolkits/github/tools/Search/search-issues.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const searchIssues = tool({
+    description: 'Search for GitHub issues and pull requests.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        q: z.string().describe('Search query (e.g., "is:issue state:open port")'),
+        sort: z.enum(['comments', 'reactions', 'reactions-+1', 'reactions--1', 'reactions-smile', 'reactions-thinking_face', 'reactions-heart', 'reactions-tada', 'updated', 'created']).optional(),
+        order: z.enum(['asc', 'desc']).optional().default('desc'),
+        perPage: z.number().optional().default(10),
+    }),
+    execute: async ({ githubToken, q, sort, order = 'desc', perPage = 10 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.search.issuesAndPullRequests({
+                q,
+                sort,
+                order,
+                per_page: perPage,
+            });
+            return {
+                total_count: data.total_count,
+                items: data.items.map((item) => ({
+                    number: item.number,
+                    title: item.title,
+                    state: item.state,
+                    html_url: item.html_url,
+                    user: item.user?.login,
+                    pull_request: !!item.pull_request,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to search issues: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=search-issues.js.map

package/dist/toolkits/github/tools/Search/search-labels.d.ts

@@ -0,0 +1,15 @@
+export declare const searchLabels: import("ai").Tool<{
+    q: string;
+    repository_id: number;
+    sort?: "created" | "updated" | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+}, {
+    total_count: number;
+    incomplete_results: boolean;
+    items: import("@octokit/openapi-types").components["schemas"]["label-search-result-item"][];
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=search-labels.d.ts.map

package/dist/toolkits/github/tools/Search/search-labels.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const searchLabels = tool({
+    description: 'Search labels. Find labels in a repository with names or descriptions that match search keywords.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        repository_id: z.number().describe('The id of the repository.'),
+        q: z.string().describe('The search keywords. This endpoint does not accept qualifiers in the query string.'),
+        sort: z.enum(['created', 'updated']).optional().describe('Sorts the results of your query.'),
+        order: z.enum(['desc', 'asc']).optional().describe('Determines whether the first search result returned is the highest number of matches (desc) or lowest number of matches (asc).'),
+        per_page: z.number().optional().describe('Results per page (max 100).'),
+    }),
+    execute: async ({ githubToken, repository_id, q, sort, order, per_page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.search.labels({
+                repository_id,
+                q,
+                sort,
+                order,
+                per_page,
+            });
+            return data;
+        }
+        catch (error) {
+            return { error: `Failed to search labels: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=search-labels.js.map

package/dist/toolkits/github/tools/Search/search-repos.d.ts

@@ -0,0 +1,22 @@
+export declare const searchRepos: import("ai").Tool<{
+    query: string;
+    perPage: number;
+    order: "asc" | "desc";
+    sort?: "updated" | "forks" | "stars" | "help-wanted-issues" | undefined;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    items?: undefined;
+} | {
+    total_count: number;
+    items: {
+        full_name: string;
+        description: string | null;
+        html_url: string;
+        stargazers_count: number;
+        language: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=search-repos.d.ts.map

package/dist/toolkits/github/tools/Search/search-repos.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const searchRepos = tool({
+    description: 'Search for GitHub repositories using a query string.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        query: z.string().describe('Search query (e.g., "topic:react stars:>1000")'),
+        sort: z.enum(['stars', 'forks', 'help-wanted-issues', 'updated']).optional(),
+        order: z.enum(['asc', 'desc']).optional().default('desc'),
+        perPage: z.number().optional().default(10),
+    }),
+    execute: async ({ githubToken, query, sort, order = 'desc', perPage = 10 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            let searchQuery = query;
+            if (searchQuery.includes('YOUR_USERNAME')) {
+                const user = await octokit.rest.users.getAuthenticated();
+                searchQuery = searchQuery.replace(/YOUR_USERNAME/g, user.data.login);
+            }
+            const { data } = await octokit.rest.search.repos({
+                q: searchQuery,
+                sort,
+                order,
+                per_page: perPage,
+            });
+            return {
+                total_count: data.total_count,
+                items: data.items.map((repo) => ({
+                    full_name: repo.full_name,
+                    description: repo.description,
+                    html_url: repo.html_url,
+                    stargazers_count: repo.stargazers_count,
+                    language: repo.language,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to search repos: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=search-repos.js.map

package/dist/toolkits/github/tools/Search/search-topics.d.ts

@@ -0,0 +1,12 @@
+export declare const searchTopics: import("ai").Tool<{
+    q: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+}, {
+    total_count: number;
+    incomplete_results: boolean;
+    items: import("@octokit/openapi-types").components["schemas"]["topic-search-result-item"][];
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=search-topics.d.ts.map

package/dist/toolkits/github/tools/Search/search-topics.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const searchTopics = tool({
+    description: 'Search topics. Find topics via various criteria.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        q: z.string().describe('The query contains one or more search keywords and qualifiers. Qualifiers allow you to limit your search to specific areas of GitHub.'),
+        per_page: z.number().optional().describe('Results per page (max 100).'),
+    }),
+    execute: async ({ githubToken, q, per_page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.search.topics({
+                q,
+                per_page,
+            });
+            return data;
+        }
+        catch (error) {
+            return { error: `Failed to search topics: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=search-topics.js.map

package/dist/toolkits/github/tools/Search/search-users.d.ts

@@ -0,0 +1,21 @@
+export declare const searchUsers: import("ai").Tool<{
+    q: string;
+    perPage: number;
+    order: "asc" | "desc";
+    sort?: "followers" | "repositories" | "joined" | undefined;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    items?: undefined;
+} | {
+    total_count: number;
+    items: {
+        login: string;
+        html_url: string;
+        avatar_url: string;
+        type: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=search-users.d.ts.map

package/dist/toolkits/github/tools/Search/search-users.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const searchUsers = tool({
+    description: 'Search for GitHub users.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        q: z.string().describe('Search query (e.g., "tom repos:>42 followers:>1000")'),
+        sort: z.enum(['followers', 'repositories', 'joined']).optional(),
+        order: z.enum(['asc', 'desc']).optional().default('desc'),
+        perPage: z.number().optional().default(10),
+    }),
+    execute: async ({ githubToken, q, sort, order = 'desc', perPage = 10 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.search.users({
+                q,
+                sort,
+                order,
+                per_page: perPage,
+            });
+            return {
+                total_count: data.total_count,
+                items: data.items.map((user) => ({
+                    login: user.login,
+                    html_url: user.html_url,
+                    avatar_url: user.avatar_url,
+                    type: user.type,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to search users: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=search-users.js.map

package/dist/toolkits/github/tools/SecretScanning/get-alert.d.ts

@@ -0,0 +1,33 @@
+export declare const getSecretScanningAlert: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    alert_number: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    number?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+    url?: undefined;
+    html_url?: undefined;
+    state?: undefined;
+    resolution?: undefined;
+    resolved_at?: undefined;
+    resolved_by?: undefined;
+    secret_type?: undefined;
+    secret?: undefined;
+} | {
+    number: number | undefined;
+    created_at: string | undefined;
+    updated_at: string | null | undefined;
+    url: string | undefined;
+    html_url: string | undefined;
+    state: "open" | "resolved" | undefined;
+    resolution: "false_positive" | "wont_fix" | "revoked" | "used_in_tests" | null | undefined;
+    resolved_at: string | null | undefined;
+    resolved_by: string | undefined;
+    secret_type: string | undefined;
+    secret: string | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-alert.d.ts.map

package/dist/toolkits/github/tools/SecretScanning/get-alert.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getSecretScanningAlert = tool({
+    description: 'Get a secret scanning alert.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner (username or org)'),
+        repo: z.string().describe('Repository name'),
+        alert_number: z.number().describe('The alert number'),
+    }),
+    execute: async ({ githubToken, owner, repo, alert_number }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.secretScanning.getAlert({
+                owner,
+                repo,
+                alert_number,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                number: data.number,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+                url: data.url,
+                html_url: data.html_url,
+                state: data.state,
+                resolution: data.resolution,
+                resolved_at: data.resolved_at,
+                resolved_by: data.resolved_by?.login,
+                secret_type: data.secret_type,
+                secret: data.secret,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get secret scanning alert: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-alert.js.map