@rnsk/toolkits 0.0.1 → 0.0.3

package/dist/toolkits/github/tools/Actions/list-artifacts.d.ts

@@ -0,0 +1,23 @@
+export declare const listArtifacts: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    artifacts?: undefined;
+} | {
+    total_count: number;
+    artifacts: {
+        id: number;
+        name: string;
+        size_in_bytes: number;
+        created_at: string | null;
+        expired: boolean;
+        expires_at: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-artifacts.d.ts.map

package/dist/toolkits/github/tools/Actions/list-artifacts.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listArtifacts = tool({
+    description: 'List artifacts for a GitHub repository. Returns workflow run artifacts with their names, sizes, and download URLs.',
+    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.actions.listArtifactsForRepo({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                total_count: data.total_count,
+                artifacts: data.artifacts.map(artifact => ({
+                    id: artifact.id,
+                    name: artifact.name,
+                    size_in_bytes: artifact.size_in_bytes,
+                    created_at: artifact.created_at,
+                    expired: artifact.expired,
+                    expires_at: artifact.expires_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list artifacts: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-artifacts.js.map

package/dist/toolkits/github/tools/Actions/list-workflow-jobs.d.ts

@@ -0,0 +1,27 @@
+export declare const listWorkflowJobs: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    run_id: number;
+    filter?: "all" | "latest" | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    jobs?: undefined;
+} | {
+    total_count: number;
+    jobs: {
+        id: number;
+        run_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;
+        completed_at: string | null;
+        html_url: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-workflow-jobs.d.ts.map

package/dist/toolkits/github/tools/Actions/list-workflow-jobs.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listWorkflowJobs = tool({
+    description: 'List jobs for a workflow run. Returns job details including status, conclusion, and steps.',
+    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'),
+        run_id: z.number().describe('The unique identifier of the workflow run'),
+        filter: z.enum(['latest', 'all']).optional().describe('Filter jobs by latest or all attempts'),
+        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, run_id, filter, 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.actions.listJobsForWorkflowRun({
+                owner,
+                repo,
+                run_id,
+                filter: filter ?? 'latest',
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                total_count: data.total_count,
+                jobs: data.jobs.map(job => ({
+                    id: job.id,
+                    run_id: job.run_id,
+                    name: job.name,
+                    status: job.status,
+                    conclusion: job.conclusion,
+                    started_at: job.started_at,
+                    completed_at: job.completed_at,
+                    html_url: job.html_url,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list workflow jobs: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-workflow-jobs.js.map

package/dist/toolkits/github/tools/Actions/list-workflow-run-artifacts.d.ts

@@ -0,0 +1,24 @@
+export declare const listWorkflowRunArtifacts: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    run_id: number;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    total_count?: undefined;
+    artifacts?: undefined;
+} | {
+    total_count: number;
+    artifacts: {
+        id: number;
+        name: string;
+        size_in_bytes: number;
+        created_at: string | null;
+        expired: boolean;
+        expires_at: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-workflow-run-artifacts.d.ts.map

package/dist/toolkits/github/tools/Actions/list-workflow-run-artifacts.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listWorkflowRunArtifacts = tool({
+    description: 'List artifacts for a specific workflow 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'),
+        run_id: z.number().describe('The unique identifier of the workflow run'),
+        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, run_id, 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.actions.listWorkflowRunArtifacts({
+                owner,
+                repo,
+                run_id,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                total_count: data.total_count,
+                artifacts: data.artifacts.map(artifact => ({
+                    id: artifact.id,
+                    name: artifact.name,
+                    size_in_bytes: artifact.size_in_bytes,
+                    created_at: artifact.created_at,
+                    expired: artifact.expired,
+                    expires_at: artifact.expires_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list workflow run artifacts: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-workflow-run-artifacts.js.map

package/dist/toolkits/github/tools/Activity/list-notifications.d.ts

@@ -0,0 +1,24 @@
+export declare const listNotifications: import("ai").Tool<{
+    all?: boolean | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    participating?: boolean | undefined;
+}, {
+    error: string;
+    notifications?: undefined;
+} | {
+    notifications: {
+        id: string;
+        repository: string;
+        subject: {
+            title: string;
+            type: string;
+        };
+        reason: string;
+        unread: boolean;
+        updated_at: string;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-notifications.d.ts.map

package/dist/toolkits/github/tools/Activity/list-notifications.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listNotifications = tool({
+    description: 'List notifications for the authenticated user. Returns unread notifications by default.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        all: z.boolean().optional().describe('If true, show notifications marked as read'),
+        participating: z.boolean().optional().describe('If true, only show notifications in which the user is directly participating'),
+        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, all, participating, 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.listNotificationsForAuthenticatedUser({
+                all: all ?? false,
+                participating: participating ?? false,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                notifications: data.map(notification => ({
+                    id: notification.id,
+                    repository: notification.repository?.full_name,
+                    subject: {
+                        title: notification.subject?.title,
+                        type: notification.subject?.type,
+                    },
+                    reason: notification.reason,
+                    unread: notification.unread,
+                    updated_at: notification.updated_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list notifications: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-notifications.js.map

package/dist/toolkits/github/tools/Activity/list-public-events.d.ts

@@ -0,0 +1,18 @@
+export declare const listPublicEvents: import("ai").Tool<{
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    events?: undefined;
+} | {
+    events: {
+        id: string;
+        type: string | null;
+        actor: string;
+        repo: string;
+        created_at: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-public-events.d.ts.map

package/dist/toolkits/github/tools/Activity/list-public-events.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listPublicEvents = tool({
+    description: 'List public events on GitHub. Returns recent public activity across GitHub.',
+    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.listPublicEvents({
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                events: data.map(event => ({
+                    id: event.id,
+                    type: event.type,
+                    actor: event.actor?.login,
+                    repo: event.repo?.name,
+                    created_at: event.created_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list public events: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-public-events.js.map

package/dist/toolkits/github/tools/Activity/list-repo-events.d.ts

@@ -0,0 +1,19 @@
+export declare const listRepoEvents: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    events?: undefined;
+} | {
+    events: {
+        id: string;
+        type: string | null;
+        actor: string;
+        created_at: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-repo-events.d.ts.map

package/dist/toolkits/github/tools/Activity/list-repo-events.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listRepoEvents = tool({
+    description: 'List events for a repository. Returns recent activity for a specific 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.activity.listRepoEvents({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                events: data.map(event => ({
+                    id: event.id,
+                    type: event.type,
+                    actor: event.actor?.login,
+                    created_at: event.created_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list repository events: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-repo-events.js.map

package/dist/toolkits/github/tools/Activity/list-user-events.d.ts

@@ -0,0 +1,17 @@
+export declare const listUserEvents: import("ai").Tool<{
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+}, {
+    error: string;
+    events?: undefined;
+} | {
+    events: {
+        id: string;
+        type: string | null;
+        repo: string;
+        created_at: string | null;
+    }[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=list-user-events.d.ts.map

package/dist/toolkits/github/tools/Activity/list-user-events.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listUserEvents = tool({
+    description: 'List events for the authenticated user. Returns recent activity for 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.listEventsForAuthenticatedUser({
+                username: 'placeholder', // This will be ignored by the API for authenticated user
+                per_page: per_page ?? 30,
+                page: page ?? 1,
+            });
+            return {
+                events: data.map(event => ({
+                    id: event.id,
+                    type: event.type,
+                    repo: event.repo?.name,
+                    created_at: event.created_at,
+                })),
+            };
+        }
+        catch (error) {
+            return { error: `Failed to list user events: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-user-events.js.map

package/dist/toolkits/github/tools/Activity/mark-notifications-read.d.ts

@@ -0,0 +1,11 @@
+export declare const markNotificationsRead: import("ai").Tool<{
+    githubToken?: string | undefined;
+    last_read_at?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=mark-notifications-read.d.ts.map

package/dist/toolkits/github/tools/Activity/mark-notifications-read.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const markNotificationsRead = tool({
+    description: 'Mark notifications as read for the authenticated user.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        last_read_at: z.string().optional().describe('Describes the last point that notifications were checked (ISO 8601 timestamp)'),
+    }),
+    execute: async ({ githubToken, last_read_at }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.activity.markNotificationsAsRead({
+                last_read_at: last_read_at ?? new Date().toISOString(),
+            });
+            return { message: 'Successfully marked notifications as read' };
+        }
+        catch (error) {
+            return { error: `Failed to mark notifications as read: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=mark-notifications-read.js.map

package/dist/toolkits/github/tools/Apps/get-authenticated-app.d.ts

@@ -0,0 +1,24 @@
+export declare const getAuthenticatedApp: import("ai").Tool<{
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    name?: undefined;
+    slug?: undefined;
+    owner?: undefined;
+    description?: undefined;
+    html_url?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+} | {
+    id: number;
+    name: string;
+    slug: string | undefined;
+    owner: any;
+    description: string | null;
+    html_url: string;
+    created_at: string;
+    updated_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-authenticated-app.d.ts.map

package/dist/toolkits/github/tools/Apps/get-authenticated-app.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getAuthenticatedApp = tool({
+    description: 'Get the authenticated GitHub App. Returns information about the authenticated app.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+    }),
+    execute: async ({ githubToken }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.apps.getAuthenticated();
+            if (!data) {
+                return { error: 'No data returned from GitHub API' };
+            }
+            return {
+                id: data.id,
+                name: data.name,
+                slug: data.slug,
+                owner: data.owner?.login || data.owner?.name,
+                description: data.description,
+                html_url: data.html_url,
+                created_at: data.created_at,
+                updated_at: data.updated_at,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get authenticated app: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-authenticated-app.js.map

package/dist/toolkits/github/tools/Apps/get-installation.d.ts

@@ -0,0 +1,76 @@
+export declare const getInstallation: import("ai").Tool<{
+    installation_id: number;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    id?: undefined;
+    account?: undefined;
+    app_id?: undefined;
+    target_type?: undefined;
+    permissions?: undefined;
+    events?: undefined;
+    created_at?: undefined;
+    updated_at?: undefined;
+} | {
+    id: number;
+    account: any;
+    app_id: number;
+    target_type: string;
+    permissions: {
+        actions?: "read" | "write";
+        administration?: "read" | "write";
+        checks?: "read" | "write";
+        codespaces?: "read" | "write";
+        contents?: "read" | "write";
+        dependabot_secrets?: "read" | "write";
+        deployments?: "read" | "write";
+        environments?: "read" | "write";
+        issues?: "read" | "write";
+        metadata?: "read" | "write";
+        packages?: "read" | "write";
+        pages?: "read" | "write";
+        pull_requests?: "read" | "write";
+        repository_custom_properties?: "read" | "write";
+        repository_hooks?: "read" | "write";
+        repository_projects?: "read" | "write" | "admin";
+        secret_scanning_alerts?: "read" | "write";
+        secrets?: "read" | "write";
+        security_events?: "read" | "write";
+        single_file?: "read" | "write";
+        statuses?: "read" | "write";
+        vulnerability_alerts?: "read" | "write";
+        workflows?: "write";
+        custom_properties_for_organizations?: "read" | "write";
+        members?: "read" | "write";
+        organization_administration?: "read" | "write";
+        organization_custom_roles?: "read" | "write";
+        organization_custom_org_roles?: "read" | "write";
+        organization_custom_properties?: "read" | "write" | "admin";
+        organization_copilot_seat_management?: "write";
+        organization_announcement_banners?: "read" | "write";
+        organization_events?: "read";
+        organization_hooks?: "read" | "write";
+        organization_personal_access_tokens?: "read" | "write";
+        organization_personal_access_token_requests?: "read" | "write";
+        organization_plan?: "read";
+        organization_projects?: "read" | "write" | "admin";
+        organization_packages?: "read" | "write";
+        organization_secrets?: "read" | "write";
+        organization_self_hosted_runners?: "read" | "write";
+        organization_user_blocking?: "read" | "write";
+        team_discussions?: "read" | "write";
+        email_addresses?: "read" | "write";
+        followers?: "read" | "write";
+        git_ssh_keys?: "read" | "write";
+        gpg_keys?: "read" | "write";
+        interaction_limits?: "read" | "write";
+        profile?: "write";
+        starring?: "read" | "write";
+        enterprise_custom_properties_for_organizations?: "read" | "write" | "admin";
+    };
+    events: string[];
+    created_at: string;
+    updated_at: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-installation.d.ts.map