@rnsk/toolkits 0.0.1 → 0.0.3

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

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getGist = tool({
+    description: 'Get a specific gist.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        gistId: z.string().describe('ID of the gist'),
+    }),
+    execute: async ({ githubToken, gistId }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.gists.get({
+                gist_id: gistId,
+            });
+            return {
+                id: data.id,
+                description: data.description,
+                public: data.public,
+                owner: data.owner?.login,
+                files: Object.entries(data.files || {}).reduce((acc, [filename, file]) => {
+                    acc[filename] = {
+                        content: file?.content,
+                        size: file?.size,
+                        truncated: file?.truncated,
+                        language: file?.language,
+                    };
+                    return acc;
+                }, {}),
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get gist: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-gist.js.map

package/dist/toolkits/github/tools/Gists/list-gists.d.ts

@@ -0,0 +1,19 @@
+export declare const listGists: import("ai").Tool<{
+    perPage: number;
+    since?: string | undefined;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    gists?: undefined;
+} | {
+    gists: {
+        id: string;
+        description: string | null;
+        public: boolean;
+        html_url: string;
+        files: string[];
+        created_at: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-gists.d.ts.map

package/dist/toolkits/github/tools/Gists/list-gists.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listGists = tool({
+    description: 'List the authenticated user\'s gists or public gists.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        perPage: z.number().optional().default(30),
+        since: z.string().optional().describe('Filter gists starting from this date'),
+    }),
+    execute: async ({ githubToken, perPage = 30, since }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.gists.list({
+                per_page: perPage,
+                since,
+            });
+            return {
+                gists: data.map((gist) => ({
+                    id: gist.id,
+                    description: gist.description,
+                    public: gist.public,
+                    html_url: gist.html_url,
+                    files: Object.keys(gist.files || {}),
+                    created_at: gist.created_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list gists: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-gists.js.map

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

@@ -0,0 +1,16 @@
+export declare const createBlob: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    content: string;
+    githubToken?: string | undefined;
+    encoding?: "utf-8" | "base64" | undefined;
+}, {
+    error: string;
+    sha?: undefined;
+    url?: undefined;
+} | {
+    sha: string;
+    url: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-blob.d.ts.map

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

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createBlob = tool({
+    description: 'Create a blob 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'),
+        content: z.string().describe('The new blob\'s content'),
+        encoding: z.enum(['utf-8', 'base64']).optional().describe('The encoding used for content'),
+    }),
+    execute: async ({ githubToken, owner, repo, content, encoding }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.git.createBlob({
+                owner,
+                repo,
+                content,
+                encoding: encoding ?? 'utf-8',
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                sha: data.sha,
+                url: data.url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create blob: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-blob.js.map

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

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

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

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createGitCommit = tool({
+    description: 'Create a new 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'),
+        message: z.string().describe('The commit message'),
+        tree: z.string().describe('The SHA of the tree object this commit points to'),
+        parents: z.array(z.string()).describe('The SHAs of the commits that were the parents of this commit'),
+        author: z.object({
+            name: z.string(),
+            email: z.string(),
+            date: z.string().optional(),
+        }).optional().describe('Information about the author of the commit'),
+    }),
+    execute: async ({ githubToken, owner, repo, message, tree, parents, author }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.git.createCommit({
+                owner,
+                repo,
+                message,
+                tree,
+                parents,
+                author,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                sha: data.sha,
+                url: data.url,
+                message: data.message,
+                author: data.author,
+                committer: data.committer,
+                tree: data.tree,
+                parents: data.parents,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create git commit: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-git-commit.js.map

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

@@ -0,0 +1,24 @@
+export declare const createRef: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    ref: string;
+    sha: string;
+    githubToken?: string | 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=create-ref.d.ts.map

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