@rnsk/toolkits 0.0.1 → 0.0.2

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;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    state?: "all" | "open" | "closed" | undefined;
+    direction?: "asc" | "desc" | undefined;
+    labels?: string | 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;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    state?: "all" | "open" | "closed" | undefined;
+    direction?: "asc" | "desc" | undefined;
+    labels?: string | 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

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

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listRepoIssues = tool({
+    description: 'List issues for a GitHub repository. Use when the user asks to see issues, open issues, or list issues in a repo. Provide owner and repo (e.g. owner: octocat, repo: hello-world).',
+    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'),
+        state: z.enum(['open', 'closed', 'all']).optional().default('open').describe('Filter by issue state'),
+        perPage: z.number().min(1).max(100).optional().default(30).describe('Number of issues per page'),
+        page: z.number().min(1).optional().default(1).describe('Page number'),
+    }),
+    execute: async ({ githubToken, owner, repo, state = 'open', perPage = 30, page = 1 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        const { data } = await octokit.rest.issues.listForRepo({
+            owner,
+            repo,
+            state,
+            per_page: perPage,
+            page,
+        });
+        return {
+            owner,
+            repo,
+            issues: data.map((issue) => ({
+                number: issue.number,
+                title: issue.title,
+                state: issue.state,
+                html_url: issue.html_url ?? null,
+                user: issue.user?.login ?? null,
+                created_at: issue.created_at,
+            })),
+            total: data.length,
+        };
+    },
+});
+//# sourceMappingURL=list-repo-issues.js.map

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

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

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

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listUserAccountIssues = tool({
+    description: 'List issues assigned to the authenticated user across their own user repositories.',
+    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.list({
+            ...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-user-account-issues.js.map

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

@@ -0,0 +1,15 @@
+export declare const lockIssue: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    issueNumber: number;
+    githubToken?: string | undefined;
+    lockReason?: "off-topic" | "too heated" | "resolved" | "spam" | undefined;
+    unlock?: boolean | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=lock-issue.d.ts.map

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

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const lockIssue = tool({
+    description: 'Lock or unlock 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'),
+        lockReason: z.enum(['off-topic', 'too heated', 'resolved', 'spam']).optional(),
+        unlock: z.boolean().optional().describe('If true, unlock the issue. Default is false (lock).'),
+    }),
+    execute: async ({ githubToken, owner, repo, issueNumber, lockReason, unlock = false }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            if (unlock) {
+                await octokit.rest.issues.unlock({
+                    owner,
+                    repo,
+                    issue_number: issueNumber,
+                });
+                return { message: `Unlocked issue #${issueNumber}` };
+            }
+            else {
+                await octokit.rest.issues.lock({
+                    owner,
+                    repo,
+                    issue_number: issueNumber,
+                    lock_reason: lockReason,
+                });
+                return { message: `Locked issue #${issueNumber}` };
+            }
+        }
+        catch (error) {
+            return { error: `Failed to lock/unlock issue: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=lock-issue.js.map

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

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

package/dist/toolkits/github/tools/Issues/remove-issue-label.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const removeIssueLabel = tool({
+    description: 'Remove a label from 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'),
+        label: z.string().describe('Label name'),
+    }),
+    execute: async ({ githubToken, owner, repo, issueNumber, label }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.issues.removeLabel({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                name: label,
+            });
+            return { message: `Removed label ${label} from issue #${issueNumber}` };
+        }
+        catch (error) {
+            return { error: `Failed to remove label: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=remove-issue-label.js.map

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

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

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

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const unlockIssue = tool({
+    description: 'Unlock a GitHub issue. Use when the user wants to unlock an issue to allow new comments.',
+    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 });
+        try {
+            await octokit.rest.issues.unlock({
+                owner,
+                repo,
+                issue_number,
+            });
+            return { message: `Successfully unlocked issue #${issue_number} in ${owner}/${repo}` };
+        }
+        catch (error) {
+            return { error: `Failed to unlock issue: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=unlock-issue.js.map

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

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