fraim 2.0.100

package/dist/src/cli/providers/local-provider-registry.js

@@ -0,0 +1,166 @@
+"use strict";
+// Local provider registry - fallback when server is unavailable
+// This is the original provider metadata that was in provider-registry.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalProvider = getLocalProvider;
+exports.getAllLocalProviders = getAllLocalProviders;
+exports.getAllLocalProviderIds = getAllLocalProviderIds;
+exports.isValidLocalProviderId = isValidLocalProviderId;
+exports.getLocalProviderDisplayName = getLocalProviderDisplayName;
+exports.getLocalProviderSetupInstructions = getLocalProviderSetupInstructions;
+exports.getLocalProviderConfigRequirements = getLocalProviderConfigRequirements;
+exports.localRequiresAdditionalConfig = localRequiresAdditionalConfig;
+exports.validateLocalProviderConfig = validateLocalProviderConfig;
+exports.getLocalProvidersWithCapability = getLocalProvidersWithCapability;
+exports.getLocalProviderIdsWithCapability = getLocalProviderIdsWithCapability;
+exports.localProviderHasCapability = localProviderHasCapability;
+// Local provider definitions (fallback data)
+const LOCAL_PROVIDERS = [
+    {
+        id: 'github',
+        displayName: 'GitHub',
+        description: 'GitHub repository and issue management',
+        capabilities: ['code', 'issues', 'integrated'],
+        docsUrl: 'https://docs.github.com',
+        setupInstructions: 'Create a Personal Access Token at https://github.com/settings/tokens',
+        hasAdditionalConfig: false,
+        mcpServer: {
+            type: 'http',
+            url: 'https://api.githubcopilot.com/mcp/',
+            authHeaderTemplate: 'Bearer {token}'
+        }
+    },
+    {
+        id: 'gitlab',
+        displayName: 'GitLab',
+        description: 'GitLab repository and issue management',
+        capabilities: ['code', 'issues', 'integrated'],
+        docsUrl: 'https://docs.gitlab.com',
+        setupInstructions: 'Create a Personal Access Token in your GitLab settings',
+        hasAdditionalConfig: false,
+        mcpServer: {
+            type: 'http',
+            url: 'https://gitlab.com/api/v4/mcp',
+            authHeaderTemplate: 'Bearer {token}'
+        }
+    },
+    {
+        id: 'ado',
+        displayName: 'Azure DevOps',
+        description: 'Azure DevOps repository and issue management',
+        capabilities: ['code', 'issues', 'integrated'],
+        docsUrl: 'https://docs.microsoft.com/azure/devops',
+        setupInstructions: 'Create a Personal Access Token in Azure DevOps',
+        hasAdditionalConfig: true,
+        mcpServer: {
+            type: 'stdio',
+            command: 'npx',
+            args: ['-y', '@azure-devops/mcp', '{config.organization}', '--authentication', 'envvar'],
+            envTemplate: {
+                ADO_MCP_AUTH_TOKEN: '{token}'
+            }
+        }
+    },
+    {
+        id: 'jira',
+        displayName: 'Jira',
+        description: 'Jira issue tracking and project management',
+        capabilities: ['issues'],
+        docsUrl: 'https://support.atlassian.com/jira',
+        setupInstructions: 'Create an API token at https://id.atlassian.com/manage-profile/security/api-tokens',
+        hasAdditionalConfig: true,
+        mcpServer: {
+            type: 'stdio',
+            command: 'uvx',
+            args: ['mcp-atlassian'],
+            envTemplate: {
+                JIRA_URL: '{config.baseUrl}',
+                JIRA_USERNAME: '{config.email}',
+                JIRA_API_TOKEN: '{token}'
+            }
+        }
+    }
+];
+const ADO_CONFIG_REQUIREMENTS = [
+    {
+        key: 'organization',
+        displayName: 'Azure DevOps Organization',
+        description: 'Your Azure DevOps organization name (e.g., contoso)',
+        required: true,
+        type: 'string',
+        cliOptionName: 'organization'
+    }
+];
+const JIRA_CONFIG_REQUIREMENTS = [
+    {
+        key: 'baseUrl',
+        displayName: 'Jira Instance URL',
+        description: 'Your Jira instance URL (e.g., mycompany.atlassian.net)',
+        required: true,
+        type: 'url',
+        cliOptionName: 'url'
+    },
+    {
+        key: 'email',
+        displayName: 'Email Address',
+        description: 'Your Jira account email address',
+        required: true,
+        type: 'email'
+    }
+];
+function getLocalProvider(id) {
+    return LOCAL_PROVIDERS.find(p => p.id === id);
+}
+function getAllLocalProviders() {
+    return [...LOCAL_PROVIDERS];
+}
+function getAllLocalProviderIds() {
+    return LOCAL_PROVIDERS.map(p => p.id);
+}
+function isValidLocalProviderId(id) {
+    return LOCAL_PROVIDERS.some(p => p.id === id);
+}
+function getLocalProviderDisplayName(providerId) {
+    const provider = getLocalProvider(providerId);
+    return provider?.displayName || providerId;
+}
+function getLocalProviderSetupInstructions(providerId) {
+    const provider = getLocalProvider(providerId);
+    return provider?.setupInstructions || '';
+}
+function getLocalProviderConfigRequirements(providerId) {
+    if (providerId === 'ado') {
+        return ADO_CONFIG_REQUIREMENTS;
+    }
+    if (providerId === 'jira') {
+        return JIRA_CONFIG_REQUIREMENTS;
+    }
+    return [];
+}
+function localRequiresAdditionalConfig(providerId) {
+    return getLocalProviderConfigRequirements(providerId).length > 0;
+}
+function validateLocalProviderConfig(providerId, config) {
+    const requirements = getLocalProviderConfigRequirements(providerId);
+    const missing = [];
+    for (const req of requirements) {
+        if (req.required && !config[req.key]) {
+            missing.push(req.key);
+        }
+    }
+    return {
+        valid: missing.length === 0,
+        missing
+    };
+}
+function getLocalProvidersWithCapability(capability) {
+    return LOCAL_PROVIDERS.filter(provider => provider.capabilities.includes(capability));
+}
+function getLocalProviderIdsWithCapability(capability) {
+    const providers = getLocalProvidersWithCapability(capability);
+    return providers.map(p => p.id);
+}
+function localProviderHasCapability(providerId, capability) {
+    const provider = getLocalProvider(providerId);
+    return provider ? provider.capabilities.includes(capability) : false;
+}

package/dist/src/cli/providers/provider-registry.js

@@ -0,0 +1,230 @@
+"use strict";
+// Provider Registry - Client stub that fetches from server
+// This file maintains the same API as before but calls the server instead of using local data
+// Falls back to local registry when server is unavailable (for tests and offline usage)
+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.getProvider = getProvider;
+exports.getAllProviders = getAllProviders;
+exports.getAllProviderIds = getAllProviderIds;
+exports.isValidProviderId = isValidProviderId;
+exports.getProviderDisplayName = getProviderDisplayName;
+exports.getProviderSetupInstructions = getProviderSetupInstructions;
+exports.getProviderConfigRequirements = getProviderConfigRequirements;
+exports.requiresAdditionalConfig = requiresAdditionalConfig;
+exports.validateProviderConfig = validateProviderConfig;
+exports.getProvidersWithCapability = getProvidersWithCapability;
+exports.getProviderIdsWithCapability = getProviderIdsWithCapability;
+exports.providerHasCapability = providerHasCapability;
+const get_provider_client_1 = require("../api/get-provider-client");
+const local = __importStar(require("./local-provider-registry"));
+// ============================================================================
+// CACHE
+// ============================================================================
+let cachedProviders = null;
+const schemaCache = new Map();
+let useLocalFallback = false;
+async function fetchProviders() {
+    // Don't use cache in test environment to avoid stale data
+    const useCache = process.env.NODE_ENV !== 'test';
+    if (useCache && cachedProviders)
+        return cachedProviders;
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            const providers = await client.getAllProviders();
+            if (useCache) {
+                cachedProviders = providers;
+            }
+            return providers;
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            console.warn('⚠️  Using local provider registry (server unavailable)');
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    const providers = local.getAllLocalProviders();
+    if (useCache) {
+        cachedProviders = providers;
+    }
+    return providers;
+}
+async function fetchProviderSchema(id) {
+    if (schemaCache.has(id)) {
+        return schemaCache.get(id);
+    }
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            const schema = await client.getProviderSchema(id);
+            schemaCache.set(id, schema.configRequirements);
+            return schema.configRequirements;
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    const requirements = local.getLocalProviderConfigRequirements(id);
+    schemaCache.set(id, requirements);
+    return requirements;
+}
+// ============================================================================
+// REGISTRY LOOKUP FUNCTIONS (Same API as before, but async)
+// ============================================================================
+async function getProvider(id) {
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            const provider = await client.getProvider(id);
+            return provider || undefined;
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            console.warn('⚠️  Using local provider registry (server unavailable)');
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    const provider = local.getLocalProvider(id);
+    return provider;
+}
+async function getAllProviders() {
+    return await fetchProviders();
+}
+async function getAllProviderIds() {
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            return await client.getAllProviderIds();
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    return local.getAllLocalProviderIds();
+}
+async function isValidProviderId(id) {
+    const providers = await fetchProviders();
+    return providers.some(p => p.id === id);
+}
+async function getProviderDisplayName(providerId) {
+    const provider = await getProvider(providerId);
+    return provider?.displayName || providerId;
+}
+async function getProviderSetupInstructions(providerId) {
+    const provider = await getProvider(providerId);
+    return provider?.setupInstructions || '';
+}
+async function getProviderConfigRequirements(providerId) {
+    return await fetchProviderSchema(providerId);
+}
+async function requiresAdditionalConfig(providerId) {
+    const requirements = await getProviderConfigRequirements(providerId);
+    return requirements.length > 0;
+}
+async function validateProviderConfig(providerId, config) {
+    const requirements = await getProviderConfigRequirements(providerId);
+    const missing = [];
+    for (const req of requirements) {
+        if (req.required && !config[req.key]) {
+            missing.push(req.key);
+        }
+    }
+    return {
+        valid: missing.length === 0,
+        missing
+    };
+}
+// ============================================================================
+// CAPABILITY FILTERING FUNCTIONS
+// ============================================================================
+async function getProvidersWithCapability(capability) {
+    // In test environment, always try server first (don't persist fallback flag)
+    const shouldTryServer = process.env.NODE_ENV === 'test' || !useLocalFallback;
+    // Try server first
+    if (shouldTryServer) {
+        try {
+            const client = (0, get_provider_client_1.getProviderClient)();
+            return await client.getProvidersWithCapability(capability);
+        }
+        catch (error) {
+            // Server unavailable - use local fallback
+            // Only persist fallback flag in non-test environments
+            if (process.env.NODE_ENV !== 'test') {
+                useLocalFallback = true;
+            }
+        }
+    }
+    // Use local fallback
+    return local.getLocalProvidersWithCapability(capability);
+}
+async function getProviderIdsWithCapability(capability) {
+    const providers = await getProvidersWithCapability(capability);
+    return providers.map(p => p.id);
+}
+async function providerHasCapability(providerId, capability) {
+    const provider = await getProvider(providerId);
+    return provider ? provider.capabilities.includes(capability) : false;
+}