@rnsk/toolkits 0.0.1 → 0.0.2

package/dist/toolkits/github/tools/Webhooks/create-repo-webhook.d.ts

@@ -0,0 +1,34 @@
+export declare const createRepoWebhook: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    config: {
+        url: string;
+        secret?: string | undefined;
+        content_type?: string | undefined;
+        insecure_ssl?: string | undefined;
+    };
+    githubToken?: string | undefined;
+    name?: string | undefined;
+    events?: string[] | undefined;
+    active?: boolean | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    active?: undefined;
+    events?: undefined;
+    config?: undefined;
+} | {
+    id: number;
+    name: string;
+    active: boolean;
+    events: string[];
+    config: {
+        url?: import("@octokit/openapi-types").components["schemas"]["webhook-config-url"];
+        content_type?: import("@octokit/openapi-types").components["schemas"]["webhook-config-content-type"];
+        secret?: import("@octokit/openapi-types").components["schemas"]["webhook-config-secret"];
+        insecure_ssl?: import("@octokit/openapi-types").components["schemas"]["webhook-config-insecure-ssl"];
+    };
+    error?: undefined;
+}>;
+//# sourceMappingURL=create-repo-webhook.d.ts.map

package/dist/toolkits/github/tools/Webhooks/create-repo-webhook.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const createRepoWebhook = tool({
+    description: 'Create a webhook 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'),
+        name: z.string().optional().describe('The name of the webhook. Default: "web"'),
+        active: z.boolean().optional().describe('Determines if notifications are sent when the webhook is triggered'),
+        events: z.array(z.string()).optional().describe('Determines what events the hook is triggered for'),
+        config: z.object({
+            url: z.string().describe('The URL to which the payloads will be delivered'),
+            content_type: z.string().optional().describe('The media type used to serialize the payloads'),
+            secret: z.string().optional().describe('If provided, payloads will be delivered with an X-Hub-Signature header'),
+            insecure_ssl: z.string().optional().describe('Determines whether the SSL certificate of the host for url will be verified'),
+        }).describe('Key/value pairs to provide settings for this webhook'),
+    }),
+    execute: async ({ githubToken, owner, repo, ...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.createWebhook({
+                owner,
+                repo,
+                ...options,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                name: data.name,
+                active: data.active,
+                events: data.events,
+                config: data.config,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create repository webhook: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=create-repo-webhook.js.map

package/dist/toolkits/github/tools/Webhooks/delete-repo-webhook.d.ts

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

package/dist/toolkits/github/tools/Webhooks/delete-repo-webhook.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const deleteRepoWebhook = tool({
+    description: 'Delete a webhook from 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'),
+        hook_id: z.number().describe('The unique identifier of the webhook'),
+    }),
+    execute: async ({ githubToken, owner, repo, hook_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.repos.deleteWebhook({
+                owner,
+                repo,
+                hook_id,
+            });
+            return { message: `Successfully deleted repository webhook ${hook_id}` };
+        }
+        catch (error) {
+            return { error: `Failed to delete repository webhook: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=delete-repo-webhook.js.map

package/dist/toolkits/github/tools/Webhooks/get-repo-webhook.d.ts

@@ -0,0 +1,30 @@
+export declare const getRepoWebhook: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    hook_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    active?: undefined;
+    events?: undefined;
+    config?: undefined;
+    updated_at?: undefined;
+    created_at?: undefined;
+} | {
+    id: number;
+    name: string;
+    active: boolean;
+    events: string[];
+    config: {
+        url?: import("@octokit/openapi-types").components["schemas"]["webhook-config-url"];
+        content_type?: import("@octokit/openapi-types").components["schemas"]["webhook-config-content-type"];
+        secret?: import("@octokit/openapi-types").components["schemas"]["webhook-config-secret"];
+        insecure_ssl?: import("@octokit/openapi-types").components["schemas"]["webhook-config-insecure-ssl"];
+    };
+    updated_at: string;
+    created_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-repo-webhook.d.ts.map

package/dist/toolkits/github/tools/Webhooks/get-repo-webhook.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getRepoWebhook = tool({
+    description: 'Get a webhook 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'),
+        hook_id: z.number().describe('The unique identifier of the webhook'),
+    }),
+    execute: async ({ githubToken, owner, repo, hook_id }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.repos.getWebhook({
+                owner,
+                repo,
+                hook_id,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                name: data.name,
+                active: data.active,
+                events: data.events,
+                config: data.config,
+                updated_at: data.updated_at,
+                created_at: data.created_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get repository webhook: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-repo-webhook.js.map

package/dist/toolkits/github/tools/Webhooks/list-repo-webhooks.d.ts

@@ -0,0 +1,31 @@
+export declare const listRepoWebhooks: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    id: number;
+    name: string;
+    active: boolean;
+    events: string[];
+    config: {
+        url?: import("@octokit/openapi-types").components["schemas"]["webhook-config-url"];
+        content_type?: import("@octokit/openapi-types").components["schemas"]["webhook-config-content-type"];
+        secret?: import("@octokit/openapi-types").components["schemas"]["webhook-config-secret"];
+        insecure_ssl?: import("@octokit/openapi-types").components["schemas"]["webhook-config-insecure-ssl"];
+    };
+    updated_at: string;
+    created_at: string;
+    url: string;
+    test_url: string;
+    ping_url: string;
+    last_response: {
+        code: number | null;
+        status: string | null;
+        message: string | null;
+    };
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-repo-webhooks.d.ts.map

package/dist/toolkits/github/tools/Webhooks/list-repo-webhooks.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listRepoWebhooks = tool({
+    description: 'List webhooks 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'),
+        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.repos.listWebhooks({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(hook => ({
+                id: hook.id,
+                name: hook.name,
+                active: hook.active,
+                events: hook.events,
+                config: hook.config,
+                updated_at: hook.updated_at,
+                created_at: hook.created_at,
+                url: hook.url,
+                test_url: hook.test_url,
+                ping_url: hook.ping_url,
+                last_response: hook.last_response,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list repository webhooks: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-repo-webhooks.js.map

package/dist/toolkits/github/tools/Webhooks/update-repo-webhook.d.ts

@@ -0,0 +1,36 @@
+export declare const updateRepoWebhook: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    hook_id: number;
+    githubToken?: string | undefined;
+    events?: string[] | undefined;
+    active?: boolean | undefined;
+    config?: {
+        url: string;
+        secret?: string | undefined;
+        content_type?: string | undefined;
+        insecure_ssl?: string | undefined;
+    } | undefined;
+    add_events?: string[] | undefined;
+    remove_events?: string[] | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    active?: undefined;
+    events?: undefined;
+    config?: undefined;
+} | {
+    id: number;
+    name: string;
+    active: boolean;
+    events: string[];
+    config: {
+        url?: import("@octokit/openapi-types").components["schemas"]["webhook-config-url"];
+        content_type?: import("@octokit/openapi-types").components["schemas"]["webhook-config-content-type"];
+        secret?: import("@octokit/openapi-types").components["schemas"]["webhook-config-secret"];
+        insecure_ssl?: import("@octokit/openapi-types").components["schemas"]["webhook-config-insecure-ssl"];
+    };
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-repo-webhook.d.ts.map

package/dist/toolkits/github/tools/Webhooks/update-repo-webhook.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateRepoWebhook = tool({
+    description: 'Update a webhook 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'),
+        hook_id: z.number().describe('The unique identifier of the webhook'),
+        config: z.object({
+            url: z.string().describe('The URL to which the payloads will be delivered'),
+            content_type: z.string().optional().describe('The media type used to serialize the payloads'),
+            secret: z.string().optional().describe('If provided, payloads will be delivered with an X-Hub-Signature header'),
+            insecure_ssl: z.string().optional().describe('Determines whether the SSL certificate of the host for url will be verified'),
+        }).optional().describe('Key/value pairs to provide settings for this webhook'),
+        events: z.array(z.string()).optional().describe('Determines what events the hook is triggered for'),
+        add_events: z.array(z.string()).optional().describe('Determines a list of events to be added to the list of events that the Hook triggers for'),
+        remove_events: z.array(z.string()).optional().describe('Determines a list of events to be removed from the list of events that the Hook triggers for'),
+        active: z.boolean().optional().describe('Determines if notifications are sent when the webhook is triggered'),
+    }),
+    execute: async ({ githubToken, owner, repo, hook_id, ...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.updateWebhook({
+                owner,
+                repo,
+                hook_id,
+                ...options,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                id: data.id,
+                name: data.name,
+                active: data.active,
+                events: data.events,
+                config: data.config,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update repository webhook: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-repo-webhook.js.map

package/dist/toolkits/github/tools/Workflows/get-workflow-run.d.ts

@@ -0,0 +1,31 @@
+export declare const getWorkflowRun: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    runId: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    status?: undefined;
+    conclusion?: undefined;
+    workflow_id?: undefined;
+    html_url?: undefined;
+    head_branch?: undefined;
+    head_sha?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+} | {
+    id: number;
+    name: string | null | undefined;
+    status: string | null;
+    conclusion: string | null;
+    workflow_id: number;
+    html_url: string;
+    head_branch: string | null;
+    head_sha: string;
+    created_at: string;
+    updated_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-workflow-run.d.ts.map

package/dist/toolkits/github/tools/Workflows/get-workflow-run.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getWorkflowRun = tool({
+    description: 'Get details of a specific GitHub Actions workflow run.',
+    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'),
+        runId: z.number().describe('The ID of the workflow run'),
+    }),
+    execute: async ({ githubToken, owner, repo, runId }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.actions.getWorkflowRun({
+                owner,
+                repo,
+                run_id: runId,
+            });
+            return {
+                id: data.id,
+                name: data.name,
+                status: data.status,
+                conclusion: data.conclusion,
+                workflow_id: data.workflow_id,
+                html_url: data.html_url,
+                head_branch: data.head_branch,
+                head_sha: data.head_sha,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get workflow run: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-workflow-run.js.map

package/dist/toolkits/github/tools/Workflows/list-workflow-runs.d.ts

@@ -0,0 +1,25 @@
+export declare const listWorkflowRuns: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    perPage: number;
+    status?: "success" | "queued" | "in_progress" | "completed" | "waiting" | "requested" | "failure" | "neutral" | "cancelled" | "skipped" | "timed_out" | "action_required" | "stale" | undefined;
+    githubToken?: string | undefined;
+    workflowId?: string | number | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    workflow_runs?: undefined;
+} | {
+    total_count: number;
+    workflow_runs: {
+        id: number;
+        name: string | null | undefined;
+        status: string | null;
+        conclusion: string | null;
+        html_url: string;
+        created_at: string;
+        updated_at: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-workflow-runs.d.ts.map

package/dist/toolkits/github/tools/Workflows/list-workflow-runs.js

@@ -0,0 +1,59 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listWorkflowRuns = tool({
+    description: 'List GitHub Actions workflow runs.',
+    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'),
+        workflowId: z.union([z.string(), z.number()]).optional().describe('Specific workflow ID or filename to filter by'),
+        status: z.enum(['completed', 'action_required', 'cancelled', 'failure', 'neutral', 'skipped', 'stale', 'success', 'timed_out', 'in_progress', 'queued', 'requested', 'waiting']).optional(),
+        perPage: z.number().optional().default(30),
+    }),
+    execute: async ({ githubToken, owner, repo, workflowId, status, perPage = 30 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            let data;
+            if (workflowId) {
+                const response = await octokit.rest.actions.listWorkflowRuns({
+                    owner,
+                    repo,
+                    workflow_id: workflowId,
+                    status,
+                    per_page: perPage,
+                });
+                data = response.data;
+            }
+            else {
+                const response = await octokit.rest.actions.listWorkflowRunsForRepo({
+                    owner,
+                    repo,
+                    status,
+                    per_page: perPage,
+                });
+                data = response.data;
+            }
+            return {
+                total_count: data.total_count,
+                workflow_runs: data.workflow_runs.map((run) => ({
+                    id: run.id,
+                    name: run.name,
+                    status: run.status,
+                    conclusion: run.conclusion,
+                    html_url: run.html_url,
+                    created_at: run.created_at,
+                    updated_at: run.updated_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list workflow runs: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-workflow-runs.js.map

package/dist/toolkits/github/tools/Workflows/list-workflows.d.ts

@@ -0,0 +1,21 @@
+export declare const listWorkflows: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    perPage: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    workflows?: undefined;
+} | {
+    total_count: number;
+    workflows: {
+        id: number;
+        name: string;
+        state: "active" | "deleted" | "disabled_fork" | "disabled_inactivity" | "disabled_manually";
+        path: string;
+        html_url: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-workflows.d.ts.map

package/dist/toolkits/github/tools/Workflows/list-workflows.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listWorkflows = tool({
+    description: 'List GitHub Actions workflows 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'),
+        perPage: z.number().optional().default(30),
+    }),
+    execute: async ({ githubToken, owner, repo, perPage = 30 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.actions.listRepoWorkflows({
+                owner,
+                repo,
+                per_page: perPage,
+            });
+            return {
+                total_count: data.total_count,
+                workflows: data.workflows.map((wf) => ({
+                    id: wf.id,
+                    name: wf.name,
+                    state: wf.state,
+                    path: wf.path,
+                    html_url: wf.html_url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list workflows: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-workflows.js.map

package/dist/toolkits/github/tools/Workflows/trigger-workflow.d.ts

@@ -0,0 +1,15 @@
+export declare const triggerWorkflow: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    ref: string;
+    workflowId: string | number;
+    githubToken?: string | undefined;
+    inputs?: Record<string, string> | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=trigger-workflow.d.ts.map

package/dist/toolkits/github/tools/Workflows/trigger-workflow.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const triggerWorkflow = tool({
+    description: 'Trigger a GitHub Actions workflow dispatch event.',
+    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'),
+        workflowId: z.union([z.string(), z.number()]).describe('Workflow ID or filename (e.g., "main.yml")'),
+        ref: z.string().describe('The git reference for the workflow (branch or tag)'),
+        inputs: z.record(z.string(), z.string()).optional().describe('Input keys and values configured in the workflow file'),
+    }),
+    execute: async ({ githubToken, owner, repo, workflowId, ref, inputs }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.actions.createWorkflowDispatch({
+                owner,
+                repo,
+                workflow_id: workflowId,
+                ref,
+                inputs: inputs || {},
+            });
+            return { message: 'Workflow triggered successfully' };
+        }
+        catch (error) {
+            return { error: `Failed to trigger workflow: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=trigger-workflow.js.map