@hailer/mcp 0.0.2 → 0.0.4

package/.claude/hooks/PreToolUse.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Claude Code PreToolUse hook - auto-loads SDK skills before bash commands
+
+TOOL="$1"
+
+# Only process Bash tool
+if [[ "$TOOL" != "Bash" ]]; then
+  exit 0
+fi
+
+# Read tool input from stdin
+INPUT=$(cat)
+COMMAND=$(echo "$INPUT" | jq -r '.command // empty')
+
+# Marker directory for tracking loaded skills this session
+MARKER_DIR="/tmp/.claude-skills-loaded"
+mkdir -p "$MARKER_DIR"
+
+# SDK command to skill mapping
+load_skill_if_needed() {
+  local skill_name="$1"
+  local marker_file="$MARKER_DIR/$skill_name"
+  local skill_path=".claude/skills/$skill_name/SKILL.md"
+
+  if [[ ! -f "$marker_file" ]] && [[ -f "$skill_path" ]]; then
+    echo "" >&2
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" >&2
+    echo "📚 AUTO-LOADING SKILL: $skill_name" >&2
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" >&2
+    echo "" >&2
+    cat "$skill_path" >&2
+    echo "" >&2
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" >&2
+    echo "" >&2
+    touch "$marker_file"
+  fi
+}
+
+# Check for SDK commands and load appropriate skills
+case "$COMMAND" in
+  *"npm run pull"*|*"npm run push"*|*"npm run workflows"*|*"npm run phases"*|*"npm run fields"*|*"npm run groups"*|*"npm run teams"*|*"npm run insights"*)
+    load_skill_if_needed "SDK-ws-config-skill"
+    ;;
+  *"npm run generate"*|*"hailer-sdk generate"*)
+    load_skill_if_needed "SDK-generate-skill"
+    ;;
+  *"hailer-sdk init"*)
+    load_skill_if_needed "SDK-init-skill"
+    ;;
+esac
+
+exit 0

package/.claude/hooks/prompt-skill-loader.cjs

@@ -0,0 +1,452 @@
+#!/usr/bin/env node
+/**
+ * Claude Code UserPromptSubmit Hook - Auto-loads skills based on prompt keywords
+ *
+ * This hook detects keywords in user prompts and triggers disambiguation
+ * questions to clarify user intent before loading skills.
+ *
+ * Features:
+ * - Keyword-based skill loading
+ * - Disambiguation prompts for ALL keywords (no assumptions)
+ * - Marker files to avoid loading same skill twice per session
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Read hook input from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    processHook(data);
+  } catch (e) {
+    // Invalid JSON, exit silently
+    process.exit(0);
+  }
+});
+
+// ALL keywords are now ambiguous - always ask for clarification
+const AMBIGUOUS_KEYWORDS = [
+  // Pull operations
+  {
+    keyword: /\bpull\b/i,
+    contextPatterns: [
+      /\b(config|workspace|fields?|phases?|groups?|teams?|ws-config)\b/i,
+      /\bnpm run pull\b/i
+    ],
+    skill: 'SDK-ws-config-skill',
+    disambiguation: {
+      keyword: 'pull',
+      question: 'What would you like to pull?',
+      options: [
+        { label: 'Workspace configuration', description: 'Pull workflow configs, fields, phases (npm run pull)', skill: 'SDK-ws-config-skill' },
+        { label: 'Activity data', description: 'Fetch activities from a workflow (MCP tools)', skill: null }
+      ]
+    }
+  },
+  // Push operations
+  {
+    keyword: /\bpush\b/i,
+    contextPatterns: [
+      /\b(config|workspace|fields?|phases?|groups?|teams?|ws-config)\b/i,
+      /\bnpm run push\b/i
+    ],
+    skill: 'SDK-ws-config-skill',
+    disambiguation: {
+      keyword: 'push',
+      question: 'What would you like to push?',
+      options: [
+        { label: 'Workspace configuration', description: 'Push workflow configs, fields, phases (npm run push)', skill: 'SDK-ws-config-skill' },
+        { label: 'Activity updates', description: 'Update activities in a workflow (MCP tools)', skill: null }
+      ]
+    }
+  },
+  // Generate operations
+  {
+    keyword: /\bgenerate\b/i,
+    contextPatterns: [
+      /\b(types?|enums?|typescript|ts)\b/i,
+      /\bnpm run generate\b/i
+    ],
+    skill: 'SDK-generate-skill',
+    disambiguation: {
+      keyword: 'generate',
+      question: 'What would you like to generate?',
+      options: [
+        { label: 'TypeScript types/enums', description: 'Generate types from Hailer workspace (npm run generate)', skill: 'SDK-generate-skill' },
+        { label: 'Sample data', description: 'Create test activities in workflows', skill: 'MCP-populate-workflow-data-skill' },
+        { label: 'Reports/insights', description: 'Create SQL-like insights', skill: 'MCP-create-insight-skill' }
+      ]
+    }
+  },
+  // Setup operations
+  {
+    keyword: /\bsetup\b/i,
+    contextPatterns: [
+      /\b(project|init|mcp|bot.?account)\b/i,
+      /\bhailer-sdk init\b/i
+    ],
+    skill: 'SDK-init-skill',
+    disambiguation: {
+      keyword: 'setup',
+      question: 'What would you like to set up?',
+      options: [
+        { label: 'New Hailer project', description: 'Initialize project with hailer-sdk init', skill: 'SDK-init-skill' },
+        { label: 'Workspace structure', description: 'Create workflows, fields, phases', skill: 'SDK-workspace-setup-skill' },
+        { label: 'Hailer app', description: 'Scaffold a new Hailer application', skill: 'MCP-scaffold-hailer-app-skill' }
+      ]
+    }
+  },
+  // Initialize operations
+  {
+    keyword: /\b(init|initialize)\b/i,
+    contextPatterns: [
+      /\bhailer-sdk init\b/i,
+      /\bnew project\b/i
+    ],
+    skill: 'SDK-init-skill',
+    disambiguation: {
+      keyword: 'init',
+      question: 'What would you like to initialize?',
+      options: [
+        { label: 'New Hailer project', description: 'Initialize project with hailer-sdk init', skill: 'SDK-init-skill' },
+        { label: 'Bot account', description: 'Set up a bot account for automation', skill: 'SDK-init-skill' },
+        { label: 'MCP server', description: 'Configure MCP server integration', skill: 'SDK-init-skill' }
+      ]
+    }
+  },
+  // Workflow operations
+  {
+    keyword: /\bworkflow\b/i,
+    contextPatterns: [
+      /\b(install|create|new).?workflow\b/i,
+      /\bworkflow.?(install|create|new)\b/i
+    ],
+    skill: 'MCP-install-workflow-skill',
+    disambiguation: {
+      keyword: 'workflow',
+      question: 'What would you like to do with workflows?',
+      options: [
+        { label: 'Create new workflow', description: 'Install a new workflow structure', skill: 'MCP-install-workflow-skill' },
+        { label: 'List workflows', description: 'View existing workflows in workspace', skill: null },
+        { label: 'Update workflow structure', description: 'Modify fields, phases via SDK', skill: 'SDK-ws-config-skill' },
+        { label: 'Remove workflow', description: 'Delete a workflow from workspace', skill: 'MCP-remove-workflow-skill' }
+      ]
+    }
+  },
+  // Insight/Report operations
+  {
+    keyword: /\b(insight|report|analytics)\b/i,
+    contextPatterns: [
+      /\b(create|new|build).?(insight|report)\b/i,
+      /\b(insight|report).?(create|new|build)\b/i
+    ],
+    skill: 'MCP-create-insight-skill',
+    disambiguation: {
+      keyword: 'insight',
+      question: 'What would you like to do with insights?',
+      options: [
+        { label: 'Create new insight', description: 'Build a new SQL-like report', skill: 'MCP-create-insight-skill' },
+        { label: 'List insights', description: 'View existing insights in workspace', skill: null },
+        { label: 'Get insight data', description: 'Execute an insight and retrieve results', skill: 'MCP-get-insight-data-skill' },
+        { label: 'Preview/test SQL', description: 'Test a query before saving', skill: 'MCP-preview-insight-skill' }
+      ]
+    }
+  },
+  // SQL/Query operations (alias for insight)
+  {
+    keyword: /\b(sql|query)\b/i,
+    contextPatterns: [
+      /\b(run|execute|test|preview).?(sql|query)\b/i
+    ],
+    skill: 'MCP-preview-insight-skill',
+    disambiguation: {
+      keyword: 'sql',
+      question: 'What would you like to do with SQL queries?',
+      options: [
+        { label: 'Create insight with SQL', description: 'Build a saved SQL report', skill: 'MCP-create-insight-skill' },
+        { label: 'Preview/test SQL', description: 'Test a query before saving', skill: 'MCP-preview-insight-skill' },
+        { label: 'Run existing insight', description: 'Execute a saved insight', skill: 'MCP-get-insight-data-skill' }
+      ]
+    }
+  },
+  // App operations
+  {
+    keyword: /\b(app|application)\b/i,
+    contextPatterns: [
+      /\b(scaffold|create|new|build).?app\b/i,
+      /\bhailer.?app\b/i
+    ],
+    skill: 'MCP-scaffold-hailer-app-skill',
+    disambiguation: {
+      keyword: 'app',
+      question: 'What would you like to do with Hailer apps?',
+      options: [
+        { label: 'Scaffold new app', description: 'Create a new app project from template', skill: 'MCP-scaffold-hailer-app-skill' },
+        { label: 'Create app entry', description: 'Register an app in Hailer (no scaffold)', skill: 'MCP-create-app-skill' },
+        { label: 'List apps', description: 'View existing apps in workspace', skill: 'MCP-list-apps-skill' },
+        { label: 'Update app', description: 'Modify app properties', skill: 'MCP-update-app-skill' }
+      ]
+    }
+  },
+  // Publish/Deploy operations
+  {
+    keyword: /\b(publish|deploy)\b/i,
+    contextPatterns: [
+      /\b(publish|deploy).?app\b/i
+    ],
+    skill: 'MCP-publish-hailer-app-skill',
+    disambiguation: {
+      keyword: 'publish',
+      question: 'What would you like to publish or deploy?',
+      options: [
+        { label: 'Publish Hailer app', description: 'Build and upload app to production', skill: 'MCP-publish-hailer-app-skill' },
+        { label: 'Share app with users', description: 'Add members to access an app', skill: 'MCP-add-app-member-skill' }
+      ]
+    }
+  },
+  // Function field / Calculated field operations
+  {
+    keyword: /\b(function.?field|calculated.?field|formula)\b/i,
+    contextPatterns: [
+      /\b(create|add|new).?(function|calculated).?field\b/i
+    ],
+    skill: 'SDK-create-function-field-skill',
+    disambiguation: {
+      keyword: 'function field',
+      question: 'What would you like to do with function fields?',
+      options: [
+        { label: 'Create function field', description: 'Add a new calculated field to workflow', skill: 'SDK-create-function-field-skill' },
+        { label: 'Update function field', description: 'Modify existing function field formula', skill: 'MCP-update-workflow-field-skill' },
+        { label: 'Test function', description: 'Test function code against real data', skill: null }
+      ]
+    }
+  },
+  // Sample data / Populate operations
+  {
+    keyword: /\b(sample.?data|test.?data|populate|bulk.?create)\b/i,
+    contextPatterns: [
+      /\b(create|add|generate).?(sample|test).?data\b/i
+    ],
+    skill: 'MCP-populate-workflow-data-skill',
+    disambiguation: {
+      keyword: 'data',
+      question: 'What would you like to do with data?',
+      options: [
+        { label: 'Populate with sample data', description: 'Generate realistic test activities', skill: 'MCP-populate-workflow-data-skill' },
+        { label: 'Bulk create activities', description: 'Create multiple activities at once', skill: null },
+        { label: 'Import data', description: 'Import from external source', skill: null }
+      ]
+    }
+  },
+  // Field operations
+  {
+    keyword: /\b(add|modify|update|delete|remove|create).{0,20}field\b/i,
+    contextPatterns: [
+      /\bnpm run (fields|push)\b/i,
+      /\bworkspace.?config\b/i
+    ],
+    skill: 'SDK-ws-config-skill',
+    disambiguation: {
+      keyword: 'field',
+      question: 'How would you like to modify fields?',
+      options: [
+        { label: 'Via SDK (local files)', description: 'Edit workspace/ files and push (version controlled)', skill: 'SDK-ws-config-skill' },
+        { label: 'Via MCP (direct API)', description: 'Update field directly via API', skill: 'MCP-update-workflow-field-skill' }
+      ]
+    }
+  },
+  // Phase operations
+  {
+    keyword: /\b(add|modify|update|delete|remove|create).{0,20}phase\b/i,
+    contextPatterns: [
+      /\bnpm run (phases|push)\b/i,
+      /\bworkspace.?config\b/i
+    ],
+    skill: 'SDK-ws-config-skill',
+    disambiguation: {
+      keyword: 'phase',
+      question: 'How would you like to modify phases?',
+      options: [
+        { label: 'Via SDK (local files)', description: 'Edit workspace/ files and push (version controlled)', skill: 'SDK-ws-config-skill' },
+        { label: 'Via MCP (direct API)', description: 'Update phase directly via API', skill: null }
+      ]
+    }
+  },
+  // Activity operations
+  {
+    keyword: /\b(activities|activity)\b/i,
+    contextPatterns: [
+      /\b(list|show|get|fetch|create|update|delete).?(activities|activity)\b/i
+    ],
+    skill: null,
+    disambiguation: {
+      keyword: 'activity',
+      question: 'What would you like to do with activities?',
+      options: [
+        { label: 'List activities', description: 'View activities in a workflow', skill: null },
+        { label: 'Create activity', description: 'Add a new activity to workflow', skill: null },
+        { label: 'Update activity', description: 'Modify an existing activity', skill: null },
+        { label: 'Bulk create activities', description: 'Create multiple activities at once', skill: 'MCP-populate-workflow-data-skill' }
+      ]
+    }
+  },
+  // Sync operations (DESTRUCTIVE - require confirmation)
+  {
+    keyword: /\b(sync|workflows?.?sync)\b/i,
+    contextPatterns: [],  // Always require confirmation, never auto-proceed
+    skill: 'SDK-ws-config-skill',
+    disambiguation: {
+      keyword: 'sync',
+      question: '⚠️ Sync operations can DELETE resources from Hailer. Items removed from local config will be PERMANENTLY deleted remotely. Proceed?',
+      options: [
+        { label: 'Yes, run sync', description: 'I understand - proceed with destructive sync operation', skill: 'SDK-ws-config-skill', action: 'confirm-sync' },
+        { label: 'No, cancel', description: 'Abort - don\'t delete anything', skill: null, action: 'cancel' }
+      ]
+    }
+  }
+];
+
+// No more direct keywords - all require disambiguation
+const DIRECT_KEYWORDS = [];
+
+function processHook(data) {
+  const { prompt, cwd } = data;
+
+  if (!prompt) {
+    process.exit(0);
+  }
+
+  // Marker directory for tracking loaded skills this session
+  const markerDir = path.join(os.tmpdir(), '.claude-skills-loaded');
+  if (!fs.existsSync(markerDir)) {
+    fs.mkdirSync(markerDir, { recursive: true });
+  }
+
+  // Find project directory
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || cwd || process.cwd();
+
+  // Track what we'll output
+  const skillsToLoad = [];
+  const disambiguationsNeeded = [];
+  const seenDisambiguations = new Set(); // Avoid duplicate questions
+
+  // Check all ambiguous keywords
+  for (const entry of AMBIGUOUS_KEYWORDS) {
+    if (entry.keyword.test(prompt)) {
+      // Check if context makes it clear
+      const hasContext = entry.contextPatterns && entry.contextPatterns.some(p => p.test(prompt));
+
+      if (hasContext && entry.skill) {
+        // Context is clear - load the skill
+        const markerFile = path.join(markerDir, entry.skill);
+        if (!fs.existsSync(markerFile)) {
+          const skillPath = path.join(projectDir, '.claude', 'skills', entry.skill, 'SKILL.md');
+          if (fs.existsSync(skillPath)) {
+            skillsToLoad.push({
+              skill: entry.skill,
+              description: entry.disambiguation.question,
+              path: skillPath,
+              markerFile
+            });
+          }
+        }
+      } else {
+        // Context unclear - need disambiguation (avoid duplicates)
+        const disambKey = entry.disambiguation.keyword;
+        if (!seenDisambiguations.has(disambKey)) {
+          seenDisambiguations.add(disambKey);
+          disambiguationsNeeded.push(entry.disambiguation);
+        }
+      }
+    }
+  }
+
+  // Nothing to output
+  if (skillsToLoad.length === 0 && disambiguationsNeeded.length === 0) {
+    process.exit(0);
+  }
+
+  // Build output
+  let output = '\n';
+
+  // Output disambiguation prompts first
+  if (disambiguationsNeeded.length > 0) {
+    output += '='.repeat(60) + '\n';
+    output += '⚠️ MANDATORY ACTION REQUIRED - DO NOT SKIP\n';
+    output += '='.repeat(60) + '\n\n';
+    output += 'STOP! You MUST use the AskUserQuestion tool BEFORE doing anything else.\n';
+    output += 'The user\'s intent is ambiguous. Do NOT guess or assume.\n\n';
+
+    for (const disamb of disambiguationsNeeded) {
+      output += '-'.repeat(40) + '\n';
+      output += `Ambiguous keyword detected: "${disamb.keyword}"\n\n`;
+      output += 'USE THIS EXACT AskUserQuestion CALL:\n\n';
+      output += '```json\n';
+      output += JSON.stringify({
+        questions: [{
+          question: disamb.question,
+          header: disamb.keyword.charAt(0).toUpperCase() + disamb.keyword.slice(1),
+          options: disamb.options.map(opt => ({
+            label: opt.label,
+            description: opt.description
+          })),
+          multiSelect: false
+        }]
+      }, null, 2);
+      output += '\n```\n\n';
+
+      output += 'After user responds:\n';
+      for (const opt of disamb.options) {
+        if (opt.action === 'confirm-sync') {
+          output += `  - If "${opt.label}": Load Skill(${opt.skill}), then run with: yes | npm run workflows-sync\n`;
+        } else if (opt.action === 'cancel') {
+          output += `  - If "${opt.label}": Acknowledge cancellation, do NOT run any sync command\n`;
+        } else if (opt.skill) {
+          output += `  - If "${opt.label}": Load Skill(${opt.skill}), then proceed\n`;
+        } else {
+          output += `  - If "${opt.label}": Use MCP tools directly (no skill needed)\n`;
+        }
+      }
+      output += '\n';
+    }
+
+    output += '='.repeat(60) + '\n';
+    output += 'REMEMBER: Ask FIRST, then act. Never assume user intent.\n';
+    output += '='.repeat(60) + '\n\n';
+  }
+
+  // Output skills that can be loaded directly (only when context is clear)
+  if (skillsToLoad.length > 0) {
+    output += '='.repeat(60) + '\n';
+    output += 'AUTO-LOADED SKILLS (context was clear from prompt)\n';
+    output += '='.repeat(60) + '\n\n';
+
+    for (const skill of skillsToLoad) {
+      const skillContent = fs.readFileSync(skill.path, 'utf8');
+
+      output += '-'.repeat(60) + '\n';
+      output += `SKILL: ${skill.skill}\n`;
+      output += `Purpose: ${skill.description}\n`;
+      output += '-'.repeat(60) + '\n\n';
+      output += skillContent;
+      output += '\n\n';
+
+      // Mark skill as loaded
+      fs.writeFileSync(skill.markerFile, new Date().toISOString());
+    }
+
+    output += '='.repeat(60) + '\n';
+    output += 'END OF AUTO-LOADED SKILLS\n';
+    output += '='.repeat(60) + '\n';
+  }
+
+  // Output to stdout - UserPromptSubmit hooks add stdout to context
+  console.log(output);
+
+  process.exit(0);
+}

package/.claude/hooks/sdk-delete-guard.cjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * SDK Delete Guard Hook
+ *
+ * PreToolUse hook that catches SDK commands which may delete resources
+ * and blocks them, instructing Claude to use `yes |` prefix if user confirms.
+ *
+ * Triggered by: npm run push, npm run *-sync, npm run *-push commands
+ */
+
+// Commands that can cause deletions
+const DELETE_RISK_PATTERNS = [
+  /npm run push\b/,           // Full push - can delete workflows, fields, phases
+  /npm run workflows-sync\b/, // Sync workflows - can delete workflows
+  /npm run workflows-push\b/, // Push workflows - can delete workflows
+  /npm run phases-push\b/,    // Push phases - can delete phases
+  /npm run fields-push\b/,    // Push fields - can delete fields
+  /npm run groups-push\b/,    // Push groups - can delete groups
+  /npm run teams-push\b/,     // Push teams - can delete teams
+  /npm run insights-push\b/,  // Push insights - can delete insights
+  /hailer-sdk ws-config push\b/,
+  /hailer-sdk ws-config.*sync\b/,
+];
+
+// Commands that are already safe (have yes | prefix)
+const SAFE_PATTERNS = [
+  /^yes\s*\|/,
+  /^echo\s+[yYnN]\s*\|/,
+];
+
+// Read stdin
+async function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => data += chunk);
+    process.stdin.on('end', () => resolve(data));
+    setTimeout(() => resolve(data), 100);
+  });
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+
+    if (!input.trim()) {
+      process.exit(0);
+    }
+
+    const hookData = JSON.parse(input);
+    const command = hookData.tool_input?.command || '';
+
+    // If command already has yes/echo prefix, allow it
+    const isSafe = SAFE_PATTERNS.some(pattern => pattern.test(command));
+    if (isSafe) {
+      process.exit(0);
+    }
+
+    // Check if this is a delete-risk command
+    const isDeleteRisk = DELETE_RISK_PATTERNS.some(pattern => pattern.test(command));
+
+    if (!isDeleteRisk) {
+      process.exit(0);
+    }
+
+    // Output instructions to stderr (appears as system reminder)
+    // This ensures Claude sees and follows the instructions
+    const instructions = `============================================================
+⚠️ MANDATORY ACTION REQUIRED - DO NOT SKIP
+============================================================
+
+STOP! You MUST use the AskUserQuestion tool BEFORE running this command.
+This is a DESTRUCTIVE operation that may DELETE resources from Hailer.
+
+USE THIS EXACT AskUserQuestion CALL:
+
+\`\`\`json
+{
+  "questions": [{
+    "question": "This command may delete resources from Hailer. Items removed from local config will be PERMANENTLY deleted. Proceed with: ${command}?",
+    "header": "Confirm Delete",
+    "options": [
+      { "label": "Yes, delete", "description": "Proceed with the destructive operation" },
+      { "label": "No, cancel", "description": "Abort - don't delete anything" }
+    ],
+    "multiSelect": false
+  }]
+}
+\`\`\`
+
+After user responds:
+- If "Yes, delete": Run: yes | ${command}
+- If "No, cancel": Acknowledge cancellation, do NOT run the command
+
+============================================================
+REMEMBER: ASK FIRST using AskUserQuestion, then act based on response.
+============================================================`;
+
+    // Output to stderr so it appears as system reminder
+    console.error(instructions);
+
+    // Block the command - Claude must ask first
+    const response = {
+      permissionDecision: "deny",
+      permissionDecisionReason: "Command blocked. Follow the instructions above to ask user for confirmation first."
+    };
+
+    console.log(JSON.stringify(response));
+    process.exit(0);
+
+  } catch (error) {
+    console.error(`[sdk-delete-guard] Error: ${error.message}`);
+    process.exit(0);
+  }
+}
+
+main();