@rnsk/toolkits 0.0.1 → 0.0.3

package/dist/toolkits/github/tools/Issues/list-repo-issues.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listRepoIssues = tool({
+    description: 'List issues for a GitHub repository. Use when the user asks to see issues, open issues, or list issues in a repo. Provide owner and repo (e.g. owner: octocat, repo: hello-world).',
+    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', 'closed', 'all']).optional().default('open').describe('Filter by issue state'),
+        perPage: z.number().min(1).max(100).optional().default(30).describe('Number of issues per page'),
+        page: z.number().min(1).optional().default(1).describe('Page number'),
+    }),
+    execute: async ({ githubToken, owner, repo, state = 'open', perPage = 30, page = 1 }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        const { data } = await octokit.rest.issues.listForRepo({
+            owner,
+            repo,
+            state,
+            per_page: perPage,
+            page,
+        });
+        return {
+            owner,
+            repo,
+            issues: data.map((issue) => ({
+                number: issue.number,
+                title: issue.title,
+                state: issue.state,
+                html_url: issue.html_url ?? null,
+                user: issue.user?.login ?? null,
+                created_at: issue.created_at,
+            })),
+            total: data.length,
+        };
+    },
+});
+//# sourceMappingURL=list-repo-issues.js.map

package/dist/toolkits/github/tools/Issues/list-user-account-issues.d.ts

@@ -0,0 +1,21 @@
+export declare const listUserAccountIssues: import("ai").Tool<{
+    sort?: "created" | "updated" | "comments" | undefined;
+    filter?: "all" | "assigned" | "created" | "mentioned" | "subscribed" | undefined;
+    since?: string | undefined;
+    labels?: string | undefined;
+    githubToken?: string | undefined;
+    per_page?: number | undefined;
+    page?: number | undefined;
+    state?: "all" | "open" | "closed" | undefined;
+    direction?: "asc" | "desc" | undefined;
+}, {
+    number: number;
+    title: string;
+    state: string;
+    repository: string | undefined;
+    html_url: string;
+    created_at: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-user-account-issues.d.ts.map

package/dist/toolkits/github/tools/Issues/list-user-account-issues.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listUserAccountIssues = tool({
+    description: 'List issues assigned to the authenticated user across their own user repositories.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        filter: z.enum(['assigned', 'created', 'mentioned', 'subscribed', 'all']).optional().describe('Indicates which sorts of issues to return.'),
+        state: z.enum(['open', 'closed', 'all']).optional().describe('Indicates the state of the issues to return.'),
+        labels: z.string().optional().describe('A list of comma separated label names.'),
+        sort: z.enum(['created', 'updated', 'comments']).optional().describe('What to sort results by.'),
+        direction: z.enum(['asc', 'desc']).optional().describe('The direction to sort the results by.'),
+        since: z.string().optional().describe('Only show issues updated after this time (ISO 8601 format).'),
+        per_page: z.number().optional().describe('The number of results per page (max 100).'),
+        page: z.number().optional().describe('Page number of the results to fetch.'),
+    }),
+    execute: async ({ githubToken, ...params }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        const { data } = await octokit.rest.issues.list({
+            ...params,
+        });
+        return data.map((issue) => ({
+            number: issue.number,
+            title: issue.title,
+            state: issue.state,
+            repository: issue.repository?.full_name,
+            html_url: issue.html_url,
+            created_at: issue.created_at,
+        }));
+    },
+});
+//# sourceMappingURL=list-user-account-issues.js.map

package/dist/toolkits/github/tools/Issues/lock-issue.d.ts

@@ -0,0 +1,15 @@
+export declare const lockIssue: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    issueNumber: number;
+    githubToken?: string | undefined;
+    lockReason?: "off-topic" | "too heated" | "resolved" | "spam" | undefined;
+    unlock?: boolean | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=lock-issue.d.ts.map

package/dist/toolkits/github/tools/Issues/lock-issue.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const lockIssue = tool({
+    description: 'Lock or unlock a GitHub issue.',
+    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'),
+        issueNumber: z.number().describe('Issue number'),
+        lockReason: z.enum(['off-topic', 'too heated', 'resolved', 'spam']).optional(),
+        unlock: z.boolean().optional().describe('If true, unlock the issue. Default is false (lock).'),
+    }),
+    execute: async ({ githubToken, owner, repo, issueNumber, lockReason, unlock = false }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            if (unlock) {
+                await octokit.rest.issues.unlock({
+                    owner,
+                    repo,
+                    issue_number: issueNumber,
+                });
+                return { message: `Unlocked issue #${issueNumber}` };
+            }
+            else {
+                await octokit.rest.issues.lock({
+                    owner,
+                    repo,
+                    issue_number: issueNumber,
+                    lock_reason: lockReason,
+                });
+                return { message: `Locked issue #${issueNumber}` };
+            }
+        }
+        catch (error) {
+            return { error: `Failed to lock/unlock issue: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=lock-issue.js.map

package/dist/toolkits/github/tools/Issues/remove-issue-label.d.ts

@@ -0,0 +1,14 @@
+export declare const removeIssueLabel: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    issueNumber: number;
+    label: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    message: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=remove-issue-label.d.ts.map

package/dist/toolkits/github/tools/Issues/remove-issue-label.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const removeIssueLabel = tool({
+    description: 'Remove a label from a GitHub issue.',
+    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'),
+        issueNumber: z.number().describe('Issue number'),
+        label: z.string().describe('Label name'),
+    }),
+    execute: async ({ githubToken, owner, repo, issueNumber, label }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.issues.removeLabel({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                name: label,
+            });
+            return { message: `Removed label ${label} from issue #${issueNumber}` };
+        }
+        catch (error) {
+            return { error: `Failed to remove label: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=remove-issue-label.js.map

package/dist/toolkits/github/tools/Issues/unlock-issue.d.ts

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

package/dist/toolkits/github/tools/Issues/unlock-issue.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const unlockIssue = tool({
+    description: 'Unlock a GitHub issue. Use when the user wants to unlock an issue to allow new comments.',
+    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'),
+        issue_number: z.number().describe('The number that identifies the issue'),
+    }),
+    execute: async ({ githubToken, owner, repo, issue_number }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            await octokit.rest.issues.unlock({
+                owner,
+                repo,
+                issue_number,
+            });
+            return { message: `Successfully unlocked issue #${issue_number} in ${owner}/${repo}` };
+        }
+        catch (error) {
+            return { error: `Failed to unlock issue: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=unlock-issue.js.map

package/dist/toolkits/github/tools/Issues/update-issue.d.ts

@@ -0,0 +1,22 @@
+export declare const updateIssue: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    issueNumber: number;
+    title?: string | undefined;
+    body?: string | undefined;
+    githubToken?: string | undefined;
+    state?: "open" | "closed" | undefined;
+}, {
+    error: string;
+    number?: undefined;
+    title?: undefined;
+    state?: undefined;
+    html_url?: undefined;
+} | {
+    number: number;
+    title: string;
+    state: string;
+    html_url: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=update-issue.d.ts.map

package/dist/toolkits/github/tools/Issues/update-issue.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const updateIssue = tool({
+    description: 'Update a GitHub issue (close, reopen, edit title/body).',
+    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'),
+        issueNumber: z.number().describe('Issue number'),
+        title: z.string().optional().describe('New title'),
+        body: z.string().optional().describe('New body'),
+        state: z.enum(['open', 'closed']).optional().describe('New state'),
+    }),
+    execute: async ({ githubToken, owner, repo, issueNumber, title, body, state }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.issues.update({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                title,
+                body,
+                state,
+            });
+            return {
+                number: data.number,
+                title: data.title,
+                state: data.state,
+                html_url: data.html_url,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to update issue: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=update-issue.js.map

package/dist/toolkits/github/tools/Licenses/get-license.d.ts

@@ -0,0 +1,33 @@
+export declare const getLicense: import("ai").Tool<{
+    license: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    key?: undefined;
+    name?: undefined;
+    spdx_id?: undefined;
+    url?: undefined;
+    node_id?: undefined;
+    description?: undefined;
+    implementation?: undefined;
+    permissions?: undefined;
+    conditions?: undefined;
+    limitations?: undefined;
+    body?: undefined;
+    featured?: undefined;
+} | {
+    key: string;
+    name: string;
+    spdx_id: string | null;
+    url: string | null;
+    node_id: string;
+    description: string;
+    implementation: string;
+    permissions: string[];
+    conditions: string[];
+    limitations: string[];
+    body: string;
+    featured: boolean;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-license.d.ts.map

package/dist/toolkits/github/tools/Licenses/get-license.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getLicense = tool({
+    description: 'Get an individual license.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        license: z.string().describe('The key of the license (e.g., mit)'),
+    }),
+    execute: async ({ githubToken, license }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.licenses.get({
+                license,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                key: data.key,
+                name: data.name,
+                spdx_id: data.spdx_id,
+                url: data.url,
+                node_id: data.node_id,
+                description: data.description,
+                implementation: data.implementation,
+                permissions: data.permissions,
+                conditions: data.conditions,
+                limitations: data.limitations,
+                body: data.body,
+                featured: data.featured,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get license: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-license.js.map

package/dist/toolkits/github/tools/Licenses/get-repo-license.d.ts

@@ -0,0 +1,47 @@
+export declare const getRepoLicense: import("ai").Tool<{
+    repo: string;
+    owner: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    name?: undefined;
+    path?: undefined;
+    sha?: undefined;
+    size?: undefined;
+    url?: undefined;
+    html_url?: undefined;
+    git_url?: undefined;
+    download_url?: undefined;
+    type?: undefined;
+    content?: undefined;
+    encoding?: undefined;
+    _links?: undefined;
+    license?: undefined;
+} | {
+    name: string;
+    path: string;
+    sha: string;
+    size: number;
+    url: string;
+    html_url: string | null;
+    git_url: string | null;
+    download_url: string | null;
+    type: string;
+    content: string;
+    encoding: string;
+    _links: {
+        git: string | null;
+        html: string | null;
+        self: string;
+    };
+    license: {
+        key: string;
+        name: string;
+        url: string | null;
+        spdx_id: string | null;
+        node_id: string;
+        html_url?: string;
+    } | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-repo-license.d.ts.map

package/dist/toolkits/github/tools/Licenses/get-repo-license.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const getRepoLicense = tool({
+    description: 'Get the license 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'),
+    }),
+    execute: async ({ githubToken, owner, repo }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.licenses.getForRepo({
+                owner,
+                repo,
+            });
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return {
+                name: data.name,
+                path: data.path,
+                sha: data.sha,
+                size: data.size,
+                url: data.url,
+                html_url: data.html_url,
+                git_url: data.git_url,
+                download_url: data.download_url,
+                type: data.type,
+                content: data.content,
+                encoding: data.encoding,
+                _links: data._links,
+                license: data.license,
+            };
+        }
+        catch (error) {
+            return { error: `Failed to get repo license: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=get-repo-license.js.map

package/dist/toolkits/github/tools/Licenses/list-licenses.d.ts

@@ -0,0 +1,12 @@
+export declare const listLicenses: import("ai").Tool<{
+    githubToken?: string | undefined;
+}, {
+    key: string;
+    name: string;
+    spdx_id: string | null;
+    url: string | null;
+    node_id: string;
+}[] | {
+    error: string;
+}>;
+//# sourceMappingURL=list-licenses.d.ts.map

package/dist/toolkits/github/tools/Licenses/list-licenses.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const listLicenses = tool({
+    description: 'Get all commonly used licenses.',
+    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.licenses.getAllCommonlyUsed();
+            if (!data)
+                return { error: 'No data returned from GitHub API' };
+            return data.map(license => ({
+                key: license.key,
+                name: license.name,
+                spdx_id: license.spdx_id,
+                url: license.url,
+                node_id: license.node_id,
+            }));
+        }
+        catch (error) {
+            return { error: `Failed to list licenses: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=list-licenses.js.map

package/dist/toolkits/github/tools/Markdown/render-markdown.d.ts

@@ -0,0 +1,13 @@
+export declare const renderMarkdown: import("ai").Tool<{
+    text: string;
+    mode?: "markdown" | "gfm" | undefined;
+    githubToken?: string | undefined;
+    context?: string | undefined;
+}, {
+    error: string;
+    html?: undefined;
+} | {
+    html: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=render-markdown.d.ts.map

package/dist/toolkits/github/tools/Markdown/render-markdown.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Octokit } from 'octokit';
+export const renderMarkdown = tool({
+    description: 'Render a Markdown document.',
+    inputSchema: z.object({
+        githubToken: z.string().optional().describe('Injected by system; do not provide'),
+        text: z.string().describe('The Markdown text to render'),
+        mode: z.enum(['markdown', 'gfm']).optional().describe('The rendering mode'),
+        context: z.string().optional().describe('The repository context to use when rendering links in GFM mode'),
+    }),
+    execute: async ({ githubToken, text, mode, context }) => {
+        if (!githubToken) {
+            return { error: 'GitHub token is required. Connect GitHub first.' };
+        }
+        const octokit = new Octokit({ auth: githubToken });
+        try {
+            const { data } = await octokit.rest.markdown.render({
+                text,
+                mode: mode ?? 'markdown',
+                context,
+            });
+            return { html: data };
+        }
+        catch (error) {
+            return { error: `Failed to render markdown: ${error.message}` };
+        }
+    },
+});
+//# sourceMappingURL=render-markdown.js.map

package/dist/toolkits/github/tools/Organizations/get-org-membership.d.ts

@@ -0,0 +1,58 @@
+export declare const getOrgMembership: import("ai").Tool<{
+    username: string;
+    org: string;
+    githubToken?: string | undefined;
+}, {
+    error: string;
+    url?: undefined;
+    state?: undefined;
+    role?: undefined;
+    organization_url?: undefined;
+    organization?: undefined;
+    user?: undefined;
+} | {
+    url: string;
+    state: "pending" | "active";
+    role: "admin" | "member" | "billing_manager";
+    organization_url: string;
+    organization: {
+        login: string;
+        id: number;
+        node_id: string;
+        url: string;
+        repos_url: string;
+        events_url: string;
+        hooks_url: string;
+        issues_url: string;
+        members_url: string;
+        public_members_url: string;
+        avatar_url: string;
+        description: string | null;
+    };
+    user: {
+        name?: string | null;
+        email?: string | null;
+        login: string;
+        id: number;
+        node_id: string;
+        avatar_url: string;
+        gravatar_id: string | null;
+        url: string;
+        html_url: string;
+        followers_url: string;
+        following_url: string;
+        gists_url: string;
+        starred_url: string;
+        subscriptions_url: string;
+        organizations_url: string;
+        repos_url: string;
+        events_url: string;
+        received_events_url: string;
+        type: string;
+        site_admin: boolean;
+        starred_at?: string;
+        user_view_type?: string;
+    } | null;
+    error?: undefined;
+}>;
+//# sourceMappingURL=get-org-membership.d.ts.map