@rnsk/toolkits 0.0.1 → 0.0.2

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

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const deleteDeployKey = tool({
+    description: 'Delete a deploy key from 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'),
+        key_id: z.number().describe('The unique identifier of the key'),
+    }),
+    execute: async ({ githubToken, owner, repo, key_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.repos.deleteDeployKey({
+                owner,
+                repo,
+                key_id,
+            });
+            return { message: `Successfully deleted deploy key ${key_id}` };
+        }
+        catch (error) {
+            return { error: `Failed to delete deploy key: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=delete-deploy-key.js.map

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

@@ -0,0 +1,21 @@
+export declare const getDeployKey: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    key_id: number;
+    githubToken?: string | 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=get-deploy-key.d.ts.map

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

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getDeployKey = tool({
+    description: 'Get a specific deploy key from 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'),
+        key_id: z.number().describe('The unique identifier of the key'),
+    }),
+    execute: async ({ githubToken, owner, repo, key_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.getDeployKey({
+                owner,
+                repo,
+                key_id,
+            });
+            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 get deploy key: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-deploy-key.js.map

package/dist/toolkits/github/tools/DeployKeys/list-deploy-keys.d.ts

@@ -0,0 +1,21 @@
+export declare const listDeployKeys: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    keys?: undefined;
+} | {
+    keys: {
+        id: number;
+        key: string;
+        url: string;
+        title: string;
+        read_only: boolean;
+        created_at: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-deploy-keys.d.ts.map

package/dist/toolkits/github/tools/DeployKeys/list-deploy-keys.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listDeployKeys = tool({
+    description: 'List deploy keys 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.listDeployKeys({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                keys: data.map(key => ({
+                    id: key.id,
+                    key: key.key,
+                    url: key.url,
+                    title: key.title,
+                    read_only: key.read_only,
+                    created_at: key.created_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list deploy keys: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-deploy-keys.js.map

package/dist/toolkits/github/tools/Deployments/create-deployment.d.ts

@@ -0,0 +1,33 @@
+export declare const createDeployment: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    ref: string;
+    description?: string | undefined;
+    githubToken?: string | undefined;
+    task?: string | undefined;
+    auto_merge?: boolean | undefined;
+    required_contexts?: string[] | undefined;
+    payload?: string | undefined;
+    environment?: string | undefined;
+    transient_environment?: boolean | undefined;
+    production_environment?: boolean | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    sha?: undefined;
+    ref?: undefined;
+    task?: undefined;
+    environment?: undefined;
+    description?: undefined;
+    created_at?: undefined;
+} | {
+    id: any;
+    sha: any;
+    ref: any;
+    task: any;
+    environment: any;
+    description: any;
+    created_at: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-deployment.d.ts.map

package/dist/toolkits/github/tools/Deployments/create-deployment.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createDeployment = tool({
+    description: 'Create a deployment 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'),
+        ref: z.string().describe('The ref to deploy (e.g., branch name, tag, or SHA)'),
+        task: z.string().optional().describe('Specifies a task to execute (e.g., deploy or deploy:migrations)'),
+        auto_merge: z.boolean().optional().describe('Attempts to automatically merge the default branch into the requested ref, if it\'s behind the default branch'),
+        required_contexts: z.array(z.string()).optional().describe('The status contexts that must be in a success state for a deployment to be created'),
+        payload: z.string().optional().describe('JSON payload with extra information about the deployment'),
+        environment: z.string().optional().describe('Name for the target deployment environment (e.g., production, staging)'),
+        description: z.string().optional().describe('Short description of the deployment'),
+        transient_environment: z.boolean().optional().describe('Specifies if the given environment is specific to the deployment and will no longer exist at some point'),
+        production_environment: z.boolean().optional().describe('Specifies if the given environment is one that end-users directly interact with'),
+    }),
+    execute: async ({ githubToken, owner, repo, ref, ...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.createDeployment({
+                owner,
+                repo,
+                ref,
+                ...options,
+                payload: options.payload ? JSON.parse(options.payload) : undefined,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                sha: data.sha,
+                ref: data.ref,
+                task: data.task,
+                environment: data.environment,
+                description: data.description,
+                created_at: data.created_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create deployment: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-deployment.js.map

package/dist/toolkits/github/tools/Deployments/delete-deployment.d.ts

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

package/dist/toolkits/github/tools/Deployments/delete-deployment.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const deleteDeployment = tool({
+    description: 'Delete a deployment from 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'),
+        deployment_id: z.number().describe('The unique identifier of the deployment'),
+    }),
+    execute: async ({ githubToken, owner, repo, deployment_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.repos.deleteDeployment({
+                owner,
+                repo,
+                deployment_id,
+            });
+            return { message: `Successfully deleted deployment ${deployment_id}` };
+        }
+        catch (error) {
+            return { error: `Failed to delete deployment: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=delete-deployment.js.map

package/dist/toolkits/github/tools/Deployments/get-deployment.d.ts

@@ -0,0 +1,27 @@
+export declare const getDeployment: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    deployment_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    sha?: undefined;
+    ref?: undefined;
+    task?: undefined;
+    environment?: undefined;
+    description?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+} | {
+    id: number;
+    sha: string;
+    ref: string;
+    task: string;
+    environment: string;
+    description: string | null;
+    created_at: string;
+    updated_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-deployment.d.ts.map

package/dist/toolkits/github/tools/Deployments/get-deployment.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getDeployment = tool({
+    description: 'Get a specific deployment information.',
+    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'),
+        deployment_id: z.number().describe('The unique identifier of the deployment'),
+    }),
+    execute: async ({ githubToken, owner, repo, deployment_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.getDeployment({
+                owner,
+                repo,
+                deployment_id,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                sha: data.sha,
+                ref: data.ref,
+                task: data.task,
+                environment: data.environment,
+                description: data.description,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get deployment: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-deployment.js.map

package/dist/toolkits/github/tools/Deployments/list-deployments.d.ts

@@ -0,0 +1,27 @@
+export declare const listDeployments: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    ref?: string | undefined;
+    environment?: string | undefined;
+}, {
+    error: string;
+    deployments?: undefined;
+} | {
+    deployments: {
+        id: number;
+        sha: string;
+        ref: string;
+        task: string;
+        environment: string;
+        description: string | null;
+        created_at: string;
+        updated_at: string;
+        statuses_url: string;
+        repository_url: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-deployments.d.ts.map

package/dist/toolkits/github/tools/Deployments/list-deployments.js

@@ -0,0 +1,52 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listDeployments = tool({
+    description: 'List deployments 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'),
+        environment: z.string().optional().describe('The name of the environment that was deployed to'),
+        ref: z.string().optional().describe('The name of the ref to search for'),
+        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, environment, ref, 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.listDeployments({
+                owner,
+                repo,
+                environment,
+                ref,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                deployments: data.map(deployment => ({
+                    id: deployment.id,
+                    sha: deployment.sha,
+                    ref: deployment.ref,
+                    task: deployment.task,
+                    environment: deployment.environment,
+                    description: deployment.description,
+                    created_at: deployment.created_at,
+                    updated_at: deployment.updated_at,
+                    statuses_url: deployment.statuses_url,
+                    repository_url: deployment.repository_url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list deployments: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-deployments.js.map

package/dist/toolkits/github/tools/Environments/create-or-update-environment.d.ts

@@ -0,0 +1,32 @@
+export declare const createOrUpdateEnvironment: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    environment_name: string;
+    githubToken?: string | undefined;
+    wait_timer?: number | undefined;
+    reviewers?: {
+        type: "User" | "Team";
+        id: number;
+    }[] | undefined;
+    deployment_branch_policy?: {
+        protected_branches: boolean;
+        custom_branch_policies: boolean;
+    } | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    url?: undefined;
+    html_url?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+} | {
+    id: number;
+    name: string;
+    url: string;
+    html_url: string;
+    created_at: string;
+    updated_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-or-update-environment.d.ts.map

package/dist/toolkits/github/tools/Environments/create-or-update-environment.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createOrUpdateEnvironment = tool({
+    description: 'Create or update an environment 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'),
+        environment_name: z.string().describe('The name of the environment'),
+        wait_timer: z.number().optional().describe('The amount of time to delay a deployment after the job is triggered in minutes'),
+        reviewers: z.array(z.object({
+            type: z.enum(['User', 'Team']),
+            id: z.number(),
+        })).optional().describe('The people or teams that may review jobs that deploy to this environment'),
+        deployment_branch_policy: z.object({
+            protected_branches: z.boolean(),
+            custom_branch_policies: z.boolean(),
+        }).optional().describe('The type of deployment branch policy for this environment'),
+    }),
+    execute: async ({ githubToken, owner, repo, environment_name, ...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.createOrUpdateEnvironment({
+                owner,
+                repo,
+                environment_name,
+                ...options,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                name: data.name,
+                url: data.url,
+                html_url: data.html_url,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create or update environment: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-or-update-environment.js.map

package/dist/toolkits/github/tools/Environments/delete-environment.d.ts

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

package/dist/toolkits/github/tools/Environments/delete-environment.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const deleteEnvironment = tool({
+    description: 'Delete an environment from 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'),
+        environment_name: z.string().describe('The name of the environment'),
+    }),
+    execute: async ({ githubToken, owner, repo, environment_name }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.repos.deleteAnEnvironment({
+                owner,
+                repo,
+                environment_name,
+            });
+            return { message: `Successfully deleted environment ${environment_name}` };
+        }
+        catch (error) {
+            return { error: `Failed to delete environment: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=delete-environment.js.map

package/dist/toolkits/github/tools/Environments/get-environment.d.ts

@@ -0,0 +1,48 @@
+export declare const getEnvironment: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    environment_name: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    url?: undefined;
+    html_url?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+    protection_rules?: undefined;
+    deployment_branch_policy?: undefined;
+} | {
+    id: number;
+    name: string;
+    url: string;
+    html_url: string;
+    created_at: string;
+    updated_at: string;
+    protection_rules: ({
+        id: number;
+        node_id: string;
+        type: string;
+        wait_timer?: import("@octokit/openapi-types").components["schemas"]["wait-timer"];
+    } | {
+        id: number;
+        node_id: string;
+        prevent_self_review?: boolean;
+        type: string;
+        reviewers?: {
+            type?: import("@octokit/openapi-types").components["schemas"]["deployment-reviewer-type"];
+            reviewer?: import("@octokit/openapi-types").components["schemas"]["simple-user"] | import("@octokit/openapi-types").components["schemas"]["team"];
+        }[];
+    } | {
+        id: number;
+        node_id: string;
+        type: string;
+    })[] | undefined;
+    deployment_branch_policy: {
+        protected_branches: boolean;
+        custom_branch_policies: boolean;
+    } | null | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-environment.d.ts.map

package/dist/toolkits/github/tools/Environments/get-environment.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getEnvironment = tool({
+    description: 'Get a specific environment info 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'),
+        environment_name: z.string().describe('The name of the environment'),
+    }),
+    execute: async ({ githubToken, owner, repo, environment_name }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.getEnvironment({
+                owner,
+                repo,
+                environment_name,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                name: data.name,
+                url: data.url,
+                html_url: data.html_url,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+                protection_rules: data.protection_rules,
+                deployment_branch_policy: data.deployment_branch_policy,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get environment: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-environment.js.map