@rnsk/toolkits 0.0.1 → 0.0.2

package/dist/toolkits/github/tools/Teams/remove-team-repo.d.ts

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

package/dist/toolkits/github/tools/Teams/remove-team-repo.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const removeTeamRepo = tool({
+    description: 'Remove a repository from a team.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+        team_slug: z.string().describe('The slug of the team'),
+        owner: z.string().describe('The owner of the repository'),
+        repo: z.string().describe('The name of the repository'),
+    }),
+    execute: async ({ githubToken, org, team_slug, owner, repo }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.teams.removeRepoInOrg({
+                org,
+                team_slug,
+                owner,
+                repo,
+            });
+            return { message: `Successfully removed ${owner}/${repo} from team ${team_slug}` };
+        }
+        catch (error) {
+            return { error: `Failed to remove team repo: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=remove-team-repo.js.map

package/dist/toolkits/github/tools/Teams/update-team.d.ts

@@ -0,0 +1,27 @@
+export declare const updateTeam: import("ai").Tool<{
+    org: string;
+    team_slug: string;
+    description?: string | undefined;
+    githubToken?: string | undefined;
+    name?: string | undefined;
+    permission?: "push" | "admin" | "pull" | "maintain" | "triage" | undefined;
+    privacy?: "closed" | "secret" | undefined;
+    parent_team_id?: number | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    slug?: undefined;
+    description?: undefined;
+    privacy?: undefined;
+    permission?: undefined;
+} | {
+    id: number;
+    name: string;
+    slug: string;
+    description: string | null;
+    privacy: "closed" | "secret" | undefined;
+    permission: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-team.d.ts.map

package/dist/toolkits/github/tools/Teams/update-team.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateTeam = tool({
+    description: 'Update a team.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        org: z.string().describe('The organization name'),
+        team_slug: z.string().describe('The slug of the team'),
+        name: z.string().optional().describe('The name of the team'),
+        description: z.string().optional().describe('The description of the team'),
+        privacy: z.enum(['secret', 'closed']).optional().describe('The level of privacy this team should have'),
+        permission: z.enum(['pull', 'push', 'admin', 'maintain', 'triage']).optional().describe('The default permission for new repositories added to this team'),
+        parent_team_id: z.number().optional().describe('The ID of a team to set as the parent team'),
+    }),
+    execute: async ({ githubToken, org, team_slug, ...options }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.teams.updateInOrg({
+                org,
+                team_slug,
+                ...options,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                name: data.name,
+                slug: data.slug,
+                description: data.description,
+                privacy: data.privacy,
+                permission: data.permission,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update team: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-team.js.map

package/dist/toolkits/github/tools/Users/follow-user.d.ts

@@ -0,0 +1,12 @@
+export declare const followUser: import("ai").Tool<{
+    username: string;
+    action: "follow" | "unfollow";
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=follow-user.d.ts.map

package/dist/toolkits/github/tools/Users/follow-user.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const followUser = tool({
+    description: 'Follow or unfollow a GitHub user.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        username: z.string().describe('Username of the user to follow/unfollow'),
+        action: z.enum(['follow', 'unfollow']).describe('Action to perform'),
+    }),
+    execute: async ({ githubToken, username, action }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            if (action === 'follow') {
+                await octokit.rest.users.follow({
+                    username,
+                });
+                return { message: `Followed user ${username}` };
+            }
+            else {
+                await octokit.rest.users.unfollow({
+                    username,
+                });
+                return { message: `Unfollowed user ${username}` };
+            }
+        }
+        catch (error) {
+            return { error: `Failed to ${action} user: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=follow-user.js.map

package/dist/toolkits/github/tools/Users/get-github-user.d.ts

@@ -0,0 +1,64 @@
+export declare const getGitHubUser: import("ai").Tool<{
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    login?: undefined;
+    name?: undefined;
+    email?: undefined;
+    avatar_url?: undefined;
+    html_url?: undefined;
+    bio?: undefined;
+    company?: undefined;
+    blog?: undefined;
+    location?: undefined;
+    hireable?: undefined;
+    public_repos?: undefined;
+    public_gists?: undefined;
+    followers?: undefined;
+    following?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+    total_private_repos?: undefined;
+    owned_private_repos?: undefined;
+    disk_usage?: undefined;
+    collaborators?: undefined;
+    two_factor_authentication?: undefined;
+    plan?: undefined;
+} | {
+    id: number;
+    login: string;
+    name: string | null;
+    email: string | null;
+    avatar_url: string;
+    html_url: string;
+    bio: string | null;
+    company: string | null;
+    blog: string | null;
+    location: string | null;
+    hireable: boolean | null;
+    public_repos: number;
+    public_gists: number;
+    followers: number;
+    following: number;
+    created_at: string;
+    updated_at: string;
+    total_private_repos: number | undefined;
+    owned_private_repos: number | undefined;
+    disk_usage: number | undefined;
+    collaborators: number | undefined;
+    two_factor_authentication: any;
+    plan: {
+        collaborators: number;
+        name: string;
+        space: number;
+        private_repos: number;
+    } | {
+        collaborators: number;
+        name: string;
+        space: number;
+        private_repos: number;
+    } | undefined;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-github-user.d.ts.map

package/dist/toolkits/github/tools/Users/get-github-user.js

@@ -0,0 +1,48 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getGitHubUser = tool({
+    description: 'Get the authenticated GitHub user profile. Returns detailed information including login, name, email, plan, usage, and repository counts.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+    }),
+    execute: async ({ githubToken }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.users.getAuthenticated();
+            return {
+                id: data.id,
+                login: data.login,
+                name: data.name ?? null,
+                email: data.email ?? null,
+                avatar_url: data.avatar_url,
+                html_url: data.html_url,
+                bio: data.bio ?? null,
+                company: data.company ?? null,
+                blog: data.blog ?? null,
+                location: data.location ?? null,
+                hireable: data.hireable ?? null,
+                public_repos: data.public_repos,
+                public_gists: data.public_gists,
+                followers: data.followers,
+                following: data.following,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+                total_private_repos: data.total_private_repos,
+                owned_private_repos: data.owned_private_repos,
+                disk_usage: data.disk_usage,
+                collaborators: data.collaborators,
+                two_factor_authentication: data.two_factor_authentication,
+                plan: data.plan,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get authenticated user: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-github-user.js.map

package/dist/toolkits/github/tools/Users/get-user-by-id.d.ts

@@ -0,0 +1,53 @@
+export declare const getUserById: import("ai").Tool<{
+    id: number;
+    githubToken?: string | undefined;
+}, {
+    login: string;
+    id: number;
+    user_view_type?: string;
+    node_id: string;
+    avatar_url: string;
+    gravatar_id: string | null;
+    url: string;
+    html_url: string;
+    followers_url: string;
+    following_url: string;
+    gists_url: string;
+    starred_url: string;
+    subscriptions_url: string;
+    organizations_url: string;
+    repos_url: string;
+    events_url: string;
+    received_events_url: string;
+    type: string;
+    site_admin: boolean;
+    name: string | null;
+    company: string | null;
+    blog: string | null;
+    location: string | null;
+    email: string | null;
+    notification_email?: string | null;
+    hireable: boolean | null;
+    bio: string | null;
+    twitter_username?: string | null;
+    public_repos: number;
+    public_gists: number;
+    followers: number;
+    following: number;
+    created_at: string;
+    updated_at: string;
+    plan?: {
+        collaborators: number;
+        name: string;
+        space: number;
+        private_repos: number;
+    };
+    private_gists?: number;
+    total_private_repos?: number;
+    owned_private_repos?: number;
+    disk_usage?: number;
+    collaborators?: number;
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=get-user-by-id.d.ts.map

package/dist/toolkits/github/tools/Users/get-user-by-id.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getUserById = tool({
+    description: 'Get a user using their ID.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.number().describe('The ID of the user.'),
+    }),
+    execute: async ({ githubToken, id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.users.getById({
+                account_id: id,
+            });
+            return data;
+        }
+        catch (error) {
+            return { error: `Failed to get user by ID: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-user-by-id.js.map

package/dist/toolkits/github/tools/Users/get-user-context.d.ts

@@ -0,0 +1,14 @@
+export declare const getUserContext: import("ai").Tool<{
+    username: string;
+    githubToken?: string | undefined;
+    subject_type?: "issue" | "repository" | "organization" | "pull_request" | undefined;
+    subject_id?: string | undefined;
+}, {
+    contexts: {
+        message: string;
+        octicon: string;
+    }[];
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=get-user-context.d.ts.map

package/dist/toolkits/github/tools/Users/get-user-context.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getUserContext = tool({
+    description: 'Get contextual information for a user. Provides the interaction context between the authenticated user and another user.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        username: z.string().describe('The handle for the GitHub user account.'),
+        subject_type: z.enum(['organization', 'repository', 'issue', 'pull_request']).optional().describe('The type of subject to check context for.'),
+        subject_id: z.string().optional().describe('The ID of the subject.'),
+    }),
+    execute: async ({ githubToken, username, subject_type, subject_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            // @ts-ignore - The types might be slightly off for this specific endpoint depending on octokit version
+            const { data } = await octokit.rest.users.getContextForUser({
+                username,
+                subject_type: subject_type,
+                subject_id,
+            });
+            return data;
+        }
+        catch (error) {
+            return { error: `Failed to get user context: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-user-context.js.map

package/dist/toolkits/github/tools/Users/get-user.d.ts

@@ -0,0 +1,53 @@
+export declare const getUser: import("ai").Tool<{
+    username: string;
+    githubToken?: string | undefined;
+}, {
+    login: string;
+    id: number;
+    user_view_type?: string;
+    node_id: string;
+    avatar_url: string;
+    gravatar_id: string | null;
+    url: string;
+    html_url: string;
+    followers_url: string;
+    following_url: string;
+    gists_url: string;
+    starred_url: string;
+    subscriptions_url: string;
+    organizations_url: string;
+    repos_url: string;
+    events_url: string;
+    received_events_url: string;
+    type: string;
+    site_admin: boolean;
+    name: string | null;
+    company: string | null;
+    blog: string | null;
+    location: string | null;
+    email: string | null;
+    notification_email?: string | null;
+    hireable: boolean | null;
+    bio: string | null;
+    twitter_username?: string | null;
+    public_repos: number;
+    public_gists: number;
+    followers: number;
+    following: number;
+    created_at: string;
+    updated_at: string;
+    plan?: {
+        collaborators: number;
+        name: string;
+        space: number;
+        private_repos: number;
+    };
+    private_gists?: number;
+    total_private_repos?: number;
+    owned_private_repos?: number;
+    disk_usage?: number;
+    collaborators?: number;
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=get-user.d.ts.map

package/dist/toolkits/github/tools/Users/get-user.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getUser = tool({
+    description: 'Get a user. Provides publicly available information about someone with a GitHub account.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        username: z.string().describe('The handle for the GitHub user account.'),
+    }),
+    execute: async ({ githubToken, username }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.users.getByUsername({
+                username,
+            });
+            return data;
+        }
+        catch (error) {
+            return { error: `Failed to get user: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-user.js.map

package/dist/toolkits/github/tools/Users/list-users.d.ts

@@ -0,0 +1,31 @@
+export declare const listUsers: import("ai").Tool<{
+    since?: number | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+}, {
+    name?: string | null;
+    email?: string | null;
+    login: string;
+    id: number;
+    node_id: string;
+    avatar_url: string;
+    gravatar_id: string | null;
+    url: string;
+    html_url: string;
+    followers_url: string;
+    following_url: string;
+    gists_url: string;
+    starred_url: string;
+    subscriptions_url: string;
+    organizations_url: string;
+    repos_url: string;
+    events_url: string;
+    received_events_url: string;
+    type: string;
+    site_admin: boolean;
+    starred_at?: string;
+    user_view_type?: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-users.d.ts.map

package/dist/toolkits/github/tools/Users/list-users.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listUsers = tool({
+    description: 'List users. Lists all users, in the order that they signed up 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 User that you\'ve seen.'),
+        per_page: z.number().optional().describe('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.users.list({
+                since,
+                per_page,
+            });
+            return data;
+        }
+        catch (error) {
+            return { error: `Failed to list users: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-users.js.map

package/dist/toolkits/github/tools/Users/update-authenticated-user.d.ts

@@ -0,0 +1,62 @@
+export declare const updateAuthenticatedUser: import("ai").Tool<{
+    location?: string | undefined;
+    githubToken?: string | undefined;
+    name?: string | undefined;
+    email?: string | undefined;
+    company?: string | undefined;
+    blog?: string | undefined;
+    hireable?: boolean | undefined;
+    bio?: string | undefined;
+}, {
+    login: string;
+    id: number;
+    user_view_type?: string;
+    node_id: string;
+    avatar_url: string;
+    gravatar_id: string | null;
+    url: string;
+    html_url: string;
+    followers_url: string;
+    following_url: string;
+    gists_url: string;
+    starred_url: string;
+    subscriptions_url: string;
+    organizations_url: string;
+    repos_url: string;
+    events_url: string;
+    received_events_url: string;
+    type: string;
+    site_admin: boolean;
+    name: string | null;
+    company: string | null;
+    blog: string | null;
+    location: string | null;
+    email: string | null;
+    notification_email?: string | null;
+    hireable: boolean | null;
+    bio: string | null;
+    twitter_username?: string | null;
+    public_repos: number;
+    public_gists: number;
+    followers: number;
+    following: number;
+    created_at: string;
+    updated_at: string;
+    private_gists: number;
+    total_private_repos: number;
+    owned_private_repos: number;
+    disk_usage: number;
+    collaborators: number;
+    two_factor_authentication: boolean;
+    plan?: {
+        collaborators: number;
+        name: string;
+        space: number;
+        private_repos: number;
+    };
+    business_plus?: boolean;
+    ldap_dn?: string;
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=update-authenticated-user.d.ts.map

package/dist/toolkits/github/tools/Users/update-authenticated-user.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateAuthenticatedUser = tool({
+    description: 'Update the authenticated GitHub user profile.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        name: z.string().optional().describe('The new name of the user.'),
+        email: z.string().optional().describe('The publicly visible email address.'),
+        blog: z.string().optional().describe('The new blog URL of the user.'),
+        company: z.string().optional().describe('The new company of the user.'),
+        location: z.string().optional().describe('The new location of the user.'),
+        hireable: z.boolean().optional().describe('The new hireable status of the user.'),
+        bio: z.string().optional().describe('The new short biography of the user.'),
+    }),
+    execute: async ({ githubToken, name, email, blog, company, location, hireable, bio }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.users.updateAuthenticated({
+                name,
+                email,
+                blog,
+                company,
+                location,
+                hireable,
+                bio,
+            });
+            return data;
+        }
+        catch (error) {
+            return { error: `Failed to update authenticated user: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-authenticated-user.js.map