@rnsk/toolkits 0.0.1 → 0.0.3

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<{
+    labels: string[];
+    repo: string;
+    owner: string;
+    issueNumber: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    labels?: undefined;
+} | {
+    labels: string[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=add-issue-labels.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+export declare const createIssue: import("ai").Tool<{
+    title: string;
+    repo: string;
+    owner: string;
+    body?: string | undefined;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    number?: undefined;
+    title?: undefined;
+    state?: undefined;
+    html_url?: undefined;
+    created_at?: undefined;
+} | {
+    number: number;
+    title: string;
+    state: string;
+    html_url: string;
+    created_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-issue.d.ts.map

package/dist/toolkits/github/tools/Issues/create-issue.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createIssue = tool({
+    description: 'Create a new issue in a GitHub repository. Use when the user wants to create an issue, open an issue, or file a bug/feature request. Provide owner, repo, title, and optional body.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner (username or org)'),
+        repo: z.string().describe('Repository name'),
+        title: z.string().describe('Issue title'),
+        body: z.string().optional().describe('Issue body/description'),
+    }),
+    execute: async ({ githubToken, owner, repo, title, body }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        const { data } = await octokit.rest.issues.create({
+            owner,
+            repo,
+            title,
+            body: body ?? undefined,
+        });
+        return {
+            number: data.number,
+            title: data.title,
+            state: data.state,
+            html_url: data.html_url ?? null,
+            created_at: data.created_at,
+        };
+    },
+});
+//# sourceMappingURL=create-issue.js.map

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

@@ -0,0 +1,29 @@
+export declare const getIssue: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    issue_number: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    number?: undefined;
+    title?: undefined;
+    state?: undefined;
+    body?: undefined;
+    user?: undefined;
+    html_url?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+    comments?: undefined;
+} | {
+    number: number;
+    title: string;
+    state: string;
+    body: string | null | undefined;
+    user: string | undefined;
+    html_url: string;
+    created_at: string;
+    updated_at: string;
+    comments: number;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-issue.d.ts.map

package/dist/toolkits/github/tools/Issues/get-issue.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getIssue = tool({
+    description: 'Get a single issue by its number in a GitHub repository. Use when the user wants to see the details of a specific issue.',
+    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'),
+        issue_number: z.number().describe('The number that identifies the issue'),
+    }),
+    execute: async ({ githubToken, owner, repo, issue_number }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        const { data } = await octokit.rest.issues.get({
+            owner,
+            repo,
+            issue_number,
+        });
+        return {
+            number: data.number,
+            title: data.title,
+            state: data.state,
+            body: data.body,
+            user: data.user?.login,
+            html_url: data.html_url,
+            created_at: data.created_at,
+            updated_at: data.updated_at,
+            comments: data.comments,
+        };
+    },
+});
+//# sourceMappingURL=get-issue.js.map

package/dist/toolkits/github/tools/Issues/list-authenticated-user-issues.d.ts

@@ -0,0 +1,21 @@
+export declare const listAuthenticatedUserIssues: import("ai").Tool<{
+    sort?: "created" | "updated" | "comments" | undefined;
+    filter?: "all" | "assigned" | "created" | "mentioned" | "subscribed" | undefined;
+    since?: string | undefined;
+    labels?: string | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    state?: "all" | "open" | "closed" | undefined;
+    direction?: "asc" | "desc" | undefined;
+}, {
+    number: number;
+    title: string;
+    state: string;
+    repository: string | undefined;
+    html_url: string;
+    created_at: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-authenticated-user-issues.d.ts.map

package/dist/toolkits/github/tools/Issues/list-authenticated-user-issues.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listAuthenticatedUserIssues = tool({
+    description: 'List issues assigned to the authenticated user across all visible repositories. Use when the user wants to see their assigned issues.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        filter: z.enum(['assigned', 'created', 'mentioned', 'subscribed', 'all']).optional().describe('Indicates which sorts of issues to return.'),
+        state: z.enum(['open', 'closed', 'all']).optional().describe('Indicates the state of the issues to return.'),
+        labels: z.string().optional().describe('A list of comma separated label names.'),
+        sort: z.enum(['created', 'updated', 'comments']).optional().describe('What to sort results by.'),
+        direction: z.enum(['asc', 'desc']).optional().describe('The direction to sort the results by.'),
+        since: z.string().optional().describe('Only show issues updated after this time (ISO 8601 format).'),
+        per_page: z.number().optional().describe('The number of results per page (max 100).'),
+        page: z.number().optional().describe('Page number of the results to fetch.'),
+    }),
+    execute: async ({ githubToken, ...params }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        const { data } = await octokit.rest.issues.listForAuthenticatedUser(params);
+        return data.map((issue) => ({
+            number: issue.number,
+            title: issue.title,
+            state: issue.state,
+            repository: issue.repository?.full_name,
+            html_url: issue.html_url,
+            created_at: issue.created_at,
+        }));
+    },
+});
+//# sourceMappingURL=list-authenticated-user-issues.js.map

package/dist/toolkits/github/tools/Issues/list-issue-comments.d.ts

@@ -0,0 +1,19 @@
+export declare const listIssueComments: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    perPage: number;
+    issueNumber: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    comments?: undefined;
+} | {
+    comments: {
+        id: number;
+        user: string | undefined;
+        body: string | undefined;
+        created_at: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-issue-comments.d.ts.map

package/dist/toolkits/github/tools/Issues/list-issue-comments.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listIssueComments = tool({
+    description: 'List comments on 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'),
+        perPage: z.number().optional().default(30),
+    }),
+    execute: async ({ githubToken, owner, repo, issueNumber, perPage = 30 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.issues.listComments({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                per_page: perPage,
+            });
+            return {
+                comments: data.map((comment) => ({
+                    id: comment.id,
+                    user: comment.user?.login,
+                    body: comment.body,
+                    created_at: comment.created_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list comments: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-issue-comments.js.map

package/dist/toolkits/github/tools/Issues/list-org-issues.d.ts

@@ -0,0 +1,22 @@
+export declare const listOrgIssues: import("ai").Tool<{
+    org: string;
+    sort?: "created" | "updated" | "comments" | undefined;
+    filter?: "all" | "assigned" | "created" | "mentioned" | "subscribed" | undefined;
+    since?: string | undefined;
+    labels?: string | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    state?: "all" | "open" | "closed" | undefined;
+    direction?: "asc" | "desc" | undefined;
+}, {
+    number: number;
+    title: string;
+    state: string;
+    repository: string | undefined;
+    html_url: string;
+    created_at: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-org-issues.d.ts.map

package/dist/toolkits/github/tools/Issues/list-org-issues.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listOrgIssues = tool({
+    description: 'List issues assigned to the authenticated user for a specific organization across all repositories in that organization.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+        filter: z.enum(['assigned', 'created', 'mentioned', 'subscribed', 'all']).optional().describe('Indicates which sorts of issues to return.'),
+        state: z.enum(['open', 'closed', 'all']).optional().describe('Indicates the state of the issues to return.'),
+        labels: z.string().optional().describe('A list of comma separated label names.'),
+        sort: z.enum(['created', 'updated', 'comments']).optional().describe('What to sort results by.'),
+        direction: z.enum(['asc', 'desc']).optional().describe('The direction to sort the results by.'),
+        since: z.string().optional().describe('Only show issues updated after this time (ISO 8601 format).'),
+        per_page: z.number().optional().describe('The number of results per page (max 100).'),
+        page: z.number().optional().describe('Page number of the results to fetch.'),
+    }),
+    execute: async ({ githubToken, org, ...params }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        const { data } = await octokit.rest.issues.listForOrg({
+            org,
+            ...params,
+        });
+        return data.map((issue) => ({
+            number: issue.number,
+            title: issue.title,
+            state: issue.state,
+            repository: issue.repository?.full_name,
+            html_url: issue.html_url,
+            created_at: issue.created_at,
+        }));
+    },
+});
+//# sourceMappingURL=list-org-issues.js.map

package/dist/toolkits/github/tools/Issues/list-repo-issues.d.ts

@@ -0,0 +1,28 @@
+export declare const listRepoIssues: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    page: number;
+    state: "all" | "open" | "closed";
+    perPage: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    owner?: undefined;
+    repo?: undefined;
+    issues?: undefined;
+    total?: undefined;
+} | {
+    owner: string;
+    repo: string;
+    issues: {
+        number: number;
+        title: string;
+        state: string;
+        html_url: string;
+        user: string | null;
+        created_at: string;
+    }[];
+    total: number;
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-repo-issues.d.ts.map