@rnsk/toolkits 0.0.1 → 0.0.2

package/dist/toolkits/github/tools/Checks/get-check-suite.d.ts

@@ -0,0 +1,25 @@
+export declare const getCheckSuite: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    check_suite_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    status?: undefined;
+    conclusion?: undefined;
+    head_sha?: undefined;
+    head_branch?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+} | {
+    id: number;
+    status: "queued" | "in_progress" | "completed" | "waiting" | "requested" | "pending" | null;
+    conclusion: "success" | "failure" | "neutral" | "cancelled" | "skipped" | "timed_out" | "action_required" | "stale" | "startup_failure" | null;
+    head_sha: string;
+    head_branch: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-check-suite.d.ts.map

package/dist/toolkits/github/tools/Checks/get-check-suite.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getCheckSuite = tool({
+    description: 'Get a check suite.',
+    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'),
+        check_suite_id: z.number().describe('The unique identifier of the check suite'),
+    }),
+    execute: async ({ githubToken, owner, repo, check_suite_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.checks.getSuite({
+                owner,
+                repo,
+                check_suite_id,
+            });
+            return {
+                id: data.id,
+                status: data.status,
+                conclusion: data.conclusion,
+                head_sha: data.head_sha,
+                head_branch: data.head_branch,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get check suite: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-check-suite.js.map

package/dist/toolkits/github/tools/Checks/list-check-runs.d.ts

@@ -0,0 +1,27 @@
+export declare const listCheckRuns: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    ref: string;
+    status?: "queued" | "in_progress" | "completed" | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    check_name?: string | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    check_runs?: undefined;
+} | {
+    total_count: number;
+    check_runs: {
+        id: number;
+        name: string;
+        status: "queued" | "in_progress" | "completed" | "waiting" | "requested" | "pending";
+        conclusion: "success" | "failure" | "neutral" | "cancelled" | "skipped" | "timed_out" | "action_required" | null;
+        started_at: string | null;
+        completed_at: string | null;
+        html_url: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-check-runs.d.ts.map

package/dist/toolkits/github/tools/Checks/list-check-runs.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listCheckRuns = tool({
+    description: 'List check runs for a Git 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('Git reference (branch, tag, or SHA)'),
+        check_name: z.string().optional().describe('Filter by check name'),
+        status: z.enum(['queued', 'in_progress', 'completed']).optional().describe('Filter by status'),
+        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, check_name, status, 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.checks.listForRef({
+                owner,
+                repo,
+                ref,
+                check_name,
+                status,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                total_count: data.total_count,
+                check_runs: data.check_runs.map(run => ({
+                    id: run.id,
+                    name: run.name,
+                    status: run.status,
+                    conclusion: run.conclusion,
+                    started_at: run.started_at,
+                    completed_at: run.completed_at,
+                    html_url: run.html_url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list check runs: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-check-runs.js.map

package/dist/toolkits/github/tools/Checks/update-check-run.d.ts

@@ -0,0 +1,23 @@
+export declare const updateCheckRun: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    check_run_id: number;
+    status?: "queued" | "in_progress" | "completed" | undefined;
+    githubToken?: string | undefined;
+    conclusion?: "success" | "failure" | "neutral" | "cancelled" | "skipped" | "timed_out" | "action_required" | "stale" | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    status?: undefined;
+    conclusion?: undefined;
+    html_url?: undefined;
+} | {
+    id: number;
+    name: string;
+    status: "queued" | "in_progress" | "completed" | "waiting" | "requested" | "pending";
+    conclusion: "success" | "failure" | "neutral" | "cancelled" | "skipped" | "timed_out" | "action_required" | null;
+    html_url: string | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-check-run.d.ts.map

package/dist/toolkits/github/tools/Checks/update-check-run.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateCheckRun = tool({
+    description: 'Update a check run.',
+    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'),
+        check_run_id: z.number().describe('The unique identifier of the check run'),
+        status: z.enum(['queued', 'in_progress', 'completed']).optional().describe('The current status'),
+        conclusion: z.enum(['action_required', 'cancelled', 'failure', 'neutral', 'success', 'skipped', 'stale', 'timed_out']).optional().describe('Required if status is completed'),
+    }),
+    execute: async ({ githubToken, owner, repo, check_run_id, status, conclusion }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.checks.update({
+                owner,
+                repo,
+                check_run_id,
+                status,
+                conclusion,
+            });
+            return {
+                id: data.id,
+                name: data.name,
+                status: data.status,
+                conclusion: data.conclusion,
+                html_url: data.html_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update check run: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-check-run.js.map

package/dist/toolkits/github/tools/CodeScanning/get-alert.d.ts

@@ -0,0 +1,25 @@
+export declare const getCodeScanningAlert: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    alert_number: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    number?: undefined;
+    state?: undefined;
+    rule?: undefined;
+    created_at?: undefined;
+    html_url?: undefined;
+} | {
+    number: number;
+    state: "open" | "dismissed" | "fixed" | null;
+    rule: {
+        id: string | null | undefined;
+        description: string | undefined;
+        severity: "none" | "error" | "warning" | "note" | null | undefined;
+    };
+    created_at: string;
+    html_url: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-alert.d.ts.map

package/dist/toolkits/github/tools/CodeScanning/get-alert.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getCodeScanningAlert = tool({
+    description: 'Get a code scanning alert.',
+    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'),
+        alert_number: z.number().describe('The alert number'),
+    }),
+    execute: async ({ githubToken, owner, repo, alert_number }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.codeScanning.getAlert({
+                owner,
+                repo,
+                alert_number,
+            });
+            return {
+                number: data.number,
+                state: data.state,
+                rule: {
+                    id: data.rule?.id,
+                    description: data.rule?.description,
+                    severity: data.rule?.severity,
+                },
+                created_at: data.created_at,
+                html_url: data.html_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get code scanning alert: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-alert.js.map

package/dist/toolkits/github/tools/CodeScanning/list-alerts.d.ts

@@ -0,0 +1,23 @@
+export declare const listCodeScanningAlerts: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    ref?: string | undefined;
+    state?: "open" | "dismissed" | "fixed" | undefined;
+}, {
+    error: string;
+    alerts?: undefined;
+} | {
+    alerts: {
+        number: number;
+        state: "open" | "dismissed" | "fixed" | null;
+        rule: string | undefined;
+        severity: "none" | "error" | "warning" | "note" | null | undefined;
+        created_at: string;
+        html_url: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-alerts.d.ts.map

package/dist/toolkits/github/tools/CodeScanning/list-alerts.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listCodeScanningAlerts = tool({
+    description: 'List code scanning alerts for a repository.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        owner: z.string().describe('Repository owner (username or org)'),
+        repo: z.string().describe('Repository name'),
+        state: z.enum(['open', 'dismissed', 'fixed']).optional().describe('Filter by state'),
+        ref: z.string().optional().describe('Git reference'),
+        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, state, ref, per_page, page }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const response = await octokit.rest.codeScanning.listAlertsForRepo({
+                owner,
+                repo,
+                state: state,
+                ref,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            const data = response.data;
+            if (!data) {
+                return { error: 'No data returned from GitHub API' };
+            }
+            return {
+                alerts: data.map(alert => ({
+                    number: alert.number,
+                    state: alert.state,
+                    rule: alert.rule?.description,
+                    severity: alert.rule?.severity,
+                    created_at: alert.created_at,
+                    html_url: alert.html_url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list code scanning alerts: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-alerts.js.map

package/dist/toolkits/github/tools/CodeScanning/update-alert.d.ts

@@ -0,0 +1,19 @@
+export declare const updateCodeScanningAlert: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    alert_number: number;
+    state: "open" | "dismissed";
+    githubToken?: string | undefined;
+    dismissed_reason?: "false positive" | "won't fix" | "used in tests" | undefined;
+}, {
+    error: string;
+    number?: undefined;
+    state?: undefined;
+    dismissed_reason?: undefined;
+} | {
+    number: number;
+    state: "open" | "dismissed" | "fixed" | null;
+    dismissed_reason: "false positive" | "won't fix" | "used in tests" | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-alert.d.ts.map

package/dist/toolkits/github/tools/CodeScanning/update-alert.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateCodeScanningAlert = tool({
+    description: 'Update a code scanning alert.',
+    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'),
+        alert_number: z.number().describe('The alert number'),
+        state: z.enum(['open', 'dismissed']).describe('The state to set'),
+        dismissed_reason: z.enum(['false positive', 'won\'t fix', 'used in tests']).optional().describe('Required when state is dismissed'),
+    }),
+    execute: async ({ githubToken, owner, repo, alert_number, state, dismissed_reason }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.codeScanning.updateAlert({
+                owner,
+                repo,
+                alert_number,
+                state,
+                dismissed_reason,
+            });
+            return {
+                number: data.number,
+                state: data.state,
+                dismissed_reason: data.dismissed_reason,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update code scanning alert: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-alert.js.map

package/dist/toolkits/github/tools/Collaborators/add-collaborator.d.ts

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

package/dist/toolkits/github/tools/Collaborators/add-collaborator.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const addCollaborator = tool({
+    description: 'Add a repository collaborator.',
+    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'),
+        username: z.string().describe('Username to add as collaborator'),
+        permission: z.enum(['pull', 'push', 'admin', 'maintain', 'triage']).optional().describe('Permission level'),
+    }),
+    execute: async ({ githubToken, owner, repo, username, permission }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.repos.addCollaborator({
+                owner,
+                repo,
+                username,
+                permission: permission ?? 'push',
+            });
+            return { message: `Successfully added ${username} as collaborator` };
+        }
+        catch (error) {
+            return { error: `Failed to add collaborator: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=add-collaborator.js.map

package/dist/toolkits/github/tools/Collaborators/check-collaborator.d.ts

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

package/dist/toolkits/github/tools/Collaborators/check-collaborator.js

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

package/dist/toolkits/github/tools/Collaborators/list-collaborators.d.ts

@@ -0,0 +1,25 @@
+export declare const listCollaborators: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    affiliation?: "all" | "outside" | "direct" | undefined;
+}, {
+    error: string;
+    collaborators?: undefined;
+} | {
+    collaborators: {
+        login: string;
+        id: number;
+        permissions: {
+            pull: boolean;
+            triage?: boolean;
+            push: boolean;
+            maintain?: boolean;
+            admin: boolean;
+        } | undefined;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-collaborators.d.ts.map

package/dist/toolkits/github/tools/Collaborators/list-collaborators.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listCollaborators = tool({
+    description: 'List repository collaborators.',
+    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'),
+        affiliation: z.enum(['outside', 'direct', 'all']).optional().describe('Filter by affiliation'),
+        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, affiliation, 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.listCollaborators({
+                owner,
+                repo,
+                affiliation: affiliation ?? 'all',
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                collaborators: data.map(collab => ({
+                    login: collab.login,
+                    id: collab.id,
+                    permissions: collab.permissions,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list collaborators: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-collaborators.js.map

package/dist/toolkits/github/tools/Collaborators/remove-collaborator.d.ts

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

package/dist/toolkits/github/tools/Collaborators/remove-collaborator.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const removeCollaborator = tool({
+    description: 'Remove a repository collaborator.',
+    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'),
+        username: z.string().describe('Username to remove'),
+    }),
+    execute: async ({ githubToken, owner, repo, username }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.repos.removeCollaborator({
+                owner,
+                repo,
+                username,
+            });
+            return { message: `Successfully removed ${username} as collaborator` };
+        }
+        catch (error) {
+            return { error: `Failed to remove collaborator: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=remove-collaborator.js.map

package/dist/toolkits/github/tools/Commits/compare-commits.d.ts

@@ -0,0 +1,30 @@
+export declare const compareCommits: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    page: number;
+    base: string;
+    head: string;
+    perPage: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    comparison?: undefined;
+} | {
+    comparison: {
+        url: string;
+        html_url: string;
+        permalink_url: string;
+        diff_url: string;
+        patch_url: string;
+        base_commit: import("@octokit/openapi-types").components["schemas"]["commit"];
+        merge_base_commit: import("@octokit/openapi-types").components["schemas"]["commit"];
+        status: "diverged" | "ahead" | "behind" | "identical";
+        ahead_by: number;
+        behind_by: number;
+        total_commits: number;
+        commits: import("@octokit/openapi-types").components["schemas"]["commit"][];
+        files?: import("@octokit/openapi-types").components["schemas"]["diff-entry"][];
+    };
+    error?: undefined;
+}>;
+//# sourceMappingURL=compare-commits.d.ts.map