@rnsk/toolkits 0.0.1 → 0.0.2

package/dist/toolkits/github/tools/PRs/list-pull-requests.d.ts

@@ -0,0 +1,24 @@
+export declare const listPullRequests: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    state: "all" | "open" | "closed";
+    perPage: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    pull_requests?: undefined;
+    count?: undefined;
+} | {
+    pull_requests: {
+        number: number;
+        title: string;
+        state: string;
+        html_url: string;
+        user: string | undefined;
+        head: string;
+        base: string;
+    }[];
+    count: number;
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-pull-requests.d.ts.map

package/dist/toolkits/github/tools/PRs/list-pull-requests.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listPullRequests = tool({
+    description: 'List pull requests 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'),
+        state: z.enum(['open', 'closed', 'all']).optional().default('open'),
+        perPage: z.number().optional().default(30),
+    }),
+    execute: async ({ githubToken, owner, repo, state = 'open', 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.pulls.list({
+                owner,
+                repo,
+                state,
+                per_page: perPage,
+            });
+            return {
+                pull_requests: data.map((pr) => ({
+                    number: pr.number,
+                    title: pr.title,
+                    state: pr.state,
+                    html_url: pr.html_url,
+                    user: pr.user?.login,
+                    head: pr.head.ref,
+                    base: pr.base.ref,
+                })),
+                count: data.length,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list PRs: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-pull-requests.js.map

package/dist/toolkits/github/tools/PRs/merge-pull-request.d.ts

@@ -0,0 +1,20 @@
+export declare const mergePullRequest: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    pullNumber: number;
+    mergeMethod: "merge" | "squash" | "rebase";
+    githubToken?: string | undefined;
+    commitTitle?: string | undefined;
+    commitMessage?: string | undefined;
+}, {
+    error: string;
+    sha?: undefined;
+    merged?: undefined;
+    message?: undefined;
+} | {
+    sha: string;
+    merged: boolean;
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=merge-pull-request.d.ts.map

package/dist/toolkits/github/tools/PRs/merge-pull-request.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const mergePullRequest = tool({
+    description: 'Merge a pull request.',
+    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'),
+        pullNumber: z.number().describe('Pull request number'),
+        commitTitle: z.string().optional().describe('Title for the automatic commit message'),
+        commitMessage: z.string().optional().describe('Extra detail to append to automatic commit message'),
+        mergeMethod: z.enum(['merge', 'squash', 'rebase']).optional().default('merge'),
+    }),
+    execute: async ({ githubToken, owner, repo, pullNumber, commitTitle, commitMessage, mergeMethod = 'merge' }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.pulls.merge({
+                owner,
+                repo,
+                pull_number: pullNumber,
+                commit_title: commitTitle,
+                commit_message: commitMessage,
+                merge_method: mergeMethod,
+            });
+            return {
+                sha: data.sha,
+                merged: data.merged,
+                message: data.message,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to merge PR: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=merge-pull-request.js.map

package/dist/toolkits/github/tools/PRs/update-pull-request-branch.d.ts

@@ -0,0 +1,16 @@
+export declare const updatePullRequestBranch: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    pullNumber: number;
+    githubToken?: string | undefined;
+    expected_head_sha?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+    url?: undefined;
+} | {
+    message: string | undefined;
+    url: string | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-pull-request-branch.d.ts.map

package/dist/toolkits/github/tools/PRs/update-pull-request-branch.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updatePullRequestBranch = tool({
+    description: 'Update a pull request branch with the latest changes from the base branch.',
+    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'),
+        pullNumber: z.number().describe('Pull request number'),
+        expected_head_sha: z.string().optional().describe('The expected SHA of the pull request\'s HEAD ref. This is the most recent commit on the pull request\'s branch. If the SHA has changed since you fetched it, the update will fail.'),
+    }),
+    execute: async ({ githubToken, owner, repo, pullNumber, expected_head_sha }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.pulls.updateBranch({
+                owner,
+                repo,
+                pull_number: pullNumber,
+                expected_head_sha,
+            });
+            return {
+                message: data.message,
+                url: data.url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update PR branch: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-pull-request-branch.js.map

package/dist/toolkits/github/tools/PRs/update-pull-request.d.ts

@@ -0,0 +1,26 @@
+export declare const updatePullRequest: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    pullNumber: number;
+    title?: string | undefined;
+    body?: string | undefined;
+    githubToken?: string | undefined;
+    state?: "open" | "closed" | undefined;
+    base?: string | undefined;
+    maintainer_can_modify?: boolean | undefined;
+}, {
+    error: string;
+    number?: undefined;
+    title?: undefined;
+    state?: undefined;
+    html_url?: undefined;
+    merged?: undefined;
+} | {
+    number: number;
+    title: string;
+    state: "open" | "closed";
+    html_url: string;
+    merged: boolean;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-pull-request.d.ts.map

package/dist/toolkits/github/tools/PRs/update-pull-request.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updatePullRequest = tool({
+    description: 'Update a pull request (title, body, state, base).',
+    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'),
+        pullNumber: z.number().describe('Pull request number'),
+        title: z.string().optional().describe('New title for the pull request'),
+        body: z.string().optional().describe('New body for the pull request'),
+        state: z.enum(['open', 'closed']).optional().describe('New state of the pull request'),
+        base: z.string().optional().describe('The name of the branch you want your changes pulled into.'),
+        maintainer_can_modify: z.boolean().optional().describe('Indicates whether maintainers can modify the pull request.'),
+    }),
+    execute: async ({ githubToken, owner, repo, pullNumber, title, body, state, base, maintainer_can_modify }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.pulls.update({
+                owner,
+                repo,
+                pull_number: pullNumber,
+                title,
+                body,
+                state,
+                base,
+                maintainer_can_modify,
+            });
+            return {
+                number: data.number,
+                title: data.title,
+                state: data.state,
+                html_url: data.html_url,
+                merged: data.merged,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update PR: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-pull-request.js.map

package/dist/toolkits/github/tools/Projects/create-org-project.d.ts

@@ -0,0 +1,27 @@
+export declare const createOrgProject: import("ai").Tool<{
+    name: string;
+    org: string;
+    body?: string | undefined;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    body?: undefined;
+    number?: undefined;
+    state?: undefined;
+    html_url?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+} | {
+    id: any;
+    name: any;
+    body: any;
+    number: any;
+    state: any;
+    html_url: any;
+    created_at: any;
+    updated_at: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-org-project.d.ts.map

package/dist/toolkits/github/tools/Projects/create-org-project.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createOrgProject = tool({
+    description: 'Create an organization project.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+        name: z.string().describe('The name of the project'),
+        body: z.string().optional().describe('The body of the project'),
+    }),
+    execute: async ({ githubToken, org, name, body }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.projects.createForOrg({
+                org,
+                name,
+                body,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            const d = data;
+            return {
+                id: d.id,
+                name: d.name,
+                body: d.body,
+                number: d.number,
+                state: d.state,
+                html_url: d.html_url,
+                created_at: d.created_at,
+                updated_at: d.updated_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create org project: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-org-project.js.map

package/dist/toolkits/github/tools/Projects/delete-project.d.ts

@@ -0,0 +1,11 @@
+export declare const deleteProject: import("ai").Tool<{
+    project_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=delete-project.d.ts.map

package/dist/toolkits/github/tools/Projects/delete-project.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const deleteProject = tool({
+    description: 'Delete a project.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        project_id: z.number().describe('The unique identifier of the project'),
+    }),
+    execute: async ({ githubToken, project_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.projects.delete({
+                project_id,
+            });
+            return { message: `Successfully deleted project ${project_id}` };
+        }
+        catch (error) {
+            return { error: `Failed to delete project: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=delete-project.js.map

package/dist/toolkits/github/tools/Projects/get-project.d.ts

@@ -0,0 +1,31 @@
+export declare const getProject: import("ai").Tool<{
+    project_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    body?: undefined;
+    number?: undefined;
+    state?: undefined;
+    creator?: undefined;
+    html_url?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+    organization_permission?: undefined;
+    owner_url?: undefined;
+} | {
+    id: any;
+    name: any;
+    body: any;
+    number: any;
+    state: any;
+    creator: any;
+    html_url: any;
+    created_at: any;
+    updated_at: any;
+    organization_permission: any;
+    owner_url: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-project.d.ts.map

package/dist/toolkits/github/tools/Projects/get-project.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getProject = tool({
+    description: 'Get a project.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        project_id: z.number().describe('The unique identifier of the project'),
+    }),
+    execute: async ({ githubToken, project_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.projects.get({
+                project_id,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            const d = data;
+            return {
+                id: d.id,
+                name: d.name,
+                body: d.body,
+                number: d.number,
+                state: d.state,
+                creator: d.creator?.login,
+                html_url: d.html_url,
+                created_at: d.created_at,
+                updated_at: d.updated_at,
+                organization_permission: d.organization_permission,
+                owner_url: d.owner_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get project: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-project.js.map

package/dist/toolkits/github/tools/Projects/list-org-projects.d.ts

@@ -0,0 +1,20 @@
+export declare const listOrgProjects: import("ai").Tool<{
+    org: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    state?: "all" | "open" | "closed" | undefined;
+}, {
+    id: any;
+    name: any;
+    body: any;
+    number: any;
+    state: any;
+    creator: any;
+    html_url: any;
+    created_at: any;
+    updated_at: any;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-org-projects.d.ts.map

package/dist/toolkits/github/tools/Projects/list-org-projects.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listOrgProjects = tool({
+    description: 'List organization projects.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+        state: z.enum(['open', 'closed', 'all']).optional().describe('Filter projects by state'),
+        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, org, state, 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.projects.listForOrg({
+                org,
+                state: state ?? 'open',
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map((project) => ({
+                id: project.id,
+                name: project.name,
+                body: project.body,
+                number: project.number,
+                state: project.state,
+                creator: project.creator?.login,
+                html_url: project.html_url,
+                created_at: project.created_at,
+                updated_at: project.updated_at,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list org projects: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-org-projects.js.map

package/dist/toolkits/github/tools/Projects/list-project-columns.d.ts

@@ -0,0 +1,16 @@
+export declare const listProjectColumns: import("ai").Tool<{
+    project_id: number;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    id: any;
+    name: any;
+    project_url: any;
+    cards_url: any;
+    created_at: any;
+    updated_at: any;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-project-columns.d.ts.map

package/dist/toolkits/github/tools/Projects/list-project-columns.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listProjectColumns = tool({
+    description: 'List columns for a project.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        project_id: z.number().describe('The unique identifier of the project'),
+        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, project_id, 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.projects.listColumns({
+                project_id,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map((column) => ({
+                id: column.id,
+                name: column.name,
+                project_url: column.project_url,
+                cards_url: column.cards_url,
+                created_at: column.created_at,
+                updated_at: column.updated_at,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list project columns: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-project-columns.js.map

package/dist/toolkits/github/tools/Projects/list-repo-projects.d.ts

@@ -0,0 +1,21 @@
+export declare const listRepoProjects: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    state?: "all" | "open" | "closed" | undefined;
+}, {
+    id: any;
+    name: any;
+    body: any;
+    number: any;
+    state: any;
+    creator: any;
+    html_url: any;
+    created_at: any;
+    updated_at: any;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-repo-projects.d.ts.map

package/dist/toolkits/github/tools/Projects/list-repo-projects.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listRepoProjects = tool({
+    description: 'List repository projects.',
+    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'),
+        state: z.enum(['open', 'closed', 'all']).optional().describe('Filter projects by state'),
+        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, state, 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.projects.listForRepo({
+                owner,
+                repo,
+                state: state ?? 'open',
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map((project) => ({
+                id: project.id,
+                name: project.name,
+                body: project.body,
+                number: project.number,
+                state: project.state,
+                creator: project.creator?.login,
+                html_url: project.html_url,
+                created_at: project.created_at,
+                updated_at: project.updated_at,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list repo projects: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-repo-projects.js.map

package/dist/toolkits/github/tools/Projects/update-project.d.ts

@@ -0,0 +1,22 @@
+export declare const updateProject: import("ai").Tool<{
+    project_id: number;
+    body?: string | undefined;
+    githubToken?: string | undefined;
+    name?: string | undefined;
+    state?: "open" | "closed" | undefined;
+    private?: boolean | undefined;
+    organization_permission?: "read" | "write" | "none" | "admin" | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    state?: undefined;
+    updated_at?: undefined;
+} | {
+    id: any;
+    name: any;
+    state: any;
+    updated_at: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-project.d.ts.map