@salesforce/afv-skills 1.8.0 → 1.9.0

package/skills/generating-lwc-components/assets/workspace-api/workspaceComponent.html

@@ -0,0 +1,71 @@
+<template>
+    <lightning-card title="Workspace Tab Manager" icon-name="utility:tabset">
+        <div class="slds-p-horizontal_medium">
+            <!-- Console Detection -->
+            <template lwc:if={isNotConsole}>
+                <div class="slds-notify slds-notify_alert slds-alert_warning" role="alert">
+                    <span class="slds-assistive-text">Warning</span>
+                    <lightning-icon icon-name="utility:warning" size="x-small" class="slds-m-right_x-small"></lightning-icon>
+                    <h2>Not in Console App</h2>
+                    <p class="slds-m-top_x-small">
+                        This component requires a Console App (Service Console or Sales Console) to function.
+                        Tab management APIs are not available in standard Lightning pages.
+                    </p>
+                </div>
+            </template>
+
+            <!-- Console Context UI -->
+            <template lwc:if={isConsole}>
+                <!-- Current Tab Info -->
+                <div class="slds-box slds-m-bottom_medium">
+                    <h3 class="slds-text-heading_small slds-m-bottom_small">Current Tab</h3>
+                    <dl class="slds-list_horizontal">
+                        <dt class="slds-item_label">Tab ID:</dt>
+                        <dd class="slds-item_detail">{currentTabId}</dd>
+                        <dt class="slds-item_label">Label:</dt>
+                        <dd class="slds-item_detail">{currentTabLabel}</dd>
+                    </dl>
+                </div>
+
+                <!-- Tab Actions -->
+                <div class="slds-button-group" role="group">
+                    <lightning-button
+                        label="Refresh Tab"
+                        onclick={handleRefresh}
+                        icon-name="utility:refresh">
+                    </lightning-button>
+                    <lightning-button
+                        label="Get All Tabs"
+                        onclick={handleGetAllTabs}
+                        icon-name="utility:list">
+                    </lightning-button>
+                </div>
+
+                <!-- All Tabs List -->
+                <template lwc:if={allTabs.length}>
+                    <h3 class="slds-text-heading_small slds-m-top_medium slds-m-bottom_small">
+                        Open Tabs ({allTabs.length})
+                    </h3>
+                    <ul class="slds-has-dividers_bottom-space">
+                        <template for:each={allTabs} for:item="tab">
+                            <li key={tab.tabId} class="slds-item">
+                                <div class="slds-grid slds-grid_align-spread">
+                                    <span class="slds-truncate">{tab.title}</span>
+                                    <span class="slds-text-color_weak slds-text-body_small">{tab.tabId}</span>
+                                </div>
+                            </li>
+                        </template>
+                    </ul>
+                </template>
+
+                <!-- Error Display -->
+                <template lwc:if={error}>
+                    <div class="slds-notify slds-notify_alert slds-alert_error slds-m-top_medium" role="alert">
+                        <span class="slds-assistive-text">Error</span>
+                        <h2>{error}</h2>
+                    </div>
+                </template>
+            </template>
+        </div>
+    </lightning-card>
+</template>

package/skills/generating-lwc-components/assets/workspace-api/workspaceComponent.js

@@ -0,0 +1,316 @@
+/**
+ * Workspace API Component Template
+ *
+ * Demonstrates tab management in Salesforce Console (Service/Sales Console) using:
+ * - IsConsoleNavigation wire to detect console context
+ * - Tab opening, closing, and focusing
+ * - Subtab management
+ * - Tab label and icon customization
+ * - Tab refresh
+ *
+ * @see https://developer.salesforce.com/docs/component-library/bundle/lightning-workspace-api
+ */
+import { LightningElement, wire, api } from 'lwc';
+import {
+    IsConsoleNavigation,
+    getFocusedTabInfo,
+    getTabInfo,
+    openTab,
+    closeTab,
+    focusTab,
+    refreshTab,
+    setTabLabel,
+    setTabIcon,
+    setTabHighlighted,
+    disableTabClose,
+    getAllTabInfo,
+    openSubtab,
+    MINIMUM_SUBTAB_SIZE
+} from 'lightning/platformWorkspaceApi';
+
+export default class WorkspaceComponent extends LightningElement {
+    // Wire to check if we're in a console app
+    @wire(IsConsoleNavigation) isConsoleNavigation;
+
+    // Current tab information
+    currentTabId;
+    currentTabLabel;
+    allTabs = [];
+
+    // Error tracking
+    error;
+
+    /**
+     * Check if the component is running in a console context
+     */
+    get isConsole() {
+        return this.isConsoleNavigation?.data === true;
+    }
+
+    get isNotConsole() {
+        return this.isConsoleNavigation?.data === false;
+    }
+
+    /**
+     * Connected callback - get current tab info
+     */
+    async connectedCallback() {
+        if (this.isConsole) {
+            await this._refreshCurrentTabInfo();
+        }
+    }
+
+    // ==================
+    // Public API Methods
+    // ==================
+
+    /**
+     * Open a record in a new tab
+     * @param {String} recordId - The record ID to open
+     * @param {String} objectApiName - The object API name (for icon)
+     * @param {Boolean} focus - Whether to focus the new tab
+     */
+    @api
+    async openRecordTab(recordId, objectApiName = 'Account', focus = true) {
+        if (!this.isConsole) {
+            console.warn('openRecordTab: Not in console context');
+            return null;
+        }
+
+        try {
+            const tabId = await openTab({
+                recordId,
+                focus,
+                icon: `standard:${objectApiName.toLowerCase()}`,
+                label: 'Loading...'
+            });
+            return tabId;
+        } catch (error) {
+            this._handleError('Error opening tab', error);
+            return null;
+        }
+    }
+
+    /**
+     * Open a URL in a new tab
+     * @param {String} url - The URL to open
+     * @param {String} label - The tab label
+     * @param {String} icon - The tab icon
+     */
+    @api
+    async openUrlTab(url, label = 'New Tab', icon = 'utility:new_window') {
+        if (!this.isConsole) return null;
+
+        try {
+            const tabId = await openTab({
+                url,
+                focus: true,
+                label,
+                icon
+            });
+            return tabId;
+        } catch (error) {
+            this._handleError('Error opening URL tab', error);
+            return null;
+        }
+    }
+
+    /**
+     * Open a subtab under the current (or specified) parent tab
+     * @param {String} recordId - The record ID for the subtab
+     * @param {String} parentTabId - Optional parent tab ID (defaults to current tab)
+     */
+    @api
+    async openRecordSubtab(recordId, parentTabId = null) {
+        if (!this.isConsole) return null;
+
+        try {
+            const parent = parentTabId || (await this._getCurrentTabId());
+            const subtabId = await openSubtab({
+                parentTabId: parent,
+                recordId,
+                focus: true
+            });
+            return subtabId;
+        } catch (error) {
+            this._handleError('Error opening subtab', error);
+            return null;
+        }
+    }
+
+    /**
+     * Close a specific tab
+     * @param {String} tabId - The tab ID to close
+     */
+    @api
+    async closeTabById(tabId) {
+        if (!this.isConsole) return;
+
+        try {
+            await closeTab(tabId);
+        } catch (error) {
+            this._handleError('Error closing tab', error);
+        }
+    }
+
+    /**
+     * Close the current tab
+     */
+    @api
+    async closeCurrentTab() {
+        if (!this.isConsole) return;
+
+        try {
+            const tabId = await this._getCurrentTabId();
+            await closeTab(tabId);
+        } catch (error) {
+            this._handleError('Error closing current tab', error);
+        }
+    }
+
+    /**
+     * Focus a specific tab
+     * @param {String} tabId - The tab ID to focus
+     */
+    @api
+    async focusTabById(tabId) {
+        if (!this.isConsole) return;
+
+        try {
+            await focusTab(tabId);
+        } catch (error) {
+            this._handleError('Error focusing tab', error);
+        }
+    }
+
+    /**
+     * Update the current tab's label
+     * @param {String} label - The new label
+     */
+    @api
+    async updateCurrentTabLabel(label) {
+        if (!this.isConsole) return;
+
+        try {
+            const tabId = await this._getCurrentTabId();
+            await setTabLabel(tabId, label);
+            this.currentTabLabel = label;
+        } catch (error) {
+            this._handleError('Error updating tab label', error);
+        }
+    }
+
+    /**
+     * Update the current tab's icon
+     * @param {String} iconName - The icon name (e.g., 'standard:account')
+     */
+    @api
+    async updateCurrentTabIcon(iconName) {
+        if (!this.isConsole) return;
+
+        try {
+            const tabId = await this._getCurrentTabId();
+            await setTabIcon(tabId, iconName);
+        } catch (error) {
+            this._handleError('Error updating tab icon', error);
+        }
+    }
+
+    /**
+     * Highlight a tab (shows visual indicator)
+     * @param {String} tabId - The tab ID to highlight
+     * @param {Boolean} highlighted - Whether to highlight or remove highlight
+     */
+    @api
+    async highlightTab(tabId, highlighted = true) {
+        if (!this.isConsole) return;
+
+        try {
+            await setTabHighlighted(tabId, highlighted);
+        } catch (error) {
+            this._handleError('Error highlighting tab', error);
+        }
+    }
+
+    /**
+     * Prevent a tab from being closed
+     * @param {String} tabId - The tab ID
+     * @param {Boolean} disabled - Whether to disable close
+     */
+    @api
+    async preventTabClose(tabId, disabled = true) {
+        if (!this.isConsole) return;
+
+        try {
+            await disableTabClose(tabId, disabled);
+        } catch (error) {
+            this._handleError('Error disabling tab close', error);
+        }
+    }
+
+    /**
+     * Refresh the current tab
+     */
+    @api
+    async refreshCurrentTab() {
+        if (!this.isConsole) return;
+
+        try {
+            const tabId = await this._getCurrentTabId();
+            await refreshTab(tabId);
+        } catch (error) {
+            this._handleError('Error refreshing tab', error);
+        }
+    }
+
+    /**
+     * Get information about all open tabs
+     */
+    @api
+    async getAllTabs() {
+        if (!this.isConsole) return [];
+
+        try {
+            const tabInfo = await getAllTabInfo();
+            this.allTabs = tabInfo;
+            return tabInfo;
+        } catch (error) {
+            this._handleError('Error getting all tabs', error);
+            return [];
+        }
+    }
+
+    // =================
+    // Private Methods
+    // =================
+
+    async _getCurrentTabId() {
+        const tabInfo = await getFocusedTabInfo();
+        this.currentTabId = tabInfo.tabId;
+        return tabInfo.tabId;
+    }
+
+    async _refreshCurrentTabInfo() {
+        try {
+            const tabInfo = await getFocusedTabInfo();
+            this.currentTabId = tabInfo.tabId;
+            this.currentTabLabel = tabInfo.title;
+        } catch (error) {
+            this._handleError('Error getting tab info', error);
+        }
+    }
+
+    _handleError(message, error) {
+        console.error(message, error);
+        this.error = `${message}: ${error?.body?.message || error?.message || 'Unknown error'}`;
+    }
+
+    // Event handlers for UI (if template is used)
+    handleRefresh() {
+        this.refreshCurrentTab();
+    }
+
+    handleGetAllTabs() {
+        this.getAllTabs();
+    }
+}

package/skills/generating-lwc-components/hooks/scripts/lwc-lsp-validate.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+"""
+LWC LSP Validation Hook
+=======================
+
+This PostToolUse hook validates LWC JavaScript files (.js) after Write/Edit
+operations using the LWC Language Server (@salesforce/lwc-language-server).
+
+Behavior (Auto-fix loop):
+- Outputs errors to Claude so it can automatically fix them
+- Repeats until valid or max attempts reached
+- Complements existing 165-point SLDS 2 validation
+
+Prerequisites:
+- npm install -g @salesforce/lwc-language-server
+
+Usage:
+    Triggered automatically by hooks.json configuration
+    Input: JSON from stdin with tool_name and tool_input
+    Output: Diagnostic messages to stdout (or empty if valid)
+"""
+
+import json
+import os
+import sys
+import tempfile
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+
+# Add shared lsp-engine to path
+# The installer places lsp-engine at ~/.claude/lsp-engine/ but in a dev
+# repo checkout it lives at <repo>/shared/lsp-engine/.  Try both.
+SCRIPT_DIR = Path(__file__).parent
+PLUGIN_ROOT = SCRIPT_DIR.parent.parent
+_LSP_CANDIDATES = [
+    Path.home() / ".claude" / "lsp-engine",               # Installed path
+    PLUGIN_ROOT.parent.parent / "shared" / "lsp-engine",  # Dev repo path
+]
+LSP_ENGINE_PATH = next((p for p in _LSP_CANDIDATES if p.is_dir()), _LSP_CANDIDATES[0])
+sys.path.insert(0, str(LSP_ENGINE_PATH))
+
+# Track validation attempts to prevent infinite loops
+ATTEMPT_FILE = Path(tempfile.gettempdir()) / "lwc_lsp_attempts.json"
+MAX_ATTEMPTS = 3
+
+# LWC file extensions
+LWC_EXTENSIONS = {".js"}
+
+# LSP Severity levels
+SEVERITY_ERROR = 1
+SEVERITY_WARNING = 2
+SEVERITY_INFO = 3
+SEVERITY_HINT = 4
+
+SEVERITY_NAMES = {
+    SEVERITY_ERROR: "ERROR",
+    SEVERITY_WARNING: "WARNING",
+    SEVERITY_INFO: "INFO",
+    SEVERITY_HINT: "HINT",
+}
+
+SEVERITY_ICONS = {
+    SEVERITY_ERROR: "❌",
+    SEVERITY_WARNING: "⚠️",
+    SEVERITY_INFO: "ℹ️",
+    SEVERITY_HINT: "💡",
+}
+
+
+def get_attempt_count(file_path: str) -> int:
+    """Get the current attempt count for a file."""
+    try:
+        if ATTEMPT_FILE.exists():
+            with open(ATTEMPT_FILE, "r") as f:
+                attempts = json.load(f)
+                return attempts.get(file_path, 0)
+    except Exception:
+        pass
+    return 0
+
+
+def increment_attempt_count(file_path: str) -> int:
+    """Increment and return the attempt count for a file."""
+    attempts = {}
+    try:
+        if ATTEMPT_FILE.exists():
+            with open(ATTEMPT_FILE, "r") as f:
+                attempts = json.load(f)
+    except Exception:
+        pass
+
+    attempts[file_path] = attempts.get(file_path, 0) + 1
+    count = attempts[file_path]
+
+    try:
+        with open(ATTEMPT_FILE, "w") as f:
+            json.dump(attempts, f)
+    except Exception:
+        pass
+
+    return count
+
+
+def reset_attempt_count(file_path: str):
+    """Reset attempt count when validation succeeds."""
+    try:
+        if ATTEMPT_FILE.exists():
+            with open(ATTEMPT_FILE, "r") as f:
+                attempts = json.load(f)
+            if file_path in attempts:
+                del attempts[file_path]
+                with open(ATTEMPT_FILE, "w") as f:
+                    json.dump(attempts, f)
+    except Exception:
+        pass
+
+
+def format_lwc_diagnostics(
+    result: Dict[str, Any],
+    file_path: str,
+    max_attempts: int = 3,
+    current_attempt: int = 1,
+) -> str:
+    """
+    Format LSP validation result for Claude Code hooks.
+
+    This output is designed to be understood by Claude so it can
+    automatically fix any issues found.
+    """
+    # If LSP had an error
+    if "error" in result and result["error"]:
+        return f"⚠️ LWC LSP validation skipped: {result['error']}"
+
+    diagnostics = result.get("diagnostics", [])
+    success = result.get("success", False)
+
+    # No issues found - show success message
+    if success and not diagnostics:
+        file_name = Path(file_path).name
+        lines = []
+        lines.append(f"✅ LWC LSP Validation Passed: {file_name}")
+        lines.append("   • JavaScript syntax: OK")
+        lines.append("   • LWC decorators: OK")
+        lines.append("   • Import resolution: OK")
+        return "\n".join(lines)
+
+    # Count errors and warnings
+    error_count = sum(1 for d in diagnostics if d.get("severity", 1) == SEVERITY_ERROR)
+    warning_count = sum(1 for d in diagnostics if d.get("severity", 2) == SEVERITY_WARNING)
+
+    # Build output for Claude
+    lines = []
+
+    # Header
+    lines.append("=" * 60)
+    lines.append("⚡ LWC LSP VALIDATION RESULTS")
+    lines.append(f"   File: {file_path}")
+    lines.append(f"   Attempt: {current_attempt}/{max_attempts}")
+    lines.append("=" * 60)
+    lines.append("")
+
+    # Summary
+    if error_count > 0 or warning_count > 0:
+        lines.append(f"Found {error_count} error(s), {warning_count} warning(s)")
+        lines.append("")
+
+    # Diagnostics
+    if diagnostics:
+        lines.append("ISSUES TO FIX:")
+        lines.append("-" * 40)
+        for diag in diagnostics:
+            severity = diag.get("severity", SEVERITY_ERROR)
+            severity_name = SEVERITY_NAMES.get(severity, "UNKNOWN")
+            icon = SEVERITY_ICONS.get(severity, "❓")
+
+            message = diag.get("message", "Unknown error")
+
+            # Extract line info
+            range_info = diag.get("range", {})
+            start = range_info.get("start", {})
+            start_line = start.get("line", 0) + 1  # LSP is 0-indexed
+
+            source = diag.get("source", "lwc")
+
+            lines.append(f"{icon} [{severity_name}] line {start_line}: {message} (source: {source})")
+        lines.append("")
+
+    # Instructions for Claude
+    if error_count > 0:
+        lines.append("ACTION REQUIRED:")
+        lines.append("Please fix the LWC JavaScript errors above and try again.")
+        if current_attempt < max_attempts:
+            lines.append(f"(Attempt {current_attempt}/{max_attempts})")
+        else:
+            lines.append("⚠️ Maximum attempts reached. Manual review may be needed.")
+
+    lines.append("=" * 60)
+
+    return "\n".join(lines)
+
+
+def is_lwc_js_file(file_path: str) -> bool:
+    """Check if file is an LWC JavaScript file."""
+    path = Path(file_path)
+    # Must be .js file in an lwc folder
+    if path.suffix.lower() not in LWC_EXTENSIONS:
+        return False
+    # Must be in /lwc/ folder structure
+    if "/lwc/" not in file_path:
+        return False
+    # Skip test files
+    if ".test.js" in file_path or "__tests__" in file_path:
+        return False
+    return True
+
+
+def main():
+    """Main hook entry point."""
+    # Read hook input from stdin
+    try:
+        hook_input = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        # No input or invalid JSON - skip validation
+        sys.exit(0)
+
+    # Extract file path
+    tool_input = hook_input.get("tool_input", {})
+    file_path = tool_input.get("file_path", "")
+
+    # Only validate LWC JavaScript files
+    if not is_lwc_js_file(file_path):
+        sys.exit(0)
+
+    # Check if file exists
+    if not os.path.exists(file_path):
+        sys.exit(0)
+
+    # Track attempts
+    current_attempt = increment_attempt_count(file_path)
+
+    # If max attempts exceeded, skip validation to avoid infinite loop
+    if current_attempt > MAX_ATTEMPTS:
+        print(f"⚠️ LWC LSP validation: Maximum attempts ({MAX_ATTEMPTS}) exceeded for {file_path}")
+        print("   Manual review may be required.")
+        reset_attempt_count(file_path)  # Reset for next edit session
+        sys.exit(0)
+
+    # Try to import LSP engine
+    try:
+        from lsp_client import LSPClient
+    except ImportError as e:
+        # LSP engine not available - skip validation silently
+        # This allows the plugin to work even without LSP
+        sys.exit(0)
+
+    # Check if LWC LSP wrapper exists
+    lwc_wrapper = LSP_ENGINE_PATH / "lwc_wrapper.sh"
+    if not lwc_wrapper.exists():
+        # LWC LSP wrapper not available - skip silently
+        sys.exit(0)
+
+    # Create LSP client with LWC wrapper and language ID
+    try:
+        client = LSPClient(wrapper_path=str(lwc_wrapper), language_id="javascript")
+    except Exception as e:
+        # LSP initialization error - skip silently
+        sys.exit(0)
+
+    # Validate the file
+    try:
+        result = client.validate_file(file_path)
+    except Exception as e:
+        # Validation error - report but don't block
+        print(f"⚠️ LWC LSP validation error: {e}")
+        sys.exit(0)
+
+    # Format output
+    output = format_lwc_diagnostics(
+        result,
+        file_path,
+        max_attempts=MAX_ATTEMPTS,
+        current_attempt=current_attempt
+    )
+
+    # If no output (validation passed), reset attempt count
+    if not output:
+        reset_attempt_count(file_path)
+        sys.exit(0)
+
+    # Output diagnostics for Claude
+    print(output)
+
+
+if __name__ == "__main__":
+    main()