@recapt/mcp 0.0.5-beta → 0.0.7-beta

package/dist/cli/utils/prompts.js

@@ -0,0 +1,133 @@
+/**
+ * Interactive Prompts
+ *
+ * Readline-based prompts for CLI interactions.
+ */
+import readline from "readline";
+function createInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+export async function confirm(message, defaultYes = true) {
+    const hint = defaultYes ? "(Y/n)" : "(y/N)";
+    const askOnce = () => {
+        const rl = createInterface();
+        return new Promise((resolve) => {
+            rl.question(`${message} ${hint} `, (answer) => {
+                rl.close();
+                const normalized = answer.trim().toLowerCase();
+                if (normalized === "") {
+                    resolve(defaultYes);
+                }
+                else if (normalized === "y" || normalized === "yes") {
+                    resolve(true);
+                }
+                else if (normalized === "n" || normalized === "no") {
+                    resolve(false);
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    };
+    let result = await askOnce();
+    while (result === null) {
+        console.log('Please enter "y" or "n"');
+        result = await askOnce();
+    }
+    return result;
+}
+export async function input(message, defaultValue) {
+    const rl = createInterface();
+    const hint = defaultValue ? ` (${defaultValue})` : "";
+    return new Promise((resolve) => {
+        rl.question(`${message}${hint}: `, (answer) => {
+            rl.close();
+            const value = answer.trim();
+            resolve(value || defaultValue || "");
+        });
+    });
+}
+export async function secret(message) {
+    const rl = createInterface();
+    return new Promise((resolve) => {
+        rl.question(`${message}: `, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function multiSelect(message, options) {
+    const rl = createInterface();
+    console.log(`\n${message}`);
+    console.log("(Enter comma-separated numbers, or 'all' for all options)\n");
+    options.forEach((opt, i) => {
+        const marker = opt.selected ? "[x]" : "[ ]";
+        console.log(`  ${i + 1}. ${marker} ${opt.label}`);
+    });
+    return new Promise((resolve) => {
+        rl.question("\nYour selection: ", (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            if (normalized === "all" || normalized === "a") {
+                resolve(options.map((o) => o.value));
+                return;
+            }
+            if (normalized === "" || normalized === "none" || normalized === "n") {
+                resolve(options.filter((o) => o.selected).map((o) => o.value));
+                return;
+            }
+            const indices = normalized
+                .split(/[,\s]+/)
+                .map((s) => parseInt(s, 10) - 1)
+                .filter((i) => i >= 0 && i < options.length);
+            resolve(indices.map((i) => options[i].value));
+        });
+    });
+}
+export async function select(message, options) {
+    const rl = createInterface();
+    console.log(`\n${message}\n`);
+    options.forEach((opt, i) => {
+        console.log(`  ${i + 1}. ${opt.label}`);
+    });
+    return new Promise((resolve) => {
+        rl.question("\nYour selection: ", (answer) => {
+            rl.close();
+            const index = parseInt(answer.trim(), 10) - 1;
+            if (index >= 0 && index < options.length) {
+                resolve(options[index].value);
+            }
+            else {
+                resolve(null);
+            }
+        });
+    });
+}
+export function print(message) {
+    console.log(message);
+}
+export function success(message) {
+    console.log(`✓ ${message}`);
+}
+export function error(message) {
+    console.error(`✗ ${message}`);
+}
+export function info(message) {
+    console.log(`ℹ ${message}`);
+}
+export function warn(message) {
+    console.log(`⚠ ${message}`);
+}
+export function newline() {
+    console.log();
+}
+export function header(title) {
+    console.log();
+    console.log(title);
+    console.log("=".repeat(title.length));
+    console.log();
+}

package/dist/index.js

@@ -223,29 +223,6 @@ All behavioral scores are 0-1 where higher = more of that signal:
 - **drop_off_rate** > 0.3: Major leak point in a flow
 - **spike_ratio** > 2: Critical frustration spike, likely recent regression
 
-## Common Workflows
-
-### Starting point - understand the landscape
-1. \`get_domains\` to see tracked domains
-2. \`run_full_diagnostic\` for comprehensive overview
-3. Or search: "site overview" → scan_site, list_pages, get_ux_health_report
-
-### Diagnosing a problematic page
-Search: "page analysis" or "element friction" → get_page_metrics, get_element_friction, get_dead_clicks, get_console_errors, get_form_friction
-
-### Understanding user flows
-Search: "user navigation" or "funnel" → analyze_flow, analyze_funnel, get_journey_patterns, get_flow_friction
-
-### Finding issues to fix
-1. \`run_full_diagnostic\` (always available)
-2. Or search: "issues" → get_issues, get_actionable_issues, get_anomalies, detect_regressions
-
-### Comparing segments
-Search: "compare users" or "cohorts" → compare_cohorts, compare_periods, discover_personas
-
-### Deep-diving a session
-Search: "session details" → search_sessions, list_sessions, get_session_details, predict_outcomes
-
 ## Reasoning Tips
 
 - High rage clicks on body/root elements often indicate JS errors - search "console errors"
@@ -254,17 +231,14 @@ Search: "session details" → search_sessions, list_sessions, get_session_detail
 - High frustration + low confusion = users know what to do but can't (broken UI)
 - Use \`memory_save\` to store intermediate results when doing multi-step analysis
 
-## Self-Healing Workflow
+## Installable Skills
 
-When asked to "fix all issues" or "heal the site":
-
-1. **Diagnose**: \`run_full_diagnostic\` (always available)
-2. **Investigate**: search "investigate issue" → investigate_issue, validate_issue
-3. **Triage**: search "dismiss issue" → dismiss_issue, mark_intended_behavior
-(you should wait here for user input, recommend continuing the workflow if the user is happy)
-4. **Fix**: search "propose fix" → propose_fix, get_similar_fixes, get_fix_history
-5. **Track**: search "deployment" → confirm_deployment, evaluate_fix, list_pending_fixes
-6. **Learn**: search "site knowledge" → get_site_knowledge, add_site_knowledge`;
+For guided workflows (self-healing, deep-dive analysis, regression hunting), install recapt skills:
+\`\`\`bash
+npx @recapt/mcp skill list
+npx @recapt/mcp skill install self-healing
+\`\`\`
+Skills provide step-by-step guidance for complex multi-tool workflows.`;
 // ─────────────────────────────────────────────────────────────────────────────
 // Main
 // ─────────────────────────────────────────────────────────────────────────────

package/dist/tools/catalog/searchTools.js

@@ -38,20 +38,65 @@ function cosineSimilarity(a, b) {
 }
 function searchByKeyword(query, limit) {
     const catalog = loadCatalog();
-    const queryWords = query
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((w) => w.length > 2);
+    const normalizedQuery = query.toLowerCase();
+    // Extract words, keeping short ones that might be meaningful (e.g., "ux", "js")
+    const queryWords = normalizedQuery
+        .split(/[\s_-]+/)
+        .filter((w) => w.length >= 2);
+    // Also check for the full query as a phrase
+    const queryPhrases = [normalizedQuery];
+    // Common synonyms and related terms
+    const synonyms = {
+        error: ["console", "js", "javascript", "bug", "crash", "exception"],
+        page: ["pages", "route", "url", "path"],
+        user: ["users", "session", "visitor"],
+        click: ["clicks", "tap", "press", "rage"],
+        form: ["forms", "input", "field", "submit"],
+        flow: ["flows", "journey", "funnel", "navigation", "path"],
+        issue: ["issues", "problem", "bug", "friction"],
+        fix: ["fixes", "remediation", "repair", "resolve"],
+        compare: ["comparison", "diff", "versus", "cohort"],
+        health: ["score", "metrics", "ux"],
+        dead: ["unresponsive", "broken", "stuck"],
+        rage: ["angry", "frustrated", "frustration"],
+    };
+    // Expand query words with synonyms
+    const expandedWords = new Set(queryWords);
+    for (const word of queryWords) {
+        if (synonyms[word]) {
+            synonyms[word].forEach((syn) => expandedWords.add(syn));
+        }
+        // Also check if query word is a synonym value
+        for (const [key, values] of Object.entries(synonyms)) {
+            if (values.includes(word)) {
+                expandedWords.add(key);
+            }
+        }
+    }
     return catalog
         .map((tool) => {
-        const text = `${tool.name} ${tool.description} ${tool.category}`.toLowerCase();
+        const toolName = tool.name.toLowerCase().replace(/_/g, " ");
+        const toolNameParts = tool.name.toLowerCase().split("_");
+        const text = `${toolName} ${tool.description} ${tool.category}`.toLowerCase();
         let score = 0;
-        for (const word of queryWords) {
-            if (text.includes(word))
-                score += 1;
-            if (tool.name.toLowerCase().includes(word))
-                score += 2;
+        // Phrase match in description (highest value)
+        for (const phrase of queryPhrases) {
+            if (phrase.length > 3 && text.includes(phrase))
+                score += 5;
+        }
+        // Word matches
+        for (const word of expandedWords) {
+            // Exact word in tool name parts (e.g., "page" matches "get_page_metrics")
+            if (toolNameParts.includes(word))
+                score += 4;
+            // Word appears in tool name
+            if (toolName.includes(word))
+                score += 3;
+            // Category match
             if (tool.category.toLowerCase() === word)
+                score += 2;
+            // Word in description
+            if (text.includes(word))
                 score += 1;
         }
         return { tool, score };