@hailer/mcp 0.1.16 → 0.2.1

package/dist/client/services/workspace-schema-cache.js

@@ -1,732 +0,0 @@
-"use strict";
-/**
- * Workspace Schema Cache Service
- *
- * Dynamically discovers and caches workflow schemas per workspace.
- * Replaces hardcoded workflow/field IDs with runtime lookup.
- *
- * WORKSPACE ISOLATION: Each workspace gets its own workflow IDs.
- * Never use hardcoded IDs - always lookup via this cache.
- *
- * CACHING STRATEGY:
- * 1. Check file cache first (~/.hailer-mcp/schema-cache-{workspaceId}.json)
- * 2. If valid cache exists, load from file (0 API calls)
- * 3. If no cache, discover via API and save to file
- * 4. Cache is valid for 7 days (configurable)
- *
- * On bot startup:
- * 1. Check file cache
- * 2. If cache miss: Query list_workflows to find AI Agent workflows by name
- * 3. If missing, install them from marketplace
- * 4. Query get_workflow_schema to get field IDs
- * 5. Save to file cache
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkspaceSchemaCacheService = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-/** Cache directory for schema files */
-const CACHE_DIR = path.join(os.homedir(), ".hailer-mcp");
-const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-/** AI Agent template ID in marketplace (HR for AI Agents) */
-const AI_AGENT_TEMPLATE_ID = "685ab3c39af7445dd5384ffd";
-/** Known workflow names from the AI Agent template (partial match, case insensitive) */
-const TEMPLATE_WORKFLOW_PATTERNS = {
-    SESSION_LOG: ["session log", "session_log"],
-    AGENT_DIRECTORY: ["agent directory", "agent_directory"],
-    POSITIONS: ["positions", "position"],
-    TEAMS: ["teams", "team"],
-    TOOL_REGISTRY: ["tool registry", "tool_registry", "mcp server"],
-    MCP_CONFIG: ["mcp config", "mcp_config", "mcp configuration"],
-};
-/** Known field labels we need to look up */
-const SESSION_LOG_FIELD_LABELS = {
-    contextSummary: "Context summary",
-    previousLog: "Previus log entry", // Note: typo in original template
-    linkedWork: "Most relevant link to work",
-    cost: "Tokens Used",
-    madeBy: "Log entry made by",
-};
-const AGENT_DIRECTORY_FIELD_LABELS = {
-    firstName: "First name",
-    lastName: "Last name",
-    description: "Description",
-    email: "Email",
-    password: "Password",
-    hailerProfile: "Hailer profile",
-    team: "Team",
-    supervisor: "Supervisor",
-    memory: "Memory",
-    position: "Position",
-    startDate: "Start date",
-};
-const POSITIONS_FIELD_LABELS = {
-    purpose: "Purpose",
-    personaTone: "Persona / Tone",
-    coreCapabilities: "Core Capabilities",
-    boundaries: "Boundaries",
-    agentCount: "Agents in this position",
-    multiAllowed: "Multi allowed",
-};
-const TEAMS_FIELD_LABELS = {
-    info: "Info",
-    leader: "Leader",
-};
-const TOOL_REGISTRY_FIELD_LABELS = {
-    baseUrl: "Base URL",
-    protocolVersion: "Protocol Version",
-    toolRegistry: "Tool Registry",
-    logEntryBy: "Log entry by",
-};
-const MCP_CONFIG_FIELD_LABELS = {
-    agentName: "Agent Name",
-    agentId: "Agent ID",
-    publicKey: "Public Key",
-    accessTo: "Access To",
-    authToken: "Auth Token",
-    apiKey: "API Key",
-    workspaceId: "Workspace ID",
-    permissions: "Permissions",
-    sessionId: "Session ID",
-    resourceLimits: "Resource Limits",
-    loggingEndpoint: "Logging Endpoint",
-    callbackUrl: "Callback URL",
-    customContext: "Custom Context",
-    permCreate: "Create",
-    permRead: "Read",
-    permUpdate: "Update",
-    permDelete: "Delete",
-};
-class WorkspaceSchemaCacheService {
-    logger;
-    callMcpTool;
-    cache = new Map();
-    constructor(logger, callMcpTool) {
-        this.logger = logger;
-        this.callMcpTool = callMcpTool;
-        // Ensure cache directory exists
-        this.ensureCacheDir();
-    }
-    /**
-     * Ensure cache directory exists
-     */
-    ensureCacheDir() {
-        try {
-            if (!fs.existsSync(CACHE_DIR)) {
-                fs.mkdirSync(CACHE_DIR, { recursive: true });
-            }
-        }
-        catch (error) {
-            this.logger.warn("Failed to create cache directory", {
-                dir: CACHE_DIR,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    /**
-     * Get cache file path for a workspace
-     */
-    getCacheFilePath(workspaceId) {
-        return path.join(CACHE_DIR, `schema-cache-${workspaceId}.json`);
-    }
-    /**
-     * Load schemas from file cache
-     * Returns null if cache doesn't exist or is expired
-     */
-    loadFromFileCache(workspaceId) {
-        const filePath = this.getCacheFilePath(workspaceId);
-        try {
-            if (!fs.existsSync(filePath)) {
-                return null;
-            }
-            const data = fs.readFileSync(filePath, "utf-8");
-            const schemas = JSON.parse(data);
-            // Check TTL
-            if (schemas.cachedAt && Date.now() - schemas.cachedAt > CACHE_TTL_MS) {
-                this.logger.debug("File cache expired", { workspaceId, cachedAt: schemas.cachedAt });
-                return null;
-            }
-            this.logger.info("Loaded schemas from file cache", {
-                workspaceId,
-                cachedAt: schemas.cachedAt ? new Date(schemas.cachedAt).toISOString() : "unknown",
-            });
-            return schemas;
-        }
-        catch (error) {
-            this.logger.warn("Failed to load file cache", {
-                filePath,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return null;
-        }
-    }
-    /**
-     * Save schemas to file cache
-     */
-    saveToFileCache(schemas) {
-        const filePath = this.getCacheFilePath(schemas.workspaceId);
-        try {
-            schemas.cachedAt = Date.now();
-            fs.writeFileSync(filePath, JSON.stringify(schemas, null, 2), "utf-8");
-            this.logger.debug("Saved schemas to file cache", { filePath });
-        }
-        catch (error) {
-            this.logger.warn("Failed to save file cache", {
-                filePath,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    /**
-     * Initialize schema cache for a workspace
-     * Call this on bot startup after connecting to Hailer
-     */
-    async initializeForWorkspace(workspaceId) {
-        // 1. Check memory cache first
-        const existing = this.cache.get(workspaceId);
-        if (existing?.initialized) {
-            this.logger.debug("Using memory-cached workspace schemas", { workspaceId });
-            return existing;
-        }
-        // 2. Check file cache (persists across restarts)
-        const fileCache = this.loadFromFileCache(workspaceId);
-        if (fileCache?.initialized) {
-            this.cache.set(workspaceId, fileCache);
-            return fileCache;
-        }
-        // 3. Discover via API (expensive - only on first run or cache expiry)
-        this.logger.info("Discovering workspace schemas via API", { workspaceId });
-        const schemas = {
-            workspaceId,
-            initialized: false,
-        };
-        try {
-            // Fetch all workflows in workspace
-            const workflowsResult = await this.callMcpTool("list_workflows", {
-                workspace: workspaceId,
-            });
-            const workflowsText = workflowsResult?.content?.[0]?.text;
-            if (!workflowsText) {
-                this.logger.warn("No workflows found in workspace", { workspaceId });
-                schemas.initialized = true;
-                this.cache.set(workspaceId, schemas);
-                return schemas;
-            }
-            // Parse workflows
-            const workflows = this.parseWorkflows(workflowsText);
-            this.logger.debug("Found workflows", { workspaceId, count: workflows.length });
-            // Find template workflows
-            this.mapWorkflowsToSchemas(workflows, schemas);
-            // Check if required workflows are missing
-            const missingRequired = !schemas.sessionLog || !schemas.agentDirectory;
-            if (missingRequired) {
-                this.logger.info("AI Agent workflows not found, installing from marketplace", { workspaceId });
-                const installed = await this.installAgentTemplate(workspaceId);
-                if (installed) {
-                    // Re-fetch workflows after installation
-                    const refreshResult = await this.callMcpTool("list_workflows", {
-                        workspace: workspaceId,
-                    });
-                    const refreshText = refreshResult?.content?.[0]?.text;
-                    if (refreshText) {
-                        const refreshedWorkflows = this.parseWorkflows(refreshText);
-                        this.mapWorkflowsToSchemas(refreshedWorkflows, schemas);
-                    }
-                }
-            }
-            // Load detailed schemas for found workflows
-            await this.loadDetailedSchemas(schemas);
-            schemas.initialized = true;
-            this.cache.set(workspaceId, schemas);
-            // Save to file cache for next startup
-            this.saveToFileCache(schemas);
-            this.logger.info("Workspace schemas cached", {
-                workspaceId,
-                hasSessionLog: !!schemas.sessionLog,
-                hasAgentDirectory: !!schemas.agentDirectory,
-                hasPositions: !!schemas.positions,
-            });
-            return schemas;
-        }
-        catch (error) {
-            this.logger.error("Failed to initialize workspace schemas", {
-                workspaceId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            schemas.initialized = true; // Mark as initialized even on error to prevent retry loops
-            this.cache.set(workspaceId, schemas);
-            return schemas;
-        }
-    }
-    /**
-     * Get cached schemas for a workspace
-     */
-    getSchemas(workspaceId) {
-        return this.cache.get(workspaceId);
-    }
-    /**
-     * Get Session Log schema for a workspace
-     */
-    getSessionLogSchema(workspaceId) {
-        return this.cache.get(workspaceId)?.sessionLog;
-    }
-    /**
-     * Get Agent Directory schema for a workspace
-     */
-    getAgentDirectorySchema(workspaceId) {
-        return this.cache.get(workspaceId)?.agentDirectory;
-    }
-    /**
-     * Get Positions schema for a workspace
-     */
-    getPositionsSchema(workspaceId) {
-        return this.cache.get(workspaceId)?.positions;
-    }
-    /**
-     * Get Teams schema for a workspace
-     */
-    getTeamsSchema(workspaceId) {
-        return this.cache.get(workspaceId)?.teams;
-    }
-    /**
-     * Get Tool Registry schema for a workspace
-     */
-    getToolRegistrySchema(workspaceId) {
-        return this.cache.get(workspaceId)?.toolRegistry;
-    }
-    /**
-     * Get MCP Config schema for a workspace
-     */
-    getMcpConfigSchema(workspaceId) {
-        return this.cache.get(workspaceId)?.mcpConfig;
-    }
-    /**
-     * Check if a workspace has the AI Agent template installed
-     */
-    hasAgentTemplate(workspaceId) {
-        const schemas = this.cache.get(workspaceId);
-        return !!(schemas?.sessionLog && schemas?.agentDirectory);
-    }
-    /**
-     * Check if workflow name matches a pattern (case insensitive, ignores emojis)
-     */
-    matchesPattern(workflowName, patterns) {
-        // Normalize: lowercase, remove emojis and extra whitespace
-        const normalized = workflowName
-            .toLowerCase()
-            .replace(/[\u{1F300}-\u{1F9FF}]/gu, "") // Remove emojis
-            .replace(/\s+/g, " ")
-            .trim();
-        return patterns.some(pattern => normalized.includes(pattern));
-    }
-    /**
-     * Map workflow list to schema slots (using pattern matching)
-     */
-    mapWorkflowsToSchemas(workflows, schemas) {
-        for (const workflow of workflows) {
-            // Filter by workspace if specified
-            if (schemas.workspaceId && workflow.workspaceId && workflow.workspaceId !== schemas.workspaceId) {
-                continue;
-            }
-            if (this.matchesPattern(workflow.name, TEMPLATE_WORKFLOW_PATTERNS.SESSION_LOG)) {
-                schemas.sessionLog = { workflowId: workflow.id, name: workflow.name, phases: {}, fields: {} };
-            }
-            else if (this.matchesPattern(workflow.name, TEMPLATE_WORKFLOW_PATTERNS.AGENT_DIRECTORY)) {
-                schemas.agentDirectory = { workflowId: workflow.id, name: workflow.name, phases: {}, fields: {} };
-            }
-            else if (this.matchesPattern(workflow.name, TEMPLATE_WORKFLOW_PATTERNS.POSITIONS)) {
-                schemas.positions = { workflowId: workflow.id, name: workflow.name, phases: {}, fields: {} };
-            }
-            else if (this.matchesPattern(workflow.name, TEMPLATE_WORKFLOW_PATTERNS.TEAMS) && workflow.name.toLowerCase().includes("team")) {
-                // Be more specific for Teams to avoid matching "Teams" workflow in sports data
-                if (workflow.name.includes("🎖️") || workflow.name.toLowerCase() === "teams") {
-                    schemas.teams = { workflowId: workflow.id, name: workflow.name, phases: {}, fields: {} };
-                }
-            }
-            else if (this.matchesPattern(workflow.name, TEMPLATE_WORKFLOW_PATTERNS.TOOL_REGISTRY)) {
-                schemas.toolRegistry = { workflowId: workflow.id, name: workflow.name, phases: {}, fields: {} };
-            }
-            else if (this.matchesPattern(workflow.name, TEMPLATE_WORKFLOW_PATTERNS.MCP_CONFIG)) {
-                schemas.mcpConfig = { workflowId: workflow.id, name: workflow.name, phases: {}, fields: {} };
-            }
-        }
-    }
-    /**
-     * Load detailed schemas (phases, fields) for all found workflows
-     */
-    async loadDetailedSchemas(schemas) {
-        if (schemas.sessionLog) {
-            await this.loadWorkflowSchemaDetails(schemas.sessionLog);
-            this.mapFieldLabelsToIds(schemas.sessionLog, SESSION_LOG_FIELD_LABELS);
-        }
-        if (schemas.agentDirectory) {
-            await this.loadWorkflowSchemaDetails(schemas.agentDirectory);
-            this.mapFieldLabelsToIds(schemas.agentDirectory, AGENT_DIRECTORY_FIELD_LABELS);
-        }
-        if (schemas.positions) {
-            await this.loadWorkflowSchemaDetails(schemas.positions);
-            this.mapFieldLabelsToIds(schemas.positions, POSITIONS_FIELD_LABELS);
-        }
-        if (schemas.teams) {
-            await this.loadWorkflowSchemaDetails(schemas.teams);
-            this.mapFieldLabelsToIds(schemas.teams, TEAMS_FIELD_LABELS);
-        }
-        if (schemas.toolRegistry) {
-            await this.loadWorkflowSchemaDetails(schemas.toolRegistry);
-            this.mapFieldLabelsToIds(schemas.toolRegistry, TOOL_REGISTRY_FIELD_LABELS);
-        }
-        if (schemas.mcpConfig) {
-            await this.loadWorkflowSchemaDetails(schemas.mcpConfig);
-            this.mapFieldLabelsToIds(schemas.mcpConfig, MCP_CONFIG_FIELD_LABELS);
-        }
-    }
-    /**
-     * Install AI Agent template from marketplace
-     */
-    async installAgentTemplate(workspaceId) {
-        try {
-            // First try to find the template by name in marketplace
-            const templatesResult = await this.callMcpTool("list_templates", {
-                publicOnly: true,
-            });
-            let templateId = AI_AGENT_TEMPLATE_ID;
-            const templatesText = templatesResult?.content?.[0]?.text;
-            if (templatesText) {
-                try {
-                    const parsed = JSON.parse(templatesText);
-                    const templates = parsed.templates || parsed.data || parsed;
-                    if (Array.isArray(templates)) {
-                        const agentTemplate = templates.find((t) => t.name?.includes("AI Agent") || t.title?.includes("AI Agent"));
-                        if (agentTemplate?._id) {
-                            templateId = agentTemplate._id;
-                        }
-                    }
-                }
-                catch {
-                    // Use default template ID
-                }
-            }
-            this.logger.info("Installing AI Agent template", { workspaceId, templateId });
-            const installResult = await this.callMcpTool("install_template", {
-                templateId,
-                workspaceId,
-            });
-            const installText = installResult?.content?.[0]?.text || "";
-            // Check for explicit error indicators
-            const hasError = installText.toLowerCase().includes("error") ||
-                installText.toLowerCase().includes("not found") ||
-                installText.toLowerCase().includes("failed");
-            const hasSuccess = installText.toLowerCase().includes("success") ||
-                installText.toLowerCase().includes("installed") ||
-                installText.toLowerCase().includes("created");
-            const success = hasSuccess && !hasError;
-            if (success) {
-                this.logger.info("AI Agent template installed successfully", { workspaceId });
-            }
-            else {
-                this.logger.warn("Template installation failed", {
-                    workspaceId,
-                    response: installText.substring(0, 300),
-                });
-            }
-            return success;
-        }
-        catch (error) {
-            this.logger.error("Failed to install AI Agent template", {
-                workspaceId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return false;
-        }
-    }
-    /**
-     * Parse workflows from list_workflows response
-     * Handles both raw JSON and markdown-wrapped JSON responses
-     */
-    parseWorkflows(text) {
-        const workflows = [];
-        try {
-            // First, try to extract JSON array from markdown-wrapped response
-            // The response often has: "📋 **18 Workflows Found**\n\n[\n  {...}\n]\n\n🔗 **Relationships**..."
-            let jsonText = text;
-            // Try to extract JSON array from markdown
-            const jsonArrayMatch = text.match(/\[\s*\{[\s\S]*?\}\s*\]/);
-            if (jsonArrayMatch) {
-                jsonText = jsonArrayMatch[0];
-            }
-            const parsed = JSON.parse(jsonText);
-            const items = Array.isArray(parsed) ? parsed : (parsed.workflows || parsed.data || []);
-            if (Array.isArray(items)) {
-                for (const item of items) {
-                    // Support both `id` and `_id` field names
-                    const id = item.id || item._id;
-                    const name = item.name;
-                    const workspaceId = item.workspaceId;
-                    if (id && name) {
-                        workflows.push({ id, name, workspaceId });
-                    }
-                }
-            }
-        }
-        catch {
-            // Fallback: regex extraction for both id and _id patterns
-            const idMatches = text.matchAll(/"(?:id|_id)":\s*"([a-f0-9]{24})"/gi);
-            const nameMatches = text.matchAll(/"name":\s*"([^"]+)"/gi);
-            const wsMatches = text.matchAll(/"workspaceId":\s*"([a-f0-9]{24})"/gi);
-            const ids = [...idMatches].map(m => m[1]);
-            const names = [...nameMatches].map(m => m[1]);
-            const wsIds = [...wsMatches].map(m => m[1]);
-            for (let i = 0; i < Math.min(ids.length, names.length); i++) {
-                workflows.push({
-                    id: ids[i],
-                    name: names[i],
-                    workspaceId: wsIds[i],
-                });
-            }
-        }
-        this.logger.debug("Parsed workflows from response", { count: workflows.length });
-        return workflows;
-    }
-    /**
-     * Load detailed workflow schema (phases and fields) for an existing schema
-     */
-    async loadWorkflowSchemaDetails(schema) {
-        try {
-            // Get phases first
-            const phasesResult = await this.callMcpTool("list_workflow_phases", {
-                workflowId: schema.workflowId,
-            });
-            const phasesText = phasesResult?.content?.[0]?.text;
-            if (phasesText) {
-                this.parsePhases(phasesText, schema);
-            }
-            this.logger.debug("Parsed phases for workflow", {
-                workflowId: schema.workflowId,
-                workflowName: schema.name,
-                phaseCount: Object.keys(schema.phases).length,
-                phases: Object.keys(schema.phases),
-            });
-            // Get schema with fields (use first phase)
-            const firstPhaseId = Object.values(schema.phases)[0];
-            if (firstPhaseId) {
-                const schemaResult = await this.callMcpTool("get_workflow_schema", {
-                    workflowId: schema.workflowId,
-                    phaseId: firstPhaseId,
-                });
-                const schemaText = schemaResult?.content?.[0]?.text;
-                if (schemaText) {
-                    this.parseFields(schemaText, schema);
-                    this.logger.debug("Parsed fields for workflow", {
-                        workflowId: schema.workflowId,
-                        workflowName: schema.name,
-                        fieldCount: Object.keys(schema.fields).length,
-                        fieldKeys: Object.keys(schema.fields).slice(0, 10), // First 10 keys
-                    });
-                }
-                else {
-                    this.logger.warn("No schema text returned from get_workflow_schema", {
-                        workflowId: schema.workflowId,
-                    });
-                }
-            }
-            else {
-                this.logger.warn("No phase ID found - skipping field schema load", {
-                    workflowId: schema.workflowId,
-                    workflowName: schema.name,
-                });
-            }
-        }
-        catch (error) {
-            this.logger.warn("Failed to load workflow schema details", {
-                workflowId: schema.workflowId,
-                workflowName: schema.name,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    /**
-     * Parse phases from list_workflow_phases response
-     * Format: 1. **PhaseName**\n   - Phase ID: `phaseId`
-     */
-    parsePhases(text, schema) {
-        this.logger.debug("Parsing phases text", {
-            workflowId: schema.workflowId,
-            textLength: text.length,
-            textPreview: text.substring(0, 500),
-        });
-        try {
-            const parsed = JSON.parse(text);
-            const phases = parsed.phases || parsed.data || parsed;
-            if (Array.isArray(phases)) {
-                for (const phase of phases) {
-                    if (phase.id && phase.name) {
-                        schema.phases[phase.name.toLowerCase()] = phase.id;
-                    }
-                    else if (phase._id && phase.name) {
-                        schema.phases[phase.name.toLowerCase()] = phase._id;
-                    }
-                }
-            }
-        }
-        catch {
-            // Markdown format: **PhaseName**\n   - Phase ID: `phaseId`
-            // Match pattern: \d+\. **Name** ... Phase ID: `id`
-            const phaseBlocks = text.split(/\d+\.\s*\*\*/).filter(Boolean);
-            for (const block of phaseBlocks) {
-                const nameMatch = block.match(/^([^*]+)\*\*/);
-                const phaseIdMatch = block.match(/Phase ID:\s*`([a-f0-9]{24})`/i);
-                if (nameMatch && phaseIdMatch) {
-                    const phaseName = nameMatch[1].trim();
-                    const phaseId = phaseIdMatch[1];
-                    schema.phases[phaseName.toLowerCase()] = phaseId;
-                }
-            }
-        }
-    }
-    /**
-     * Parse fields from get_workflow_schema response
-     * Stores fields by both label and key for flexible lookup
-     */
-    parseFields(text, schema) {
-        try {
-            const parsed = JSON.parse(text);
-            const fields = parsed.fields || parsed.data || parsed;
-            if (Array.isArray(fields)) {
-                for (const field of fields) {
-                    const fieldId = field.id || field._id || field.fieldId;
-                    const label = field.label || field.name;
-                    const key = field.key;
-                    if (fieldId && label) {
-                        schema.fields[label] = fieldId;
-                    }
-                    // Also store by key for direct lookup (e.g., "firstName" -> fieldId)
-                    if (fieldId && key) {
-                        schema.fields[key] = fieldId;
-                    }
-                }
-            }
-            else if (typeof fields === "object") {
-                // Handle object format {fieldId: {label, type, key, ...}}
-                for (const [fieldId, fieldData] of Object.entries(fields)) {
-                    const data = fieldData;
-                    const label = data.label || data.name;
-                    const key = data.key;
-                    if (label) {
-                        schema.fields[label] = fieldId;
-                    }
-                    // Also store by key
-                    if (key) {
-                        schema.fields[key] = fieldId;
-                    }
-                }
-            }
-        }
-        catch {
-            // Regex fallback for markdown format:
-            // **Label**
-            //    - Field ID: `fieldId`
-            //    - Key: `key`
-            const fieldBlocks = text.split(/\d+\.\s*\*\*/).filter(Boolean);
-            for (const block of fieldBlocks) {
-                const labelMatch = block.match(/^([^*\n]+)\*\*/);
-                const fieldIdMatch = block.match(/Field ID:\s*`([a-f0-9]{24})`/i);
-                const keyMatch = block.match(/Key:\s*`(\w+)`/i);
-                if (fieldIdMatch) {
-                    const fieldId = fieldIdMatch[1];
-                    if (labelMatch) {
-                        schema.fields[labelMatch[1].trim()] = fieldId;
-                    }
-                    if (keyMatch) {
-                        schema.fields[keyMatch[1]] = fieldId;
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Map field keys to their IDs in the schema
-     * Since parseFields now stores by key directly, this is a no-op
-     * Kept for backwards compatibility but does nothing
-     */
-    mapFieldLabelsToIds(_schema, _keyMap) {
-        // parseFields now stores fields by key directly, so this is a no-op
-    }
-    /**
-     * Clear cache for a workspace (clears both memory and file cache)
-     */
-    clearCache(workspaceId) {
-        if (workspaceId) {
-            // Clear memory cache
-            this.cache.delete(workspaceId);
-            // Clear file cache
-            const filePath = this.getCacheFilePath(workspaceId);
-            try {
-                if (fs.existsSync(filePath)) {
-                    fs.unlinkSync(filePath);
-                    this.logger.info("Cleared file cache", { workspaceId });
-                }
-            }
-            catch (error) {
-                this.logger.warn("Failed to clear file cache", {
-                    filePath,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        else {
-            // Clear all memory cache
-            this.cache.clear();
-            // Clear all file caches
-            try {
-                const files = fs.readdirSync(CACHE_DIR).filter(f => f.startsWith("schema-cache-"));
-                for (const file of files) {
-                    fs.unlinkSync(path.join(CACHE_DIR, file));
-                }
-                if (files.length > 0) {
-                    this.logger.info("Cleared all file caches", { count: files.length });
-                }
-            }
-            catch (error) {
-                this.logger.warn("Failed to clear all file caches", {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-    }
-}
-exports.WorkspaceSchemaCacheService = WorkspaceSchemaCacheService;
-//# sourceMappingURL=workspace-schema-cache.js.map