@rnsk/toolkits 0.0.1 → 0.0.2

package/dist/toolkits/github/tools/Git/create-ref.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createRef = tool({
+    description: 'Create a reference in 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 name of the fully qualified reference (e.g., refs/heads/master)'),
+        sha: z.string().describe('The SHA1 value with which you want to initialize this reference'),
+    }),
+    execute: async ({ githubToken, owner, repo, ref, sha }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.git.createRef({
+                owner,
+                repo,
+                ref,
+                sha,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                ref: data.ref,
+                node_id: data.node_id,
+                url: data.url,
+                object: data.object,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create ref: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-ref.js.map

package/dist/toolkits/github/tools/Git/create-tree.d.ts

@@ -0,0 +1,31 @@
+export declare const createTree: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    tree: {
+        path?: string | undefined;
+        type?: "commit" | "tree" | "blob" | undefined;
+        mode?: "100644" | "100755" | "040000" | "160000" | "120000" | undefined;
+        content?: string | undefined;
+        sha?: string | null | undefined;
+    }[];
+    githubToken?: string | undefined;
+    base_tree?: string | undefined;
+}, {
+    error: string;
+    sha?: undefined;
+    url?: undefined;
+    tree?: undefined;
+} | {
+    sha: string;
+    url: string | undefined;
+    tree: {
+        path: string;
+        mode: string;
+        type: string;
+        sha: string;
+        size: number | undefined;
+        url: string | undefined;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-tree.d.ts.map

package/dist/toolkits/github/tools/Git/create-tree.js

@@ -0,0 +1,52 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createTree = tool({
+    description: 'Create a tree in 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'),
+        tree: z.array(z.object({
+            path: z.string().optional(),
+            mode: z.enum(['100644', '100755', '040000', '160000', '120000']).optional(),
+            type: z.enum(['blob', 'tree', 'commit']).optional(),
+            sha: z.string().optional().nullable(),
+            content: z.string().optional(),
+        })).describe('The objects (blobs or trees) to create fine-grained control of the repository content'),
+        base_tree: z.string().optional().describe('The SHA1 of the tree you want to update with new data'),
+    }),
+    execute: async ({ githubToken, owner, repo, tree, base_tree }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.git.createTree({
+                owner,
+                repo,
+                tree,
+                base_tree,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                sha: data.sha,
+                url: data.url,
+                tree: data.tree.map(item => ({
+                    path: item.path,
+                    mode: item.mode,
+                    type: item.type,
+                    sha: item.sha,
+                    size: item.size,
+                    url: item.url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create tree: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-tree.js.map

package/dist/toolkits/github/tools/Git/delete-ref.d.ts

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

package/dist/toolkits/github/tools/Git/delete-ref.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const deleteRef = tool({
+    description: 'Delete a reference in 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 name of the reference (e.g., heads/branch-name)'),
+    }),
+    execute: async ({ githubToken, owner, repo, ref }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.git.deleteRef({
+                owner,
+                repo,
+                ref,
+            });
+            return { message: `Successfully deleted reference ${ref}` };
+        }
+        catch (error) {
+            return { error: `Failed to delete ref: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=delete-ref.js.map

package/dist/toolkits/github/tools/Git/get-blob.d.ts

@@ -0,0 +1,21 @@
+export declare const getBlob: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    file_sha: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    sha?: undefined;
+    size?: undefined;
+    url?: undefined;
+    content?: undefined;
+    encoding?: undefined;
+} | {
+    sha: string;
+    size: number | null;
+    url: string;
+    content: string;
+    encoding: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-blob.d.ts.map

package/dist/toolkits/github/tools/Git/get-blob.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getBlob = tool({
+    description: 'Get a blob 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'),
+        file_sha: z.string().describe('The SHA of the blob'),
+    }),
+    execute: async ({ githubToken, owner, repo, file_sha }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.git.getBlob({
+                owner,
+                repo,
+                file_sha,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                sha: data.sha,
+                size: data.size,
+                url: data.url,
+                content: data.content,
+                encoding: data.encoding,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get blob: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-blob.js.map

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

@@ -0,0 +1,40 @@
+export declare const getGitCommit: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    commit_sha: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    sha?: undefined;
+    url?: undefined;
+    author?: undefined;
+    committer?: undefined;
+    message?: undefined;
+    tree?: undefined;
+    parents?: undefined;
+} | {
+    sha: string;
+    url: string;
+    author: {
+        date: string;
+        email: string;
+        name: string;
+    };
+    committer: {
+        date: string;
+        email: string;
+        name: string;
+    };
+    message: string;
+    tree: {
+        sha: string;
+        url: string;
+    };
+    parents: {
+        sha: string;
+        url: string;
+        html_url: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-git-commit.d.ts.map

package/dist/toolkits/github/tools/Git/get-git-commit.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getGitCommit = tool({
+    description: 'Get a low-level Git commit object.',
+    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'),
+        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.git.getCommit({
+                owner,
+                repo,
+                commit_sha,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                sha: data.sha,
+                url: data.url,
+                author: data.author,
+                committer: data.committer,
+                message: data.message,
+                tree: data.tree,
+                parents: data.parents,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get git commit: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-git-commit.js.map

package/dist/toolkits/github/tools/Git/get-ref.d.ts

@@ -0,0 +1,18 @@
+export declare const getRef: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    ref: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    references?: undefined;
+} | {
+    references: {
+        ref: any;
+        node_id: any;
+        url: any;
+        object: any;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-ref.d.ts.map

package/dist/toolkits/github/tools/Git/get-ref.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getRef = tool({
+    description: 'Get a reference 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'),
+        ref: z.string().describe('The name of the reference (e.g., heads/branch-name)'),
+    }),
+    execute: async ({ githubToken, owner, repo, ref }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.git.getRef({
+                owner,
+                repo,
+                ref,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            // Handle array or single object
+            const refs = Array.isArray(data) ? data : [data];
+            return {
+                references: refs.map(r => ({
+                    ref: r.ref,
+                    node_id: r.node_id,
+                    url: r.url,
+                    object: r.object,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get ref: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-ref.js.map

package/dist/toolkits/github/tools/Git/get-tree.d.ts

@@ -0,0 +1,27 @@
+export declare const getTree: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    tree_sha: string;
+    githubToken?: string | undefined;
+    recursive?: boolean | undefined;
+}, {
+    error: string;
+    sha?: undefined;
+    url?: undefined;
+    tree?: undefined;
+    truncated?: undefined;
+} | {
+    sha: string;
+    url: string | undefined;
+    tree: {
+        path: string;
+        mode: string;
+        type: string;
+        sha: string;
+        size: number | undefined;
+        url: string | undefined;
+    }[];
+    truncated: boolean;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-tree.d.ts.map

package/dist/toolkits/github/tools/Git/get-tree.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getTree = tool({
+    description: 'Get a tree 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'),
+        tree_sha: z.string().describe('The SHA of the tree'),
+        recursive: z.boolean().optional().describe('If true, get a tree recursively'),
+    }),
+    execute: async ({ githubToken, owner, repo, tree_sha, recursive }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.git.getTree({
+                owner,
+                repo,
+                tree_sha,
+                recursive: recursive ? '1' : undefined,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                sha: data.sha,
+                url: data.url,
+                tree: data.tree.map(item => ({
+                    path: item.path,
+                    mode: item.mode,
+                    type: item.type,
+                    sha: item.sha,
+                    size: item.size,
+                    url: item.url,
+                })),
+                truncated: data.truncated,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get tree: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-tree.js.map

package/dist/toolkits/github/tools/Git/update-ref.d.ts

@@ -0,0 +1,25 @@
+export declare const updateRef: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    ref: string;
+    sha: string;
+    githubToken?: string | undefined;
+    force?: boolean | undefined;
+}, {
+    error: string;
+    ref?: undefined;
+    node_id?: undefined;
+    url?: undefined;
+    object?: undefined;
+} | {
+    ref: string;
+    node_id: string;
+    url: string;
+    object: {
+        type: string;
+        sha: string;
+        url: string;
+    };
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-ref.d.ts.map

package/dist/toolkits/github/tools/Git/update-ref.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateRef = tool({
+    description: 'Update a reference in 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 name of the reference (e.g., heads/branch-name)'),
+        sha: z.string().describe('The SHA1 value to set this reference to'),
+        force: z.boolean().optional().describe('Indicates whether to force the update or not'),
+    }),
+    execute: async ({ githubToken, owner, repo, ref, sha, force }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.git.updateRef({
+                owner,
+                repo,
+                ref,
+                sha,
+                force: force ?? false,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                ref: data.ref,
+                node_id: data.node_id,
+                url: data.url,
+                object: data.object,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update ref: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-ref.js.map

package/dist/toolkits/github/tools/Issues/add-issue-assignees.d.ts

@@ -0,0 +1,14 @@
+export declare const addIssueAssignees: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    issueNumber: number;
+    assignees: string[];
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    assignees?: undefined;
+} | {
+    assignees: string[] | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=add-issue-assignees.d.ts.map

package/dist/toolkits/github/tools/Issues/add-issue-assignees.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const addIssueAssignees = tool({
+    description: 'Add assignees to a GitHub issue.',
+    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'),
+        issueNumber: z.number().describe('Issue number'),
+        assignees: z.array(z.string()).describe('Array of usernames'),
+    }),
+    execute: async ({ githubToken, owner, repo, issueNumber, assignees }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.issues.addAssignees({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                assignees,
+            });
+            return {
+                assignees: data.assignees?.map((a) => a.login),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to add assignees: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=add-issue-assignees.js.map

package/dist/toolkits/github/tools/Issues/add-issue-comment.d.ts

@@ -0,0 +1,20 @@
+export declare const addIssueComment: import("ai").Tool<{
+    body: string;
+    repo: string;
+    owner: string;
+    issueNumber: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    body?: undefined;
+    html_url?: undefined;
+    created_at?: undefined;
+} | {
+    id: number;
+    body: string | undefined;
+    html_url: string;
+    created_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=add-issue-comment.d.ts.map

package/dist/toolkits/github/tools/Issues/add-issue-comment.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const addIssueComment = tool({
+    description: 'Add a comment to a GitHub issue or 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'),
+        issueNumber: z.number().describe('Issue or PR number'),
+        body: z.string().describe('Comment body'),
+    }),
+    execute: async ({ githubToken, owner, repo, issueNumber, body }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.issues.createComment({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                body,
+            });
+            return {
+                id: data.id,
+                body: data.body,
+                html_url: data.html_url,
+                created_at: data.created_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to add comment: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=add-issue-comment.js.map

package/dist/toolkits/github/tools/Issues/add-issue-labels.d.ts

@@ -0,0 +1,14 @@
+export declare const addIssueLabels: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    issueNumber: number;
+    labels: string[];
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    labels?: undefined;
+} | {
+    labels: string[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=add-issue-labels.d.ts.map