@rnsk/toolkits 0.0.2 → 0.0.4

package/dist/toolkits/linear/tools/add-comment.js

@@ -0,0 +1,52 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const linearAddComment = tool({
+    description: 'Add a comment to a Linear issue.',
+    inputSchema: z.object({
+        issueId: z.string().describe('Linear issue UUID'),
+        body: z.string().describe('Comment body (markdown supported)'),
+        linearToken: z.string().optional().describe('Linear API token (injected by system)'),
+    }),
+    execute: async ({ issueId, body, linearToken }) => {
+        const graphqlQuery = {
+            query: `
+        mutation CreateComment($input: CommentCreateInput!) {
+          commentCreate(input: $input) {
+            success
+            comment {
+              id
+              body
+              url
+              createdAt
+              user { id name }
+            }
+          }
+        }
+      `,
+            variables: {
+                input: {
+                    issueId,
+                    body,
+                },
+            },
+        };
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${linearToken}`,
+            },
+            body: JSON.stringify(graphqlQuery),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { error: 'Failed to add Linear comment', details: error };
+        }
+        const data = await response.json();
+        if (data.errors?.length) {
+            return { error: 'Linear GraphQL error', details: data.errors };
+        }
+        return data.data.commentCreate;
+    },
+});
+//# sourceMappingURL=add-comment.js.map

package/dist/toolkits/linear/tools/get-issue.d.ts

@@ -0,0 +1,6 @@
+export declare const linearGetIssue: import("ai").Tool<{
+    linearToken?: string | undefined;
+    issueId?: string | undefined;
+    identifier?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-issue.d.ts.map

package/dist/toolkits/linear/tools/get-issue.js

@@ -0,0 +1,117 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const linearGetIssue = tool({
+    description: 'Get a single Linear issue by UUID or identifier (e.g. ENG-123). Returns title, description, status, assignee, priority, and URL.',
+    inputSchema: z.object({
+        issueId: z
+            .string()
+            .optional()
+            .describe('Linear issue UUID. Use linearSearchIssues if you only have a title or keyword.'),
+        identifier: z
+            .string()
+            .optional()
+            .describe('Human-readable issue identifier, e.g. ENG-123 (team key + number).'),
+        linearToken: z.string().optional().describe('Linear API token (injected by system)'),
+    }),
+    execute: async ({ issueId, identifier, linearToken }) => {
+        if (!issueId && !identifier) {
+            return { error: 'Provide either issueId (UUID) or identifier (e.g. ENG-123).' };
+        }
+        if (issueId) {
+            const graphqlQuery = {
+                query: `
+          query GetIssue($id: String!) {
+            issue(id: $id) {
+              id
+              identifier
+              title
+              description
+              priority
+              url
+              createdAt
+              updatedAt
+              state { id name type }
+              assignee { id name email }
+              team { id name key }
+              project { id name }
+              labels { nodes { id name color } }
+            }
+          }
+        `,
+                variables: { id: issueId },
+            };
+            const response = await fetch('https://api.linear.app/graphql', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${linearToken}`,
+                },
+                body: JSON.stringify(graphqlQuery),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get Linear issue', details: error };
+            }
+            const data = await response.json();
+            if (data.errors?.length) {
+                return { error: 'Linear GraphQL error', details: data.errors };
+            }
+            return data.data.issue;
+        }
+        const match = identifier.match(/^([A-Za-z]+)-(\d+)$/);
+        if (!match) {
+            return { error: 'identifier must look like TEAM-123 (team key and issue number).' };
+        }
+        const [, teamKey, numberStr] = match;
+        const number = Number(numberStr);
+        const graphqlQuery = {
+            query: `
+        query IssueByIdentifier($teamKey: String!, $number: Float!) {
+          issues(filter: {
+            team: { key: { eq: $teamKey } }
+            number: { eq: $number }
+          }, first: 1) {
+            nodes {
+              id
+              identifier
+              title
+              description
+              priority
+              url
+              createdAt
+              updatedAt
+              state { id name type }
+              assignee { id name email }
+              team { id name key }
+              project { id name }
+              labels { nodes { id name color } }
+            }
+          }
+        }
+      `,
+            variables: { teamKey, number },
+        };
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${linearToken}`,
+            },
+            body: JSON.stringify(graphqlQuery),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { error: 'Failed to get Linear issue', details: error };
+        }
+        const data = await response.json();
+        if (data.errors?.length) {
+            return { error: 'Linear GraphQL error', details: data.errors };
+        }
+        const issue = data.data.issues.nodes[0];
+        if (!issue) {
+            return { error: `No issue found for identifier ${identifier}` };
+        }
+        return issue;
+    },
+});
+//# sourceMappingURL=get-issue.js.map

package/dist/toolkits/linear/tools/list-projects.d.ts

@@ -0,0 +1,4 @@
+export declare const linearListProjects: import("ai").Tool<{
+    linearToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-projects.d.ts.map

package/dist/toolkits/linear/tools/list-projects.js

@@ -0,0 +1,46 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const linearListProjects = tool({
+    description: 'List Linear projects. Returns project IDs, names, status, and associated teams.',
+    inputSchema: z.object({
+        linearToken: z.string().optional().describe('Linear API token (injected by system)'),
+    }),
+    execute: async ({ linearToken }) => {
+        const graphqlQuery = {
+            query: `
+        query {
+          projects(first: 50) {
+            nodes {
+              id
+              name
+              description
+              state
+              url
+              startDate
+              targetDate
+              teams { nodes { id name key } }
+            }
+          }
+        }
+      `,
+        };
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${linearToken}`,
+            },
+            body: JSON.stringify(graphqlQuery),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { error: 'Failed to list Linear projects', details: error };
+        }
+        const data = await response.json();
+        if (data.errors?.length) {
+            return { error: 'Linear GraphQL error', details: data.errors };
+        }
+        return data.data.projects.nodes;
+    },
+});
+//# sourceMappingURL=list-projects.js.map

package/dist/toolkits/linear/tools/list-workflow-states.d.ts

@@ -0,0 +1,26 @@
+export declare const linearListWorkflowStates: import("ai").Tool<{
+    teamId: string;
+    linearToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    teamId?: undefined;
+    teamName?: undefined;
+    teamKey?: undefined;
+    states?: undefined;
+} | {
+    error: string;
+    details?: undefined;
+    teamId?: undefined;
+    teamName?: undefined;
+    teamKey?: undefined;
+    states?: undefined;
+} | {
+    teamId: any;
+    teamName: any;
+    teamKey: any;
+    states: any;
+    error?: undefined;
+    details?: undefined;
+}>;
+//# sourceMappingURL=list-workflow-states.d.ts.map

package/dist/toolkits/linear/tools/list-workflow-states.js

@@ -0,0 +1,59 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const linearListWorkflowStates = tool({
+    description: 'List workflow states (statuses) for a Linear team. Use state IDs with linearUpdateIssue to move issues (e.g. Todo → In Progress → Done).',
+    inputSchema: z.object({
+        teamId: z.string().describe('Team UUID. Use linearListTeams to find team IDs.'),
+        linearToken: z.string().optional().describe('Linear API token (injected by system)'),
+    }),
+    execute: async ({ teamId, linearToken }) => {
+        const graphqlQuery = {
+            query: `
+        query TeamWorkflowStates($teamId: String!) {
+          team(id: $teamId) {
+            id
+            name
+            key
+            states {
+              nodes {
+                id
+                name
+                type
+                color
+                position
+              }
+            }
+          }
+        }
+      `,
+            variables: { teamId },
+        };
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${linearToken}`,
+            },
+            body: JSON.stringify(graphqlQuery),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { error: 'Failed to list Linear workflow states', details: error };
+        }
+        const data = await response.json();
+        if (data.errors?.length) {
+            return { error: 'Linear GraphQL error', details: data.errors };
+        }
+        const team = data.data.team;
+        if (!team) {
+            return { error: `Team not found: ${teamId}` };
+        }
+        return {
+            teamId: team.id,
+            teamName: team.name,
+            teamKey: team.key,
+            states: team.states.nodes,
+        };
+    },
+});
+//# sourceMappingURL=list-workflow-states.js.map

package/dist/toolkits/linear/tools/update-issue.d.ts

@@ -0,0 +1,11 @@
+export declare const linearUpdateIssue: import("ai").Tool<{
+    issueId: string;
+    description?: string | undefined;
+    title?: string | undefined;
+    linearToken?: string | undefined;
+    stateId?: string | undefined;
+    assigneeId?: string | null | undefined;
+    priority?: number | undefined;
+    projectId?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-issue.d.ts.map

package/dist/toolkits/linear/tools/update-issue.js

@@ -0,0 +1,78 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const linearUpdateIssue = tool({
+    description: 'Update a Linear issue. Change title, description, status (stateId), assignee, priority, or project. Use linearListWorkflowStates to find state IDs.',
+    inputSchema: z.object({
+        issueId: z.string().describe('Linear issue UUID'),
+        title: z.string().optional().describe('New title'),
+        description: z.string().optional().describe('New description (markdown supported)'),
+        stateId: z.string().optional().describe('Workflow state ID (e.g. move to Done). Use linearListWorkflowStates.'),
+        assigneeId: z.string().nullable().optional().describe('User ID to assign, or null to unassign.'),
+        priority: z
+            .number()
+            .int()
+            .min(0)
+            .max(4)
+            .optional()
+            .describe('Priority: 0=none, 1=urgent, 2=high, 3=medium, 4=low'),
+        projectId: z.string().optional().describe('Project ID to associate the issue with'),
+        linearToken: z.string().optional().describe('Linear API token (injected by system)'),
+    }),
+    execute: async ({ issueId, title, description, stateId, assigneeId, priority, projectId, linearToken }) => {
+        const input = {};
+        if (title !== undefined)
+            input.title = title;
+        if (description !== undefined)
+            input.description = description;
+        if (stateId !== undefined)
+            input.stateId = stateId;
+        if (assigneeId !== undefined)
+            input.assigneeId = assigneeId;
+        if (priority !== undefined)
+            input.priority = priority;
+        if (projectId !== undefined)
+            input.projectId = projectId;
+        if (Object.keys(input).length === 0) {
+            return { error: 'Provide at least one field to update (title, description, stateId, assigneeId, priority, or projectId).' };
+        }
+        const graphqlQuery = {
+            query: `
+        mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+          issueUpdate(id: $id, input: $input) {
+            success
+            issue {
+              id
+              identifier
+              title
+              description
+              priority
+              url
+              state { id name }
+              assignee { id name }
+              project { id name }
+            }
+          }
+        }
+      `,
+            variables: { id: issueId, input },
+        };
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${linearToken}`,
+            },
+            body: JSON.stringify(graphqlQuery),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { error: 'Failed to update Linear issue', details: error };
+        }
+        const data = await response.json();
+        if (data.errors?.length) {
+            return { error: 'Linear GraphQL error', details: data.errors };
+        }
+        return data.data.issueUpdate;
+    },
+});
+//# sourceMappingURL=update-issue.js.map

package/dist/toolkits/notion/tools/append-block-children.d.ts

@@ -1,6 +1,6 @@
 export declare const notionAppendBlockChildren: import("ai").Tool<{
-    block_id: string;
     children: any[];
+    block_id: string;
     notionToken?: string | undefined;
 }, any>;
 //# sourceMappingURL=append-block-children.d.ts.map

package/dist/toolkits/notion/tools/index.d.ts

@@ -1,16 +1,109 @@
-import { notionSearch } from './search';
-import { notionListDatabases } from './list-databases';
-import { notionQueryDatabase } from './query-database';
-import { notionGetPage } from './get-page';
-import { notionCreatePage } from './create-page';
-import { notionUpdatePage } from './update-page';
-import { notionAppendBlockChildren } from './append-block-children';
-import { notionGetDatabase } from './get-database';
+import { notionSearch } from './search.js';
+import { notionListDatabases } from './list-databases.js';
+import { notionQueryDatabase } from './query-database.js';
+import { notionGetPage } from './get-page.js';
+import { notionCreatePage } from './create-page.js';
+import { notionUpdatePage } from './update-page.js';
+import { notionAppendBlockChildren } from './append-block-children.js';
+import { notionGetDatabase } from './get-database.js';
 export { notionSearch, notionListDatabases, notionQueryDatabase, notionGetPage, notionCreatePage, notionUpdatePage, notionAppendBlockChildren, notionGetDatabase, };
-export declare const notionTools: {
+export declare const notionTools: ({
     name: string;
-    description: any;
-    tool: any;
+    description: string;
+    tool: import("ai").Tool<{
+        query: string;
+        page_size: number;
+        sort?: {
+            direction?: "ascending" | "descending" | undefined;
+            timestamp?: "last_edited_time" | undefined;
+        } | undefined;
+        filter?: {
+            value?: "page" | "database" | undefined;
+            property?: "object" | undefined;
+        } | undefined;
+        notionToken?: string | undefined;
+    }, any>;
     requiredAuth: "notionToken";
-}[];
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        page_size: number;
+        notionToken?: string | undefined;
+    }, any>;
+    requiredAuth: "notionToken";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        page_size: number;
+        database_id: string;
+        filter?: any;
+        notionToken?: string | undefined;
+        sorts?: any[] | undefined;
+    }, any>;
+    requiredAuth: "notionToken";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        page_id: string;
+        notionToken?: string | undefined;
+    }, {
+        error: string;
+        details: any;
+        page?: undefined;
+        content?: undefined;
+    } | {
+        page: any;
+        content: any;
+        error?: undefined;
+        details?: undefined;
+    }>;
+    requiredAuth: "notionToken";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        parent: {
+            database_id?: string | undefined;
+            page_id?: string | undefined;
+        };
+        notionToken?: string | undefined;
+        properties?: any;
+        children?: any[] | undefined;
+        icon?: any;
+        cover?: any;
+    }, any>;
+    requiredAuth: "notionToken";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        page_id: string;
+        notionToken?: string | undefined;
+        properties?: any;
+        icon?: any;
+        cover?: any;
+        archived?: boolean | undefined;
+    }, any>;
+    requiredAuth: "notionToken";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        children: any[];
+        block_id: string;
+        notionToken?: string | undefined;
+    }, any>;
+    requiredAuth: "notionToken";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        database_id: string;
+        notionToken?: string | undefined;
+    }, any>;
+    requiredAuth: "notionToken";
+})[];
 //# sourceMappingURL=index.d.ts.map

package/dist/toolkits/notion/tools/index.js

@@ -1,12 +1,12 @@
 // @ts-nocheck
-import { notionSearch } from './search';
-import { notionListDatabases } from './list-databases';
-import { notionQueryDatabase } from './query-database';
-import { notionGetPage } from './get-page';
-import { notionCreatePage } from './create-page';
-import { notionUpdatePage } from './update-page';
-import { notionAppendBlockChildren } from './append-block-children';
-import { notionGetDatabase } from './get-database';
+import { notionSearch } from './search.js';
+import { notionListDatabases } from './list-databases.js';
+import { notionQueryDatabase } from './query-database.js';
+import { notionGetPage } from './get-page.js';
+import { notionCreatePage } from './create-page.js';
+import { notionUpdatePage } from './update-page.js';
+import { notionAppendBlockChildren } from './append-block-children.js';
+import { notionGetDatabase } from './get-database.js';
 export { notionSearch, notionListDatabases, notionQueryDatabase, notionGetPage, notionCreatePage, notionUpdatePage, notionAppendBlockChildren, notionGetDatabase, };
 export const notionTools = [
     {

package/dist/toolkits/notion/tools/query-database.d.ts

@@ -1,6 +1,6 @@
 export declare const notionQueryDatabase: import("ai").Tool<{
-    database_id: string;
     page_size: number;
+    database_id: string;
     filter?: any;
     notionToken?: string | undefined;
     sorts?: any[] | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rnsk/toolkits",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Runstack toolkit registry — manifest-driven tool definitions for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,20 +13,18 @@
     "./core": {
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.js"
-    },
-    "./runtime": {
-      "types": "./dist/runtime/index.d.ts",
-      "import": "./dist/runtime/index.js"
     }
   },
   "files": [
+    "README.md",
     "dist/**/*.js",
     "dist/**/*.d.ts"
   ],
   "scripts": {
     "gen": "tsx scripts/gen-index.ts",
-    "validate": "tsx scripts/validate.ts",
-    "build": "npm run gen && tsc",
+    "validate": "tsx scripts/validate.ts && tsx scripts/validate-esm.ts --source",
+    "validate:dist": "tsx scripts/validate-esm.ts --dist",
+    "build": "npm run gen && tsc && npm run validate:dist",
     "prepublishOnly": "npm run validate && npm run build"
   },
   "peerDependencies": {

package/dist/runtime/credentials.d.ts

@@ -1,28 +0,0 @@
-import type { ToolkitManifest } from '../core/types.js';
-import type { ToolRegistry } from './registry.js';
-export interface CredentialResolver {
-    getToken: (tokenField: string) => Promise<string | null>;
-    getServiceEnv: (envName: string) => string | undefined;
-}
-export interface MetaToolPolicyResult {
-    allowed: boolean;
-    error?: string;
-    reason?: string;
-}
-export interface MetaToolHooks {
-    checkToolPolicy?: (toolName: string) => MetaToolPolicyResult;
-    sanitizeToolResult?: (result: unknown) => unknown;
-    sanitizeToolPayload?: (payload: Record<string, unknown>) => Record<string, unknown>;
-    isWebSearchEnabled?: () => boolean;
-    getAppUrl?: () => string;
-    getProviderSlugs?: () => string[];
-    isToolkitAvailable?: (toolkitId: string) => {
-        available: boolean;
-        reason?: string;
-    };
-}
-export declare function registerAllToolsFromManifests(registry: ToolRegistry, manifests: ToolkitManifest[], options?: {
-    skipUnavailable?: boolean;
-    isToolkitAvailable?: (id: string) => boolean;
-}): void;
-//# sourceMappingURL=credentials.d.ts.map

package/dist/runtime/credentials.js

@@ -1,15 +0,0 @@
-export function registerAllToolsFromManifests(registry, manifests, options) {
-    for (const manifest of manifests) {
-        if (options?.skipUnavailable && options.isToolkitAvailable && !options.isToolkitAvailable(manifest.id)) {
-            continue;
-        }
-        for (const toolDef of manifest.tools) {
-            registry.register(toolDef.name, toolDef.description ?? toolDef.tool.description ?? '', toolDef.tool, {
-                requiredAuth: toolDef.requiredAuth,
-                scope: toolDef.scope,
-                toolkitId: manifest.id,
-            });
-        }
-    }
-}
-//# sourceMappingURL=credentials.js.map

package/dist/runtime/index.d.ts

@@ -1,5 +0,0 @@
-export { getToolInputZodSchema, resolveZodObjectShape, toolInputToJsonSchema, extractParameterInfo, coerceArguments, TOOL_OUTPUT_JSON_SCHEMA, type ParameterInfo, } from './schema-helpers.js';
-export { createToolRegistry, type ToolRegistry, type ToolRegistryEntry } from './registry.js';
-export { registerAllToolsFromManifests, type CredentialResolver, type MetaToolHooks, type MetaToolPolicyResult, } from './credentials.js';
-export { createMetaTools } from './meta-tools.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.js

@@ -1,5 +0,0 @@
-export { getToolInputZodSchema, resolveZodObjectShape, toolInputToJsonSchema, extractParameterInfo, coerceArguments, TOOL_OUTPUT_JSON_SCHEMA, } from './schema-helpers.js';
-export { createToolRegistry } from './registry.js';
-export { registerAllToolsFromManifests, } from './credentials.js';
-export { createMetaTools } from './meta-tools.js';
-//# sourceMappingURL=index.js.map