fraim-framework 2.0.81 → 2.0.83

package/dist/src/cli/setup/provider-prompts.js

@@ -0,0 +1,300 @@
+"use strict";
+// Generic provider prompt system - no hardcoded provider knowledge
+// All provider information comes from the server via ProviderClient
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForProviders = promptForProviders;
+exports.promptForSingleProvider = promptForSingleProvider;
+exports.promptForProviderToken = promptForProviderToken;
+exports.promptForProviderConfig = promptForProviderConfig;
+exports.promptForProviderCredentials = promptForProviderCredentials;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+/**
+ * Prompt user to select multiple providers
+ */
+async function promptForProviders(client, preselectedIds) {
+    console.log(chalk_1.default.blue('\n🔧 Platform Selection'));
+    console.log(chalk_1.default.gray('Which platforms do you want to integrate with?\n'));
+    // Get providers that support integrated mode
+    const integratedProviders = await client.getProvidersWithCapability('integrated');
+    // Default to first integrated provider (typically GitHub)
+    const defaultProviderId = integratedProviders[0]?.id;
+    const choices = integratedProviders.map(provider => ({
+        title: provider.displayName,
+        value: provider.id,
+        selected: preselectedIds?.includes(provider.id) ?? provider.id === defaultProviderId
+    }));
+    const response = await (0, prompts_1.default)({
+        type: 'multiselect',
+        name: 'providers',
+        message: 'Select platforms (Space to select, Enter to confirm)',
+        choices,
+        min: 1
+    });
+    if (!response.providers || response.providers.length === 0) {
+        const defaultProvider = await client.getProvider(defaultProviderId);
+        console.log(chalk_1.default.yellow(`\nℹ️  No platforms selected, defaulting to ${defaultProvider?.displayName || 'first available provider'}`));
+        return [defaultProviderId];
+    }
+    console.log(chalk_1.default.blue('\n✓ Selected platforms:'));
+    for (const id of response.providers) {
+        const provider = await client.getProvider(id);
+        if (provider) {
+            console.log(chalk_1.default.gray(`  - ${provider.displayName}`));
+        }
+    }
+    console.log();
+    return response.providers;
+}
+/**
+ * Prompt user to select a single provider (for code repo or issue tracking)
+ */
+async function promptForSingleProvider(client, purpose, availableIds) {
+    const purposeLabel = purpose === 'code' ? 'Code Repository' : 'Issue Tracking';
+    const purposeDesc = purpose === 'code' ? 'code hosting' : 'issue tracking';
+    console.log(chalk_1.default.blue(`\n📦 ${purposeLabel} Platform`));
+    console.log(chalk_1.default.gray(`Select the platform for ${purposeDesc}:\n`));
+    // Use capability-based filtering if no explicit filter provided
+    let providers;
+    if (availableIds) {
+        providers = [];
+        for (const id of availableIds) {
+            const provider = await client.getProvider(id);
+            if (provider)
+                providers.push(provider);
+        }
+    }
+    else {
+        providers = await client.getProvidersWithCapability(purpose);
+    }
+    // Default to first available provider
+    const defaultProviderId = providers[0]?.id;
+    const choices = providers.map(provider => ({
+        title: provider.displayName,
+        value: provider.id
+    }));
+    const response = await (0, prompts_1.default)({
+        type: 'select',
+        name: 'provider',
+        message: `Select ${purposeDesc} platform`,
+        choices,
+        initial: 0
+    });
+    if (!response.provider) {
+        const defaultProvider = await client.getProvider(defaultProviderId);
+        console.log(chalk_1.default.yellow(`\nℹ️  No platform selected, defaulting to ${defaultProvider?.displayName || 'first available provider'}`));
+        return defaultProviderId;
+    }
+    const provider = await client.getProvider(response.provider);
+    if (provider) {
+        console.log(chalk_1.default.blue(`\n✓ ${purposeLabel}: ${provider.displayName}\n`));
+    }
+    return response.provider;
+}
+/**
+ * Prompt for a provider's token
+ */
+async function promptForProviderToken(client, providerId) {
+    let provider;
+    try {
+        provider = await client.getProvider(providerId);
+    }
+    catch (error) {
+        // Server unavailable - use local fallback
+        const { getLocalProvider } = await Promise.resolve().then(() => __importStar(require('../providers/local-provider-registry')));
+        provider = getLocalProvider(providerId);
+    }
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    console.log(chalk_1.default.blue(`\n🔧 ${provider.displayName} Integration Setup`));
+    console.log(`FRAIM requires a ${provider.displayName} token for integration.\n`);
+    const hasToken = await (0, prompts_1.default)({
+        type: 'confirm',
+        name: 'hasToken',
+        message: `Do you have a ${provider.displayName} token?`,
+        initial: false
+    });
+    if (!hasToken.hasToken) {
+        console.log(chalk_1.default.yellow(`\n📝 To create a ${provider.displayName} token:`));
+        console.log(chalk_1.default.gray(`   ${provider.setupInstructions}`));
+        console.log(chalk_1.default.gray(`   Visit: ${provider.docsUrl}\n`));
+    }
+    let token = null;
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (!token && attempts < maxAttempts) {
+        const tokenResponse = await (0, prompts_1.default)({
+            type: 'password',
+            name: 'token',
+            message: attempts === 0
+                ? `Enter your ${provider.displayName} token`
+                : `Enter your ${provider.displayName} token (attempt ${attempts + 1}/${maxAttempts})`,
+            validate: (value) => {
+                if (!value)
+                    return `${provider.displayName} token is required`;
+                return true;
+            }
+        });
+        if (!tokenResponse.token) {
+            console.log(chalk_1.default.red(`\n❌ ${provider.displayName} token is required.`));
+            attempts++;
+            if (attempts < maxAttempts) {
+                const retry = await (0, prompts_1.default)({
+                    type: 'confirm',
+                    name: 'retry',
+                    message: 'Would you like to try entering the token again?',
+                    initial: true
+                });
+                if (!retry.retry)
+                    break;
+            }
+            continue;
+        }
+        token = tokenResponse.token;
+        console.log(chalk_1.default.green(`✅ ${provider.displayName} token received\n`));
+    }
+    if (!token) {
+        throw new Error(`Failed to get ${provider.displayName} token`);
+    }
+    return token;
+}
+/**
+ * Prompt for additional provider configuration (e.g., Jira URL and email)
+ */
+async function promptForProviderConfig(client, providerId) {
+    let provider;
+    let schema;
+    try {
+        provider = await client.getProvider(providerId);
+        schema = await client.getProviderSchema(providerId);
+    }
+    catch (error) {
+        // Server unavailable - use local fallback
+        const { getLocalProvider, getLocalProviderConfigRequirements } = await Promise.resolve().then(() => __importStar(require('../providers/local-provider-registry')));
+        provider = getLocalProvider(providerId);
+        if (!provider) {
+            throw new Error(`Unknown provider: ${providerId}`);
+        }
+        schema = { configRequirements: getLocalProviderConfigRequirements(providerId) };
+    }
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    const requirements = schema.configRequirements;
+    if (requirements.length === 0) {
+        return {};
+    }
+    console.log(chalk_1.default.blue(`\n🔧 ${provider.displayName} Configuration`));
+    console.log(`Additional configuration required for ${provider.displayName}.\n`);
+    const config = {};
+    for (const req of requirements) {
+        const response = await (0, prompts_1.default)({
+            type: req.type === 'email' ? 'text' : req.type === 'url' ? 'text' : 'text',
+            name: 'value',
+            message: `Enter ${req.displayName}`,
+            validate: (value) => {
+                if (req.required && !value) {
+                    return `${req.displayName} is required`;
+                }
+                if (req.type === 'email' && value && !value.includes('@')) {
+                    return 'Please enter a valid email address';
+                }
+                if (req.type === 'url' && value) {
+                    try {
+                        new URL(value.startsWith('http') ? value : `https://${value}`);
+                    }
+                    catch {
+                        return 'Please enter a valid URL';
+                    }
+                }
+                return true;
+            }
+        });
+        if (!response.value && req.required) {
+            throw new Error(`${req.displayName} is required`);
+        }
+        config[req.key] = response.value;
+    }
+    console.log(chalk_1.default.green(`✅ ${provider.displayName} configuration received\n`));
+    return config;
+}
+/**
+ * Get token and config for a provider (handles both token and additional config)
+ */
+async function promptForProviderCredentials(client, providerId, existingToken, existingConfig) {
+    let provider;
+    let schema;
+    try {
+        provider = await client.getProvider(providerId);
+        schema = await client.getProviderSchema(providerId);
+    }
+    catch (error) {
+        // Server unavailable - use local fallback
+        const { getLocalProvider, getLocalProviderConfigRequirements } = await Promise.resolve().then(() => __importStar(require('../providers/local-provider-registry')));
+        provider = getLocalProvider(providerId);
+        if (!provider) {
+            throw new Error(`Unknown provider: ${providerId}`);
+        }
+        schema = { configRequirements: getLocalProviderConfigRequirements(providerId) };
+    }
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    // Get token if not provided
+    const token = existingToken || await promptForProviderToken(client, providerId);
+    // Get additional config if needed
+    const requirements = schema.configRequirements;
+    let config;
+    if (requirements.length > 0) {
+        // Check if we have all required config
+        const hasAllConfig = existingConfig && requirements.every(req => !req.required || existingConfig[req.key]);
+        if (!hasAllConfig) {
+            config = await promptForProviderConfig(client, providerId);
+            // Merge with existing config
+            if (existingConfig) {
+                config = { ...existingConfig, ...config };
+            }
+        }
+        else {
+            config = existingConfig;
+        }
+    }
+    return { token, config };
+}

package/dist/src/cli/utils/remote-sync.js

@@ -29,6 +29,7 @@ async function syncFromRemote(options) {
             workflowsSynced: 0,
             scriptsSynced: 0,
             coachingSynced: 0,
+            docsSynced: 0,
             error: 'FRAIM_API_KEY not set'
         };
     }
@@ -50,6 +51,7 @@ async function syncFromRemote(options) {
                 workflowsSynced: 0,
                 scriptsSynced: 0,
                 coachingSynced: 0,
+                docsSynced: 0,
                 error: 'No files received'
             };
         }
@@ -106,12 +108,29 @@ async function syncFromRemote(options) {
             (0, fs_1.writeFileSync)(filePath, file.content, 'utf8');
             console.log(chalk_1.default.gray(`  + coaching-moments/${file.path}`));
         }
-        console.log(chalk_1.default.green(`\n✅ Synced ${workflowFiles.length} workflows, ${scriptFiles.length} scripts, and ${coachingFiles.length} coaching files from remote`));
+        // Sync docs to .fraim/docs/
+        const docsFiles = files.filter(f => f.type === 'docs');
+        const docsDir = (0, path_1.join)(options.projectRoot, '.fraim', 'docs');
+        if (!(0, fs_1.existsSync)(docsDir)) {
+            (0, fs_1.mkdirSync)(docsDir, { recursive: true });
+        }
+        cleanDirectory(docsDir);
+        for (const file of docsFiles) {
+            const filePath = (0, path_1.join)(docsDir, file.path);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, file.content, 'utf8');
+            console.log(chalk_1.default.gray(`  + docs/${file.path}`));
+        }
+        console.log(chalk_1.default.green(`\n✅ Synced ${workflowFiles.length} workflows, ${scriptFiles.length} scripts, ${coachingFiles.length} coaching files, and ${docsFiles.length} docs from remote`));
         return {
             success: true,
             workflowsSynced: workflowFiles.length,
             scriptsSynced: scriptFiles.length,
-            coachingSynced: coachingFiles.length
+            coachingSynced: coachingFiles.length,
+            docsSynced: docsFiles.length
         };
     }
     catch (error) {
@@ -121,6 +140,7 @@ async function syncFromRemote(options) {
             workflowsSynced: 0,
             scriptsSynced: 0,
             coachingSynced: 0,
+            docsSynced: 0,
             error: error.message
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.81",
+  "version": "2.0.83",
   "description": "FRAIM v2: Framework for Rigor-based AI Management - Transform from solo developer to AI manager orchestrating production-ready code with enterprise-grade discipline",
   "main": "index.js",
   "bin": {
@@ -13,8 +13,9 @@
     "dev:prod": "npm run build && node dist/src/fraim-mcp-server.js > server.log 2>&1",
     "build": "tsc && npm run build:stubs && node scripts/copy-ai-manager-rules.js && npm run validate:registry && tsx scripts/validate-purity.ts",
     "build:stubs": "tsx scripts/build-stub-registry.ts",
-    "test-all": "npm run test && npm run test:ui",
+    "test-all": "npm run test && npm run test:isolated && npm run test:ui",
     "test": "node scripts/test-with-server.js",
+    "test:isolated": "npx tsx --test --test-reporter=spec tests/isolated/test-*.ts",
     "test:ui": "playwright test",
     "test:ui:headed": "playwright test --headed",
     "start:fraim": "tsx src/fraim-mcp-server.ts",
@@ -111,6 +112,7 @@
     "mongodb": "^7.0.0",
     "prompts": "^2.4.2",
     "stripe": "^20.3.1",
+    "toml": "^3.0.0",
     "tree-kill": "^1.2.2"
   }
 }

package/dist/src/cli/commands/install.js

@@ -1,86 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.installCommand = void 0;
-const commander_1 = require("commander");
-const chalk_1 = __importDefault(require("chalk"));
-const child_process_1 = require("child_process");
-const https_1 = __importDefault(require("https"));
-const http_1 = __importDefault(require("http"));
-/**
- * fraim install - One-command installer with key or token
- * Usage: fraim install --key=<key> | fraim install --token=<token> [--api-url=<url>]
- *
- * Convenience wrapper over fraim setup: installs fraim-framework globally, fetches key from
- * token if needed (no copy-paste), then runs fraim setup --key. fraim setup alone requires
- * the user to already have fraim installed and know their key.
- */
-exports.installCommand = new commander_1.Command('install')
-    .description('Install FRAIM globally and configure with your key (use --key or --token from dashboard)')
-    .option('--key <key>', 'FRAIM API key (from dashboard)')
-    .option('--token <token>', 'Installer token (one-time, from dashboard download link)')
-    .option('--api-url <url>', 'API base URL for token fetch', process.env.FRAIM_API_URL || 'https://fraim.wellnessatwork.me')
-    .action(async (opts) => {
-    let key = opts.key;
-    const token = opts.token;
-    const apiUrl = (opts.apiUrl || '').replace(/\/$/, '') || 'https://fraim.wellnessatwork.me';
-    if (token && !key) {
-        console.log(chalk_1.default.blue('Fetching key from FRAIM...'));
-        try {
-            key = await fetchInstallerKey(token, apiUrl);
-            console.log(chalk_1.default.green('Key retrieved.\n'));
-        }
-        catch (err) {
-            console.error(chalk_1.default.red('Failed to fetch key:'), err.message);
-            console.error(chalk_1.default.gray('Token may be expired. Get a new link from the FRAIM site.'));
-            process.exit(1);
-        }
-    }
-    if (!key) {
-        console.error(chalk_1.default.red('Usage: fraim install --key=<your-key>'));
-        console.error(chalk_1.default.gray('   or: fraim install --token=<installer-token> [--api-url=<url>]'));
-        console.error(chalk_1.default.gray('\nGet your key at https://fraim.wellnessatwork.me (click Get Started)'));
-        process.exit(1);
-    }
-    console.log(chalk_1.default.blue('Installing fraim-framework...'));
-    const installResult = (0, child_process_1.spawnSync)('npm', ['install', '-g', 'fraim-framework'], {
-        stdio: 'inherit',
-        shell: true
-    });
-    if (installResult.status !== 0)
-        process.exit(installResult.status || 1);
-    console.log(chalk_1.default.blue('\nConfiguring FRAIM with your key...'));
-    const setupResult = (0, child_process_1.spawnSync)('fraim', ['setup', '--key', key], {
-        stdio: 'inherit',
-        shell: true
-    });
-    if (setupResult.status !== 0)
-        process.exit(setupResult.status || 1);
-    console.log(chalk_1.default.green('\n✅ FRAIM is ready. Run "fraim init-project" in your project directory.'));
-});
-function fetchInstallerKey(token, apiUrl) {
-    return new Promise((resolve, reject) => {
-        const url = new URL(`${apiUrl}/api/installer-key`);
-        url.searchParams.set('token', token);
-        const lib = url.protocol === 'https:' ? https_1.default : http_1.default;
-        const req = lib.get(url.toString(), (res) => {
-            let data = '';
-            res.on('data', (chunk) => (data += chunk));
-            res.on('end', () => {
-                try {
-                    const json = JSON.parse(data);
-                    if (json.key)
-                        resolve(json.key);
-                    else
-                        reject(new Error(json.error || 'No key in response'));
-                }
-                catch {
-                    reject(new Error(`Invalid response: ${data}`));
-                }
-            });
-        });
-        req.on('error', reject);
-    });
-}

package/dist/src/cli/setup/token-validator.js

@@ -1,57 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidTokenFormat = exports.validateGitHubToken = exports.validateFraimKey = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const validateFraimKey = async (key) => {
-    // Basic format validation
-    if (!key || !key.startsWith('fraim_')) {
-        return false;
-    }
-    // TODO: Add actual API validation when FRAIM server is available
-    // For now, just validate format
-    return key.length > 15; // More reasonable minimum length
-};
-exports.validateFraimKey = validateFraimKey;
-const validateGitHubToken = async (token) => {
-    if (!token)
-        return false;
-    // Validate token format
-    if (!token.startsWith('ghp_') && !token.startsWith('github_pat_')) {
-        return false;
-    }
-    try {
-        const response = await fetch('https://api.github.com/user', {
-            headers: {
-                Authorization: `Bearer ${token}`,
-                'User-Agent': 'FRAIM-Setup/1.0'
-            }
-        });
-        return response.ok;
-    }
-    catch (error) {
-        console.log(chalk_1.default.yellow('⚠️ Could not validate GitHub token (network issue), proceeding anyway'));
-        return true; // Assume valid if network issues
-    }
-};
-exports.validateGitHubToken = validateGitHubToken;
-const isValidTokenFormat = (token, type) => {
-    if (type === 'fraim') {
-        return token.startsWith('fraim_') && token.length > 15; // More reasonable minimum length
-    }
-    if (type === 'github') {
-        return token.startsWith('ghp_') || token.startsWith('github_pat_');
-    }
-    if (type === 'gitlab') {
-        // GitLab PATs commonly use glpat- prefix, but keep a permissive fallback for self-managed/token variants.
-        return token.startsWith('glpat-') || token.length >= 20;
-    }
-    if (type === 'jira') {
-        // Jira API tokens typically start with ATATT3 and have a minimum length.
-        return token.startsWith('ATATT3') && token.length >= 20;
-    }
-    return false;
-};
-exports.isValidTokenFormat = isValidTokenFormat;