@rnsk/toolkits 0.0.1 → 0.0.3

package/dist/toolkits/github/tools/SecurityAdvisories/list-global-advisories.d.ts

@@ -0,0 +1,14 @@
+export declare const listGlobalAdvisories: import("ai").Tool<{
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    ghsa_id: string;
+    cve_id: string | null;
+    summary: string;
+    severity: "unknown" | "low" | "medium" | "high" | "critical";
+    html_url: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-global-advisories.d.ts.map

package/dist/toolkits/github/tools/SecurityAdvisories/list-global-advisories.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listGlobalAdvisories = tool({
+    description: 'List global security advisories.',
+    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.securityAdvisories.listGlobalAdvisories({
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(advisory => ({
+                ghsa_id: advisory.ghsa_id,
+                cve_id: advisory.cve_id,
+                summary: advisory.summary,
+                severity: advisory.severity,
+                html_url: advisory.html_url,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list global advisories: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-global-advisories.js.map

package/dist/toolkits/github/tools/SecurityAdvisories/list-repository-advisories.d.ts

@@ -0,0 +1,22 @@
+export declare const listRepositoryAdvisories: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    ghsa_id: string;
+    cve_id: string | null;
+    summary: string;
+    description: string | null;
+    severity: "low" | "medium" | "high" | "critical" | null;
+    state: "closed" | "triage" | "draft" | "published" | "withdrawn";
+    created_at: string | null;
+    updated_at: string | null;
+    published_at: string | null;
+    withdrawn_at: string | null;
+    html_url: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-repository-advisories.d.ts.map

package/dist/toolkits/github/tools/SecurityAdvisories/list-repository-advisories.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listRepositoryAdvisories = tool({
+    description: 'List repository security advisories.',
+    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'),
+        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, owner, repo, 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.securityAdvisories.listRepositoryAdvisories({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(advisory => ({
+                ghsa_id: advisory.ghsa_id,
+                cve_id: advisory.cve_id,
+                summary: advisory.summary,
+                description: advisory.description,
+                severity: advisory.severity,
+                state: advisory.state,
+                created_at: advisory.created_at,
+                updated_at: advisory.updated_at,
+                published_at: advisory.published_at,
+                withdrawn_at: advisory.withdrawn_at,
+                html_url: advisory.html_url,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list repository advisories: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-repository-advisories.js.map

package/dist/toolkits/github/tools/Stars/check-repo-starred.d.ts

@@ -0,0 +1,12 @@
+export declare const checkRepoStarred: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    is_starred?: undefined;
+} | {
+    is_starred: boolean;
+    error?: undefined;
+}>;
+//# sourceMappingURL=check-repo-starred.d.ts.map

package/dist/toolkits/github/tools/Stars/check-repo-starred.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const checkRepoStarred = tool({
+    description: 'Check if a repository is starred by the authenticated user.',
+    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'),
+    }),
+    execute: async ({ githubToken, owner, repo }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.activity.checkRepoIsStarredByAuthenticatedUser({
+                owner,
+                repo,
+            });
+            return { is_starred: true };
+        }
+        catch (error) {
+            if (error.status === 404) {
+                return { is_starred: false };
+            }
+            return { error: `Failed to check if repo is starred: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=check-repo-starred.js.map

package/dist/toolkits/github/tools/Stars/list-stargazers.d.ts

@@ -0,0 +1,15 @@
+export declare const listStargazers: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    login: any;
+    id: any;
+    avatar_url: any;
+    html_url: any;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-stargazers.d.ts.map

package/dist/toolkits/github/tools/Stars/list-stargazers.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listStargazers = tool({
+    description: 'List stargazers for a repository.',
+    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'),
+        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, owner, repo, 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.activity.listStargazersForRepo({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map((user) => ({
+                login: user.login || user.user?.login,
+                id: user.id || user.user?.id,
+                avatar_url: user.avatar_url || user.user?.avatar_url,
+                html_url: user.html_url || user.user?.html_url,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list stargazers: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-stargazers.js.map

package/dist/toolkits/github/tools/Stars/list-starred-repos.d.ts

@@ -0,0 +1,15 @@
+export declare const listStarredRepos: import("ai").Tool<{
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    id: number;
+    name: string;
+    full_name: string;
+    owner: string;
+    html_url: string;
+    stargazers_count: number;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-starred-repos.d.ts.map

package/dist/toolkits/github/tools/Stars/list-starred-repos.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listStarredRepos = tool({
+    description: 'List repositories starred by 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.activity.listReposStarredByAuthenticatedUser({
+                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,
+                owner: repo.owner.login,
+                html_url: repo.html_url,
+                stargazers_count: repo.stargazers_count,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list starred repos: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-starred-repos.js.map

package/dist/toolkits/github/tools/Stars/star-repo.d.ts

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

package/dist/toolkits/github/tools/Stars/star-repo.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const starRepo = tool({
+    description: 'Star a repository for the authenticated user.',
+    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'),
+    }),
+    execute: async ({ githubToken, owner, repo }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.activity.starRepoForAuthenticatedUser({
+                owner,
+                repo,
+            });
+            return { message: `Successfully starred repository ${owner}/${repo}` };
+        }
+        catch (error) {
+            return { error: `Failed to star repository: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=star-repo.js.map

package/dist/toolkits/github/tools/Stars/unstar-repo.d.ts

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

package/dist/toolkits/github/tools/Stars/unstar-repo.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const unstarRepo = tool({
+    description: 'Unstar a repository for the authenticated user.',
+    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'),
+    }),
+    execute: async ({ githubToken, owner, repo }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.activity.unstarRepoForAuthenticatedUser({
+                owner,
+                repo,
+            });
+            return { message: `Successfully unstarred repository ${owner}/${repo}` };
+        }
+        catch (error) {
+            return { error: `Failed to unstar repository: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=unstar-repo.js.map

package/dist/toolkits/github/tools/Statuses/create-commit-status.d.ts

@@ -0,0 +1,25 @@
+export declare const createCommitStatus: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    state: "error" | "success" | "pending" | "failure";
+    sha: string;
+    description?: string | undefined;
+    githubToken?: string | undefined;
+    context?: string | undefined;
+    target_url?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    state?: undefined;
+    description?: undefined;
+    context?: undefined;
+    target_url?: undefined;
+} | {
+    id: number;
+    state: string;
+    description: string | null;
+    context: string;
+    target_url: string | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-commit-status.d.ts.map

package/dist/toolkits/github/tools/Statuses/create-commit-status.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createCommitStatus = tool({
+    description: 'Create a commit status.',
+    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'),
+        sha: z.string().describe('The SHA of the commit'),
+        state: z.enum(['error', 'failure', 'pending', 'success']).describe('The state of the status'),
+        target_url: z.string().optional().describe('The target URL to associate with this status'),
+        description: z.string().optional().describe('A short description of the status'),
+        context: z.string().optional().describe('A string label to differentiate this status from the status of other systems'),
+    }),
+    execute: async ({ githubToken, owner, repo, sha, ...options }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.createCommitStatus({
+                owner,
+                repo,
+                sha,
+                ...options,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                state: data.state,
+                description: data.description,
+                context: data.context,
+                target_url: data.target_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create commit status: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-commit-status.js.map

package/dist/toolkits/github/tools/Statuses/get-combined-status.d.ts

@@ -0,0 +1,26 @@
+export declare const getCombinedStatus: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    ref: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    state?: undefined;
+    sha?: undefined;
+    total_count?: undefined;
+    statuses?: undefined;
+    repository?: undefined;
+} | {
+    state: string;
+    sha: string;
+    total_count: number;
+    statuses: {
+        id: number;
+        state: string;
+        description: string | null;
+        context: string;
+    }[];
+    repository: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-combined-status.d.ts.map

package/dist/toolkits/github/tools/Statuses/get-combined-status.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getCombinedStatus = tool({
+    description: 'Get the combined status for a specific reference.',
+    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 ref can be a SHA, a branch name, or a tag name'),
+    }),
+    execute: async ({ githubToken, owner, repo, ref }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.getCombinedStatusForRef({
+                owner,
+                repo,
+                ref,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                state: data.state,
+                sha: data.sha,
+                total_count: data.total_count,
+                statuses: data.statuses.map(status => ({
+                    id: status.id,
+                    state: status.state,
+                    description: status.description,
+                    context: status.context,
+                })),
+                repository: data.repository.full_name,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get combined status: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-combined-status.js.map

package/dist/toolkits/github/tools/Statuses/list-commit-statuses.d.ts

@@ -0,0 +1,18 @@
+export declare const listCommitStatuses: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    ref: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    id: number;
+    state: string;
+    description: string | null;
+    context: string;
+    target_url: string | null;
+    created_at: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-commit-statuses.d.ts.map

package/dist/toolkits/github/tools/Statuses/list-commit-statuses.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listCommitStatuses = tool({
+    description: 'List commit statuses for a reference.',
+    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 ref can be a SHA, a branch name, or a tag name'),
+        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, owner, repo, ref, 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.listCommitStatusesForRef({
+                owner,
+                repo,
+                ref,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(status => ({
+                id: status.id,
+                state: status.state,
+                description: status.description,
+                context: status.context,
+                target_url: status.target_url,
+                created_at: status.created_at,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list commit statuses: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-commit-statuses.js.map

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

@@ -0,0 +1,15 @@
+export declare const addTeamRepo: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    org: string;
+    team_slug: string;
+    githubToken?: string | undefined;
+    permission?: "push" | "admin" | "pull" | "maintain" | "triage" | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=add-team-repo.d.ts.map

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

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const addTeamRepo = tool({
+    description: 'Add or update team repository permissions.',
+    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'),
+        permission: z.enum(['pull', 'push', 'admin', 'maintain', 'triage']).optional().describe('The permission to grant the team on this repository'),
+    }),
+    execute: async ({ githubToken, org, team_slug, owner, repo, permission }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.teams.addOrUpdateRepoPermissionsInOrg({
+                org,
+                team_slug,
+                owner,
+                repo,
+                permission: permission ?? 'push',
+            });
+            return { message: `Successfully updated permissions for ${owner}/${repo} for team ${team_slug}` };
+        }
+        catch (error) {
+            return { error: `Failed to add team repo: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=add-team-repo.js.map

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

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