@hailer/mcp 0.0.1

package/dist/mcp/tools/skill.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Skill Management Tools - Clean Architecture
+ *
+ * Tools for discovering and loading skill documentation.
+ * Skills are comprehensive documentation files with examples and best practices.
+ */
+import { Tool } from '../tool-registry';
+export declare const listSkillsTool: Tool;
+export declare const getSkillTool: Tool;
+//# sourceMappingURL=skill.d.ts.map

package/dist/mcp/tools/skill.js

@@ -0,0 +1,279 @@
+"use strict";
+/**
+ * Skill Management Tools - Clean Architecture
+ *
+ * Tools for discovering and loading skill documentation.
+ * Skills are comprehensive documentation files with examples and best practices.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSkillTool = exports.listSkillsTool = void 0;
+const zod_1 = require("zod");
+const tool_registry_1 = require("../tool-registry");
+const logger_1 = require("../../lib/logger");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const logger = (0, logger_1.createLogger)({ component: 'skill-tools' });
+// Module-level cache for skill content
+const skillContentCache = new Map();
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Parse YAML frontmatter from skill file
+ */
+function parseSkillMetadata(skillPath) {
+    try {
+        const content = (0, fs_1.readFileSync)(skillPath, 'utf-8');
+        // Check if file starts with YAML frontmatter
+        if (!content.startsWith('---\n')) {
+            return null;
+        }
+        // Extract frontmatter (between first and second ---)
+        const endOfFrontmatter = content.indexOf('\n---\n', 4);
+        if (endOfFrontmatter === -1) {
+            return null;
+        }
+        const frontmatter = content.substring(4, endOfFrontmatter);
+        // Simple YAML parsing for name and description
+        const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+        const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+        return {
+            name: nameMatch ? nameMatch[1].trim() : '',
+            description: descMatch ? descMatch[1].trim() : ''
+        };
+    }
+    catch (error) {
+        logger.debug('Error parsing skill metadata', { skillPath, error });
+        return null;
+    }
+}
+/**
+ * Get all available skills with metadata from .claude/skills directory
+ */
+function getAvailableSkillsWithMetadata() {
+    const skillsPath = (0, path_1.join)(process.cwd(), '.claude', 'skills');
+    if (!(0, fs_1.existsSync)(skillsPath)) {
+        return [];
+    }
+    try {
+        return (0, fs_1.readdirSync)(skillsPath, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => {
+            const skillName = dirent.name;
+            const skillFile = (0, path_1.join)(skillsPath, skillName, 'SKILL.md');
+            if (!(0, fs_1.existsSync)(skillFile)) {
+                return null;
+            }
+            const metadata = parseSkillMetadata(skillFile);
+            return {
+                skillName,
+                name: metadata?.name || skillName,
+                description: metadata?.description || 'No description available'
+            };
+        })
+            .filter((skill) => skill !== null);
+    }
+    catch (error) {
+        logger.error('Error reading skills directory', error);
+        return [];
+    }
+}
+/**
+ * Get all available skills from .claude/skills directory (simple list)
+ */
+function getAvailableSkills() {
+    const skillsPath = (0, path_1.join)(process.cwd(), '.claude', 'skills');
+    if (!(0, fs_1.existsSync)(skillsPath)) {
+        return [];
+    }
+    try {
+        return (0, fs_1.readdirSync)(skillsPath, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => dirent.name)
+            .filter(name => {
+            // Only include directories that have SKILL.md
+            const skillFile = (0, path_1.join)(skillsPath, name, 'SKILL.md');
+            return (0, fs_1.existsSync)(skillFile);
+        });
+    }
+    catch (error) {
+        logger.error('Error reading skills directory', error);
+        return [];
+    }
+}
+// ============================================================================
+// TOOL 1: LIST SKILLS
+// ============================================================================
+const listSkillsDescription = `📚 List all available skills - Get skill index with names and descriptions
+
+**What it returns:**
+- Skill name/ID (used with get_skill tool)
+- Display name
+- Brief description of what the skill covers
+
+**Usage:**
+1. Call list_skills() to see all available skills
+2. Pick relevant skill based on your task
+3. Call get_skill({ skillName: "..." }) to load full documentation
+
+**Example:**
+\`\`\`javascript
+// Step 1: List all skills
+list_skills()
+
+// Step 2: Load specific skill
+get_skill({ skillName: "install-workflow-skill" })
+\`\`\`
+
+**When to use:**
+- Discovering available documentation
+- Finding relevant skill for your task
+- Before loading full skill content to save tokens`;
+const listSkillsSchema = zod_1.z.object({});
+exports.listSkillsTool = {
+    name: 'list_skills',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: listSkillsDescription,
+    schema: listSkillsSchema,
+    async execute(_args, _context) {
+        logger.debug('Listing all skills');
+        const skills = getAvailableSkillsWithMetadata();
+        if (skills.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `📚 **No skills found**\n\n` +
+                            `Skills should be located in \`.claude/skills/{skill-name}/SKILL.md\``
+                    }]
+            };
+        }
+        // Build formatted skill list
+        const skillList = skills.map((skill, index) => {
+            return `${index + 1}. **${skill.skillName}**\n` +
+                `   Name: ${skill.name}\n` +
+                `   Description: ${skill.description}`;
+        }).join('\n\n');
+        logger.info('Listed skills', { count: skills.length });
+        return {
+            content: [{
+                    type: "text",
+                    text: `📚 **Available Skills** (${skills.length} total)\n\n` +
+                        `${skillList}\n\n` +
+                        `---\n\n` +
+                        `💡 **Next step:** Use \`get_skill({ skillName: "..." })\` to load full documentation for a specific skill.`
+                }]
+        };
+    }
+};
+// ============================================================================
+// TOOL 2: GET SKILL
+// ============================================================================
+const getSkillDescription = `📚 Get skill documentation - Load detailed guides for complex tools
+
+**What are skills?**
+Skills are comprehensive documentation files with examples, best practices, and troubleshooting.
+
+**When to use:**
+- Before calling complex tools (install_workflow, create_insight, update_workflow_field, etc.)
+- When tool descriptions say "Use Skill: [skill-name]"
+- When you need detailed examples and field type documentation
+- When debugging errors or understanding tool requirements
+
+**Discovery:**
+- Use \`list_skills()\` to see all available skills with descriptions
+- Skills are automatically cached after first load
+
+**Usage pattern:**
+1. Tool description mentions skill (e.g., "Use Skill: install-workflow-skill")
+2. Call get_skill({ skillName: "install-workflow-skill" })
+3. Read documentation with examples
+4. Call the actual tool with correct format
+
+**Example:**
+\`\`\`javascript
+// Step 1: Load skill (cached after first load)
+get_skill({ skillName: "install-workflow-skill" })
+
+// Step 2: Read examples and understand format
+
+// Step 3: Call tool with correct format
+install_workflow({
+  workflowTemplates: [{ ... }]
+})
+\`\`\`
+
+**Token efficiency:** Skills are cached after first load to avoid re-reading from disk.`;
+const getSkillSchema = zod_1.z.object({
+    skillName: zod_1.z
+        .string()
+        .min(1)
+        .describe("Skill name (e.g., 'install-workflow-skill', 'create-insight-skill')")
+});
+exports.getSkillTool = {
+    name: 'get_skill',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: getSkillDescription,
+    schema: getSkillSchema,
+    async execute(args, _context) {
+        const skillName = args.skillName;
+        logger.debug('Getting skill', { skillName });
+        // Check cache first
+        if (skillContentCache.has(skillName)) {
+            logger.debug('Using cached skill content', { skillName });
+            const cachedContent = skillContentCache.get(skillName);
+            return {
+                content: [{
+                        type: "text",
+                        text: `📚 **Skill Loaded (cached):** \`${skillName}\`\n\n${cachedContent}\n\n` +
+                            `---\n\n` +
+                            `💡 **Next step:** Use the examples and guidance above to call the related MCP tool correctly.`
+                    }]
+            };
+        }
+        // Build path to skill file
+        const skillPath = (0, path_1.join)(process.cwd(), '.claude', 'skills', skillName, 'SKILL.md');
+        // Check if skill exists
+        if (!(0, fs_1.existsSync)(skillPath)) {
+            const availableSkills = getAvailableSkills();
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ **Skill not found:** \`${skillName}\`\n\n` +
+                            `**Tip:** Use \`list_skills()\` to see all available skills.\n\n` +
+                            `**Quick list:**\n${availableSkills.map(s => `- ${s}`).join('\n')}\n\n` +
+                            `**Note:** Skill names must match directory names in \`.claude/skills/\``
+                    }]
+            };
+        }
+        try {
+            // Read skill content
+            const skillContent = (0, fs_1.readFileSync)(skillPath, 'utf-8');
+            // Cache the content
+            skillContentCache.set(skillName, skillContent);
+            logger.info('Skill loaded and cached', {
+                skillName,
+                contentLength: skillContent.length,
+                cacheSize: skillContentCache.size
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `📚 **Skill Loaded:** \`${skillName}\`\n\n${skillContent}\n\n` +
+                            `---\n\n` +
+                            `💡 **Next step:** Use the examples and guidance above to call the related MCP tool correctly.`
+                    }]
+            };
+        }
+        catch (error) {
+            logger.error('Error reading skill file', error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ **Error reading skill:** ${error instanceof Error ? error.message : String(error)}\n\n` +
+                            `Skill path: \`${skillPath}\``
+                    }]
+            };
+        }
+    }
+};
+//# sourceMappingURL=skill.js.map

package/dist/mcp/tools/user.d.ts

@@ -0,0 +1,10 @@
+/**
+ * User Tools - Clean Architecture Implementation
+ *
+ * Tools for managing users in Hailer workspaces:
+ * - Search for users by name (WRITE)
+ * - Get initialization data (READ) - currently disabled
+ */
+import { Tool } from '../tool-registry';
+export declare const searchWorkspaceUsersTool: Tool;
+//# sourceMappingURL=user.d.ts.map

package/dist/mcp/tools/user.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * User Tools - Clean Architecture Implementation
+ *
+ * Tools for managing users in Hailer workspaces:
+ * - Search for users by name (WRITE)
+ * - Get initialization data (READ) - currently disabled
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchWorkspaceUsersTool = void 0;
+const zod_1 = require("zod");
+const tool_registry_1 = require("../tool-registry");
+const index_1 = require("../utils/index");
+const logger = (0, index_1.createLogger)({ component: 'user-tools' });
+// ============================================================================
+// TOOL 1: SEARCH WORKSPACE USERS
+// ============================================================================
+const searchWorkspaceUsersDescription = `Search for users in the current workspace by name - Returns valid user IDs for assignment`;
+exports.searchWorkspaceUsersTool = {
+    name: 'search_workspace_users',
+    group: tool_registry_1.ToolGroup.READ,
+    description: searchWorkspaceUsersDescription,
+    schema: zod_1.z.object({
+        query: zod_1.z
+            .string()
+            .min(1, "Query cannot be empty")
+            .describe("User's first name, last name, or full name to search for"),
+        exactMatch: zod_1.z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Whether to require exact match (default: partial match)"),
+    }),
+    async execute(args, context) {
+        logger.debug('Searching workspace users', {
+            query: args.query,
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            if (!context.workspaceCache) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "❌ Workspace cache not available for user search. You must report it to user that there is a problem with MCP Server that must be forwarded to development team",
+                        },
+                    ],
+                };
+            }
+            const query = args.query.toLowerCase().trim();
+            const exactMatch = args.exactMatch;
+            const matchingUsers = context.workspaceCache.users.filter((user) => {
+                const fullName = user.fullName.toLowerCase();
+                const firstName = (user.firstname || "").toLowerCase();
+                const lastName = (user.lastname || "").toLowerCase();
+                if (exactMatch) {
+                    return (fullName === query || firstName === query || lastName === query);
+                }
+                else {
+                    return (fullName.includes(query) ||
+                        firstName.includes(query) ||
+                        lastName.includes(query));
+                }
+            });
+            if (matchingUsers.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ No users found matching "${args.query}" in the current workspace.\n\n` +
+                                `💡 Available users:\n${context.workspaceCache.users.map((u) => `- ${u.fullName} (${u.id})`).join("\n")}`,
+                        },
+                    ],
+                };
+            }
+            const userList = matchingUsers.map((user) => ({
+                id: user.id,
+                name: user.fullName,
+                firstName: user.firstname,
+                lastName: user.lastname,
+            }));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ Found ${matchingUsers.length} user(s) matching "${args.query}":\n\n` +
+                            userList
+                                .map((user) => `• **${user.name}**\n  - ID: \`${user.id}\`\n  - Use this ID for assignment or followers`)
+                                .join("\n\n") +
+                            `\n\n💡 Use these IDs in create_activity fields or followerIds parameters.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error("Error searching workspace users", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Error searching users: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    },
+};
+//# sourceMappingURL=user.js.map

package/dist/mcp/tools/workflow-template.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Workflow Template Tools - Clean Architecture Implementation
+ *
+ * Document template management for Hailer workflows:
+ * - Templates define how to convert activity data into documents (PDF, etc.)
+ * - Templates can be workflow-specific or global
+ * - Preview and install capabilities for testing and deployment
+ *
+ * All 7 template management tools in one file for cohesion.
+ */
+import { Tool } from '../tool-registry';
+export declare const listTemplatesTool: Tool;
+export declare const getTemplateTool: Tool;
+export declare const createTemplateTool: Tool;
+export declare const updateTemplateTool: Tool;
+export declare const deleteTemplateTool: Tool;
+export declare const previewTemplateTool: Tool;
+export declare const installTemplateTool: Tool;
+//# sourceMappingURL=workflow-template.d.ts.map