@rnsk/toolkits 0.0.1 → 0.0.3

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

@@ -0,0 +1,57 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createRepo = tool({
+    description: 'Create a new repository for the authenticated GitHub user. Use when the user asks to create a new repo, start a new project on GitHub, or initialize a repository.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        name: z.string().describe('The name of the repository.'),
+        description: z.string().optional().describe('A short description of the repository.'),
+        homepage: z.string().optional().describe('A URL with more information about the repository.'),
+        private: z.boolean().optional().default(false).describe('Whether the repository is private.'),
+        has_issues: z.boolean().optional().default(true).describe('Whether issues are enabled.'),
+        has_projects: z.boolean().optional().default(true).describe('Whether projects are enabled.'),
+        has_wiki: z.boolean().optional().default(true).describe('Whether the wiki is enabled.'),
+        auto_init: z.boolean().optional().default(false).describe('Whether the repository is initialized with a minimal README.'),
+        gitignore_template: z.string().optional().describe('The desired language or platform to apply to the .gitignore. (e.g., "Node", "Python")'),
+        license_template: z.string().optional().describe('The license keyword of the open source license for this repository. (e.g., "mit", "apache-2.0")'),
+    }),
+    execute: async ({ githubToken, name, description, homepage, private: isPrivate, has_issues, has_projects, has_wiki, auto_init, gitignore_template, license_template }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.createForAuthenticatedUser({
+                name,
+                description,
+                homepage,
+                private: isPrivate,
+                has_issues,
+                has_projects,
+                has_wiki,
+                auto_init,
+                gitignore_template,
+                license_template,
+            });
+            return {
+                success: true,
+                repo: {
+                    name: data.name,
+                    full_name: data.full_name,
+                    description: data.description,
+                    html_url: data.html_url,
+                    private: data.private,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to create repository',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-repo.js.map

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

@@ -0,0 +1,17 @@
+export declare const forkRepo: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    organization?: string | undefined;
+}, {
+    error: string;
+    full_name?: undefined;
+    html_url?: undefined;
+    message?: undefined;
+} | {
+    full_name: string;
+    html_url: string;
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=fork-repo.d.ts.map

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

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const forkRepo = tool({
+    description: 'Fork a GitHub repository to your account or an organization.',
+    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'),
+        organization: z.string().optional().describe('Optional: Organization to fork to'),
+    }),
+    execute: async ({ githubToken, owner, repo, organization }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.createFork({
+                owner,
+                repo,
+                organization,
+            });
+            return {
+                full_name: data.full_name,
+                html_url: data.html_url,
+                message: 'Fork created successfully',
+            };
+        }
+        catch (error) {
+            return { error: `Failed to fork repo: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=fork-repo.js.map

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

@@ -0,0 +1,20 @@
+export declare const getRepoContributors: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    perPage: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    contributors?: undefined;
+    count?: undefined;
+} | {
+    contributors: {
+        login: string | undefined;
+        contributions: number;
+        avatar_url: string | undefined;
+        html_url: string | undefined;
+    }[];
+    count: number;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-repo-contributors.d.ts.map

package/dist/toolkits/github/tools/Repos/get-repo-contributors.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getRepoContributors = tool({
+    description: 'List contributors for 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'),
+        perPage: z.number().optional().default(30),
+    }),
+    execute: async ({ githubToken, owner, repo, perPage = 30 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.listContributors({
+                owner,
+                repo,
+                per_page: perPage,
+            });
+            return {
+                contributors: data.map((c) => ({
+                    login: c.login,
+                    contributions: c.contributions,
+                    avatar_url: c.avatar_url,
+                    html_url: c.html_url,
+                })),
+                count: data.length,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get contributors: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-repo-contributors.js.map

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

@@ -0,0 +1,14 @@
+export declare const getRepoLanguages: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    languages?: undefined;
+} | {
+    languages: {
+        [key: string]: number;
+    };
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-repo-languages.d.ts.map

package/dist/toolkits/github/tools/Repos/get-repo-languages.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getRepoLanguages = tool({
+    description: 'List languages used in 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'),
+    }),
+    execute: async ({ githubToken, owner, repo }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.listLanguages({
+                owner,
+                repo,
+            });
+            return { languages: data };
+        }
+        catch (error) {
+            return { error: `Failed to get languages: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-repo-languages.js.map

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

@@ -0,0 +1,36 @@
+export declare const getRepo: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    name?: undefined;
+    full_name?: undefined;
+    description?: undefined;
+    private?: undefined;
+    html_url?: undefined;
+    clone_url?: undefined;
+    stars?: undefined;
+    forks?: undefined;
+    open_issues?: undefined;
+    default_branch?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+    language?: undefined;
+} | {
+    name: string;
+    full_name: string;
+    description: string | null;
+    private: boolean;
+    html_url: string;
+    clone_url: string;
+    stars: number;
+    forks: number;
+    open_issues: number;
+    default_branch: string;
+    created_at: string;
+    updated_at: string;
+    language: string | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-repo.d.ts.map

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

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getRepo = tool({
+    description: 'Get detailed information about a specific GitHub repository. Returns stars, forks, issues count, description, etc.',
+    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'),
+    }),
+    execute: async ({ githubToken, owner, repo }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.get({
+                owner,
+                repo,
+            });
+            return {
+                name: data.name,
+                full_name: data.full_name,
+                description: data.description,
+                private: data.private,
+                html_url: data.html_url,
+                clone_url: data.clone_url,
+                stars: data.stargazers_count,
+                forks: data.forks_count,
+                open_issues: data.open_issues_count,
+                default_branch: data.default_branch,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+                language: data.language,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get repo: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-repo.js.map

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

@@ -0,0 +1,17 @@
+export declare const listBranches: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    perPage: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    branches?: undefined;
+} | {
+    branches: {
+        name: string;
+        sha: string;
+        protected: boolean;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-branches.d.ts.map

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

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listBranches = tool({
+    description: 'List branches of 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'),
+        perPage: z.number().optional().default(30),
+    }),
+    execute: async ({ githubToken, owner, repo, perPage = 30 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.listBranches({
+                owner,
+                repo,
+                per_page: perPage,
+            });
+            return {
+                branches: data.map((branch) => ({
+                    name: branch.name,
+                    sha: branch.commit.sha,
+                    protected: branch.protected,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list branches: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-branches.js.map

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