@rnsk/toolkits 0.0.1 → 0.0.3

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

package/dist/toolkits/github/tools/Environments/list-environments.d.ts

@@ -0,0 +1,23 @@
+export declare const listEnvironments: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    environments?: undefined;
+} | {
+    total_count: number | undefined;
+    environments: {
+        id: number;
+        name: string;
+        url: string;
+        html_url: string;
+        created_at: string;
+        updated_at: string;
+    }[] | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-environments.d.ts.map

package/dist/toolkits/github/tools/Environments/list-environments.js

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

package/dist/toolkits/github/tools/Files/create-or-update-file.d.ts

@@ -0,0 +1,21 @@
+export declare const createOrUpdateFile: import("ai").Tool<{
+    path: string;
+    message: string;
+    repo: string;
+    owner: string;
+    content: string;
+    githubToken?: string | undefined;
+    sha?: string | undefined;
+    branch?: string | undefined;
+}, {
+    error: string;
+    content?: undefined;
+    commit?: undefined;
+    html_url?: undefined;
+} | {
+    content: string | undefined;
+    commit: string | undefined;
+    html_url: string | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-or-update-file.d.ts.map

package/dist/toolkits/github/tools/Files/create-or-update-file.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createOrUpdateFile = tool({
+    description: 'Create or update a file 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'),
+        path: z.string().describe('Path to the file'),
+        message: z.string().describe('Commit message'),
+        content: z.string().describe('File content (will be base64 encoded)'),
+        sha: z.string().optional().describe('SHA of the file being replaced (required if updating)'),
+        branch: z.string().optional().describe('Branch name'),
+    }),
+    execute: async ({ githubToken, owner, repo, path, message, content, sha, branch }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const encodedContent = Buffer.from(content).toString('base64');
+            const { data } = await octokit.rest.repos.createOrUpdateFileContents({
+                owner,
+                repo,
+                path,
+                message,
+                content: encodedContent,
+                sha,
+                branch,
+            });
+            return {
+                content: data.content?.name,
+                commit: data.commit.sha,
+                html_url: data.content?.html_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create/update file: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-or-update-file.js.map

package/dist/toolkits/github/tools/Files/delete-file.d.ts

@@ -0,0 +1,18 @@
+export declare const deleteFile: import("ai").Tool<{
+    path: string;
+    message: string;
+    repo: string;
+    owner: string;
+    sha: string;
+    githubToken?: string | undefined;
+    branch?: string | undefined;
+}, {
+    error: string;
+    commit?: undefined;
+    message?: undefined;
+} | {
+    commit: string | undefined;
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=delete-file.d.ts.map

package/dist/toolkits/github/tools/Files/delete-file.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const deleteFile = tool({
+    description: 'Delete a file from 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'),
+        path: z.string().describe('Path to the file'),
+        message: z.string().describe('Commit message'),
+        sha: z.string().describe('SHA of the file to delete'),
+        branch: z.string().optional().describe('Branch name'),
+    }),
+    execute: async ({ githubToken, owner, repo, path, message, sha, branch }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.deleteFile({
+                owner,
+                repo,
+                path,
+                message,
+                sha,
+                branch,
+            });
+            return {
+                commit: data.commit.sha,
+                message: 'File deleted successfully',
+            };
+        }
+        catch (error) {
+            return { error: `Failed to delete file: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=delete-file.js.map

package/dist/toolkits/github/tools/Files/get-file-content.d.ts

@@ -0,0 +1,32 @@
+export declare const getFileContent: import("ai").Tool<{
+    path: string;
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    ref?: string | undefined;
+}, {
+    error: string;
+    name?: undefined;
+    path?: undefined;
+    sha?: undefined;
+    content?: undefined;
+    download_url?: undefined;
+    message?: undefined;
+} | {
+    name: string;
+    path: string;
+    sha: string;
+    content: string;
+    error?: undefined;
+    download_url?: undefined;
+    message?: undefined;
+} | {
+    name: string;
+    path: string;
+    sha: string;
+    download_url: string | null;
+    message: string;
+    error?: undefined;
+    content?: undefined;
+}>;
+//# sourceMappingURL=get-file-content.d.ts.map

package/dist/toolkits/github/tools/Files/get-file-content.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getFileContent = tool({
+    description: 'Get the content of a file from a GitHub repository. Returns decoded content if text, or info if binary/large.',
+    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'),
+        path: z.string().describe('Path to the file'),
+        ref: z.string().optional().describe('Branch, tag, or commit SHA'),
+    }),
+    execute: async ({ githubToken, owner, repo, path, ref }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.getContent({
+                owner,
+                repo,
+                path,
+                ref,
+            });
+            if (Array.isArray(data)) {
+                return { error: 'Path is a directory, not a file.' };
+            }
+            if ('content' in data && data.encoding === 'base64') {
+                const decoded = Buffer.from(data.content, 'base64').toString('utf-8');
+                return {
+                    name: data.name,
+                    path: data.path,
+                    sha: data.sha,
+                    content: decoded,
+                };
+            }
+            return {
+                name: data.name,
+                path: data.path,
+                sha: data.sha,
+                download_url: data.download_url,
+                message: 'Content not returned in base64 (possibly too large or binary).',
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get file content: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-file-content.js.map

package/dist/toolkits/github/tools/Gists/create-gist.d.ts

@@ -0,0 +1,19 @@
+export declare const createGist: import("ai").Tool<{
+    public: boolean;
+    files: Record<string, {
+        content: string;
+    }>;
+    description?: string | undefined;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    html_url?: undefined;
+    files?: undefined;
+} | {
+    id: string | undefined;
+    html_url: string | undefined;
+    files: string[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-gist.d.ts.map

package/dist/toolkits/github/tools/Gists/create-gist.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createGist = tool({
+    description: 'Create a new gist.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        description: z.string().optional().describe('Description of the gist'),
+        public: z.boolean().optional().default(false).describe('True for public, false for secret'),
+        files: z.record(z.string(), z.object({
+            content: z.string().describe('File content'),
+        })).describe('Object where keys are filenames and values are objects with content'),
+    }),
+    execute: async ({ githubToken, description, public: isPublic = false, files }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.gists.create({
+                description,
+                public: isPublic,
+                files,
+            });
+            return {
+                id: data.id,
+                html_url: data.html_url,
+                files: Object.keys(data.files || {}),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create gist: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-gist.js.map

package/dist/toolkits/github/tools/Gists/get-gist.d.ts

@@ -0,0 +1,23 @@
+export declare const getGist: import("ai").Tool<{
+    gistId: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    description?: undefined;
+    public?: undefined;
+    owner?: undefined;
+    files?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+} | {
+    id: string | undefined;
+    description: string | null | undefined;
+    public: boolean | undefined;
+    owner: string | undefined;
+    files: Record<string, any>;
+    created_at: string | undefined;
+    updated_at: string | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-gist.d.ts.map