fraim-framework 2.0.24 → 2.0.26

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/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,51 @@ 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 || {})
             },
+            architecture: {
+                ...types_1.DEFAULT_FRAIM_CONFIG.architecture,
+                ...(config.architecture || {})
+            },
+            testing: {
+                ...types_1.DEFAULT_FRAIM_CONFIG.testing,
+                ...(config.testing || {})
+            },
             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 +69,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

@@ -69,6 +69,7 @@ function createDirectoryStructure() {
  * Generate architecture.md template
  */
 function generateArchitectureTemplate(config) {
+    const arch = config.architecture;
     let template = `# Project Architecture
 
 This document describes the architecture patterns and conventions for ${config.project.name}.
@@ -76,8 +77,34 @@ This document describes the architecture patterns and conventions for ${config.p
 ## Overview
 
 - **Project Name:** ${config.project.name}
+- **Project Type:** ${config.project.type || 'Not specified'}
+- **Primary Language:** ${config.project.primaryLanguage || 'Not specified'}
+- **Database:** ${config.project.database || 'Not specified'}
+- **ORM:** ${config.project.orm || 'Not specified'}
 
-## Development Guidelines
+`;
+    if (arch) {
+        template += `## Architecture Pattern
+
+**Pattern:** ${arch.pattern || 'Not specified'}
+
+`;
+        if (arch.llmFramework) {
+            template += `### LLM Integration
+
+- **Framework:** ${arch.llmFramework}
+- **Usage:** ${arch.llmUsage?.join(', ') || 'Not specified'}
+- **Deterministic Usage:** ${arch.deterministicUsage?.join(', ') || 'Not specified'}
+
+`;
+        }
+    }
+    template += `## Development Guidelines
+
+### Testing
+- **Framework:** ${config.testing?.framework || 'Not specified'}
+- **Test Location:** ${config.testing?.testLocation || 'Not specified'}
+- **Test Naming:** ${config.testing?.testNaming || 'Not specified'}
 
 ### Git Workflow
 - **Default Branch:** ${config.git.defaultBranch}

package/dist/src/fraim/types.js

@@ -18,6 +18,17 @@ exports.DEFAULT_FRAIM_CONFIG = {
         repoOwner: '',
         repoName: ''
     },
+    architecture: {
+        pattern: 'llm-deterministic-separation',
+        llmFramework: 'baml',
+        llmUsage: [],
+        deterministicUsage: ['data-processing', 'api-calls']
+    },
+    testing: {
+        framework: 'tsx-test',
+        testLocation: 'root',
+        testNaming: 'test-*.ts'
+    },
     customizations: {
         workflowsPath: '.fraim/workflows'
     },

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/tests/test-cli.js

@@ -0,0 +1,169 @@
+"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.architecture, 'architecture should be in generated config');
+        node_assert_1.default.ok(config.testing, 'testing should be in generated config');
+        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,66 @@
+"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.architecture, 'architecture should be restored');
+        node_assert_1.default.ok(types_1.DEFAULT_FRAIM_CONFIG.testing, 'testing should be restored');
+        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');