@rnsk/toolkits 0.0.1 → 0.0.2

package/dist/toolkits/github/tools/Commits/compare-commits.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const compareCommits = tool({
+    description: 'Compare two commits',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('The account owner of the repository. The name is not case sensitive.'),
+        repo: z.string().describe('The name of the repository without the .git extension. The name is not case sensitive.'),
+        base: z.string().describe('The base branch or commit SHA to compare against.'),
+        head: z.string().describe('The head branch or commit SHA to compare.'),
+        perPage: z.number().optional().default(30),
+        page: z.number().optional().default(1),
+    }),
+    execute: async ({ githubToken, owner, repo, base, head, perPage = 30, page = 1 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.compareCommits({
+                owner,
+                repo,
+                base,
+                head,
+                per_page: perPage,
+                page,
+            });
+            return { comparison: data };
+        }
+        catch (error) {
+            return { error: `Failed to compare commits: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=compare-commits.js.map

package/dist/toolkits/github/tools/Commits/get-commit.d.ts

@@ -0,0 +1,46 @@
+export declare const getCommit: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    page: number;
+    ref: string;
+    perPage: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    commit?: undefined;
+} | {
+    commit: {
+        url: string;
+        sha: string;
+        node_id: string;
+        html_url: string;
+        comments_url: string;
+        commit: {
+            url: string;
+            author: import("@octokit/openapi-types").components["schemas"]["nullable-git-user"];
+            committer: import("@octokit/openapi-types").components["schemas"]["nullable-git-user"];
+            message: string;
+            comment_count: number;
+            tree: {
+                sha: string;
+                url: string;
+            };
+            verification?: import("@octokit/openapi-types").components["schemas"]["verification"];
+        };
+        author: import("@octokit/openapi-types").components["schemas"]["simple-user"] | import("@octokit/openapi-types").components["schemas"]["empty-object"] | null;
+        committer: import("@octokit/openapi-types").components["schemas"]["simple-user"] | import("@octokit/openapi-types").components["schemas"]["empty-object"] | null;
+        parents: {
+            sha: string;
+            url: string;
+            html_url?: string;
+        }[];
+        stats?: {
+            additions?: number;
+            deletions?: number;
+            total?: number;
+        };
+        files?: import("@octokit/openapi-types").components["schemas"]["diff-entry"][];
+    };
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-commit.d.ts.map

package/dist/toolkits/github/tools/Commits/get-commit.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getCommit = tool({
+    description: 'Get a commit',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('The account owner of the repository. The name is not case sensitive.'),
+        repo: z.string().describe('The name of the repository without the .git extension. The name is not case sensitive.'),
+        ref: z.string().describe('The commit reference. Can be a commit SHA, branch name, or tag name.'),
+        perPage: z.number().optional().default(30),
+        page: z.number().optional().default(1),
+    }),
+    execute: async ({ githubToken, owner, repo, ref, perPage = 30, page = 1 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.getCommit({
+                owner,
+                repo,
+                ref,
+                per_page: perPage,
+                page,
+            });
+            return { commit: data };
+        }
+        catch (error) {
+            return { error: `Failed to get commit: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-commit.js.map

package/dist/toolkits/github/tools/Commits/list-branches-for-head-commit.d.ts

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

package/dist/toolkits/github/tools/Commits/list-branches-for-head-commit.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listBranchesForHeadCommit = tool({
+    description: 'List branches for HEAD commit',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('The account owner of the repository. The name is not case sensitive.'),
+        repo: z.string().describe('The name of the repository without the .git extension. The name is not case sensitive.'),
+        commit_sha: z.string().describe('The SHA of the commit.'),
+    }),
+    execute: async ({ githubToken, owner, repo, commit_sha }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.listBranchesForHeadCommit({
+                owner,
+                repo,
+                commit_sha,
+            });
+            return { branches: data };
+        }
+        catch (error) {
+            return { error: `Failed to list branches for HEAD commit: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-branches-for-head-commit.js.map

package/dist/toolkits/github/tools/Commits/list-commits.d.ts

@@ -0,0 +1,21 @@
+export declare const listCommits: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    perPage: number;
+    path?: string | undefined;
+    githubToken?: string | undefined;
+    sha?: string | undefined;
+}, {
+    error: string;
+    commits?: undefined;
+} | {
+    commits: {
+        sha: string;
+        message: string;
+        author: string | undefined;
+        date: string | undefined;
+        html_url: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-commits.d.ts.map

package/dist/toolkits/github/tools/Commits/list-commits.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listCommits = tool({
+    description: 'List commits on 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),
+        sha: z.string().optional().describe('SHA or branch to start listing from'),
+        path: z.string().optional().describe('Only commits containing this file path'),
+    }),
+    execute: async ({ githubToken, owner, repo, perPage = 30, sha, path }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.listCommits({
+                owner,
+                repo,
+                per_page: perPage,
+                sha,
+                path,
+            });
+            return {
+                commits: data.map((commit) => ({
+                    sha: commit.sha,
+                    message: commit.commit.message,
+                    author: commit.commit.author?.name,
+                    date: commit.commit.author?.date,
+                    html_url: commit.html_url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list commits: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-commits.js.map

package/dist/toolkits/github/tools/Commits/list-pull-requests-associated-with-commit.d.ts

@@ -0,0 +1,81 @@
+export declare const listPullRequestsAssociatedWithCommit: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    page: number;
+    perPage: number;
+    commit_sha: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    pullRequests?: undefined;
+} | {
+    pullRequests: {
+        url: string;
+        id: number;
+        node_id: string;
+        html_url: string;
+        diff_url: string;
+        patch_url: string;
+        issue_url: string;
+        commits_url: string;
+        review_comments_url: string;
+        review_comment_url: string;
+        comments_url: string;
+        statuses_url: string;
+        number: number;
+        state: string;
+        locked: boolean;
+        title: string;
+        user: import("@octokit/openapi-types").components["schemas"]["nullable-simple-user"];
+        body: string | null;
+        labels: {
+            id: number;
+            node_id: string;
+            url: string;
+            name: string;
+            description: string;
+            color: string;
+            default: boolean;
+        }[];
+        milestone: import("@octokit/openapi-types").components["schemas"]["nullable-milestone"];
+        active_lock_reason?: string | null;
+        created_at: string;
+        updated_at: string;
+        closed_at: string | null;
+        merged_at: string | null;
+        merge_commit_sha: string | null;
+        assignee: import("@octokit/openapi-types").components["schemas"]["nullable-simple-user"];
+        assignees?: import("@octokit/openapi-types").components["schemas"]["simple-user"][] | null;
+        requested_reviewers?: import("@octokit/openapi-types").components["schemas"]["simple-user"][] | null;
+        requested_teams?: import("@octokit/openapi-types").components["schemas"]["team"][] | null;
+        head: {
+            label: string;
+            ref: string;
+            repo: import("@octokit/openapi-types").components["schemas"]["repository"];
+            sha: string;
+            user: import("@octokit/openapi-types").components["schemas"]["nullable-simple-user"];
+        };
+        base: {
+            label: string;
+            ref: string;
+            repo: import("@octokit/openapi-types").components["schemas"]["repository"];
+            sha: string;
+            user: import("@octokit/openapi-types").components["schemas"]["nullable-simple-user"];
+        };
+        _links: {
+            comments: import("@octokit/openapi-types").components["schemas"]["link"];
+            commits: import("@octokit/openapi-types").components["schemas"]["link"];
+            statuses: import("@octokit/openapi-types").components["schemas"]["link"];
+            html: import("@octokit/openapi-types").components["schemas"]["link"];
+            issue: import("@octokit/openapi-types").components["schemas"]["link"];
+            review_comments: import("@octokit/openapi-types").components["schemas"]["link"];
+            review_comment: import("@octokit/openapi-types").components["schemas"]["link"];
+            self: import("@octokit/openapi-types").components["schemas"]["link"];
+        };
+        author_association: import("@octokit/openapi-types").components["schemas"]["author-association"];
+        auto_merge: import("@octokit/openapi-types").components["schemas"]["auto-merge"];
+        draft?: boolean;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-pull-requests-associated-with-commit.d.ts.map

package/dist/toolkits/github/tools/Commits/list-pull-requests-associated-with-commit.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listPullRequestsAssociatedWithCommit = tool({
+    description: 'List pull requests associated with a commit',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('The account owner of the repository. The name is not case sensitive.'),
+        repo: z.string().describe('The name of the repository without the .git extension. The name is not case sensitive.'),
+        commit_sha: z.string().describe('The SHA of the commit.'),
+        perPage: z.number().optional().default(30),
+        page: z.number().optional().default(1),
+    }),
+    execute: async ({ githubToken, owner, repo, commit_sha, perPage = 30, page = 1 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.listPullRequestsAssociatedWithCommit({
+                owner,
+                repo,
+                commit_sha,
+                per_page: perPage,
+                page,
+            });
+            return { pullRequests: data };
+        }
+        catch (error) {
+            return { error: `Failed to list PRs associated with commit: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-pull-requests-associated-with-commit.js.map

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

@@ -0,0 +1,53 @@
+export declare const getDependabotAlert: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    alert_number: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    number?: undefined;
+    state?: undefined;
+    dependency?: undefined;
+    security_advisory?: undefined;
+    html_url?: undefined;
+} | {
+    number: number;
+    state: "open" | "dismissed" | "fixed" | "auto_dismissed";
+    dependency: {
+        readonly package?: import("@octokit/openapi-types").components["schemas"]["dependabot-alert-package"];
+        readonly manifest_path?: string;
+        readonly scope?: "development" | "runtime" | null;
+        readonly relationship?: "unknown" | "direct" | "transitive" | null;
+    };
+    security_advisory: {
+        readonly ghsa_id: string;
+        readonly cve_id: string | null;
+        readonly summary: string;
+        readonly description: string;
+        readonly vulnerabilities: readonly import("@octokit/openapi-types").components["schemas"]["dependabot-alert-security-vulnerability"][];
+        readonly severity: "low" | "medium" | "high" | "critical";
+        readonly cvss: {
+            readonly score: number;
+            readonly vector_string: string | null;
+        };
+        readonly cvss_severities?: import("@octokit/openapi-types").components["schemas"]["cvss-severities"];
+        readonly epss?: import("@octokit/openapi-types").components["schemas"]["security-advisory-epss"];
+        readonly cwes: readonly {
+            readonly cwe_id: string;
+            readonly name: string;
+        }[];
+        readonly identifiers: readonly {
+            readonly type: "CVE" | "GHSA";
+            readonly value: string;
+        }[];
+        readonly references: readonly {
+            readonly url: string;
+        }[];
+        readonly published_at: string;
+        readonly updated_at: string;
+        readonly withdrawn_at: string | null;
+    };
+    html_url: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-alert.d.ts.map

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

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getDependabotAlert = tool({
+    description: 'Get a Dependabot 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.dependabot.getAlert({
+                owner,
+                repo,
+                alert_number,
+            });
+            return {
+                number: data.number,
+                state: data.state,
+                dependency: data.dependency,
+                security_advisory: data.security_advisory,
+                html_url: data.html_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get Dependabot alert: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-alert.js.map

package/dist/toolkits/github/tools/Dependabot/list-alerts.d.ts

@@ -0,0 +1,23 @@
+export declare const listDependabotAlerts: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    state?: "open" | "dismissed" | "fixed" | "auto_dismissed" | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | undefined;
+}, {
+    error: string;
+    alerts?: undefined;
+} | {
+    alerts: {
+        number: number;
+        state: "open" | "dismissed" | "fixed" | "auto_dismissed";
+        dependency: string | undefined;
+        security_advisory: string;
+        severity: "low" | "medium" | "high" | "critical";
+        html_url: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-alerts.d.ts.map

package/dist/toolkits/github/tools/Dependabot/list-alerts.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listDependabotAlerts = tool({
+    description: 'List Dependabot alerts 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'),
+        state: z.enum(['auto_dismissed', 'dismissed', 'fixed', 'open']).optional().describe('Filter by state'),
+        severity: z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Filter by severity'),
+        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, severity, 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.dependabot.listAlertsForRepo({
+                owner,
+                repo,
+                state,
+                severity,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                alerts: data.map(alert => ({
+                    number: alert.number,
+                    state: alert.state,
+                    dependency: alert.dependency?.package?.name,
+                    security_advisory: alert.security_advisory?.summary,
+                    severity: alert.security_advisory?.severity,
+                    html_url: alert.html_url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list Dependabot alerts: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-alerts.js.map

package/dist/toolkits/github/tools/Dependabot/update-alert.d.ts

@@ -0,0 +1,19 @@
+export declare const updateDependabotAlert: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    alert_number: number;
+    state: "open" | "dismissed";
+    githubToken?: string | undefined;
+    dismissed_reason?: "fix_started" | "inaccurate" | "no_bandwidth" | "not_used" | "tolerable_risk" | undefined;
+}, {
+    error: string;
+    number?: undefined;
+    state?: undefined;
+    dismissed_reason?: undefined;
+} | {
+    number: number;
+    state: "open" | "dismissed" | "fixed" | "auto_dismissed";
+    dismissed_reason: "fix_started" | "inaccurate" | "no_bandwidth" | "not_used" | "tolerable_risk" | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-alert.d.ts.map

package/dist/toolkits/github/tools/Dependabot/update-alert.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateDependabotAlert = tool({
+    description: 'Update a Dependabot 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'),
+        state: z.enum(['dismissed', 'open']).describe('The state to set'),
+        dismissed_reason: z.enum(['fix_started', 'inaccurate', 'no_bandwidth', 'not_used', 'tolerable_risk']).optional().describe('Required when state is dismissed'),
+    }),
+    execute: async ({ githubToken, owner, repo, alert_number, state, dismissed_reason }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.dependabot.updateAlert({
+                owner,
+                repo,
+                alert_number,
+                state,
+                dismissed_reason,
+            });
+            return {
+                number: data.number,
+                state: data.state,
+                dismissed_reason: data.dismissed_reason,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update Dependabot alert: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-alert.js.map

package/dist/toolkits/github/tools/DeployKeys/create-deploy-key.d.ts

@@ -0,0 +1,23 @@
+export declare const createDeployKey: import("ai").Tool<{
+    title: string;
+    repo: string;
+    owner: string;
+    key: string;
+    githubToken?: string | undefined;
+    read_only?: boolean | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    key?: undefined;
+    title?: undefined;
+    read_only?: undefined;
+    created_at?: undefined;
+} | {
+    id: number;
+    key: string;
+    title: string;
+    read_only: boolean;
+    created_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-deploy-key.d.ts.map

package/dist/toolkits/github/tools/DeployKeys/create-deploy-key.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createDeployKey = tool({
+    description: 'Create a deploy key 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'),
+        title: z.string().describe('A name for the key'),
+        key: z.string().describe('The contents of the key'),
+        read_only: z.boolean().optional().describe('If true, the key will only be able to read repository contents'),
+    }),
+    execute: async ({ githubToken, owner, repo, title, key, read_only }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.createDeployKey({
+                owner,
+                repo,
+                title,
+                key,
+                read_only: read_only ?? true,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                key: data.key,
+                title: data.title,
+                read_only: data.read_only,
+                created_at: data.created_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create deploy key: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-deploy-key.js.map

package/dist/toolkits/github/tools/DeployKeys/delete-deploy-key.d.ts

@@ -0,0 +1,13 @@
+export declare const deleteDeployKey: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    key_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=delete-deploy-key.d.ts.map