toolpack-cli 0.1.0-SNAPSHOT

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

@@ -0,0 +1,251 @@
+/**
+ * Skill Index Manager
+ *
+ * Manages the BM25 index for skill files, handling indexing, caching,
+ * and automatic re-indexing when skills change.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { BM25Index } from './bm25.js';
+const SKILLS_DIR = '.skills';
+class SkillIndexManager {
+    constructor() {
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "skillCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "lastIndexTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "indexedDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        this.index = new BM25Index({ k1: 1.5, b: 0.75 });
+    }
+    /**
+     * Parse a skill file and extract all searchable content
+     */
+    parseSkillFile(content, filePath) {
+        const skill = {
+            name: '',
+            title: '',
+            description: '',
+            tags: [],
+            triggers: [],
+            keywords: [],
+            path: filePath,
+            lastModified: Date.now(),
+        };
+        // Parse frontmatter
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (frontmatterMatch && frontmatterMatch[1]) {
+            const lines = frontmatterMatch[1].split('\n');
+            for (const line of lines) {
+                const colonIndex = line.indexOf(':');
+                if (colonIndex === -1)
+                    continue;
+                const key = line.substring(0, colonIndex).trim();
+                const value = line.substring(colonIndex + 1).trim();
+                if (key === 'name')
+                    skill.name = value;
+                if (key === 'title')
+                    skill.title = value;
+                if (key === 'tags') {
+                    const tagsMatch = value.match(/\[(.*)\]/);
+                    if (tagsMatch && tagsMatch[1]) {
+                        skill.tags = tagsMatch[1]
+                            .split(',')
+                            .map(t => t.trim().replace(/"/g, ''))
+                            .filter(Boolean);
+                    }
+                }
+                if (key === 'keywords') {
+                    const keywordsMatch = value.match(/\[(.*)\]/);
+                    if (keywordsMatch && keywordsMatch[1]) {
+                        skill.keywords = keywordsMatch[1]
+                            .split(',')
+                            .map(k => k.trim().replace(/"/g, ''))
+                            .filter(Boolean);
+                    }
+                }
+            }
+        }
+        // Parse description section
+        const descMatch = content.match(/## Description\n\n([\s\S]*?)(?=\n## |$)/);
+        if (descMatch && descMatch[1]) {
+            skill.description = descMatch[1].trim();
+        }
+        // Parse triggers section
+        const triggersMatch = content.match(/## Triggers\n\n([\s\S]*?)(?=\n## |$)/);
+        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]) {
+                    skill.triggers.push(match[1]);
+                }
+            }
+        }
+        // If no name from frontmatter, derive from filename
+        if (!skill.name) {
+            skill.name = path.basename(filePath, '.skill.md');
+        }
+        if (!skill.title) {
+            skill.title = skill.name;
+        }
+        return skill;
+    }
+    /**
+     * Build searchable content for BM25 indexing
+     * Weights different fields by repeating important terms
+     */
+    buildSearchableContent(skill) {
+        const parts = [];
+        // Name and title are highly weighted (repeat 3x)
+        parts.push(skill.name, skill.name, skill.name);
+        parts.push(skill.title, skill.title, skill.title);
+        // Tags and keywords are weighted (repeat 2x)
+        for (const tag of skill.tags) {
+            parts.push(tag, tag);
+        }
+        for (const keyword of skill.keywords) {
+            parts.push(keyword, keyword);
+        }
+        // Triggers are weighted (repeat 2x)
+        for (const trigger of skill.triggers) {
+            parts.push(trigger, trigger);
+        }
+        // Description is included once
+        parts.push(skill.description);
+        return parts.join(' ');
+    }
+    /**
+     * Index all skills in the .skills directory
+     */
+    async indexSkills(workspaceRoot) {
+        const cwd = workspaceRoot || process.cwd();
+        const skillsDir = path.join(cwd, SKILLS_DIR);
+        // Check if .skills directory exists
+        try {
+            await fs.access(skillsDir);
+        }
+        catch {
+            this.index.clear();
+            this.skillCache.clear();
+            return 0;
+        }
+        // Check if we need to re-index
+        const dirStat = await fs.stat(skillsDir);
+        if (this.indexedDir === skillsDir &&
+            dirStat.mtimeMs <= this.lastIndexTime) {
+            // Directory hasn't changed, check individual files
+            let needsReindex = false;
+            const files = await fs.readdir(skillsDir);
+            for (const file of files) {
+                if (!file.endsWith('.skill.md'))
+                    continue;
+                const filePath = path.join(skillsDir, file);
+                const fileStat = await fs.stat(filePath);
+                const cached = this.skillCache.get(file);
+                if (!cached || fileStat.mtimeMs > cached.lastModified) {
+                    needsReindex = true;
+                    break;
+                }
+            }
+            if (!needsReindex) {
+                return this.index.size;
+            }
+        }
+        // Clear and rebuild index
+        this.index.clear();
+        this.skillCache.clear();
+        const files = await fs.readdir(skillsDir);
+        const skillFiles = files.filter(f => f.endsWith('.skill.md'));
+        for (const file of skillFiles) {
+            const filePath = path.join(skillsDir, file);
+            const content = await fs.readFile(filePath, 'utf-8');
+            const fileStat = await fs.stat(filePath);
+            const skill = this.parseSkillFile(content, filePath);
+            skill.lastModified = fileStat.mtimeMs;
+            // Add to cache
+            this.skillCache.set(file, skill);
+            // Add to BM25 index
+            this.index.addDocument({
+                id: skill.name,
+                content: this.buildSearchableContent(skill),
+                fields: {
+                    name: skill.name,
+                    title: skill.title,
+                    description: skill.description,
+                    tags: skill.tags,
+                    triggers: skill.triggers,
+                    keywords: skill.keywords,
+                },
+            });
+        }
+        this.lastIndexTime = Date.now();
+        this.indexedDir = skillsDir;
+        return this.index.size;
+    }
+    /**
+     * Search for skills matching the query
+     */
+    async search(query, limit = 5, workspaceRoot) {
+        // Ensure index is up to date
+        await this.indexSkills(workspaceRoot);
+        if (this.index.size === 0) {
+            return [];
+        }
+        const results = this.index.search(query, limit);
+        // Enrich results with full skill data
+        return results.map(result => {
+            const skillFile = `${result.id}.skill.md`;
+            const skill = this.skillCache.get(skillFile) || {
+                name: result.id,
+                title: result.fields['title'] || result.id,
+                description: result.fields['description'] || '',
+                tags: result.fields['tags'] || [],
+                triggers: result.fields['triggers'] || [],
+                keywords: result.fields['keywords'] || [],
+                path: '',
+                lastModified: 0,
+            };
+            return {
+                ...result,
+                skill,
+            };
+        });
+    }
+    /**
+     * Get the number of indexed skills
+     */
+    get size() {
+        return this.index.size;
+    }
+    /**
+     * Force a full re-index
+     */
+    async reindex(workspaceRoot) {
+        this.lastIndexTime = 0;
+        this.indexedDir = '';
+        return this.indexSkills(workspaceRoot);
+    }
+}
+// Singleton instance for the skill index
+export const skillIndex = new SkillIndexManager();

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

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

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

@@ -0,0 +1,115 @@
+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 newTitle = args['title'];
+    const newDescription = args['description'];
+    const newTriggers = args['triggers'];
+    const newInstructions = args['instructions'];
+    const addExamples = args['addExamples'];
+    const addTags = args['addTags'];
+    const skillPath = path.join(process.cwd(), SKILLS_DIR, `${skillName}.skill.md`);
+    // Check if skill exists
+    let content;
+    try {
+        content = await fs.readFile(skillPath, 'utf-8');
+    }
+    catch {
+        return JSON.stringify({
+            error: 'skill_not_found',
+            message: `Skill "${skillName}" not found. Use skill.create to create it first.`,
+        }, null, 2);
+    }
+    // Parse existing frontmatter
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    let existingTags = [];
+    let existingTitle = '';
+    if (frontmatterMatch && frontmatterMatch[1]) {
+        const lines = frontmatterMatch[1].split('\n');
+        for (const line of lines) {
+            if (line.startsWith('title:')) {
+                existingTitle = line.replace('title:', '').trim();
+            }
+            if (line.startsWith('tags:')) {
+                const tagsMatch = line.match(/\[(.*)\]/);
+                if (tagsMatch && tagsMatch[1]) {
+                    existingTags = tagsMatch[1]
+                        .split(',')
+                        .map(t => t.trim().replace(/"/g, ''))
+                        .filter(Boolean);
+                }
+            }
+        }
+    }
+    // Update frontmatter
+    const now = new Date().toISOString();
+    const finalTitle = newTitle || existingTitle;
+    const finalTags = addTags
+        ? [...new Set([...existingTags, ...addTags])]
+        : existingTags;
+    // Update sections
+    if (newDescription) {
+        content = content.replace(/## Description\n\n[\s\S]*?(?=\n## )/, `## Description\n\n${newDescription}\n\n`);
+    }
+    if (newTriggers) {
+        const triggersContent = newTriggers.map(t => `- "${t}"`).join('\n');
+        content = content.replace(/## Triggers\n\n[\s\S]*?(?=\n## )/, `## Triggers\n\n${triggersContent}\n\n`);
+    }
+    if (newInstructions) {
+        content = content.replace(/## Instructions\n\n[\s\S]*?(?=\n## )/, `## Instructions\n\n${newInstructions}\n\n`);
+    }
+    if (addExamples && addExamples.length > 0) {
+        // Find existing examples section and append
+        const examplesMatch = content.match(/## Examples\n\n([\s\S]*?)(?=\n## |$)/);
+        if (examplesMatch) {
+            const existingExamples = examplesMatch[1] || '';
+            const existingCount = (existingExamples.match(/### Example \d+/g) || [])
+                .length;
+            const newExamplesContent = addExamples
+                .map((ex, i) => `### Example ${existingCount + i + 1}\n\n${ex}`)
+                .join('\n\n');
+            content = content.replace(/## Examples\n\n[\s\S]*?(?=\n## |$)/, `## Examples\n\n${existingExamples}\n\n${newExamplesContent}\n\n`);
+        }
+    }
+    // Update frontmatter with new values
+    content = content.replace(/^---\n[\s\S]*?\n---/, `---
+name: ${skillName}
+title: ${finalTitle}
+version: 1.0.0
+created: ${content.match(/created: (.*)/)?.[1] || now}
+updated: ${now}
+tags: [${finalTags.map(t => `"${t}"`).join(', ')}]
+---`);
+    // Write updated content
+    await fs.writeFile(skillPath, content, 'utf-8');
+    const updates = [];
+    if (newTitle)
+        updates.push('title');
+    if (newDescription)
+        updates.push('description');
+    if (newTriggers)
+        updates.push('triggers');
+    if (newInstructions)
+        updates.push('instructions');
+    if (addExamples)
+        updates.push(`${addExamples.length} examples`);
+    if (addTags)
+        updates.push(`${addTags.length} tags`);
+    return JSON.stringify({
+        success: true,
+        skill: skillName,
+        path: skillPath,
+        updated: updates,
+        message: `Skill "${skillName}" updated successfully`,
+    }, null, 2);
+}
+export const skillUpdateTool = {
+    name,
+    displayName,
+    description,
+    parameters,
+    category,
+    execute,
+};

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

@@ -0,0 +1,6 @@
+import { ToolParameters } from 'toolpack-sdk';
+export declare const name = "skill.update";
+export declare const displayName = "Update Skill";
+export declare const description = "Update an existing SKILL.md file. Can update specific sections like description, triggers, instructions, or examples.";
+export declare const category = "productivity";
+export declare const parameters: ToolParameters;

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

@@ -0,0 +1,41 @@
+export const name = 'skill.update';
+export const displayName = 'Update Skill';
+export const description = 'Update an existing SKILL.md file. Can update specific sections like description, triggers, instructions, or examples.';
+export const category = 'productivity';
+export const parameters = {
+    type: 'object',
+    properties: {
+        name: {
+            type: 'string',
+            description: 'The skill name to update (e.g., "code-review")',
+        },
+        title: {
+            type: 'string',
+            description: 'New title for the skill (optional)',
+        },
+        description: {
+            type: 'string',
+            description: 'New description (optional)',
+        },
+        triggers: {
+            type: 'array',
+            description: 'New list of triggers (replaces existing)',
+            items: { type: 'string' },
+        },
+        instructions: {
+            type: 'string',
+            description: 'New instructions (optional)',
+        },
+        addExamples: {
+            type: 'array',
+            description: 'Examples to add to existing examples',
+            items: { type: 'string' },
+        },
+        addTags: {
+            type: 'array',
+            description: 'Tags to add to existing tags',
+            items: { type: 'string' },
+        },
+    },
+    required: ['name'],
+};

package/dist/screens/ChatScreen.d.ts

@@ -0,0 +1 @@
+export declare function ChatScreen(): import("react/jsx-runtime").JSX.Element;