toolpack-cli 0.1.0-SNAPSHOT

package/dist/custom-providers/XAIAdapter.js

@@ -0,0 +1,295 @@
+/**
+ * xAI Adapter - Custom Provider Example
+ *
+ * Demonstrates how to create a custom provider adapter for the Toolpack SDK.
+ * xAI provides Grok models for fast, intelligent AI responses.
+ *
+ * API Docs: https://docs.x.ai/api
+ */
+export class XAIAdapter {
+    constructor(config = {}) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'xai'
+        });
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaultModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Resolve API key from config or environment (defer error to usage time)
+        this.apiKey =
+            config.apiKey ||
+                process.env['XAI_API_KEY'] ||
+                process.env['TOOLPACK_XAI_KEY'] ||
+                null;
+        this.baseUrl = config.baseUrl || 'https://api.x.ai/v1';
+        this.defaultModel = config.defaultModel || 'grok-3-latest';
+    }
+    getDisplayName() {
+        return 'xAI (Grok)';
+    }
+    async getModels() {
+        return [
+            {
+                id: 'grok-3-latest',
+                displayName: 'Grok 3 (Latest)',
+                capabilities: {
+                    chat: true,
+                    streaming: true,
+                    toolCalling: true,
+                    embeddings: false,
+                    vision: false,
+                },
+                contextWindow: 131072,
+            },
+            {
+                id: 'grok-beta',
+                displayName: 'Grok Beta',
+                capabilities: {
+                    chat: true,
+                    streaming: true,
+                    toolCalling: true,
+                    embeddings: false,
+                    vision: false,
+                },
+                contextWindow: 131072,
+            },
+            {
+                id: 'grok-vision-beta',
+                displayName: 'Grok Vision Beta',
+                capabilities: {
+                    chat: true,
+                    streaming: true,
+                    toolCalling: true,
+                    embeddings: false,
+                    vision: true,
+                },
+                contextWindow: 8192,
+            },
+        ];
+    }
+    ensureApiKey() {
+        if (!this.apiKey) {
+            throw new Error('No API key found for xAI. Set XAI_API_KEY or TOOLPACK_XAI_KEY environment variable, ' +
+                'or pass apiKey in config.');
+        }
+        return this.apiKey;
+    }
+    async generate(request) {
+        const apiKey = this.ensureApiKey();
+        const model = request.model || this.defaultModel;
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model,
+                messages: request.messages.map(m => ({
+                    role: m.role,
+                    content: m.content,
+                    ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {}),
+                    ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
+                })),
+                tools: request.tools?.map(t => ({
+                    type: 'function',
+                    function: {
+                        name: t.function.name,
+                        description: t.function.description,
+                        parameters: t.function.parameters,
+                    },
+                })),
+                tool_choice: request.tool_choice,
+                temperature: request.temperature ?? 0.7,
+                max_tokens: request.max_tokens ?? 4096,
+                top_p: request.top_p,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`xAI API error: ${response.status} - ${error}`);
+        }
+        const data = (await response.json());
+        const choice = data.choices[0];
+        // Extract tool calls if present
+        let toolCalls = undefined;
+        if (choice.message.tool_calls) {
+            toolCalls = choice.message.tool_calls.map((tc) => ({
+                id: tc.id,
+                name: tc.function.name,
+                arguments: typeof tc.function.arguments === 'string'
+                    ? JSON.parse(tc.function.arguments)
+                    : tc.function.arguments,
+            }));
+        }
+        return {
+            content: choice.message.content,
+            usage: data.usage
+                ? {
+                    prompt_tokens: data.usage.prompt_tokens,
+                    completion_tokens: data.usage.completion_tokens,
+                    total_tokens: data.usage.total_tokens,
+                }
+                : undefined,
+            finish_reason: choice.finish_reason === 'tool_calls'
+                ? 'tool_calls'
+                : choice.finish_reason === 'length'
+                    ? 'length'
+                    : 'stop',
+            tool_calls: toolCalls,
+            raw: data,
+        };
+    }
+    async *stream(request) {
+        const apiKey = this.ensureApiKey();
+        const model = request.model || this.defaultModel;
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model,
+                messages: request.messages.map(m => ({
+                    role: m.role,
+                    content: m.content,
+                    ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {}),
+                    ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
+                })),
+                tools: request.tools?.map(t => ({
+                    type: 'function',
+                    function: {
+                        name: t.function.name,
+                        description: t.function.description,
+                        parameters: t.function.parameters,
+                    },
+                })),
+                tool_choice: request.tool_choice,
+                temperature: request.temperature ?? 0.7,
+                max_tokens: request.max_tokens ?? 4096,
+                stream: true,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`xAI API error: ${response.status} - ${error}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        // Accumulate tool calls across chunks
+        const toolCallsAccumulator = new Map();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === '[DONE]') {
+                    // Emit accumulated tool calls if any
+                    if (toolCallsAccumulator.size > 0) {
+                        const toolCalls = Array.from(toolCallsAccumulator.values()).map(tc => ({
+                            id: tc.id,
+                            name: tc.name,
+                            arguments: JSON.parse(tc.arguments || '{}'),
+                        }));
+                        yield {
+                            delta: '',
+                            finish_reason: 'tool_calls',
+                            tool_calls: toolCalls,
+                        };
+                    }
+                    return;
+                }
+                try {
+                    const chunk = JSON.parse(data);
+                    const delta = chunk.choices[0]?.delta;
+                    const finishReason = chunk.choices[0]?.finish_reason;
+                    // Handle text content
+                    if (delta?.content) {
+                        yield { delta: delta.content };
+                    }
+                    // Accumulate tool calls (they come in fragments)
+                    if (delta?.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index ?? 0;
+                            if (!toolCallsAccumulator.has(idx)) {
+                                toolCallsAccumulator.set(idx, {
+                                    id: '',
+                                    name: '',
+                                    arguments: '',
+                                });
+                            }
+                            const acc = toolCallsAccumulator.get(idx);
+                            if (tc.id)
+                                acc.id = tc.id;
+                            if (tc.function?.name)
+                                acc.name = tc.function.name;
+                            if (tc.function?.arguments)
+                                acc.arguments += tc.function.arguments;
+                        }
+                    }
+                    // Handle finish reasons
+                    if (finishReason === 'stop') {
+                        yield { delta: '', finish_reason: 'stop' };
+                    }
+                    else if (finishReason === 'tool_calls') {
+                        const toolCalls = Array.from(toolCallsAccumulator.values()).map(tc => ({
+                            id: tc.id,
+                            name: tc.name,
+                            arguments: JSON.parse(tc.arguments || '{}'),
+                        }));
+                        yield {
+                            delta: '',
+                            finish_reason: 'tool_calls',
+                            tool_calls: toolCalls,
+                        };
+                    }
+                    else if (finishReason === 'length') {
+                        yield { delta: '', finish_reason: 'length' };
+                    }
+                }
+                catch {
+                    // Ignore parse errors from partial lines
+                }
+            }
+        }
+    }
+    async embed(_request) {
+        // xAI doesn't support embeddings - throw a clear error
+        throw new Error('xAI does not support embeddings. Use OpenAI or another provider for embeddings.');
+    }
+    // File upload is not supported by xAI
+    supportsFileUpload() {
+        return false;
+    }
+    async uploadFile(_request) {
+        throw new Error('xAI does not support file uploads.');
+    }
+    async deleteFile(_fileId) {
+        throw new Error('xAI does not support file operations.');
+    }
+}

package/dist/custom-tools/skill-tools/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Skill Tools Project
+ *
+ * Tools for managing SKILL.md files - structured documentation for AI agent
+ * skills, capabilities, and learned behaviors.
+ *
+ * Skills are stored in .skills/ directory and follow a structured markdown
+ * format with:
+ * - Frontmatter metadata (name, title, version, tags)
+ * - Description section
+ * - Triggers (phrases that activate the skill)
+ * - Instructions (how the AI should behave)
+ * - Examples (sample interactions)
+ *
+ * Structure:
+ * skill-tools/
+ * ├── toolproject.json
+ * ├── index.ts (this file)
+ * └── tools/
+ *     ├── create/
+ *     ├── read/
+ *     ├── update/
+ *     ├── list/
+ *     └── search/  (BM25-powered skill search)
+ */
+import { ToolProject } from 'toolpack-sdk';
+export { skillCreateTool } from './tools/create/index.js';
+export { skillReadTool } from './tools/read/index.js';
+export { skillUpdateTool } from './tools/update/index.js';
+export { skillListTool } from './tools/list/index.js';
+export { skillSearchTool } from './tools/search/index.js';
+export declare const skillToolsProject: ToolProject;
+export default skillToolsProject;

package/dist/custom-tools/skill-tools/index.js

@@ -0,0 +1,63 @@
+/**
+ * Skill Tools Project
+ *
+ * Tools for managing SKILL.md files - structured documentation for AI agent
+ * skills, capabilities, and learned behaviors.
+ *
+ * Skills are stored in .skills/ directory and follow a structured markdown
+ * format with:
+ * - Frontmatter metadata (name, title, version, tags)
+ * - Description section
+ * - Triggers (phrases that activate the skill)
+ * - Instructions (how the AI should behave)
+ * - Examples (sample interactions)
+ *
+ * Structure:
+ * skill-tools/
+ * ├── toolproject.json
+ * ├── index.ts (this file)
+ * └── tools/
+ *     ├── create/
+ *     ├── read/
+ *     ├── update/
+ *     ├── list/
+ *     └── search/  (BM25-powered skill search)
+ */
+import { skillCreateTool } from './tools/create/index.js';
+import { skillReadTool } from './tools/read/index.js';
+import { skillUpdateTool } from './tools/update/index.js';
+import { skillListTool } from './tools/list/index.js';
+import { skillSearchTool } from './tools/search/index.js';
+// Re-export individual tools for direct access
+export { skillCreateTool } from './tools/create/index.js';
+export { skillReadTool } from './tools/read/index.js';
+export { skillUpdateTool } from './tools/update/index.js';
+export { skillListTool } from './tools/list/index.js';
+export { skillSearchTool } from './tools/search/index.js';
+// Export the complete ToolProject
+export const skillToolsProject = {
+    manifest: {
+        key: 'skill',
+        name: 'skill-tools',
+        displayName: 'Skill Tools',
+        version: '1.0.0',
+        description: 'Tools for managing SKILL.md files - structured documentation for AI agent skills, capabilities, and learned behaviors.',
+        author: 'Toolpack Team',
+        tools: [
+            'skill.create',
+            'skill.read',
+            'skill.update',
+            'skill.list',
+            'skill.search',
+        ],
+        category: 'productivity',
+    },
+    tools: [
+        skillCreateTool,
+        skillReadTool,
+        skillUpdateTool,
+        skillListTool,
+        skillSearchTool,
+    ],
+};
+export default skillToolsProject;

package/dist/custom-tools/skill-tools/tools/create/index.d.ts

@@ -0,0 +1,2 @@
+import { ToolDefinition } from 'toolpack-sdk';
+export declare const skillCreateTool: ToolDefinition;

package/dist/custom-tools/skill-tools/tools/create/index.js

@@ -0,0 +1,93 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { name, displayName, description, parameters, category, } from './schema.js';
+const SKILLS_DIR = '.skills';
+async function execute(args) {
+    const skillName = args['name'];
+    const title = args['title'];
+    const desc = args['description'];
+    const triggers = args['triggers'] || [];
+    const instructions = args['instructions'];
+    const examples = args['examples'] || [];
+    const tags = args['tags'] || [];
+    // Validate skill name (kebab-case)
+    if (!/^[a-z][a-z0-9-]*$/.test(skillName)) {
+        return JSON.stringify({
+            error: 'invalid_name',
+            message: 'Skill name must be kebab-case (lowercase letters, numbers, hyphens, starting with a letter)',
+        }, null, 2);
+    }
+    // Ensure .skills directory exists
+    const skillsDir = path.join(process.cwd(), SKILLS_DIR);
+    try {
+        await fs.mkdir(skillsDir, { recursive: true });
+    }
+    catch (e) {
+        // Directory might already exist
+    }
+    // Check if skill already exists
+    const skillPath = path.join(skillsDir, `${skillName}.skill.md`);
+    try {
+        await fs.access(skillPath);
+        return JSON.stringify({
+            error: 'skill_exists',
+            message: `Skill "${skillName}" already exists at ${skillPath}. Use skill.update to modify it.`,
+        }, null, 2);
+    }
+    catch {
+        // File doesn't exist, we can create it
+    }
+    // Generate SKILL.md content
+    const now = new Date().toISOString();
+    const content = `---
+name: ${skillName}
+title: ${title}
+version: 1.0.0
+created: ${now}
+updated: ${now}
+tags: [${tags.map(t => `"${t}"`).join(', ')}]
+---
+
+# ${title}
+
+## Description
+
+${desc}
+
+## Triggers
+
+${triggers.length > 0
+        ? triggers.map(t => `- "${t}"`).join('\n')
+        : '_No specific triggers defined_'}
+
+## Instructions
+
+${instructions}
+
+## Examples
+
+${examples.length > 0
+        ? examples.map((ex, i) => `### Example ${i + 1}\n\n${ex}`).join('\n\n')
+        : '_No examples provided_'}
+
+## Usage Notes
+
+_Add any additional notes about when and how to use this skill._
+`;
+    // Write the skill file
+    await fs.writeFile(skillPath, content, 'utf-8');
+    return JSON.stringify({
+        success: true,
+        skill: skillName,
+        path: skillPath,
+        message: `Skill "${title}" created successfully`,
+    }, null, 2);
+}
+export const skillCreateTool = {
+    name,
+    displayName,
+    description,
+    parameters,
+    category,
+    execute,
+};

package/dist/custom-tools/skill-tools/tools/create/schema.d.ts

@@ -0,0 +1,6 @@
+import { ToolParameters } from 'toolpack-sdk';
+export declare const name = "skill.create";
+export declare const displayName = "Create Skill";
+export declare const description = "Create a new SKILL.md file documenting an AI agent skill or capability. Skills are stored in .skills/ directory and follow a structured markdown format with metadata, description, examples, and usage guidelines.";
+export declare const category = "productivity";
+export declare const parameters: ToolParameters;

package/dist/custom-tools/skill-tools/tools/create/schema.js

@@ -0,0 +1,41 @@
+export const name = 'skill.create';
+export const displayName = 'Create Skill';
+export const description = 'Create a new SKILL.md file documenting an AI agent skill or capability. Skills are stored in .skills/ directory and follow a structured markdown format with metadata, description, examples, and usage guidelines.';
+export const category = 'productivity';
+export const parameters = {
+    type: 'object',
+    properties: {
+        name: {
+            type: 'string',
+            description: 'Unique skill name in kebab-case (e.g., "code-review", "data-analysis", "api-integration")',
+        },
+        title: {
+            type: 'string',
+            description: 'Human-readable title for the skill (e.g., "Code Review Assistant")',
+        },
+        description: {
+            type: 'string',
+            description: 'Brief description of what this skill enables the AI to do',
+        },
+        triggers: {
+            type: 'array',
+            description: 'List of phrases or keywords that should activate this skill',
+            items: { type: 'string' },
+        },
+        instructions: {
+            type: 'string',
+            description: 'Detailed instructions for how the AI should behave when using this skill',
+        },
+        examples: {
+            type: 'array',
+            description: 'Example prompts and expected behaviors',
+            items: { type: 'string' },
+        },
+        tags: {
+            type: 'array',
+            description: 'Tags for categorizing the skill (e.g., ["coding", "review", "quality"])',
+            items: { type: 'string' },
+        },
+    },
+    required: ['name', 'title', 'description', 'instructions'],
+};

package/dist/custom-tools/skill-tools/tools/list/index.d.ts

@@ -0,0 +1,2 @@
+import { ToolDefinition } from 'toolpack-sdk';
+export declare const skillListTool: ToolDefinition;

package/dist/custom-tools/skill-tools/tools/list/index.js

@@ -0,0 +1,113 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { name, displayName, description, parameters, category, } from './schema.js';
+const SKILLS_DIR = '.skills';
+async function execute(args) {
+    const filterTag = args['tag'];
+    const verbose = args['verbose'] || false;
+    const skillsDir = path.join(process.cwd(), SKILLS_DIR);
+    // Check if .skills directory exists
+    try {
+        await fs.access(skillsDir);
+    }
+    catch {
+        return JSON.stringify({
+            skills: [],
+            count: 0,
+            message: 'No .skills directory found. Use skill.create to create your first skill.',
+        }, null, 2);
+    }
+    // Read all .skill.md files
+    const files = await fs.readdir(skillsDir);
+    const skillFiles = files.filter(f => f.endsWith('.skill.md'));
+    if (skillFiles.length === 0) {
+        return JSON.stringify({
+            skills: [],
+            count: 0,
+            message: 'No skills found. Use skill.create to create your first skill.',
+        }, null, 2);
+    }
+    const skills = [];
+    for (const file of skillFiles) {
+        const filePath = path.join(skillsDir, file);
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Parse frontmatter
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        let skillName = file.replace('.skill.md', '');
+        let title = skillName;
+        let tags = [];
+        if (frontmatterMatch && frontmatterMatch[1]) {
+            const lines = frontmatterMatch[1].split('\n');
+            for (const line of lines) {
+                if (line.startsWith('name:')) {
+                    skillName = line.replace('name:', '').trim();
+                }
+                if (line.startsWith('title:')) {
+                    title = line.replace('title:', '').trim();
+                }
+                if (line.startsWith('tags:')) {
+                    const tagsMatch = line.match(/\[(.*)\]/);
+                    if (tagsMatch && tagsMatch[1]) {
+                        tags = tagsMatch[1]
+                            .split(',')
+                            .map(t => t.trim().replace(/"/g, ''))
+                            .filter(Boolean);
+                    }
+                }
+            }
+        }
+        // Filter by tag if specified
+        if (filterTag && !tags.includes(filterTag)) {
+            continue;
+        }
+        skills.push({
+            name: skillName,
+            title,
+            tags,
+            path: filePath,
+        });
+    }
+    if (verbose) {
+        // Return full details for each skill
+        const detailedSkills = [];
+        for (const skill of skills) {
+            const content = await fs.readFile(skill.path, 'utf-8');
+            const descMatch = content.match(/## Description\n\n([\s\S]*?)(?=\n## |$)/);
+            const triggersMatch = content.match(/## Triggers\n\n([\s\S]*?)(?=\n## |$)/);
+            const triggers = [];
+            if (triggersMatch && triggersMatch[1]) {
+                const triggerLines = triggersMatch[1]
+                    .split('\n')
+                    .filter(l => l.startsWith('- '));
+                for (const line of triggerLines) {
+                    const match = line.match(/- "(.*)"/);
+                    if (match && match[1])
+                        triggers.push(match[1]);
+                }
+            }
+            detailedSkills.push({
+                ...skill,
+                description: descMatch && descMatch[1] ? descMatch[1].trim() : '',
+                triggers,
+            });
+        }
+        return JSON.stringify({
+            skills: detailedSkills,
+            count: detailedSkills.length,
+            filtered: filterTag ? `by tag: ${filterTag}` : null,
+        }, null, 2);
+    }
+    return JSON.stringify({
+        skills: skills.map(s => ({ name: s.name, title: s.title, tags: s.tags })),
+        count: skills.length,
+        filtered: filterTag ? `by tag: ${filterTag}` : null,
+    }, null, 2);
+}
+export const skillListTool = {
+    name,
+    displayName,
+    description,
+    parameters,
+    category,
+    execute,
+};

package/dist/custom-tools/skill-tools/tools/list/schema.d.ts

@@ -0,0 +1,6 @@
+import { ToolParameters } from 'toolpack-sdk';
+export declare const name = "skill.list";
+export declare const displayName = "List Skills";
+export declare const description = "List all available SKILL.md files in the .skills directory with their metadata.";
+export declare const category = "productivity";
+export declare const parameters: ToolParameters;

package/dist/custom-tools/skill-tools/tools/list/schema.js

@@ -0,0 +1,19 @@
+export const name = 'skill.list';
+export const displayName = 'List Skills';
+export const description = 'List all available SKILL.md files in the .skills directory with their metadata.';
+export const category = 'productivity';
+export const parameters = {
+    type: 'object',
+    properties: {
+        tag: {
+            type: 'string',
+            description: 'Optional: filter skills by tag',
+        },
+        verbose: {
+            type: 'boolean',
+            description: 'Include full metadata for each skill. Default: false',
+            default: false,
+        },
+    },
+    required: [],
+};

package/dist/custom-tools/skill-tools/tools/read/index.d.ts

@@ -0,0 +1,2 @@
+import { ToolDefinition } from 'toolpack-sdk';
+export declare const skillReadTool: ToolDefinition;