toolpack-cli 0.1.0-SNAPSHOT

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

@@ -0,0 +1,124 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { name, displayName, description, parameters, category, } from './schema.js';
+const SKILLS_DIR = '.skills';
+function parseSkillFile(content) {
+    // Parse frontmatter
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    const metadata = {
+        name: '',
+        title: '',
+        version: '1.0.0',
+        created: '',
+        updated: '',
+        tags: [],
+    };
+    if (frontmatterMatch && frontmatterMatch[1]) {
+        const frontmatter = frontmatterMatch[1];
+        const lines = frontmatter.split('\n');
+        for (const line of lines) {
+            const [key, ...valueParts] = line.split(':');
+            const value = valueParts.join(':').trim();
+            if (key === 'name')
+                metadata.name = value;
+            if (key === 'title')
+                metadata.title = value;
+            if (key === 'version')
+                metadata.version = value;
+            if (key === 'created')
+                metadata.created = value;
+            if (key === 'updated')
+                metadata.updated = value;
+            if (key === 'tags') {
+                const tagsMatch = value.match(/\[(.*)\]/);
+                if (tagsMatch) {
+                    metadata.tags = (tagsMatch[1] || '')
+                        .split(',')
+                        .map(t => t.trim().replace(/"/g, ''))
+                        .filter(Boolean);
+                }
+            }
+        }
+    }
+    // Parse sections
+    const descMatch = content.match(/## Description\n\n([\s\S]*?)(?=\n## |$)/);
+    const triggersMatch = content.match(/## Triggers\n\n([\s\S]*?)(?=\n## |$)/);
+    const instructionsMatch = content.match(/## Instructions\n\n([\s\S]*?)(?=\n## |$)/);
+    const examplesMatch = content.match(/## Examples\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]);
+        }
+    }
+    const examples = [];
+    if (examplesMatch && examplesMatch[1]) {
+        const exampleBlocks = (examplesMatch[1] || '')
+            .split(/### Example \d+\n\n/)
+            .filter(Boolean);
+        examples.push(...exampleBlocks.map(e => e.trim()));
+    }
+    return {
+        metadata,
+        description: descMatch && descMatch[1] ? descMatch[1].trim() : '',
+        triggers,
+        instructions: instructionsMatch && instructionsMatch[1]
+            ? instructionsMatch[1].trim()
+            : '',
+        examples,
+    };
+}
+async function execute(args) {
+    const skillName = args['name'];
+    const section = args['section'] || 'all';
+    const skillPath = path.join(process.cwd(), SKILLS_DIR, `${skillName}.skill.md`);
+    // Check if skill exists
+    try {
+        await fs.access(skillPath);
+    }
+    catch {
+        return JSON.stringify({
+            error: 'skill_not_found',
+            message: `Skill "${skillName}" not found. Use skill.list to see available skills.`,
+        }, null, 2);
+    }
+    // Read and parse the skill file
+    const content = await fs.readFile(skillPath, 'utf-8');
+    const parsed = parseSkillFile(content);
+    // Return requested section
+    if (section === 'metadata') {
+        return JSON.stringify({ skill: skillName, metadata: parsed.metadata }, null, 2);
+    }
+    else if (section === 'description') {
+        return JSON.stringify({ skill: skillName, description: parsed.description }, null, 2);
+    }
+    else if (section === 'triggers') {
+        return JSON.stringify({ skill: skillName, triggers: parsed.triggers }, null, 2);
+    }
+    else if (section === 'instructions') {
+        return JSON.stringify({ skill: skillName, instructions: parsed.instructions }, null, 2);
+    }
+    else if (section === 'examples') {
+        return JSON.stringify({ skill: skillName, examples: parsed.examples }, null, 2);
+    }
+    else {
+        return JSON.stringify({
+            skill: skillName,
+            path: skillPath,
+            ...parsed,
+        }, null, 2);
+    }
+}
+export const skillReadTool = {
+    name,
+    displayName,
+    description,
+    parameters,
+    category,
+    execute,
+};

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

@@ -0,0 +1,6 @@
+import { ToolParameters } from 'toolpack-sdk';
+export declare const name = "skill.read";
+export declare const displayName = "Read Skill";
+export declare const description = "Read and parse a SKILL.md file to retrieve skill documentation including metadata, triggers, instructions, and examples.";
+export declare const category = "productivity";
+export declare const parameters: ToolParameters;

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

@@ -0,0 +1,27 @@
+export const name = 'skill.read';
+export const displayName = 'Read Skill';
+export const description = 'Read and parse a SKILL.md file to retrieve skill documentation including metadata, triggers, instructions, and examples.';
+export const category = 'productivity';
+export const parameters = {
+    type: 'object',
+    properties: {
+        name: {
+            type: 'string',
+            description: 'The skill name to read (e.g., "code-review")',
+        },
+        section: {
+            type: 'string',
+            description: 'Optional: specific section to retrieve ("metadata", "description", "triggers", "instructions", "examples"). Default: returns all.',
+            enum: [
+                'metadata',
+                'description',
+                'triggers',
+                'instructions',
+                'examples',
+                'all',
+            ],
+            default: 'all',
+        },
+    },
+    required: ['name'],
+};

package/dist/custom-tools/skill-tools/tools/search/bm25.d.ts

@@ -0,0 +1,71 @@
+/**
+ * BM25 (Best Matching 25) Search Implementation
+ *
+ * A lightweight, zero-dependency implementation of the BM25 ranking algorithm
+ * for searching skill documents. BM25 is a bag-of-words retrieval function that
+ * ranks documents based on query term frequency and inverse document frequency.
+ */
+export interface BM25Document {
+    id: string;
+    content: string;
+    fields: Record<string, string | string[]>;
+}
+export interface BM25SearchResult {
+    id: string;
+    score: number;
+    fields: Record<string, string | string[]>;
+}
+export interface BM25Options {
+    k1?: number;
+    b?: number;
+}
+export declare class BM25Index {
+    private documents;
+    private termFrequencies;
+    private documentLengths;
+    private avgDocLength;
+    private k1;
+    private b;
+    constructor(options?: BM25Options);
+    /**
+     * Tokenize text into searchable terms.
+     * Handles camelCase, snake_case, kebab-case, and common word boundaries.
+     */
+    private tokenize;
+    /**
+     * Common stop words to filter out
+     */
+    private isStopWord;
+    /**
+     * Add a document to the index
+     */
+    addDocument(doc: BM25Document): void;
+    /**
+     * Remove a document from the index
+     */
+    removeDocument(docId: string): void;
+    /**
+     * Clear the entire index
+     */
+    clear(): void;
+    /**
+     * Update average document length
+     */
+    private updateAvgDocLength;
+    /**
+     * Calculate IDF (Inverse Document Frequency) for a term
+     */
+    private idf;
+    /**
+     * Search the index with a query
+     */
+    search(query: string, limit?: number): BM25SearchResult[];
+    /**
+     * Get the number of indexed documents
+     */
+    get size(): number;
+    /**
+     * Check if a document exists in the index
+     */
+    has(docId: string): boolean;
+}

package/dist/custom-tools/skill-tools/tools/search/bm25.js

@@ -0,0 +1,305 @@
+/**
+ * BM25 (Best Matching 25) Search Implementation
+ *
+ * A lightweight, zero-dependency implementation of the BM25 ranking algorithm
+ * for searching skill documents. BM25 is a bag-of-words retrieval function that
+ * ranks documents based on query term frequency and inverse document frequency.
+ */
+export class BM25Index {
+    constructor(options = {}) {
+        Object.defineProperty(this, "documents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "termFrequencies", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        }); // term -> docId -> frequency
+        Object.defineProperty(this, "documentLengths", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "avgDocLength", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "k1", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "b", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.k1 = options.k1 ?? 1.5;
+        this.b = options.b ?? 0.75;
+    }
+    /**
+     * Tokenize text into searchable terms.
+     * Handles camelCase, snake_case, kebab-case, and common word boundaries.
+     */
+    tokenize(text) {
+        if (!text)
+            return [];
+        // Convert to lowercase
+        let normalized = text.toLowerCase();
+        // Split camelCase and PascalCase
+        normalized = normalized.replace(/([a-z])([A-Z])/g, '$1 $2');
+        // Replace non-alphanumeric with spaces
+        normalized = normalized.replace(/[^a-z0-9]/g, ' ');
+        // Split and filter
+        const tokens = normalized
+            .split(/\s+/)
+            .filter(token => token.length > 1) // Remove single chars
+            .filter(token => !this.isStopWord(token));
+        return tokens;
+    }
+    /**
+     * Common stop words to filter out
+     */
+    isStopWord(word) {
+        const stopWords = new Set([
+            'a',
+            'an',
+            'the',
+            'and',
+            'or',
+            'but',
+            'in',
+            'on',
+            'at',
+            'to',
+            'for',
+            'of',
+            'with',
+            'by',
+            'from',
+            'as',
+            'is',
+            'was',
+            'are',
+            'were',
+            'been',
+            'be',
+            'have',
+            'has',
+            'had',
+            'do',
+            'does',
+            'did',
+            'will',
+            'would',
+            'could',
+            'should',
+            'may',
+            'might',
+            'must',
+            'shall',
+            'can',
+            'need',
+            'it',
+            'its',
+            'this',
+            'that',
+            'these',
+            'those',
+            'i',
+            'you',
+            'he',
+            'she',
+            'we',
+            'they',
+            'what',
+            'which',
+            'who',
+            'when',
+            'where',
+            'why',
+            'how',
+            'all',
+            'each',
+            'every',
+            'both',
+            'few',
+            'more',
+            'most',
+            'other',
+            'some',
+            'such',
+            'no',
+            'nor',
+            'not',
+            'only',
+            'own',
+            'same',
+            'so',
+            'than',
+            'too',
+            'very',
+            'just',
+            'also',
+            'now',
+            'here',
+            'there',
+            'then',
+        ]);
+        return stopWords.has(word);
+    }
+    /**
+     * Add a document to the index
+     */
+    addDocument(doc) {
+        this.documents.set(doc.id, doc);
+        // Build searchable content from all fields
+        let fullContent = doc.content;
+        for (const [, value] of Object.entries(doc.fields)) {
+            if (Array.isArray(value)) {
+                fullContent += ' ' + value.join(' ');
+            }
+            else {
+                fullContent += ' ' + value;
+            }
+        }
+        const tokens = this.tokenize(fullContent);
+        this.documentLengths.set(doc.id, tokens.length);
+        // Count term frequencies for this document
+        const termCounts = {};
+        for (const token of tokens) {
+            termCounts[token] = (termCounts[token] || 0) + 1;
+        }
+        // Update global term frequencies
+        for (const term of Object.keys(termCounts)) {
+            const count = termCounts[term] || 0;
+            if (!this.termFrequencies.has(term)) {
+                this.termFrequencies.set(term, new Map());
+            }
+            this.termFrequencies.get(term).set(doc.id, count);
+        }
+        // Recalculate average document length
+        this.updateAvgDocLength();
+    }
+    /**
+     * Remove a document from the index
+     */
+    removeDocument(docId) {
+        if (!this.documents.has(docId))
+            return;
+        // Remove from term frequencies
+        const termsToDelete = [];
+        this.termFrequencies.forEach((docFreqs, term) => {
+            docFreqs.delete(docId);
+            if (docFreqs.size === 0) {
+                termsToDelete.push(term);
+            }
+        });
+        for (const term of termsToDelete) {
+            this.termFrequencies.delete(term);
+        }
+        this.documents.delete(docId);
+        this.documentLengths.delete(docId);
+        this.updateAvgDocLength();
+    }
+    /**
+     * Clear the entire index
+     */
+    clear() {
+        this.documents.clear();
+        this.termFrequencies.clear();
+        this.documentLengths.clear();
+        this.avgDocLength = 0;
+    }
+    /**
+     * Update average document length
+     */
+    updateAvgDocLength() {
+        if (this.documentLengths.size === 0) {
+            this.avgDocLength = 0;
+            return;
+        }
+        let total = 0;
+        this.documentLengths.forEach(length => {
+            total += length;
+        });
+        this.avgDocLength = total / this.documentLengths.size;
+    }
+    /**
+     * Calculate IDF (Inverse Document Frequency) for a term
+     */
+    idf(term) {
+        const N = this.documents.size;
+        const docFreq = this.termFrequencies.get(term)?.size || 0;
+        if (docFreq === 0)
+            return 0;
+        // Standard BM25 IDF formula
+        return Math.log((N - docFreq + 0.5) / (docFreq + 0.5) + 1);
+    }
+    /**
+     * Search the index with a query
+     */
+    search(query, limit = 10) {
+        const queryTokens = this.tokenize(query);
+        if (queryTokens.length === 0) {
+            return [];
+        }
+        const scores = {};
+        // Calculate BM25 score for each document
+        this.documents.forEach((_, docId) => {
+            let score = 0;
+            const docLength = this.documentLengths.get(docId) || 0;
+            for (const term of queryTokens) {
+                const termDocFreqs = this.termFrequencies.get(term);
+                if (!termDocFreqs)
+                    continue;
+                const tf = termDocFreqs.get(docId) || 0;
+                if (tf === 0)
+                    continue;
+                const idf = this.idf(term);
+                // BM25 scoring formula
+                const numerator = tf * (this.k1 + 1);
+                const denominator = tf +
+                    this.k1 * (1 - this.b + this.b * (docLength / this.avgDocLength));
+                score += idf * (numerator / denominator);
+            }
+            if (score > 0) {
+                scores[docId] = score;
+            }
+        });
+        // Sort by score descending
+        const results = [];
+        for (const docId of Object.keys(scores)) {
+            const score = scores[docId] || 0;
+            const doc = this.documents.get(docId);
+            results.push({
+                id: docId,
+                score,
+                fields: doc.fields,
+            });
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, limit);
+    }
+    /**
+     * Get the number of indexed documents
+     */
+    get size() {
+        return this.documents.size;
+    }
+    /**
+     * Check if a document exists in the index
+     */
+    has(docId) {
+        return this.documents.has(docId);
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Skill Search Tool
+ *
+ * Uses BM25 search to find relevant skills based on a natural language query.
+ * Searches across skill names, titles, descriptions, tags, keywords, and triggers.
+ */
+import { ToolDefinition } from 'toolpack-sdk';
+export declare const skillSearchTool: ToolDefinition;

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

@@ -0,0 +1,63 @@
+/**
+ * Skill Search Tool
+ *
+ * Uses BM25 search to find relevant skills based on a natural language query.
+ * Searches across skill names, titles, descriptions, tags, keywords, and triggers.
+ */
+import { name, displayName, description, parameters, category, } from './schema.js';
+import { skillIndex } from './skill-index.js';
+async function execute(args) {
+    const query = args['query'];
+    const limit = args['limit'] || 5;
+    if (!query || query.trim().length === 0) {
+        return JSON.stringify({
+            error: 'invalid_query',
+            message: 'Search query cannot be empty.',
+        }, null, 2);
+    }
+    try {
+        const results = await skillIndex.search(query, limit);
+        if (results.length === 0) {
+            return JSON.stringify({
+                query,
+                results: [],
+                count: 0,
+                message: 'No skills found matching your query. Try different keywords or use skill.list to see all available skills.',
+            }, null, 2);
+        }
+        // Format results for AI consumption
+        const formattedResults = results.map((result, index) => ({
+            rank: index + 1,
+            name: result.skill.name,
+            title: result.skill.title,
+            score: Math.round(result.score * 100) / 100,
+            description: result.skill.description.length > 200
+                ? result.skill.description.substring(0, 200) + '...'
+                : result.skill.description,
+            tags: result.skill.tags,
+            triggers: result.skill.triggers.slice(0, 3), // Limit triggers shown
+            path: result.skill.path,
+        }));
+        return JSON.stringify({
+            query,
+            results: formattedResults,
+            count: results.length,
+            indexed_skills: skillIndex.size,
+            hint: 'Use skill.read with the skill name to get full details including instructions and examples.',
+        }, null, 2);
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: 'search_failed',
+            message: error.message || 'Failed to search skills.',
+        }, null, 2);
+    }
+}
+export const skillSearchTool = {
+    name,
+    displayName,
+    description,
+    parameters,
+    category,
+    execute,
+};

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

@@ -0,0 +1,6 @@
+import { ToolParameters } from 'toolpack-sdk';
+export declare const name = "skill.search";
+export declare const displayName = "Search Skills";
+export declare const description = "Search for relevant skills using BM25 text search. Searches across skill names, titles, descriptions, tags, keywords, and triggers to find the most relevant skills for a given query.";
+export declare const category = "productivity";
+export declare const parameters: ToolParameters;

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

@@ -0,0 +1,19 @@
+export const name = 'skill.search';
+export const displayName = 'Search Skills';
+export const description = 'Search for relevant skills using BM25 text search. Searches across skill names, titles, descriptions, tags, keywords, and triggers to find the most relevant skills for a given query.';
+export const category = 'productivity';
+export const parameters = {
+    type: 'object',
+    properties: {
+        query: {
+            type: 'string',
+            description: 'The search query to find relevant skills. Can be natural language like "how to deploy to AWS" or keywords like "react testing".',
+        },
+        limit: {
+            type: 'number',
+            description: 'Maximum number of results to return. Default: 5',
+            default: 5,
+        },
+    },
+    required: ['query'],
+};

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

@@ -0,0 +1,54 @@
+/**
+ * Skill Index Manager
+ *
+ * Manages the BM25 index for skill files, handling indexing, caching,
+ * and automatic re-indexing when skills change.
+ */
+import { BM25SearchResult } from './bm25.js';
+export interface SkillDocument {
+    name: string;
+    title: string;
+    description: string;
+    tags: string[];
+    triggers: string[];
+    keywords: string[];
+    path: string;
+    lastModified: number;
+}
+export interface SkillSearchResult extends BM25SearchResult {
+    skill: SkillDocument;
+}
+declare class SkillIndexManager {
+    private index;
+    private skillCache;
+    private lastIndexTime;
+    private indexedDir;
+    constructor();
+    /**
+     * Parse a skill file and extract all searchable content
+     */
+    private parseSkillFile;
+    /**
+     * Build searchable content for BM25 indexing
+     * Weights different fields by repeating important terms
+     */
+    private buildSearchableContent;
+    /**
+     * Index all skills in the .skills directory
+     */
+    indexSkills(workspaceRoot?: string): Promise<number>;
+    /**
+     * Search for skills matching the query
+     */
+    search(query: string, limit?: number, workspaceRoot?: string): Promise<SkillSearchResult[]>;
+    /**
+     * Get the number of indexed skills
+     */
+    get size(): number;
+    /**
+     * Force a full re-index
+     */
+    reindex(workspaceRoot?: string): Promise<number>;
+}
+export declare const skillIndex: SkillIndexManager;
+export {};