@rnsk/toolkits 0.0.1 → 0.0.3

package/dist/toolkits/github/tools/Apps/get-installation.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getInstallation = tool({
+    description: 'Get a specific installation for the authenticated GitHub App.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        installation_id: z.number().describe('The unique identifier of the installation'),
+    }),
+    execute: async ({ githubToken, installation_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.apps.getInstallation({
+                installation_id,
+            });
+            return {
+                id: data.id,
+                account: data.account?.login || data.account?.name,
+                app_id: data.app_id,
+                target_type: data.target_type,
+                permissions: data.permissions,
+                events: data.events,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get installation: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-installation.js.map

package/dist/toolkits/github/tools/Apps/list-installations.d.ts

@@ -0,0 +1,19 @@
+export declare const listInstallations: import("ai").Tool<{
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    installations?: undefined;
+} | {
+    installations: {
+        id: number;
+        account: any;
+        app_id: number;
+        target_type: string;
+        created_at: string;
+        updated_at: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-installations.d.ts.map

package/dist/toolkits/github/tools/Apps/list-installations.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listInstallations = tool({
+    description: 'List installations for the authenticated GitHub App.',
+    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.apps.listInstallations({
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                installations: data.map(installation => ({
+                    id: installation.id,
+                    account: installation.account?.login || installation.account?.name,
+                    app_id: installation.app_id,
+                    target_type: installation.target_type,
+                    created_at: installation.created_at,
+                    updated_at: installation.updated_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list installations: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-installations.js.map

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

@@ -0,0 +1,24 @@
+export declare const createCheckRun: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    name: string;
+    head_sha: string;
+    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=create-check-run.d.ts.map

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

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createCheckRun = tool({
+    description: 'Create a check run for a commit in 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'),
+        name: z.string().describe('The name of the check'),
+        head_sha: z.string().describe('The SHA of the commit'),
+        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, name, head_sha, 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.create({
+                owner,
+                repo,
+                name,
+                head_sha,
+                status: status ?? 'queued',
+                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 create check run: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-check-run.js.map

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

@@ -0,0 +1,21 @@
+export declare const createCheckSuite: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    head_sha: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    status?: undefined;
+    conclusion?: undefined;
+    head_sha?: undefined;
+    created_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;
+    created_at: string | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-check-suite.d.ts.map

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

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

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

@@ -0,0 +1,25 @@
+export declare const getCheckRun: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    check_run_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    status?: undefined;
+    conclusion?: undefined;
+    started_at?: undefined;
+    completed_at?: 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;
+    started_at: string | null;
+    completed_at: string | null;
+    html_url: string | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-check-run.d.ts.map

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

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getCheckRun = tool({
+    description: 'Get 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'),
+    }),
+    execute: async ({ githubToken, owner, repo, check_run_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.get({
+                owner,
+                repo,
+                check_run_id,
+            });
+            return {
+                id: data.id,
+                name: data.name,
+                status: data.status,
+                conclusion: data.conclusion,
+                started_at: data.started_at,
+                completed_at: data.completed_at,
+                html_url: data.html_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get check run: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-check-run.js.map

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