fraim-framework 2.0.47 → 2.0.49

package/dist/tests/test-modular-issue-tracking.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Test Multi-Provider Platform Support (Issue #39)
+ *
+ * Verifies that the template engine correctly processes workflows
+ * with provider-specific action mappings for GitHub and ADO.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testMultiProviderSupport = testMultiProviderSupport;
+const template_processor_1 = require("../src/fraim/template-processor");
+const platform_detection_1 = require("../src/utils/platform-detection");
+async function testMultiProviderSupport() {
+    console.log('🧪 Testing Multi-Provider Platform Support (Issue #39)...');
+    try {
+        // Test 1: Template Engine Creation
+        console.log('   Test 1: Template engine initialization...');
+        const templateEngine = new template_processor_1.TemplateEngine();
+        const providers = templateEngine.getAvailableProviders();
+        if (!providers.includes('github') || !providers.includes('ado')) {
+            throw new Error('Expected GitHub and ADO providers not found');
+        }
+        console.log(`   ✅ Loaded providers: ${providers.join(', ')}`);
+        // Test 2: GitHub Template Processing
+        console.log('   Test 2: GitHub template processing...');
+        const githubConfig = {
+            version: '2.0.47',
+            project: { name: 'Test Project' },
+            repository: {
+                provider: 'github',
+                owner: 'testowner',
+                name: 'testrepo',
+                defaultBranch: 'main'
+            },
+            persona: { name: 'Test', voice: 'Test', emailSignature: 'Test', displayNamePattern: 'Test' }
+        };
+        const testWorkflow = `
+# Test Workflow
+{{get_issue}} to get issue details.
+{{create_pr}} to create pull request.
+{{merge_pr}} to merge when ready.
+        `.trim();
+        const githubProcessed = templateEngine.processWorkflow(testWorkflow, githubConfig);
+        if (!githubProcessed.includes('mcp_github_issue_read')) {
+            throw new Error('GitHub template processing failed - missing mcp_github_issue_read');
+        }
+        if (!githubProcessed.includes('testowner')) {
+            throw new Error('GitHub template processing failed - missing owner substitution');
+        }
+        console.log('   ✅ GitHub template processing works');
+        // Test 3: ADO Template Processing
+        console.log('   Test 3: ADO template processing...');
+        const adoConfig = {
+            version: '2.0.47',
+            project: { name: 'Test Project' },
+            repository: {
+                provider: 'ado',
+                organization: 'testorg',
+                project: 'testproject',
+                name: 'testrepo',
+                defaultBranch: 'main'
+            },
+            persona: { name: 'Test', voice: 'Test', emailSignature: 'Test', displayNamePattern: 'Test' }
+        };
+        const adoProcessed = templateEngine.processWorkflow(testWorkflow, adoConfig);
+        if (!adoProcessed.includes('mcp_ado_get_work_item')) {
+            throw new Error('ADO template processing failed - missing mcp_ado_get_work_item');
+        }
+        if (!adoProcessed.includes('testorg')) {
+            throw new Error('ADO template processing failed - missing organization substitution');
+        }
+        console.log('   ✅ ADO template processing works');
+        // Test 4: Platform Detection
+        console.log('   Test 4: Platform detection...');
+        const githubDetection = (0, platform_detection_1.detectPlatformFromUrl)('https://github.com/owner/repo.git');
+        if (githubDetection.provider !== 'github' || githubDetection.repository?.owner !== 'owner') {
+            throw new Error('GitHub URL detection failed');
+        }
+        const adoDetection = (0, platform_detection_1.detectPlatformFromUrl)('https://dev.azure.com/org/project/_git/repo');
+        if (adoDetection.provider !== 'ado' || adoDetection.repository?.organization !== 'org') {
+            throw new Error('ADO URL detection failed');
+        }
+        console.log('   ✅ Platform detection works');
+        // Test 5: Repository Config Validation
+        console.log('   Test 5: Repository config validation...');
+        const validGitHub = (0, platform_detection_1.validateRepositoryConfig)({
+            provider: 'github',
+            owner: 'test',
+            name: 'repo'
+        });
+        if (!validGitHub.valid) {
+            throw new Error(`Valid GitHub config rejected: ${validGitHub.errors.join(', ')}`);
+        }
+        const validAdo = (0, platform_detection_1.validateRepositoryConfig)({
+            provider: 'ado',
+            organization: 'org',
+            project: 'proj',
+            name: 'repo'
+        });
+        if (!validAdo.valid) {
+            throw new Error(`Valid ADO config rejected: ${validAdo.errors.join(', ')}`);
+        }
+        const invalidConfig = (0, platform_detection_1.validateRepositoryConfig)({
+            provider: 'github'
+            // Missing required fields
+        });
+        if (invalidConfig.valid) {
+            throw new Error('Invalid config should have been rejected');
+        }
+        console.log('   ✅ Repository config validation works');
+        // Test 6: Template Action Coverage
+        console.log('   Test 6: Template action coverage...');
+        const githubActions = templateEngine.getProviderActions('github');
+        const adoActions = templateEngine.getProviderActions('ado');
+        const requiredActions = ['get_issue', 'create_pr', 'merge_pr', 'update_issue_status'];
+        for (const action of requiredActions) {
+            if (!githubActions.includes(action)) {
+                throw new Error(`GitHub missing required action: ${action}`);
+            }
+            if (!adoActions.includes(action)) {
+                throw new Error(`ADO missing required action: ${action}`);
+            }
+        }
+        console.log(`   ✅ Action coverage: GitHub(${githubActions.length}), ADO(${adoActions.length})`);
+        // Test 7: Workflow Validation
+        console.log('   Test 7: Workflow validation...');
+        const validation = templateEngine.validateWorkflow(testWorkflow, 'github');
+        if (!validation.valid) {
+            throw new Error(`Workflow validation failed: ${validation.missingActions.join(', ')}`);
+        }
+        const invalidWorkflow = '{{nonexistent_action}} should fail';
+        const invalidValidation = templateEngine.validateWorkflow(invalidWorkflow, 'github');
+        if (invalidValidation.valid) {
+            throw new Error('Invalid workflow should have failed validation');
+        }
+        console.log('   ✅ Workflow validation works');
+        console.log('✅ All Multi-Provider Platform Support tests passed!');
+        console.log(`
+📋 **Summary**: 
+- Providers: ${providers.join(', ')}
+- GitHub Actions: ${githubActions.length}
+- ADO Actions: ${adoActions.length}
+- Template Processing: ✅ Working
+- Platform Detection: ✅ Working
+- Config Validation: ✅ Working
+        `);
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Multi-Provider Platform Support test failed:', error.message);
+        return false;
+    }
+}
+// Run if called directly
+if (require.main === module) {
+    testMultiProviderSupport()
+        .then(success => process.exit(success ? 0 : 1))
+        .catch(err => {
+        console.error('Test runner error:', err);
+        process.exit(1);
+    });
+}

package/dist/tests/test-package-size.js

@@ -26,6 +26,9 @@ function findProjectRoot() {
     const projectRoot = findProjectRoot();
     const fullWorkflowsPath = path_1.default.join(projectRoot, 'registry', 'workflows');
     const stubWorkflowsPath = path_1.default.join(projectRoot, 'registry', 'stubs', 'workflows');
+    console.log(`Project root: ${projectRoot}`);
+    console.log(`Full workflows path: ${fullWorkflowsPath}`);
+    console.log(`Stub workflows path: ${stubWorkflowsPath}`);
     (0, node_assert_1.default)(fs_1.default.existsSync(fullWorkflowsPath), 'Full workflows directory should exist');
     (0, node_assert_1.default)(fs_1.default.existsSync(stubWorkflowsPath), 'Stub workflows directory should exist');
     // Calculate sizes
@@ -39,6 +42,10 @@ function findProjectRoot() {
     // Should have same number of files
     const fullFiles = getAllFiles(fullWorkflowsPath, '.md');
     const stubFiles = getAllFiles(stubWorkflowsPath, '.md');
+    console.log(`Full files found: ${fullFiles.length}`);
+    console.log(`Stub files found: ${stubFiles.length}`);
+    console.log(`First few full files: ${fullFiles.slice(0, 3).join(', ')}`);
+    console.log(`First few stub files: ${stubFiles.slice(0, 3).join(', ')}`);
     node_assert_1.default.strictEqual(stubFiles.length, fullFiles.length, 'Should have same number of workflow files');
     console.log(`✅ Package size reduced by ${Math.round((1 - stubSize / fullSize) * 100)}% while maintaining all ${stubFiles.length} workflows`);
 });

package/dist/tests/test-pr-review-workflow.js

@@ -43,9 +43,9 @@ async function testPRReviewFailureHandling() {
         // Test submit-pr failure
         const submitPRFailure = (0, phase_flow_js_1.getPhaseOnFailure)('submit-pr', 'implement', 'bug');
         node_assert_1.strict.equal(submitPRFailure, 'implement-completeness-review', 'submit-pr failure should return to completeness-review');
-        // Test wait-for-pr-review failure (default)
+        // Test wait-for-pr-review failure (should go to address-pr-feedback)
         const waitPRFailure = (0, phase_flow_js_1.getPhaseOnFailure)('wait-for-pr-review', 'implement', 'bug');
-        node_assert_1.strict.equal(waitPRFailure, 'implement-code', 'wait-for-pr-review failure should default to implement-code');
+        node_assert_1.strict.equal(waitPRFailure, 'address-pr-feedback', 'wait-for-pr-review failure should go to address-pr-feedback');
         // Test all workflow types have new phases
         const specPhases = (0, phase_flow_js_1.getPhasesForWorkflow)('spec');
         (0, node_assert_1.strict)(specPhases.includes('submit-pr'), 'Spec workflow should include submit-pr');
@@ -191,10 +191,14 @@ async function testRealWorldPRReviewScenario() {
         node_assert_1.strict.equal(finalPhase, null, 'wait-for-pr-review should be final phase when approved');
         // Test PR review with changes requested (failure scenario)
         const failurePhase = (0, phase_flow_js_1.getPhaseOnFailure)('wait-for-pr-review', workflowType, issueType);
-        node_assert_1.strict.equal(failurePhase, 'implement-code', 'PR changes requested should route to implement-code by default');
-        // Test iteration: after fixing code, go through validation again
-        let iterationPhase = 'implement-code';
-        const iterationFlow = ['implement-validate', 'implement-smoke', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review'];
+        node_assert_1.strict.equal(failurePhase, 'address-pr-feedback', 'PR changes requested should route to address-pr-feedback');
+        // Test iteration: after addressing feedback, go through validation again
+        let iterationPhase = 'address-pr-feedback';
+        // After addressing feedback, should go to validation phase
+        const nextAfterFeedback = (0, phase_flow_js_1.getNextPhase)(iterationPhase, workflowType, issueType);
+        node_assert_1.strict.equal(nextAfterFeedback, 'implement-validate', 'After address-pr-feedback should go to implement-validate');
+        iterationPhase = nextAfterFeedback;
+        const iterationFlow = ['implement-smoke', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review'];
         for (const expectedNext of iterationFlow) {
             const nextPhase = (0, phase_flow_js_1.getNextPhase)(iterationPhase, workflowType, issueType);
             node_assert_1.strict.equal(nextPhase, expectedNext, `Iteration: after ${iterationPhase} should go to ${expectedNext}`);

package/dist/tests/test-session-rehydration.js

@@ -92,7 +92,11 @@ async function testRehydrationAndExemptions() {
             params: {
                 name: 'fraim_connect',
                 arguments: {
-                    machine: { hostname: 'repro-host' },
+                    agent: {
+                        name: 'Claude',
+                        model: 'test-model'
+                    },
+                    machine: { hostname: 'repro-host', platform: 'test' },
                     repo: { url: 'http://github.com/repro' }
                 }
             }

package/dist/tests/test-telemetry.js

@@ -94,6 +94,10 @@ async function testTelemetryFlow() {
             params: {
                 name: 'fraim_connect',
                 arguments: {
+                    agent: {
+                        name: 'Claude',
+                        model: 'test-model'
+                    },
                     machine: { hostname: 'test-host', platform: 'test-os' },
                     repo: { url: 'http://github.com/test/repo' }
                 }

package/dist/tests/test-workflow-discovery.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * Tests for dynamic workflow discovery in MCP server
+ * Ensures workflows from all categories can be found without hardcoded category lists
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const shared_server_utils_js_1 = require("./shared-server-utils.js");
+(0, node_test_1.describe)('Workflow Discovery', () => {
+    (0, node_test_1.before)(async () => {
+        // Wait for the test server to be ready
+        await (0, shared_server_utils_js_1.waitForServer)();
+    });
+    (0, node_test_1.describe)('Dynamic Category Discovery', () => {
+        (0, node_test_1.it)('should find workflows from product-building category', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'get_fraim_workflow',
+                    arguments: { workflow: 'spec' }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            node_assert_1.default.ok(Array.isArray(response.data.result.content));
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(content.text.includes('Workflow: spec'));
+            node_assert_1.default.ok(content.text.includes('workflows/product-building/spec.md'));
+        });
+        (0, node_test_1.it)('should find workflows from compliance category', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 2,
+                method: 'tools/call',
+                params: {
+                    name: 'get_fraim_workflow',
+                    arguments: { workflow: 'detect-compliance-requirements' }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(content.text.includes('Workflow: detect-compliance-requirements'));
+            node_assert_1.default.ok(content.text.includes('workflows/compliance/detect-compliance-requirements.md'));
+            node_assert_1.default.ok(content.text.includes('Detect Compliance Requirements'));
+        });
+        (0, node_test_1.it)('should find workflows from brainstorming category', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'get_fraim_workflow',
+                    arguments: { workflow: 'blue-sky-brainstorming' }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(content.text.includes('Workflow: blue-sky-brainstorming'));
+            node_assert_1.default.ok(content.text.includes('workflows/brainstorming/blue-sky-brainstorming.md'));
+        });
+        (0, node_test_1.it)('should find workflows from learning category', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 4,
+                method: 'tools/call',
+                params: {
+                    name: 'get_fraim_workflow',
+                    arguments: { workflow: 'synthesize-learnings' }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(content.text.includes('Workflow: synthesize-learnings'));
+            node_assert_1.default.ok(content.text.includes('workflows/learning/synthesize-learnings.md'));
+        });
+        (0, node_test_1.it)('should find workflows from replicate category', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 5,
+                method: 'tools/call',
+                params: {
+                    name: 'get_fraim_workflow',
+                    arguments: { workflow: 'replicate-discovery' }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(content.text.includes('Workflow: replicate-discovery'));
+            node_assert_1.default.ok(content.text.includes('workflows/replicate/replicate-discovery.md'));
+        });
+        (0, node_test_1.it)('should find workflows from marketing category', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 6,
+                method: 'tools/call',
+                params: {
+                    name: 'get_fraim_workflow',
+                    arguments: { workflow: 'create-modern-website' }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(content.text.includes('Workflow: create-modern-website'));
+            node_assert_1.default.ok(content.text.includes('workflows/marketing/create-modern-website.md'));
+        });
+    });
+    (0, node_test_1.describe)('Error Handling', () => {
+        (0, node_test_1.it)('should return helpful error for non-existent workflow', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 7,
+                method: 'tools/call',
+                params: {
+                    name: 'get_fraim_workflow',
+                    arguments: { workflow: 'non-existent-workflow' }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(content.text.includes('Workflow "non-existent-workflow" not found'));
+            node_assert_1.default.ok(content.text.includes('Available workflows:'));
+        });
+        (0, node_test_1.it)('should handle workflow names with .md extension', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 8,
+                method: 'tools/call',
+                params: {
+                    name: 'get_fraim_workflow',
+                    arguments: { workflow: 'spec.md' }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(content.text.includes('Workflow: spec'));
+            node_assert_1.default.ok(content.text.includes('workflows/product-building/spec.md'));
+        });
+    });
+    (0, node_test_1.describe)('Regression Prevention', () => {
+        (0, node_test_1.it)('should discover all workflow categories dynamically', async () => {
+            const axios = require('axios');
+            // Test that we can find workflows from multiple categories without hardcoding
+            const testCases = [
+                { workflow: 'spec', expectedCategory: 'product-building' },
+                { workflow: 'detect-compliance-requirements', expectedCategory: 'compliance' },
+                { workflow: 'blue-sky-brainstorming', expectedCategory: 'brainstorming' },
+                { workflow: 'synthesize-learnings', expectedCategory: 'learning' },
+                { workflow: 'replicate-discovery', expectedCategory: 'replicate' },
+                { workflow: 'create-modern-website', expectedCategory: 'marketing' }
+            ];
+            for (const testCase of testCases) {
+                const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                    jsonrpc: '2.0',
+                    id: 100 + testCases.indexOf(testCase),
+                    method: 'tools/call',
+                    params: {
+                        name: 'get_fraim_workflow',
+                        arguments: { workflow: testCase.workflow }
+                    }
+                });
+                node_assert_1.default.strictEqual(response.status, 200, `Failed to find workflow: ${testCase.workflow}`);
+                node_assert_1.default.ok(response.data.result, `No result for workflow: ${testCase.workflow}`);
+                node_assert_1.default.ok(response.data.result.content, `No content for workflow: ${testCase.workflow}`);
+                const content = response.data.result.content[0];
+                node_assert_1.default.strictEqual(content.type, 'text');
+                node_assert_1.default.ok(content.text.includes(`workflows/${testCase.expectedCategory}/${testCase.workflow}.md`), `Expected workflow ${testCase.workflow} to be found in category ${testCase.expectedCategory}, but got: ${content.text.substring(0, 200)}`);
+            }
+        });
+        (0, node_test_1.it)('should not fail when new categories are added', async () => {
+            // This test documents the expected behavior:
+            // When new workflow categories are added to the registry,
+            // they should be automatically discoverable without code changes
+            const axios = require('axios');
+            // Get list of all workflows to verify dynamic discovery is working
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 200,
+                method: 'tools/call',
+                params: {
+                    name: 'list_fraim_workflows'
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            // Verify that multiple categories are listed
+            const expectedCategories = [
+                'bootstrap',
+                'brainstorming',
+                'business-development',
+                'compliance',
+                'customer-development',
+                'learning',
+                'marketing',
+                'product-building',
+                'replicate'
+            ];
+            for (const category of expectedCategories) {
+                node_assert_1.default.ok(content.text.includes(category), `Expected category "${category}" to be listed in workflows, but got: ${content.text.substring(0, 500)}`);
+            }
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.47",
+  "version": "2.0.49",
   "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": {
@@ -15,8 +15,10 @@
     "test": "node scripts/test-with-server.js",
     "start:fraim": "tsx src/fraim-mcp-server.ts",
     "dev:fraim": "tsx --watch src/fraim-mcp-server.ts",
+    "serve:website": "node fraim-pro/serve.js",
     "watch:fraimlogs": "tsx scripts/watch-fraim-logs.ts",
     "manage-keys": "tsx scripts/fraim/manage-keys.ts",
+    "view-signups": "tsx scripts/view-signups.ts",
     "fraim:init": "npm run build && node bin/fraim.js init",
     "fraim:sync": "node bin/fraim.js sync",
     "postinstall": "fraim sync || echo 'FRAIM setup skipped.'",

package/registry/scripts/create-website-structure.js

@@ -10,7 +10,21 @@
 const fs = require('fs');
 const path = require('path');
 
-function createWebsiteStructure(projectName, outputDir = '.') {
+// Read configuration from .fraim/config.json if available
+function loadConfig() {
+    const configPath = path.join(process.cwd(), '.fraim', 'config.json');
+    if (fs.existsSync(configPath)) {
+        try {
+            return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        } catch (error) {
+            console.warn('Warning: Could not parse .fraim/config.json, using defaults');
+            return {};
+        }
+    }
+    return {};
+}
+
+function createWebsiteStructure(projectName, outputDir = process.cwd()) {
     const websiteDir = path.join(outputDir, projectName);
     
     // Create main directory
@@ -531,9 +545,10 @@ Thumbs.db
 
 // CLI usage
 if (require.main === module) {
+    const config = loadConfig();
     const args = process.argv.slice(2);
     const projectName = args[0];
-    const outputDir = args[1] || '.';
+    const outputDir = args[1] || process.cwd();
     
     if (!projectName) {
         console.log('Usage: node create-website-structure.js <project-name> [output-directory]');

package/registry/scripts/profile-server.ts

@@ -3,6 +3,7 @@
 import { execSync } from 'child_process';
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
+import * as path from 'path';
 
 /**
  * Production Server Profiler

package/registry/stubs/workflows/compliance/soc2-evidence-generator.md

@@ -0,0 +1,11 @@
+# FRAIM Workflow: soc2-evidence-generator
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
+> To load the full context (rules, templates, and execution steps), ask your AI agent to:
+> `@fraim get_fraim_workflow("soc2-evidence-generator")`
+>
+> DO NOT EXECUTE.
+
+## Intent
+Generate comprehensive SOC2 compliance evidence packages by automatically collecting, documenting, and formatting evidence from project systems to demonstrate adherence to Trust Service Criteria during annual audits.

package/registry/stubs/workflows/learning/build-skillset.md

@@ -0,0 +1,11 @@
+# FRAIM Workflow: build-skillset
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
+> To load the full context (rules, templates, and execution steps), ask your AI agent to:
+> `@fraim get_fraim_workflow("build-skillset")`
+>
+> DO NOT EXECUTE.
+
+## Intent
+Create new project-specific skills through conversation with the user. This workflow allows agents to learn and document custom workflows, processes, and knowledge that are specific to the current project or team.

package/registry/stubs/workflows/legal/contract-review-analysis.md

@@ -0,0 +1,11 @@
+# FRAIM Workflow: contract-review-analysis
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
+> To load the full context (rules, templates, and execution steps), ask your AI agent to:
+> `@fraim get_fraim_workflow("contract-review-analysis")`
+>
+> DO NOT EXECUTE.
+
+## Intent
+Provide thorough, strategic legal contract review that identifies risks, strengthens protections, and optimizes business positioning. This skill enables comprehensive analysis of SOWs, NDAs, Terms & Conditions, and other legal documents to protect interests while maintaining business relationships.

package/registry/stubs/workflows/legal/saas-contract-development.md

@@ -0,0 +1,11 @@
+# FRAIM Workflow: saas-contract-development
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
+> To load the full context (rules, templates, and execution steps), ask your AI agent to:
+> `@fraim get_fraim_workflow("saas-contract-development")`
+>
+> DO NOT EXECUTE.
+
+## Intent
+Create comprehensive, legally protective contract packages for SaaS engagements including SOWs, Terms & Conditions, and strategic pricing negotiations. This skill enables rapid development of professional-grade legal documents that protect IP, limit liability, and position for business growth.