@rnsk/toolkits 0.0.1 → 0.0.2

package/dist/toolkits/github/tools/Releases/get-latest-release.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getLatestRelease = tool({
+    description: 'Get the latest release for a repository.',
+    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.getLatestRelease({
+                owner,
+                repo,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                tag_name: data.tag_name,
+                name: data.name,
+                body: data.body,
+                published_at: data.published_at,
+                html_url: data.html_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get latest release: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-latest-release.js.map

package/dist/toolkits/github/tools/Releases/get-release.d.ts

@@ -0,0 +1,37 @@
+export declare const getRelease: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    release_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    tag_name?: undefined;
+    name?: undefined;
+    body?: undefined;
+    draft?: undefined;
+    prerelease?: undefined;
+    created_at?: undefined;
+    published_at?: undefined;
+    html_url?: undefined;
+    assets?: undefined;
+} | {
+    id: number;
+    tag_name: string;
+    name: string | null;
+    body: string | null | undefined;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    html_url: string;
+    assets: {
+        id: number;
+        name: string;
+        size: number;
+        download_count: number;
+        browser_download_url: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-release.d.ts.map

package/dist/toolkits/github/tools/Releases/get-release.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getRelease = tool({
+    description: 'Get a release.',
+    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'),
+        release_id: z.number().describe('The unique identifier of the release'),
+    }),
+    execute: async ({ githubToken, owner, repo, release_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.getRelease({
+                owner,
+                repo,
+                release_id,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                tag_name: data.tag_name,
+                name: data.name,
+                body: data.body,
+                draft: data.draft,
+                prerelease: data.prerelease,
+                created_at: data.created_at,
+                published_at: data.published_at,
+                html_url: data.html_url,
+                assets: data.assets.map(asset => ({
+                    id: asset.id,
+                    name: asset.name,
+                    size: asset.size,
+                    download_count: asset.download_count,
+                    browser_download_url: asset.browser_download_url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get release: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-release.js.map

package/dist/toolkits/github/tools/Releases/list-releases.d.ts

@@ -0,0 +1,22 @@
+export declare const listReleases: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    id: number;
+    tag_name: string;
+    target_commitish: string;
+    name: string | null;
+    body: string | null | undefined;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    html_url: string;
+    author: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-releases.d.ts.map

package/dist/toolkits/github/tools/Releases/list-releases.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listReleases = tool({
+    description: 'List releases for a repository.',
+    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'),
+        per_page: z.number().optional().describe('Number of results per page (max 100)'),
+        page: z.number().optional().describe('Page number of results to fetch'),
+    }),
+    execute: async ({ githubToken, owner, repo, per_page, page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.listReleases({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(release => ({
+                id: release.id,
+                tag_name: release.tag_name,
+                target_commitish: release.target_commitish,
+                name: release.name,
+                body: release.body,
+                draft: release.draft,
+                prerelease: release.prerelease,
+                created_at: release.created_at,
+                published_at: release.published_at,
+                html_url: release.html_url,
+                author: release.author?.login,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list releases: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-releases.js.map

package/dist/toolkits/github/tools/Releases/update-release.d.ts

@@ -0,0 +1,27 @@
+export declare const updateRelease: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    release_id: number;
+    body?: string | undefined;
+    githubToken?: string | undefined;
+    name?: string | undefined;
+    draft?: boolean | undefined;
+    tag_name?: string | undefined;
+    target_commitish?: string | undefined;
+    prerelease?: boolean | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    tag_name?: undefined;
+    name?: undefined;
+    body?: undefined;
+    html_url?: undefined;
+} | {
+    id: number;
+    tag_name: string;
+    name: string | null;
+    body: string | null | undefined;
+    html_url: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-release.d.ts.map

package/dist/toolkits/github/tools/Releases/update-release.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateRelease = tool({
+    description: 'Update a release.',
+    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'),
+        release_id: z.number().describe('The unique identifier of the release'),
+        tag_name: z.string().optional().describe('The name of the tag'),
+        target_commitish: z.string().optional().describe('Specifies the commitish value that determines where the Git tag is created from'),
+        name: z.string().optional().describe('The name of the release'),
+        body: z.string().optional().describe('Text describing the contents of the tag'),
+        draft: z.boolean().optional().describe('true to create a draft (unpublished) release, false to create a published one'),
+        prerelease: z.boolean().optional().describe('true to identify the release as a prerelease, false to identify the release as a full release'),
+    }),
+    execute: async ({ githubToken, owner, repo, release_id, ...options }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.updateRelease({
+                owner,
+                repo,
+                release_id,
+                ...options,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                tag_name: data.tag_name,
+                name: data.name,
+                body: data.body,
+                html_url: data.html_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update release: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-release.js.map

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

@@ -0,0 +1,32 @@
+export declare const createRepo: import("ai").Tool<{
+    name: string;
+    private: boolean;
+    has_issues: boolean;
+    has_projects: boolean;
+    has_wiki: boolean;
+    auto_init: boolean;
+    description?: string | undefined;
+    homepage?: string | undefined;
+    githubToken?: string | undefined;
+    gitignore_template?: string | undefined;
+    license_template?: string | undefined;
+}, {
+    error: string;
+    success?: undefined;
+    repo?: undefined;
+} | {
+    success: boolean;
+    repo: {
+        name: string;
+        full_name: string;
+        description: string | null;
+        html_url: string;
+        private: boolean;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    repo?: undefined;
+}>;
+//# sourceMappingURL=create-repo.d.ts.map

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