fraim-framework 2.0.67 → 2.0.69

package/dist/src/fraim/issue-tracking-config.js

@@ -1,83 +0,0 @@
-"use strict";
-/**
- * Issue Tracking Configuration Helper
- *
- * Provides guidance on which MCP tools to use based on configuration.
- * This replaces custom providers with MCP tool recommendations.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIssueTrackingGuidance = getIssueTrackingGuidance;
-exports.getRepositoryInfo = getRepositoryInfo;
-const config_loader_1 = require("./config-loader");
-/**
- * Get guidance on which MCP tools to use for issue tracking
- */
-function getIssueTrackingGuidance() {
-    const config = (0, config_loader_1.loadFraimConfig)();
-    // Check for ADO configuration
-    if (config.repository?.provider === 'ado') {
-        return {
-            provider: 'ado',
-            mcpTools: {
-                createIssue: 'mcp_ado_create_work_item',
-                getIssue: 'mcp_ado_get_work_item',
-                updateIssue: 'mcp_ado_update_work_item',
-                listIssues: 'mcp_ado_list_work_items',
-                createPR: 'mcp_ado_create_pull_request',
-                getPR: 'mcp_ado_get_pull_request',
-                mergePR: 'mcp_ado_merge_pull_request'
-            },
-            config: {
-                organization: config.repository.organization,
-                project: config.repository.project
-            },
-            environmentVars: ['ADO_TOKEN', 'AZURE_DEVOPS_TOKEN'],
-            setupInstructions: `Configure ADO MCP server in your IDE with:
-- Organization: ${config.repository.organization}
-- Project: ${config.repository.project}
-- Token: Set ADO_TOKEN or AZURE_DEVOPS_TOKEN environment variable`
-        };
-    }
-    // Default to GitHub
-    const owner = config.repository?.owner || config.git?.repoOwner || 'mathursrus';
-    const repo = config.repository?.name || config.git?.repoName || 'FRAIM';
-    return {
-        provider: 'github',
-        mcpTools: {
-            createIssue: 'mcp_github_issue_write',
-            getIssue: 'mcp_github_issue_read',
-            updateIssue: 'mcp_github_issue_write',
-            listIssues: 'mcp_github_list_issues',
-            createPR: 'mcp_github_create_pull_request',
-            getPR: 'mcp_github_pull_request_read',
-            mergePR: 'mcp_github_merge_pull_request'
-        },
-        config: {
-            owner,
-            repo
-        },
-        environmentVars: ['GITHUB_TOKEN'],
-        setupInstructions: `GitHub MCP tools are configured for:
-- Repository: ${owner}/${repo}
-- Token: Set GITHUB_TOKEN environment variable
-- MCP Server: Ensure GitHub MCP server is configured in your IDE`
-    };
-}
-/**
- * Get repository information from .fraim/config.json
- */
-function getRepositoryInfo() {
-    try {
-        const config = (0, config_loader_1.loadFraimConfig)();
-        const owner = config.repository?.owner || config.git?.repoOwner;
-        const repo = config.repository?.name || config.git?.repoName;
-        return {
-            owner,
-            repo,
-            url: owner && repo ? `https://github.com/${owner}/${repo}.git` : undefined
-        };
-    }
-    catch (e) {
-        return {};
-    }
-}

package/dist/src/fraim/retrospective-learner.js

@@ -1,301 +0,0 @@
-"use strict";
-/**
- * FRAIM Retrospective Learning System
- * Scans retrospectives, extracts learnings, and generates rules
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scanRetrospectives = scanRetrospectives;
-exports.detectPatterns = detectPatterns;
-exports.generateRuleFromPattern = generateRuleFromPattern;
-exports.learnFromRetrospectives = learnFromRetrospectives;
-const fs_1 = require("fs");
-const path_1 = require("path");
-/**
- * Scan retrospectives directory and parse files
- */
-function scanRetrospectives(retrospectivesPath = 'retrospectives') {
-    const fullPath = (0, path_1.join)(process.cwd(), retrospectivesPath);
-    if (!(0, fs_1.existsSync)(fullPath)) {
-        console.warn(`⚠️  Retrospectives directory not found: ${fullPath}`);
-        return [];
-    }
-    const learnings = [];
-    const files = (0, fs_1.readdirSync)(fullPath, { withFileTypes: true });
-    for (const file of files) {
-        if (file.isFile() && (0, path_1.extname)(file.name) === '.md') {
-            const filePath = (0, path_1.join)(fullPath, file.name);
-            try {
-                const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
-                const parsed = parseRetrospective(content, file.name);
-                if (parsed) {
-                    learnings.push(parsed);
-                }
-            }
-            catch (error) {
-                console.warn(`⚠️  Failed to parse retrospective ${file.name}: ${error}`);
-            }
-        }
-    }
-    return learnings;
-}
-/**
- * Parse a retrospective markdown file
- * Looks for common patterns: issues, problems, solutions, lessons learned
- */
-function parseRetrospective(content, filename) {
-    // Extract issue number from filename (e.g., "393-retrospective.md" -> "393")
-    const issueMatch = filename.match(/(\d+)/);
-    const issue = issueMatch ? `Issue #${issueMatch[1]}` : filename.replace('.md', '');
-    // Try to extract date from filename or content
-    const dateMatch = filename.match(/(\d{4}-\d{2}-\d{2})/) || content.match(/(\d{4}-\d{2}-\d{2})/);
-    const date = dateMatch ? dateMatch[1] : new Date().toISOString().split('T')[0];
-    // Extract problems (look for sections like "Problems", "Issues", "What went wrong")
-    const problems = extractSection(content, ['problem', 'issue', 'what went wrong', 'challenges', 'bugs']);
-    // Extract solutions (look for sections like "Solutions", "Fixes", "What we did")
-    const solutions = extractSection(content, ['solution', 'fix', 'what we did', 'resolution', 'action']);
-    // Extract lessons (look for sections like "Lessons", "Learnings", "Takeaways")
-    const lessons = extractSection(content, ['lesson', 'learning', 'takeaway', 'insight', 'prevention']);
-    // Determine category based on content
-    const category = categorizeLearning(content, problems, lessons);
-    if (problems.length === 0 && lessons.length === 0) {
-        return null; // Skip if no useful content
-    }
-    return {
-        issue,
-        date,
-        problems,
-        solutions,
-        lessons,
-        category
-    };
-}
-/**
- * Extract content from a section
- */
-function extractSection(content, keywords) {
-    const items = [];
-    const lines = content.split('\n');
-    let inSection = false;
-    let currentItem = '';
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        const lineLower = line.toLowerCase();
-        // Check if this line starts a relevant section
-        if (keywords.some(keyword => lineLower.includes(keyword) && (line.startsWith('#') || line.startsWith('##')))) {
-            inSection = true;
-            continue;
-        }
-        // Check if we hit a new section
-        if (inSection && (line.startsWith('#') || line.startsWith('##'))) {
-            if (currentItem.trim()) {
-                items.push(currentItem.trim());
-                currentItem = '';
-            }
-            // Check if this is still a relevant section
-            if (!keywords.some(keyword => lineLower.includes(keyword))) {
-                inSection = false;
-            }
-            continue;
-        }
-        // Collect content in section
-        if (inSection) {
-            // Look for list items
-            if (line.startsWith('-') || line.startsWith('*') || line.match(/^\d+\./)) {
-                if (currentItem.trim()) {
-                    items.push(currentItem.trim());
-                }
-                currentItem = line.replace(/^[-*\d+.\s]*/, '');
-            }
-            else if (line.trim()) {
-                currentItem += (currentItem ? ' ' : '') + line;
-            }
-        }
-    }
-    if (currentItem.trim()) {
-        items.push(currentItem.trim());
-    }
-    return items.filter(item => item.length > 10); // Filter out very short items
-}
-/**
- * Categorize learning based on content
- */
-function categorizeLearning(content, problems, lessons) {
-    const allText = (content + ' ' + problems.join(' ') + ' ' + lessons.join(' ')).toLowerCase();
-    if (allText.includes('test') || allText.includes('spec') || allText.includes('coverage')) {
-        return 'testing';
-    }
-    if (allText.includes('architecture') || allText.includes('pattern') || allText.includes('design')) {
-        return 'architecture';
-    }
-    if (allText.includes('workflow') || allText.includes('process') || allText.includes('step')) {
-        return 'workflow';
-    }
-    if (allText.includes('code quality') || allText.includes('lint') || allText.includes('type')) {
-        return 'code-quality';
-    }
-    return 'other';
-}
-/**
- * Detect patterns across multiple retrospectives
- */
-function detectPatterns(learnings) {
-    const patterns = new Map();
-    for (const learning of learnings) {
-        // Analyze problems
-        for (const problem of learning.problems) {
-            const key = extractKeyPhrase(problem);
-            if (key) {
-                const existing = patterns.get(key) || {
-                    pattern: key,
-                    frequency: 0,
-                    examples: [],
-                    lesson: '',
-                    suggestedRule: `learned-${key.toLowerCase().replace(/\s+/g, '-')}.md`,
-                    category: learning.category
-                };
-                existing.frequency++;
-                if (!existing.examples.includes(learning.issue)) {
-                    existing.examples.push(learning.issue);
-                }
-                patterns.set(key, existing);
-            }
-        }
-        // Analyze lessons
-        for (const lesson of learning.lessons) {
-            const key = extractKeyPhrase(lesson);
-            if (key) {
-                const existing = patterns.get(key) || {
-                    pattern: key,
-                    frequency: 0,
-                    examples: [],
-                    lesson: lesson,
-                    suggestedRule: `learned-${key.toLowerCase().replace(/\s+/g, '-')}.md`,
-                    category: learning.category
-                };
-                existing.frequency++;
-                if (!existing.examples.includes(learning.issue)) {
-                    existing.examples.push(learning.issue);
-                }
-                if (!existing.lesson && lesson.length > existing.lesson.length) {
-                    existing.lesson = lesson;
-                }
-                patterns.set(key, existing);
-            }
-        }
-    }
-    // Filter patterns that appear multiple times
-    return Array.from(patterns.values())
-        .filter(p => p.frequency >= 2)
-        .sort((a, b) => b.frequency - a.frequency);
-}
-/**
- * Extract key phrase from text (simplified)
- */
-function extractKeyPhrase(text) {
-    // Look for common patterns
-    const patterns = [
-        /(?:always|never|must|should)\s+([^.!?]+)/i,
-        /(?:don'?t|do not)\s+([^.!?]+)/i,
-        /(?:ensure|verify|check|test)\s+([^.!?]+)/i
-    ];
-    for (const pattern of patterns) {
-        const match = text.match(pattern);
-        if (match && match[1]) {
-            return match[1].trim().substring(0, 100); // Limit length
-        }
-    }
-    // Fallback: first sentence
-    const firstSentence = text.split(/[.!?]/)[0].trim();
-    if (firstSentence.length > 10 && firstSentence.length < 150) {
-        return firstSentence;
-    }
-    return null;
-}
-/**
- * Generate a rule from a learning pattern
- */
-function generateRuleFromPattern(pattern, learnings) {
-    const relatedLearnings = learnings.filter(l => pattern.examples.some(ex => l.issue.includes(ex.split('#')[1] || '')));
-    let rule = `# Learned Rule: ${pattern.pattern}\n\n`;
-    rule += `## Source\n`;
-    rule += `This rule was automatically generated from project retrospectives:\n`;
-    for (const example of pattern.examples) {
-        rule += `- ${example}\n`;
-    }
-    rule += `\n`;
-    rule += `## Problem Pattern\n`;
-    if (relatedLearnings.length > 0) {
-        const problems = relatedLearnings.flatMap(l => l.problems).slice(0, 3);
-        rule += problems.map(p => `- ${p}`).join('\n') + '\n';
-    }
-    rule += `\n`;
-    rule += `## Learned Behavior\n`;
-    rule += `**${pattern.lesson || pattern.pattern}**\n\n`;
-    rule += `## Rule\n`;
-    rule += `Based on ${pattern.frequency} occurrence(s) across retrospectives:\n`;
-    rule += `1. Follow the learned behavior above\n`;
-    rule += `2. Reference this rule when similar situations arise\n`;
-    rule += `3. Update this rule if new learnings emerge\n\n`;
-    rule += `## Enforcement\n`;
-    rule += `- This is a learned rule from project experience\n`;
-    rule += `- Violations should trigger review of retrospective learnings\n`;
-    return rule;
-}
-/**
- * Learn from retrospectives and generate rules
- */
-function learnFromRetrospectives(retrospectivesPath = 'retrospectives', autoApply = false) {
-    try {
-        // Scan retrospectives
-        const learnings = scanRetrospectives(retrospectivesPath);
-        if (learnings.length === 0) {
-            return {
-                success: false,
-                message: 'No retrospectives found or no learnings extracted',
-                patterns: [],
-                rulesGenerated: 0
-            };
-        }
-        // Detect patterns
-        const patterns = detectPatterns(learnings);
-        if (patterns.length === 0) {
-            return {
-                success: true,
-                message: `Scanned ${learnings.length} retrospectives but found no recurring patterns (need at least 2 occurrences)`,
-                patterns: [],
-                rulesGenerated: 0
-            };
-        }
-        let rulesGenerated = 0;
-        if (autoApply) {
-            // Generate and write rules
-            const fraimRulesPath = (0, path_1.join)(process.cwd(), '.fraim', 'rules');
-            if (!(0, fs_1.existsSync)(fraimRulesPath)) {
-                throw new Error('.fraim/rules directory does not exist. Run fraim_setup first.');
-            }
-            for (const pattern of patterns) {
-                const ruleContent = generateRuleFromPattern(pattern, learnings);
-                const rulePath = (0, path_1.join)(fraimRulesPath, pattern.suggestedRule);
-                (0, fs_1.writeFileSync)(rulePath, ruleContent, 'utf-8');
-                rulesGenerated++;
-            }
-        }
-        const message = autoApply
-            ? `✅ Learned from ${learnings.length} retrospectives. Generated ${rulesGenerated} rules in .fraim/rules/`
-            : `📊 Found ${patterns.length} recurring patterns across ${learnings.length} retrospectives. Set autoApply=true to generate rules.`;
-        return {
-            success: true,
-            message,
-            patterns,
-            rulesGenerated
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            message: `Learning failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
-            patterns: [],
-            rulesGenerated: 0
-        };
-    }
-}

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

@@ -1,99 +0,0 @@
-"use strict";
-/**
- * FRAIM Setup Wizard
- * Generates .fraim/config.json and initial directory structure
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateConfigFromAnswers = generateConfigFromAnswers;
-exports.writeConfig = writeConfig;
-exports.createDirectoryStructure = createDirectoryStructure;
-exports.runSetup = runSetup;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const types_js_1 = require("./types.js");
-/**
- * Generate configuration from setup answers
- */
-function generateConfigFromAnswers(answers) {
-    const config = {
-        ...types_js_1.DEFAULT_FRAIM_CONFIG,
-        project: {
-            ...types_js_1.DEFAULT_FRAIM_CONFIG.project,
-            name: answers.projectName || types_js_1.DEFAULT_FRAIM_CONFIG.project.name
-        },
-        repository: {
-            provider: 'github',
-            owner: 'your-username',
-            name: 'your-project',
-            defaultBranch: answers.defaultBranch || 'main'
-        }
-    };
-    return config;
-}
-/**
- * Write configuration to .fraim/config.json
- */
-function writeConfig(config) {
-    const fraimDir = (0, path_1.join)(process.cwd(), '.fraim');
-    const configPath = (0, path_1.join)(fraimDir, 'config.json');
-    // Create .fraim directory if it doesn't exist
-    if (!(0, fs_1.existsSync)(fraimDir)) {
-        (0, fs_1.mkdirSync)(fraimDir, { recursive: true });
-    }
-    // Write config file
-    (0, fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2), 'utf-8');
-    console.log(`✅ Created .fraim/config.json`);
-}
-/**
- * Create initial directory structure
- */
-function createDirectoryStructure() {
-    const fraimDir = (0, path_1.join)(process.cwd(), '.fraim');
-    const dirs = [
-        (0, path_1.join)(fraimDir, 'rules'),
-        (0, path_1.join)(fraimDir, 'workflows'),
-        (0, path_1.join)(fraimDir, 'templates', 'specs'),
-        (0, path_1.join)(fraimDir, 'templates', 'evidence'),
-        (0, path_1.join)(fraimDir, 'templates', 'help'),
-        (0, path_1.join)(fraimDir, 'templates', 'retrospective'),
-        (0, path_1.join)(fraimDir, 'scripts')
-    ];
-    for (const dir of dirs) {
-        if (!(0, fs_1.existsSync)(dir)) {
-            (0, fs_1.mkdirSync)(dir, { recursive: true });
-            console.log(`✅ Created ${dir}`);
-        }
-    }
-}
-/**
- * Run setup wizard
- */
-function runSetup(answers) {
-    try {
-        // Check if config already exists
-        const configPath = (0, path_1.join)(process.cwd(), '.fraim', 'config.json');
-        if ((0, fs_1.existsSync)(configPath)) {
-            return {
-                success: false,
-                message: 'Configuration already exists at .fraim/config.json. Delete it first to run setup again.'
-            };
-        }
-        // Generate config from answers
-        const config = generateConfigFromAnswers(answers);
-        // Create directory structure
-        createDirectoryStructure();
-        // Write config
-        writeConfig(config);
-        return {
-            success: true,
-            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
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            message: `Setup failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-        };
-    }
-}