fraim-framework 2.0.24 → 2.0.27

package/.github/workflows/deploy-fraim.yml

@@ -7,6 +7,7 @@ on:
       - master
     paths:
       - 'src/fraim-mcp-server.ts'
+      - 'src/fraim/**'
       - '.ai-agents/**'
       - '.fraim/**'
       - '.github/workflows/deploy-fraim.yml'
@@ -55,7 +56,8 @@ jobs:
           # Copy necessary files
           cp -r dist deploy-package/
           cp -r node_modules deploy-package/
-          # Include .fraim directory for runtime configuration
+          # Include registry and .fraim directory for runtime
+          cp -r registry deploy-package/
           cp -r .fraim deploy-package/
           
           cp package.json deploy-package/

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

@@ -12,6 +12,7 @@ const first_run_js_1 = require("../setup/first-run.js");
 const sync_js_1 = require("./sync.js");
 const types_js_1 = require("../../fraim/types.js");
 const git_utils_js_1 = require("../../utils/git-utils.js");
+const version_utils_js_1 = require("../../utils/version-utils.js");
 const runInit = async () => {
     const projectRoot = process.cwd();
     const fraimDir = path_1.default.join(projectRoot, '.fraim');
@@ -28,6 +29,7 @@ const runInit = async () => {
         const remoteInfo = (0, git_utils_js_1.getGitRemoteInfo)();
         const config = {
             ...types_js_1.DEFAULT_FRAIM_CONFIG,
+            version: (0, version_utils_js_1.getFraimVersion)(),
             project: {
                 ...types_js_1.DEFAULT_FRAIM_CONFIG.project,
                 name: path_1.default.basename(projectRoot)

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

@@ -11,6 +11,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const digest_utils_1 = require("../../utils/digest-utils");
 const stub_generator_1 = require("../../utils/stub-generator");
 const config_loader_js_1 = require("../../fraim/config-loader.js");
+const version_utils_js_1 = require("../../utils/version-utils.js");
 const runSync = async (options) => {
     const projectRoot = process.cwd();
     const config = (0, config_loader_js_1.loadFraimConfig)();
@@ -37,6 +38,22 @@ const runSync = async (options) => {
     if (!fs_1.default.existsSync(workflowsDir)) {
         fs_1.default.mkdirSync(workflowsDir, { recursive: true });
     }
+    // Update version in config.json
+    const configPath = path_1.default.join(fraimDir, 'config.json');
+    if (fs_1.default.existsSync(configPath)) {
+        try {
+            const currentConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+            const newVersion = (0, version_utils_js_1.getFraimVersion)();
+            if (currentConfig.version !== newVersion) {
+                currentConfig.version = newVersion;
+                fs_1.default.writeFileSync(configPath, JSON.stringify(currentConfig, null, 2));
+                console.log(chalk_1.default.green(`✅ Updated FRAIM version to ${newVersion} in config.`));
+            }
+        }
+        catch (e) {
+            console.warn(chalk_1.default.yellow('⚠️ Could not update version in config.json.'));
+        }
+    }
     console.log(chalk_1.default.blue('🔄 Syncing FRAIM workflows...'));
     const currentDigest = await (0, digest_utils_1.generateDigest)(registryPath);
     const existingDigest = fs_1.default.existsSync(digestPath) ? fs_1.default.readFileSync(digestPath, 'utf8') : '';

package/dist/src/fraim/config-loader.js

@@ -8,7 +8,7 @@ exports.loadFraimConfig = loadFraimConfig;
 exports.getConfigValue = getConfigValue;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const types_js_1 = require("./types.js");
+const types_1 = require("./types");
 /**
  * Load FRAIM configuration from .fraim/config.json
  * Falls back to defaults if file doesn't exist
@@ -17,43 +17,43 @@ function loadFraimConfig() {
     const configPath = (0, path_1.join)(process.cwd(), '.fraim', 'config.json');
     if (!(0, fs_1.existsSync)(configPath)) {
         console.log('📋 No .fraim/config.json found, using defaults');
-        return { ...types_js_1.DEFAULT_FRAIM_CONFIG };
+        return { ...types_1.DEFAULT_FRAIM_CONFIG };
     }
     try {
         const configContent = (0, fs_1.readFileSync)(configPath, 'utf-8');
         const config = JSON.parse(configContent);
         // Merge with defaults to ensure all required fields exist
         const mergedConfig = {
-            ...types_js_1.DEFAULT_FRAIM_CONFIG,
+            ...types_1.DEFAULT_FRAIM_CONFIG,
             ...config,
             project: {
-                ...types_js_1.DEFAULT_FRAIM_CONFIG.project,
+                ...types_1.DEFAULT_FRAIM_CONFIG.project,
                 ...(config.project || {})
             },
             git: {
-                ...types_js_1.DEFAULT_FRAIM_CONFIG.git,
+                ...types_1.DEFAULT_FRAIM_CONFIG.git,
                 ...(config.git || {})
             },
             customizations: {
-                ...types_js_1.DEFAULT_FRAIM_CONFIG.customizations,
+                ...types_1.DEFAULT_FRAIM_CONFIG.customizations,
                 ...(config.customizations || {})
             },
             persona: {
-                ...types_js_1.DEFAULT_FRAIM_CONFIG.persona,
+                ...types_1.DEFAULT_FRAIM_CONFIG.persona,
                 ...(config.persona || {})
             },
             marketing: {
-                ...types_js_1.DEFAULT_FRAIM_CONFIG.marketing,
+                ...types_1.DEFAULT_FRAIM_CONFIG.marketing,
                 ...(config.marketing || {})
             },
             database: {
-                ...types_js_1.DEFAULT_FRAIM_CONFIG.database,
+                ...types_1.DEFAULT_FRAIM_CONFIG.database,
                 ...(config.database || {})
             }
         };
         // Validate version
         if (!mergedConfig.version) {
-            mergedConfig.version = types_js_1.DEFAULT_FRAIM_CONFIG.version;
+            mergedConfig.version = types_1.DEFAULT_FRAIM_CONFIG.version;
         }
         console.log(`📋 Loaded FRAIM config from .fraim/config.json (version ${mergedConfig.version})`);
         return mergedConfig;
@@ -61,7 +61,7 @@ function loadFraimConfig() {
     catch (error) {
         console.warn(`⚠️  Failed to load .fraim/config.json: ${error instanceof Error ? error.message : 'Unknown error'}`);
         console.warn('   Using default configuration');
-        return { ...types_js_1.DEFAULT_FRAIM_CONFIG };
+        return { ...types_1.DEFAULT_FRAIM_CONFIG };
     }
 }
 /**

package/dist/src/fraim/setup-wizard.js

@@ -7,8 +7,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateConfigFromAnswers = generateConfigFromAnswers;
 exports.writeConfig = writeConfig;
 exports.createDirectoryStructure = createDirectoryStructure;
-exports.generateArchitectureTemplate = generateArchitectureTemplate;
-exports.writeArchitectureTemplate = writeArchitectureTemplate;
 exports.runSetup = runSetup;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -65,43 +63,6 @@ function createDirectoryStructure() {
         }
     }
 }
-/**
- * Generate architecture.md template
- */
-function generateArchitectureTemplate(config) {
-    let template = `# Project Architecture
-
-This document describes the architecture patterns and conventions for ${config.project.name}.
-
-## Overview
-
-- **Project Name:** ${config.project.name}
-
-## Development Guidelines
-
-### Git Workflow
-- **Default Branch:** ${config.git.defaultBranch}
-
-## Customization
-
-This project uses FRAIM with customizations in \`.fraim/\`:
-- Custom rules: \`.fraim/rules/\`
-- Custom workflows: \`.fraim/workflows/\`
-- Custom templates: \`.fraim/templates/\`
-- Custom scripts: \`.fraim/scripts/\`
-`;
-    return template;
-}
-/**
- * Write architecture.md template
- */
-function writeArchitectureTemplate(config) {
-    const fraimDir = (0, path_1.join)(process.cwd(), '.fraim');
-    const archPath = (0, path_1.join)(fraimDir, 'architecture.md');
-    const template = generateArchitectureTemplate(config);
-    (0, fs_1.writeFileSync)(archPath, template, 'utf-8');
-    console.log(`✅ Created .fraim/architecture.md`);
-}
 /**
  * Run setup wizard
  */
@@ -121,11 +82,9 @@ function runSetup(answers) {
         createDirectoryStructure();
         // Write config
         writeConfig(config);
-        // Write architecture template
-        writeArchitectureTemplate(config);
         return {
             success: true,
-            message: `✅ FRAIM setup complete!\n\nCreated:\n- .fraim/config.json\n- .fraim/architecture.md\n- Directory structure\n\nNext steps:\n1. Review .fraim/config.json and adjust as needed\n2. Add custom rules to .fraim/rules/\n3. Add custom workflows to .fraim/workflows/\n4. Customize templates in .fraim/templates/`,
+            message: `✅ FRAIM setup complete!\n\nCreated:\n- .fraim/config.json\n- Directory structure\n\nNext steps:\n1. Review .fraim/config.json and adjust as needed\n2. Add custom rules to .fraim/rules/\n3. Add custom workflows to .fraim/workflows/\n4. Customize templates in .fraim/templates/`,
             config
         };
     }

package/dist/src/fraim-mcp-server.js

@@ -82,9 +82,19 @@ class FraimMCPServer {
         this.app.use(express_1.default.json());
         // Load server version
         try {
-            const pkgPath = (0, path_1.join)(__dirname, '..', 'package.json');
-            const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf8'));
-            this.serverVersion = pkg.version;
+            // Try process.cwd() first as it's the root in most deployments
+            let pkgPath = (0, path_1.join)(process.cwd(), 'package.json');
+            if (!(0, fs_1.existsSync)(pkgPath)) {
+                // Fallback to relative to __dirname (dist/src/ -> ../../package.json)
+                pkgPath = (0, path_1.join)(__dirname, '..', '..', 'package.json');
+            }
+            if ((0, fs_1.existsSync)(pkgPath)) {
+                const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf8'));
+                this.serverVersion = pkg.version;
+            }
+            else {
+                this.serverVersion = 'unknown';
+            }
         }
         catch (e) {
             this.serverVersion = 'unknown';
@@ -217,8 +227,11 @@ class FraimMCPServer {
             });
         }
         catch (error) {
-            console.error('❌ FRAIM AUTH: Error during verification:', error);
-            res.status(500).json({ error: 'Internal Server Error' });
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error('❌ FRAIM AUTH: Error during verification:', msg);
+            if (error instanceof Error && error.stack)
+                console.error(error.stack);
+            res.status(500).json({ error: 'Internal Server Error', details: msg });
         }
     }
     adminAuthMiddleware(req, res, next) {
@@ -956,12 +969,10 @@ Use this to discover which workflow to call with get_fraim_workflow.`,
         const workflowPath = `workflows/${normalizedName}.md`;
         const metadata = this.fileIndex.get(workflowPath);
         if (!metadata) {
-            // Try alternative paths (e.g., customer-development subdirectory)
-            const alternativePaths = [
-                `workflows/customer-development/${normalizedName}.md`,
-                `workflows/business-development/${normalizedName}.md`
-            ];
-            for (const altPath of alternativePaths) {
+            // Try alternative category paths
+            const categories = ['product-building', 'customer-development', 'business-development', 'marketing', 'performance', 'quality-assurance', 'reviewer', 'startup-credits', 'bootstrap', 'deploy'];
+            for (const cat of categories) {
+                const altPath = `workflows/${cat}/${normalizedName}.md`;
                 const altMetadata = this.fileIndex.get(altPath);
                 if (altMetadata) {
                     return this.returnWorkflowFile(altMetadata);

package/dist/src/utils/git-utils.js

@@ -24,7 +24,7 @@ function getPort() {
     catch (e) {
         // Silently fail and use default
     }
-    return Number(process.env.FRAIM_MCP_PORT) || 15300;
+    return Number(process.env.PORT) || Number(process.env.WEBSITES_PORT) || Number(process.env.FRAIM_MCP_PORT) || 15300;
 }
 /**
  * Determines the database name based on the git branch

package/dist/src/utils/version-utils.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFraimVersion = getFraimVersion;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function getFraimVersion() {
+    // Try reliable paths to find package.json relative to this file
+    // locally: src/utils/version-utils.ts -> package.json is ../../package.json
+    // dist: dist/src/utils/version-utils.js -> package.json is ../../../package.json
+    const possiblePaths = [
+        path_1.default.join(__dirname, '../../package.json'), // Local dev (src)
+        path_1.default.join(__dirname, '../../../package.json'), // Dist (dist/src)
+        path_1.default.join(process.cwd(), 'package.json') // Fallback to CWD (unlikely to be correct for global install but safe fallback)
+    ];
+    for (const pkgPath of possiblePaths) {
+        if (fs_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === 'fraim-framework') {
+                    return pkg.version;
+                }
+            }
+            catch (e) {
+                // Ignore parsing errors
+            }
+        }
+    }
+    return '1.0.0'; // Fallback
+}

package/dist/tests/test-cli.js

@@ -0,0 +1,167 @@
+"use strict";
+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 });
+const node_child_process_1 = require("node:child_process");
+const test_utils_1 = require("./test-utils");
+const node_assert_1 = __importDefault(require("node:assert"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function testCliLifecycle() {
+    console.log('   🚀 Testing Fraim CLI Lifecycle...');
+    // Create a temp directory for the test project
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-test-'));
+    console.log(`   📂 Created temp dir: ${tempDir}`);
+    try {
+        const platform = process.platform;
+        const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
+        const cliScript = path_1.default.resolve(__dirname, '../src/cli/fraim.ts');
+        // Helper to run CLI commands
+        const runFraim = (args, cwdOverride) => {
+            return new Promise((resolve, reject) => {
+                const ps = (0, node_child_process_1.spawn)(npx, ['tsx', `"${cliScript}"`, ...args], {
+                    cwd: cwdOverride || tempDir,
+                    env: { ...process.env, TEST_MODE: 'true' }, // Disable interactive first-run
+                    shell: true
+                });
+                let stdout = '';
+                let stderr = '';
+                ps.stdout.on('data', d => stdout += d.toString());
+                ps.stderr.on('data', d => stderr += d.toString());
+                ps.on('close', (code) => {
+                    resolve({ stdout, stderr, code });
+                });
+            });
+        };
+        // 1. Test `fraim init`
+        console.log('   Testing "fraim init"...');
+        // Create a fake git repo to test population
+        try {
+            const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+            execSync('git init', { cwd: tempDir });
+            execSync('git remote add origin https://github.com/test-owner/test-repo.git', { cwd: tempDir });
+        }
+        catch (e) {
+            console.warn('   ⚠️ Could not initialize git in temp dir, skipping population test');
+        }
+        const initRes = await runFraim(['init'], tempDir);
+        if (initRes.code !== 0) {
+            console.error('Init failed:', initRes.stderr);
+            console.error('STDOUT:', initRes.stdout); // Keep this line for better debugging
+        }
+        node_assert_1.default.strictEqual(initRes.code, 0, 'Init should exit with 0');
+        node_assert_1.default.ok(fs_1.default.existsSync(path_1.default.join(tempDir, '.fraim')), '.fraim dir should exist');
+        const configPath = path_1.default.join(tempDir, '.fraim', 'config.json');
+        node_assert_1.default.ok(fs_1.default.existsSync(configPath), 'config.json should exist');
+        const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        // Deep structure validation
+        node_assert_1.default.ok(config.project, 'config.project should exist');
+        node_assert_1.default.strictEqual(typeof config.project.name, 'string', 'project.name should be a string');
+        node_assert_1.default.ok(config.persona, 'config.persona should exist');
+        node_assert_1.default.strictEqual(config.persona.name, 'AI Agent', 'Default persona name should be correct');
+        node_assert_1.default.ok(config.marketing, 'config.marketing should exist');
+        node_assert_1.default.strictEqual(config.marketing.websiteUrl, '', 'websiteUrl should be empty placeholder');
+        node_assert_1.default.ok(config.git, 'config.git should exist');
+        // If git was initialized successfully, these should NOT be empty
+        const hasGit = fs_1.default.existsSync(path_1.default.join(tempDir, '.git'));
+        if (hasGit) {
+            node_assert_1.default.strictEqual(config.git.repoOwner, 'test-owner', 'repoOwner should be detected from git');
+            node_assert_1.default.strictEqual(config.git.repoName, 'test-repo', 'repoName should be detected from git');
+        }
+        else {
+            console.warn('   ⚠️ No .git found in tempDir, owner/repo detection skipped');
+            node_assert_1.default.strictEqual(config.git.repoOwner, '', 'repoOwner should be empty if no git');
+            node_assert_1.default.strictEqual(config.git.repoName, '', 'repoName should be empty if no git');
+        }
+        node_assert_1.default.ok(config.customizations, 'config.customizations should exist');
+        node_assert_1.default.strictEqual(config.customizations.workflowsPath, '.fraim/workflows');
+        node_assert_1.default.ok(!config.mcp, 'mcp should not be in generated config');
+        // 2. Test `fraim sync`
+        // We need a fake registry for sync to work against
+        const registryDir = path_1.default.join(tempDir, 'registry', 'workflows');
+        fs_1.default.mkdirSync(registryDir, { recursive: true });
+        const dummyWorkflow = `---
+intent: Test Intent
+principles:
+- Test Principle
+---
+# Test Workflow`;
+        fs_1.default.writeFileSync(path_1.default.join(registryDir, 'test-workflow.md'), dummyWorkflow);
+        console.log('   Testing "fraim sync"...');
+        const syncRes = await runFraim(['sync']);
+        if (syncRes.code === 0) {
+            console.log('   ✅ Sync successful');
+        }
+        else {
+            console.log('   ⚠️ Sync warning (env dependent):', syncRes.stderr);
+        }
+        // 3. Test `fraim list`
+        console.log('   Testing "fraim list"...');
+        const listRes = await runFraim(['list']);
+        node_assert_1.default.strictEqual(listRes.code, 0);
+        // 4. Test `fraim doctor`
+        console.log('   Testing "fraim doctor"...');
+        const doctorRes = await runFraim(['doctor']);
+        node_assert_1.default.strictEqual(doctorRes.code, 0);
+        node_assert_1.default.ok(doctorRes.stdout.includes('Everything looks great'), 'Doctor should be happy');
+        console.log('   ✅ CLI Lifecycle verified!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ CLI Test failed:', error);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) { }
+    }
+}
+async function runCliTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'Fraim CLI Lifecycle',
+        description: 'Tests init, sync, list, and doctor commands',
+        testFunction: testCliLifecycle,
+        tags: ['cli', 'fraim']
+    },
+];
+(0, test_utils_1.runTests)(testCases, runCliTest, 'Fraim CLI Tests');

package/dist/tests/test-first-run-journey.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const test_utils_1 = require("./test-utils");
+const node_assert_1 = __importDefault(require("node:assert"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+/**
+ * Helper to run the interactive first-run experience within 'fraim init'
+ */
+async function runInteractiveInit(cwd, interactions) {
+    const projectRoot = path_1.default.resolve(__dirname, '..');
+    const cliScript = path_1.default.resolve(projectRoot, 'src/cli/fraim.ts');
+    const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    return new Promise(resolve => {
+        const ps = (0, node_child_process_1.spawn)(npx, ['tsx', `"${cliScript}"`, 'init'], {
+            cwd,
+            env: { ...process.env, CI: 'false', TEST_MODE: 'false' },
+            shell: true,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        let currentPromptIndex = 0;
+        const timeout = setTimeout(() => {
+            console.error('   ❌ Interactive init timed out');
+            ps.kill('SIGKILL');
+            resolve({ stdout, stderr, code: -1 });
+        }, 45000);
+        ps.stdout.on('data', d => {
+            const chunk = d.toString();
+            stdout += chunk;
+            if (currentPromptIndex < interactions.length) {
+                const target = interactions[currentPromptIndex];
+                if (chunk.includes(target.prompt)) {
+                    currentPromptIndex++;
+                    setTimeout(() => {
+                        ps.stdin.write(target.response + '\n');
+                    }, 500);
+                }
+            }
+        });
+        ps.stderr.on('data', d => stderr += d.toString());
+        ps.on('close', code => {
+            clearTimeout(timeout);
+            resolve({ stdout, stderr, code });
+        });
+    });
+}
+const testCases = [
+    {
+        name: 'Journey: Setup with Key, No Arch Doc',
+        testFunction: async () => {
+            const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-jour-1-'));
+            try {
+                const res = await runInteractiveInit(tempDir, [
+                    { prompt: 'Do you have a FRAIM key?', response: 'key-123' },
+                    { prompt: 'Do you have an architecture document', response: 'n' }
+                ]);
+                node_assert_1.default.strictEqual(res.code, 0);
+                node_assert_1.default.ok(res.stdout.includes('Key received'));
+                node_assert_1.default.ok(res.stdout.includes('Run the bootstrap/create-architecture workflow'));
+                // VERIFY STUBS EXIST
+                const workflowsDir = path_1.default.join(tempDir, '.fraim', 'workflows');
+                node_assert_1.default.ok(fs_1.default.existsSync(workflowsDir), 'Workflows dir missing');
+                const stubs = fs_1.default.readdirSync(workflowsDir);
+                node_assert_1.default.ok(stubs.length > 0, 'No workflow stubs created');
+                return true;
+            }
+            finally {
+                fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            }
+        },
+        tags: ['cli', 'journey', 'init']
+    },
+    {
+        name: 'Journey: Setup with Arch Doc Path',
+        testFunction: async () => {
+            const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-jour-2-'));
+            const archPath = 'docs/my-architecture.md';
+            try {
+                fs_1.default.mkdirSync(path_1.default.join(tempDir, '.fraim'), { recursive: true });
+                fs_1.default.writeFileSync(path_1.default.join(tempDir, '.fraim', 'config.json'), JSON.stringify({ version: '1.0.0' }));
+                fs_1.default.mkdirSync(path_1.default.join(tempDir, 'docs'), { recursive: true });
+                fs_1.default.writeFileSync(path_1.default.join(tempDir, archPath), '# Arch');
+                const res = await runInteractiveInit(tempDir, [
+                    { prompt: 'Do you have a FRAIM key?', response: '' },
+                    { prompt: 'Do you have an architecture document', response: 'y' },
+                    { prompt: 'provide the relative path', response: archPath }
+                ]);
+                node_assert_1.default.strictEqual(res.code, 0);
+                node_assert_1.default.ok(res.stdout.includes(`Linked architecture document: ${archPath}`));
+                const config = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tempDir, '.fraim', 'config.json'), 'utf8'));
+                node_assert_1.default.strictEqual(config.customizations.architectureDoc, archPath);
+                return true;
+            }
+            finally {
+                fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            }
+        },
+        tags: ['cli', 'journey', 'init']
+    }
+];
+(0, test_utils_1.runTests)(testCases, (tc) => tc.testFunction(), 'Fraim Setup Journeys');

package/dist/tests/test-genericization.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_utils_1 = require("./test-utils");
+const node_assert_1 = __importDefault(require("node:assert"));
+const types_1 = require("../src/fraim/types");
+const template_processor_1 = require("../src/fraim/template-processor");
+async function testConfigDefaults() {
+    console.log('   🧪 Testing DEFAULT_FRAIM_CONFIG placeholders...');
+    try {
+        node_assert_1.default.strictEqual(types_1.DEFAULT_FRAIM_CONFIG.persona.name, 'AI Agent', 'Default persona name should be "AI Agent"');
+        node_assert_1.default.ok(types_1.DEFAULT_FRAIM_CONFIG.customizations?.workflowsPath, 'workflowsPath should exist');
+        node_assert_1.default.ok(!types_1.DEFAULT_FRAIM_CONFIG.mcp, 'mcp should still be removed');
+        return true;
+    }
+    catch (e) {
+        console.error('   ❌ Default configuration verification failed:', e);
+        return false;
+    }
+}
+async function testTemplateProcessor() {
+    console.log('   🧪 Testing Template Processor with new config fields...');
+    try {
+        const mockConfig = {
+            ...types_1.DEFAULT_FRAIM_CONFIG,
+            project: { ...types_1.DEFAULT_FRAIM_CONFIG.project, name: 'Generic Bot' },
+            persona: { ...types_1.DEFAULT_FRAIM_CONFIG.persona, name: 'Ava' },
+            marketing: {
+                ...types_1.DEFAULT_FRAIM_CONFIG.marketing,
+                websiteUrl: 'https://ava.ai',
+                chatUrl: 'https://chat.ava.ai'
+            }
+        };
+        const template = 'Welcome to {{config.project.name}}. I am {{config.persona.name}}. Visit {{config.marketing.websiteUrl}} or chat at {{config.marketing.chatUrl}}.';
+        const processed = (0, template_processor_1.processTemplateVariables)(template, mockConfig);
+        const expected = 'Welcome to Generic Bot. I am Ava. Visit https://ava.ai or chat at https://chat.ava.ai.';
+        node_assert_1.default.strictEqual(processed, expected, 'Template variables should be correctly replaced');
+        return true;
+    }
+    catch (e) {
+        console.error('   ❌ Template processing verification failed:', e);
+        return false;
+    }
+}
+const testCases = [
+    {
+        name: 'Config Defaults',
+        description: 'Verify DEFAULT_FRAIM_CONFIG has empty placeholders',
+        testFunction: testConfigDefaults,
+        tags: ['config', 'genericization']
+    },
+    {
+        name: 'Template Processor',
+        description: 'Verify template variables for new config fields',
+        testFunction: testTemplateProcessor,
+        tags: ['templates', 'genericization']
+    }
+];
+async function runGenericizationTests(testCase) {
+    return await testCase.testFunction();
+}
+(0, test_utils_1.runTests)(testCases, runGenericizationTests, 'FRAIM Genericization');