@rnsk/toolkits 0.0.1 → 0.0.3

package/dist/toolkits/github/tools/Organizations/get-org-membership.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getOrgMembership = tool({
+    description: 'Get organization membership for a user.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+        username: z.string().describe('The handle for the GitHub user'),
+    }),
+    execute: async ({ githubToken, org, username }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.orgs.getMembershipForUser({
+                org,
+                username,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                url: data.url,
+                state: data.state,
+                role: data.role,
+                organization_url: data.organization_url,
+                organization: data.organization,
+                user: data.user,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get org membership: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-org-membership.js.map

package/dist/toolkits/github/tools/Organizations/get-organization.d.ts

@@ -0,0 +1,65 @@
+export declare const getOrganization: import("ai").Tool<{
+    org: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    login?: undefined;
+    id?: undefined;
+    url?: undefined;
+    repos_url?: undefined;
+    events_url?: undefined;
+    hooks_url?: undefined;
+    issues_url?: undefined;
+    members_url?: undefined;
+    public_members_url?: undefined;
+    avatar_url?: undefined;
+    description?: undefined;
+    name?: undefined;
+    company?: undefined;
+    blog?: undefined;
+    location?: undefined;
+    email?: undefined;
+    twitter_username?: undefined;
+    is_verified?: undefined;
+    has_organization_projects?: undefined;
+    has_repository_projects?: undefined;
+    public_repos?: undefined;
+    public_gists?: undefined;
+    followers?: undefined;
+    following?: undefined;
+    html_url?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+    type?: undefined;
+} | {
+    login: string;
+    id: number;
+    url: string;
+    repos_url: string;
+    events_url: string;
+    hooks_url: string;
+    issues_url: string;
+    members_url: string;
+    public_members_url: string;
+    avatar_url: string;
+    description: string | null;
+    name: string | undefined;
+    company: string | undefined;
+    blog: string | undefined;
+    location: string | undefined;
+    email: string | undefined;
+    twitter_username: string | null | undefined;
+    is_verified: boolean | undefined;
+    has_organization_projects: boolean;
+    has_repository_projects: boolean;
+    public_repos: number;
+    public_gists: number;
+    followers: number;
+    following: number;
+    html_url: string;
+    created_at: string;
+    updated_at: string;
+    type: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-organization.d.ts.map

package/dist/toolkits/github/tools/Organizations/get-organization.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getOrganization = tool({
+    description: 'Get an organization.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+    }),
+    execute: async ({ githubToken, org }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.orgs.get({
+                org,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                login: data.login,
+                id: data.id,
+                url: data.url,
+                repos_url: data.repos_url,
+                events_url: data.events_url,
+                hooks_url: data.hooks_url,
+                issues_url: data.issues_url,
+                members_url: data.members_url,
+                public_members_url: data.public_members_url,
+                avatar_url: data.avatar_url,
+                description: data.description,
+                name: data.name,
+                company: data.company,
+                blog: data.blog,
+                location: data.location,
+                email: data.email,
+                twitter_username: data.twitter_username,
+                is_verified: data.is_verified,
+                has_organization_projects: data.has_organization_projects,
+                has_repository_projects: data.has_repository_projects,
+                public_repos: data.public_repos,
+                public_gists: data.public_gists,
+                followers: data.followers,
+                following: data.following,
+                html_url: data.html_url,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+                type: data.type,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get organization: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-organization.js.map

package/dist/toolkits/github/tools/Organizations/list-org-members.d.ts

@@ -0,0 +1,18 @@
+export declare const listOrgMembers: import("ai").Tool<{
+    org: string;
+    filter?: "all" | "2fa_disabled" | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    role?: "all" | "admin" | "member" | undefined;
+}, {
+    login: string;
+    id: number;
+    avatar_url: string;
+    url: string;
+    html_url: string;
+    type: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-org-members.d.ts.map

package/dist/toolkits/github/tools/Organizations/list-org-members.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listOrgMembers = tool({
+    description: 'List organization members.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+        filter: z.enum(['2fa_disabled', 'all']).optional().describe('Filter by 2fa status'),
+        role: z.enum(['all', 'admin', 'member']).optional().describe('Filter by role'),
+        per_page: z.number().optional().describe('Number of results per page (max 100)'),
+        page: z.number().optional().describe('Page number of results to fetch'),
+    }),
+    execute: async ({ githubToken, org, filter, role, per_page, page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.orgs.listMembers({
+                org,
+                filter,
+                role,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(member => ({
+                login: member.login,
+                id: member.id,
+                avatar_url: member.avatar_url,
+                url: member.url,
+                html_url: member.html_url,
+                type: member.type,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list org members: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-org-members.js.map

package/dist/toolkits/github/tools/Organizations/list-org-repositories.d.ts

@@ -0,0 +1,50 @@
+export declare const listOrgRepositories: import("ai").Tool<{
+    org: string;
+    type?: "all" | "sources" | "public" | "member" | "private" | "forks" | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    id: number;
+    name: string;
+    full_name: string;
+    private: boolean;
+    owner: string;
+    html_url: string;
+    description: string | null;
+    fork: boolean;
+    url: string;
+    created_at: string | null | undefined;
+    updated_at: string | null | undefined;
+    pushed_at: string | null | undefined;
+    git_url: string | undefined;
+    ssh_url: string | undefined;
+    clone_url: string | undefined;
+    svn_url: string | undefined;
+    homepage: string | null | undefined;
+    size: number | undefined;
+    stargazers_count: number | undefined;
+    watchers_count: number | undefined;
+    language: string | null | undefined;
+    has_issues: boolean | undefined;
+    has_projects: boolean | undefined;
+    has_downloads: boolean | undefined;
+    has_wiki: boolean | undefined;
+    has_pages: boolean | undefined;
+    forks_count: number | undefined;
+    archived: boolean | undefined;
+    disabled: boolean | undefined;
+    open_issues_count: number | undefined;
+    license: {
+        key?: string;
+        name?: string;
+        spdx_id?: string;
+        url?: string;
+        node_id?: string;
+    } | null | undefined;
+    topics: string[] | undefined;
+    visibility: any;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-org-repositories.d.ts.map

package/dist/toolkits/github/tools/Organizations/list-org-repositories.js

@@ -0,0 +1,69 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listOrgRepositories = tool({
+    description: 'List repositories for an organization.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+        type: z.enum(['all', 'public', 'private', 'forks', 'sources', 'member']).optional().describe('Specifies the types of repositories you want listed'),
+        per_page: z.number().optional().describe('Number of results per page (max 100)'),
+        page: z.number().optional().describe('Page number of results to fetch'),
+    }),
+    execute: async ({ githubToken, org, type, per_page, page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.listForOrg({
+                org,
+                type: type ?? 'all',
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(repo => ({
+                id: repo.id,
+                name: repo.name,
+                full_name: repo.full_name,
+                private: repo.private,
+                owner: repo.owner.login,
+                html_url: repo.html_url,
+                description: repo.description,
+                fork: repo.fork,
+                url: repo.url,
+                created_at: repo.created_at,
+                updated_at: repo.updated_at,
+                pushed_at: repo.pushed_at,
+                git_url: repo.git_url,
+                ssh_url: repo.ssh_url,
+                clone_url: repo.clone_url,
+                svn_url: repo.svn_url,
+                homepage: repo.homepage,
+                size: repo.size,
+                stargazers_count: repo.stargazers_count,
+                watchers_count: repo.watchers_count,
+                language: repo.language,
+                has_issues: repo.has_issues,
+                has_projects: repo.has_projects,
+                has_downloads: repo.has_downloads,
+                has_wiki: repo.has_wiki,
+                has_pages: repo.has_pages,
+                forks_count: repo.forks_count,
+                archived: repo.archived,
+                disabled: repo.disabled,
+                open_issues_count: repo.open_issues_count,
+                license: repo.license,
+                topics: repo.topics,
+                visibility: repo.visibility,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list org repositories: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-org-repositories.js.map

package/dist/toolkits/github/tools/Organizations/list-organizations.d.ts

@@ -0,0 +1,13 @@
+export declare const listOrganizations: import("ai").Tool<{
+    since?: number | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+}, {
+    login: string;
+    id: number;
+    url: string;
+    description: string | null;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-organizations.d.ts.map

package/dist/toolkits/github/tools/Organizations/list-organizations.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listOrganizations = tool({
+    description: 'List organizations. Lists all organizations, in the order that they were created on GitHub.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        since: z.number().optional().describe('The integer ID of the last organization that you saw'),
+        per_page: z.number().optional().describe('Number of results per page (max 100)'),
+    }),
+    execute: async ({ githubToken, since, per_page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.orgs.list({
+                since,
+                per_page: per_page ?? 30,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(org => ({
+                login: org.login,
+                id: org.id,
+                url: org.url,
+                description: org.description,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list organizations: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-organizations.js.map

package/dist/toolkits/github/tools/Organizations/list-user-organizations.d.ts

@@ -0,0 +1,20 @@
+export declare const listUserOrganizations: import("ai").Tool<{
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    login: string;
+    id: number;
+    url: string;
+    repos_url: string;
+    events_url: string;
+    hooks_url: string;
+    issues_url: string;
+    members_url: string;
+    public_members_url: string;
+    avatar_url: string;
+    description: string | null;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-user-organizations.d.ts.map

package/dist/toolkits/github/tools/Organizations/list-user-organizations.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listUserOrganizations = tool({
+    description: 'List organizations for the authenticated user.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        per_page: z.number().optional().describe('Number of results per page (max 100)'),
+        page: z.number().optional().describe('Page number of results to fetch'),
+    }),
+    execute: async ({ githubToken, per_page, page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.orgs.listForAuthenticatedUser({
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(org => ({
+                login: org.login,
+                id: org.id,
+                url: org.url,
+                repos_url: org.repos_url,
+                events_url: org.events_url,
+                hooks_url: org.hooks_url,
+                issues_url: org.issues_url,
+                members_url: org.members_url,
+                public_members_url: org.public_members_url,
+                avatar_url: org.avatar_url,
+                description: org.description,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list user organizations: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-user-organizations.js.map

package/dist/toolkits/github/tools/Organizations/update-organization.d.ts

@@ -0,0 +1,33 @@
+export declare const updateOrganization: import("ai").Tool<{
+    org: string;
+    description?: string | undefined;
+    location?: string | undefined;
+    githubToken?: string | undefined;
+    name?: string | undefined;
+    email?: string | undefined;
+    billing_email?: string | undefined;
+    company?: string | undefined;
+    has_organization_projects?: boolean | undefined;
+    has_repository_projects?: boolean | undefined;
+    default_repository_permission?: "read" | "write" | "none" | "admin" | undefined;
+    members_can_create_repositories?: boolean | undefined;
+    members_can_create_internal_repositories?: boolean | undefined;
+    members_can_create_private_repositories?: boolean | undefined;
+    members_can_create_public_repositories?: boolean | undefined;
+    members_allowed_repository_creation_type?: "none" | "all" | "private" | undefined;
+}, {
+    error: string;
+    login?: undefined;
+    name?: undefined;
+    email?: undefined;
+    description?: undefined;
+    updated_at?: undefined;
+} | {
+    login: string;
+    name: string | undefined;
+    email: string | undefined;
+    description: string | null;
+    updated_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-organization.d.ts.map

package/dist/toolkits/github/tools/Organizations/update-organization.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateOrganization = tool({
+    description: 'Update an organization.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+        billing_email: z.string().optional().describe('Billing email address. This address is use to send notifications about billing for GitHub.com.'),
+        company: z.string().optional().describe('The company name'),
+        email: z.string().optional().describe('The publicly visible email address'),
+        location: z.string().optional().describe('The location'),
+        name: z.string().optional().describe('The shorthand name of the company'),
+        description: z.string().optional().describe('The description of the company'),
+        has_organization_projects: z.boolean().optional().describe('Whether organization projects are enabled'),
+        has_repository_projects: z.boolean().optional().describe('Whether repository projects are enabled'),
+        default_repository_permission: z.enum(['read', 'write', 'admin', 'none']).optional().describe('Default permission level members have for organization repositories'),
+        members_can_create_repositories: z.boolean().optional().describe('Whether of not organization members can create repositories'),
+        members_can_create_internal_repositories: z.boolean().optional().describe('Whether of not organization members can create internal repositories'),
+        members_can_create_private_repositories: z.boolean().optional().describe('Whether of not organization members can create private repositories'),
+        members_can_create_public_repositories: z.boolean().optional().describe('Whether of not organization members can create public repositories'),
+        members_allowed_repository_creation_type: z.enum(['all', 'private', 'none']).optional().describe('Specifies which repository creation type is allowed for organization members'),
+    }),
+    execute: async ({ githubToken, org, ...options }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.orgs.update({
+                org,
+                ...options,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                login: data.login,
+                name: data.name,
+                email: data.email,
+                description: data.description,
+                updated_at: data.updated_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update organization: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-organization.js.map

package/dist/toolkits/github/tools/PRs/check-pull-request-merged.d.ts

@@ -0,0 +1,13 @@
+export declare const checkPullRequestMerged: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    pullNumber: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    merged?: undefined;
+} | {
+    merged: boolean;
+    error?: undefined;
+}>;
+//# sourceMappingURL=check-pull-request-merged.d.ts.map

package/dist/toolkits/github/tools/PRs/check-pull-request-merged.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const checkPullRequestMerged = tool({
+    description: 'Check if a pull request has been merged.',
+    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'),
+        pullNumber: z.number().describe('Pull request number'),
+    }),
+    execute: async ({ githubToken, owner, repo, pullNumber }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { status } = await octokit.rest.pulls.checkIfMerged({
+                owner,
+                repo,
+                pull_number: pullNumber,
+            });
+            return { merged: status === 204 };
+        }
+        catch (error) {
+            if (error.status === 404) {
+                return { merged: false };
+            }
+            return { error: `Failed to check PR merge status: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=check-pull-request-merged.js.map

package/dist/toolkits/github/tools/PRs/create-pull-request-review.d.ts

@@ -0,0 +1,19 @@
+export declare const createPullRequestReview: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    event: "APPROVE" | "REQUEST_CHANGES" | "COMMENT";
+    pullNumber: number;
+    body?: string | undefined;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    state?: undefined;
+    html_url?: undefined;
+} | {
+    id: number;
+    state: string;
+    html_url: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-pull-request-review.d.ts.map

package/dist/toolkits/github/tools/PRs/create-pull-request-review.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createPullRequestReview = tool({
+    description: 'Create a review for a pull request (approve, request changes, or comment).',
+    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'),
+        pullNumber: z.number().describe('Pull request number'),
+        event: z.enum(['APPROVE', 'REQUEST_CHANGES', 'COMMENT']).describe('Review action'),
+        body: z.string().optional().describe('Review body/comment'),
+    }),
+    execute: async ({ githubToken, owner, repo, pullNumber, event, body }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.pulls.createReview({
+                owner,
+                repo,
+                pull_number: pullNumber,
+                event,
+                body,
+            });
+            return {
+                id: data.id,
+                state: data.state,
+                html_url: data.html_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create review: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-pull-request-review.js.map