fraim 2.0.100

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

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserFraimDir = getUserFraimDir;
+exports.getUserScriptsDir = getUserScriptsDir;
+exports.ensureUserFraimDirectories = ensureUserFraimDirectories;
+exports.getRegistryScripts = getRegistryScripts;
+exports.copyScriptToUserDirectory = copyScriptToUserDirectory;
+exports.syncScriptsToUserDirectory = syncScriptsToUserDirectory;
+exports.cleanupObsoleteUserScripts = cleanupObsoleteUserScripts;
+exports.getUserScriptPath = getUserScriptPath;
+exports.userScriptExists = userScriptExists;
+exports.validateUserScripts = validateUserScripts;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Get the user-level FRAIM directory path
+ * Can be overridden with FRAIM_USER_DIR environment variable for testing
+ */
+function getUserFraimDir() {
+    return process.env.FRAIM_USER_DIR || path_1.default.join(os_1.default.homedir(), '.fraim');
+}
+/**
+ * Get the user-level scripts directory path
+ */
+function getUserScriptsDir() {
+    return path_1.default.join(getUserFraimDir(), 'scripts');
+}
+/**
+ * Ensure the user-level FRAIM directories exist and initialize user config
+ */
+function ensureUserFraimDirectories() {
+    const userFraimDir = getUserFraimDir();
+    const userScriptsDir = getUserScriptsDir();
+    if (!fs_1.default.existsSync(userFraimDir)) {
+        fs_1.default.mkdirSync(userFraimDir, { recursive: true });
+    }
+    if (!fs_1.default.existsSync(userScriptsDir)) {
+        fs_1.default.mkdirSync(userScriptsDir, { recursive: true });
+    }
+    // Initialize user config (~/.fraim/config.json) if it doesn't exist
+    const userConfigPath = path_1.default.join(userFraimDir, 'config.json');
+    if (!fs_1.default.existsSync(userConfigPath)) {
+        fs_1.default.writeFileSync(userConfigPath, JSON.stringify({ workingStyle: 'PR' }, null, 2));
+    }
+}
+/**
+ * Get all script files from the registry (recursively)
+ */
+function getRegistryScripts(registryPath) {
+    const scriptsPath = path_1.default.join(registryPath, 'scripts');
+    if (!fs_1.default.existsSync(scriptsPath)) {
+        return [];
+    }
+    const getAllFiles = (dir, baseDir = dir) => {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        let files = [];
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Recursively get files from subdirectories
+                files = files.concat(getAllFiles(fullPath, baseDir));
+            }
+            else {
+                // Include all files (not just specific extensions)
+                files.push(fullPath);
+            }
+        }
+        return files;
+    };
+    return getAllFiles(scriptsPath);
+}
+/**
+ * Copy a script file to the user scripts directory with proper permissions
+ * Preserves directory structure from registry/scripts/
+ */
+function copyScriptToUserDirectory(sourcePath, registryScriptsPath) {
+    const userScriptsDir = getUserScriptsDir();
+    // Calculate relative path from registry/scripts to preserve structure
+    const relativePath = path_1.default.relative(registryScriptsPath, sourcePath);
+    const targetPath = path_1.default.join(userScriptsDir, relativePath);
+    // Ensure target directory exists
+    const targetDir = path_1.default.dirname(targetPath);
+    if (!fs_1.default.existsSync(targetDir)) {
+        fs_1.default.mkdirSync(targetDir, { recursive: true });
+    }
+    // Copy the file
+    fs_1.default.copyFileSync(sourcePath, targetPath);
+    // Set executable permissions on Unix systems for shell scripts
+    if (process.platform !== 'win32' && sourcePath.endsWith('.sh')) {
+        try {
+            fs_1.default.chmodSync(targetPath, 0o755);
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`⚠️ Could not set executable permissions for ${relativePath}`));
+        }
+    }
+}
+/**
+ * Sync all scripts from registry to user directory
+ */
+function syncScriptsToUserDirectory(registryPath) {
+    ensureUserFraimDirectories();
+    const registryScriptsPath = path_1.default.join(registryPath, 'scripts');
+    const allScripts = getRegistryScripts(registryPath);
+    let syncedCount = 0;
+    console.log(chalk_1.default.gray(`  Syncing all scripts to ~/.fraim/scripts/:`));
+    for (const scriptPath of allScripts) {
+        const relativePath = path_1.default.relative(registryScriptsPath, scriptPath);
+        const userScriptPath = path_1.default.join(getUserScriptsDir(), relativePath);
+        try {
+            // Check if script needs updating
+            let needsUpdate = true;
+            if (fs_1.default.existsSync(userScriptPath)) {
+                const registryContent = fs_1.default.readFileSync(scriptPath, 'utf-8');
+                const userContent = fs_1.default.readFileSync(userScriptPath, 'utf-8');
+                needsUpdate = registryContent !== userContent;
+            }
+            if (needsUpdate) {
+                copyScriptToUserDirectory(scriptPath, registryScriptsPath);
+                syncedCount++;
+                console.log(chalk_1.default.gray(`    + ${relativePath}`));
+            }
+            else {
+                console.log(chalk_1.default.gray(`    = ${relativePath} (up to date)`));
+            }
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`⚠️ Could not sync script ${relativePath}: ${error}`));
+        }
+    }
+    return { synced: syncedCount, ephemeral: 0 };
+}
+/**
+ * Clean up scripts in user directory that no longer exist in registry
+ */
+function cleanupObsoleteUserScripts(registryPath) {
+    const userScriptsDir = getUserScriptsDir();
+    if (!fs_1.default.existsSync(userScriptsDir)) {
+        return 0;
+    }
+    const registryScriptsPath = path_1.default.join(registryPath, 'scripts');
+    const registryScripts = getRegistryScripts(registryPath);
+    const registryRelativePaths = registryScripts.map(scriptPath => path_1.default.relative(registryScriptsPath, scriptPath));
+    // Get all files in user scripts directory recursively
+    const getAllUserFiles = (dir, baseDir = dir) => {
+        if (!fs_1.default.existsSync(dir))
+            return [];
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        let files = [];
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files = files.concat(getAllUserFiles(fullPath, baseDir));
+            }
+            else {
+                files.push(path_1.default.relative(baseDir, fullPath));
+            }
+        }
+        return files;
+    };
+    const userFiles = getAllUserFiles(userScriptsDir);
+    let cleanedCount = 0;
+    for (const userFile of userFiles) {
+        // Normalize path separators for comparison
+        const normalizedUserFile = userFile.replace(/\\/g, '/');
+        const normalizedRegistry = registryRelativePaths.map(p => p.replace(/\\/g, '/'));
+        if (!normalizedRegistry.includes(normalizedUserFile)) {
+            try {
+                const userFilePath = path_1.default.join(userScriptsDir, userFile);
+                fs_1.default.unlinkSync(userFilePath);
+                cleanedCount++;
+                console.log(chalk_1.default.yellow(`  - ${userFile} (removed from registry)`));
+                // Cleanup empty directories
+                try {
+                    const dir = path_1.default.dirname(userFilePath);
+                    if (fs_1.default.existsSync(dir) && fs_1.default.readdirSync(dir).length === 0) {
+                        fs_1.default.rmdirSync(dir);
+                    }
+                }
+                catch (e) { }
+            }
+            catch (error) {
+                console.warn(chalk_1.default.yellow(`⚠️ Could not remove obsolete script ${userFile}: ${error}`));
+            }
+        }
+    }
+    return cleanedCount;
+}
+/**
+ * Get the path to a script in the user directory
+ */
+function getUserScriptPath(scriptName) {
+    return path_1.default.join(getUserScriptsDir(), scriptName);
+}
+/**
+ * Check if a script exists in the user directory
+ */
+function userScriptExists(scriptName) {
+    return fs_1.default.existsSync(getUserScriptPath(scriptName));
+}
+/**
+ * Validate that all expected scripts are present in user directory
+ */
+function validateUserScripts(expectedScripts) {
+    const missing = [];
+    const present = [];
+    for (const scriptName of expectedScripts) {
+        if (userScriptExists(scriptName)) {
+            present.push(scriptName);
+        }
+        else {
+            missing.push(scriptName);
+        }
+    }
+    return { missing, present };
+}

package/dist/src/cli/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/cli/utils/version-utils.ts -> package.json is ../../../package.json
+    // dist: dist/src/cli/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
+    ];
+    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/src/core/ai-mentor.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIMentor = void 0;
+const include_resolver_1 = require("./utils/include-resolver");
+class AIMentor {
+    constructor(resolver) {
+        this.jobCache = new Map();
+        this.resolver = resolver;
+    }
+    /**
+     * Handle mentoring/coaching request from agent
+     */
+    async handleMentoringRequest(args) {
+        const workflow = await this.getOrLoadJob(args.jobName);
+        if (!workflow) {
+            throw new Error(`Job "${args.jobName}" not found or invalid.`);
+        }
+        const validStatus = ['starting', 'complete', 'incomplete', 'failure'].includes(args.status);
+        if (!validStatus) {
+            throw new Error(`Invalid status: ${args.status}. Must be one of: starting, complete, incomplete, failure.`);
+        }
+        // For simple workflows, skip phase validation
+        if (!workflow.isSimple) {
+            const phases = workflow.metadata.phases || {};
+            const hasMetadata = !!phases[args.currentPhase];
+            const hasMarkdown = workflow.phases.has(args.currentPhase);
+            if (!hasMetadata && !hasMarkdown && args.currentPhase !== 'starting') {
+                throw new Error(`Phase "${args.currentPhase}" not found in job "${args.jobName}".`);
+            }
+        }
+        // Handle different statuses
+        if (args.status === 'starting') {
+            return await this.generateStartingMessage(workflow, args.currentPhase, args.skipIncludes);
+        }
+        else if (args.status === 'complete') {
+            return await this.generateCompletionMessage(workflow, args.currentPhase, args.findings, args.evidence, args.skipIncludes);
+        }
+        else {
+            return await this.generateHelpMessage(workflow, args.currentPhase, args.status, args.skipIncludes);
+        }
+    }
+    async getOrLoadJob(jobType) {
+        if (this.jobCache.has(jobType)) {
+            return this.jobCache.get(jobType);
+        }
+        const job = await this.resolver.getJob(jobType);
+        if (job) {
+            this.jobCache.set(jobType, job);
+            return job;
+        }
+        return null;
+    }
+    async resolveIncludes(content, basePath) {
+        return (0, include_resolver_1.resolveIncludes)(content, this.resolver, basePath);
+    }
+    assertNoUnresolvedIncludes(content, context) {
+        const matches = content.match(/\{\{include:[^}]+\}\}/g);
+        if (!matches || matches.length === 0)
+            return;
+        const unique = Array.from(new Set(matches));
+        throw new Error(`Unresolved include directives in ${context}: ${unique.join(', ')}`);
+    }
+    buildReportBackFooter(jobName, phaseId, phaseFlow) {
+        if (!phaseFlow)
+            return '';
+        const base = `seekMentoring({
+  jobName: "${jobName}",
+  issueNumber: "<issue_number>",
+  currentPhase: "${phaseId}",
+  status: "complete",`;
+        const onSuccess = phaseFlow.onSuccess;
+        let successBlock;
+        if (!onSuccess) {
+            successBlock = `\n\n---\n\n> **⚑ Phase Complete — Report Back**\n> When you have finished all steps above, call:\n> \`\`\`javascript\n> ${base}\n>   // This is the final phase.\n> })\n> \`\`\``;
+        }
+        else if (typeof onSuccess === 'string') {
+            successBlock = `\n\n---\n\n> **⚑ Phase Complete — Report Back**\n> When you have finished all steps above, call:\n> \`\`\`javascript\n> ${base}\n> })\n> \`\`\``;
+        }
+        else {
+            const validOutcomes = Object.keys(onSuccess)
+                .filter(k => k !== 'default')
+                .map(k => `"${k}"`)
+                .join(' | ');
+            successBlock = `\n\n---\n\n> **⚑ Phase Complete — Report Back**\n> The next phase depends on your outcome. Set \`findings.issueType\` (or \`findings.phaseOutcome\`) to one of: ${validOutcomes}\n>\n> Then call:\n> \`\`\`javascript\n> ${base}\n>   findings: { issueType: "<Outcome>" }\n> })\n> \`\`\``;
+        }
+        return successBlock;
+    }
+    /** Phase-authority content injected for all phased workflows. Loaded from orchestration/phase-authority.md. */
+    async getPhaseAuthorityContent() {
+        try {
+            const content = await this.resolver.getFile('orchestration/phase-authority.md');
+            return content?.trim() || '';
+        }
+        catch {
+            return '';
+        }
+    }
+    async prependPhaseAuthority(message, isPhased) {
+        if (!isPhased)
+            return message;
+        const block = await this.getPhaseAuthorityContent();
+        if (!block)
+            return message;
+        return `${block}\n\n---\n\n${message}`;
+    }
+    async generateStartingMessage(workflow, phaseId, skipIncludes) {
+        const entityType = 'Job';
+        if (workflow.isSimple) {
+            const message = `🚀 **Starting ${entityType}: ${workflow.metadata.name}**\n\n${workflow.overview}`;
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name} (starting)`);
+            return {
+                message,
+                nextPhase: null,
+                status: 'starting'
+            };
+        }
+        const isVeryFirstCall = phaseId === 'starting';
+        const targetPhase = isVeryFirstCall ? (workflow.metadata.initialPhase || 'starting') : phaseId;
+        let message = '';
+        if (isVeryFirstCall && workflow.overview) {
+            message += `${workflow.overview}\n\n---\n\n`;
+        }
+        let instructions = workflow.phases.get(targetPhase);
+        if (instructions) {
+            instructions = skipIncludes ? instructions : await this.resolveIncludes(instructions, workflow.path);
+            message += `${instructions}`;
+        }
+        else {
+            message += `⚠️ No specific instructions found for phase: ${targetPhase}`;
+        }
+        const phaseFlow = workflow.metadata.phases?.[targetPhase];
+        message += this.buildReportBackFooter(workflow.metadata.name, targetPhase, phaseFlow);
+        if (!skipIncludes) {
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name}:${targetPhase} (starting)`);
+        }
+        return {
+            message: await this.prependPhaseAuthority(message, true),
+            nextPhase: targetPhase,
+            status: 'starting'
+        };
+    }
+    async generateCompletionMessage(workflow, phaseId, findings, evidence, skipIncludes) {
+        const entityType = 'Job';
+        if (workflow.isSimple) {
+            const message = `✅ **${entityType} Complete: ${workflow.metadata.name}**\n\n🎉 Great work! You have completed the ${workflow.metadata.name} ${entityType.toLowerCase()}.`;
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name} (complete)`);
+            return {
+                message,
+                nextPhase: null,
+                status: 'complete'
+            };
+        }
+        const phaseFlow = workflow.metadata.phases?.[phaseId];
+        let nextPhaseId = null;
+        if (phaseFlow && phaseFlow.onSuccess) {
+            if (typeof phaseFlow.onSuccess === 'string') {
+                nextPhaseId = phaseFlow.onSuccess;
+            }
+            else {
+                const outcome = findings?.phaseOutcome ?? findings?.issueType ?? evidence?.issueType ?? evidence?.phaseOutcome ?? 'default';
+                nextPhaseId = phaseFlow.onSuccess[outcome] ?? phaseFlow.onSuccess['default'] ?? null;
+            }
+        }
+        let message = '';
+        if (nextPhaseId) {
+            message += `Great work. Moving to the next phase: **${nextPhaseId}**.\n\n`;
+            let nextInstructions = workflow.phases.get(nextPhaseId);
+            if (nextInstructions) {
+                nextInstructions = skipIncludes ? nextInstructions : await this.resolveIncludes(nextInstructions, workflow.path);
+                message += nextInstructions;
+            }
+            const nextPhaseFlow = workflow.metadata.phases?.[nextPhaseId];
+            message += this.buildReportBackFooter(workflow.metadata.name, nextPhaseId, nextPhaseFlow);
+        }
+        else {
+            message += `🎉 **${entityType} Accomplished!** You have completed all phases of the ${workflow.metadata.name} ${entityType.toLowerCase()}.`;
+        }
+        if (!skipIncludes) {
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name}:${phaseId} (complete)`);
+        }
+        return {
+            message: await this.prependPhaseAuthority(message, true),
+            nextPhase: nextPhaseId,
+            status: 'complete'
+        };
+    }
+    async generateHelpMessage(workflow, phaseId, status, skipIncludes) {
+        const entityType = 'Job';
+        if (workflow.isSimple) {
+            const message = `**${entityType}: ${workflow.metadata.name}**\n\n${workflow.overview}`;
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name} (${status})`);
+            return {
+                message,
+                nextPhase: null,
+                status
+            };
+        }
+        const phaseMeta = workflow.metadata.phases?.[phaseId];
+        const targetPhaseId = status === 'failure' ? (phaseMeta?.onFailure || phaseId) : phaseId;
+        let message = `### Current Phase: ${targetPhaseId}\n\n`;
+        let instructions = workflow.phases.get(targetPhaseId);
+        if (instructions) {
+            instructions = skipIncludes ? instructions : await this.resolveIncludes(instructions, workflow.path);
+            message += instructions;
+        }
+        if (!skipIncludes) {
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name}:${targetPhaseId} (${status})`);
+        }
+        return {
+            message: await this.prependPhaseAuthority(message, true),
+            nextPhase: targetPhaseId,
+            status
+        };
+    }
+    async getJobOverview(jobName) {
+        const job = await this.getOrLoadJob(jobName);
+        return job ? { overview: job.overview, isSimple: job.isSimple } : null;
+    }
+    async getAllJobMetadata() {
+        const items = await this.resolver.listItems('job');
+        const jobs = [];
+        for (const item of items) {
+            const job = await this.resolver.getJob(item.name);
+            if (job)
+                jobs.push(job);
+        }
+        return jobs;
+    }
+}
+exports.AIMentor = AIMentor;

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

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * FRAIM Configuration Loader
+ * Loads and validates workspace FRAIM config with fallback to defaults.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeFraimConfig = normalizeFraimConfig;
+exports.loadFraimConfig = loadFraimConfig;
+exports.getConfigValue = getConfigValue;
+exports.getRepositoryInfo = getRepositoryInfo;
+const fs_1 = require("fs");
+const types_1 = require("./types");
+const project_fraim_paths_1 = require("./utils/project-fraim-paths");
+function normalizeFraimConfig(config) {
+    // Handle backward compatibility and migration
+    const mergedConfig = {
+        version: config.version || types_1.DEFAULT_FRAIM_CONFIG.version,
+        project: {
+            ...types_1.DEFAULT_FRAIM_CONFIG.project,
+            ...(config.project || {})
+        },
+        repository: {
+            ...types_1.DEFAULT_FRAIM_CONFIG.repository,
+            ...(config.repository || {}),
+            // Migrate from old git config if repository is missing
+            ...((!config.repository && config.git) ? {
+                provider: config.git.provider || 'github',
+                owner: config.git.repoOwner,
+                name: config.git.repoName,
+                defaultBranch: config.git.defaultBranch || 'main'
+            } : {})
+        },
+        customizations: {
+            ...types_1.DEFAULT_FRAIM_CONFIG.customizations,
+            ...(config.customizations || {})
+        }
+    };
+    if (config.customizations?.postCleanupHook || config.customizations?.cleanupCommand) {
+        if (!mergedConfig.customizations)
+            mergedConfig.customizations = {};
+        mergedConfig.customizations.postCleanupHook = config.customizations.postCleanupHook || config.customizations.cleanupCommand;
+    }
+    if (config.issueTracking && typeof config.issueTracking === 'object') {
+        mergedConfig.issueTracking = config.issueTracking;
+    }
+    if (config.compliance) {
+        mergedConfig.compliance = config.compliance;
+    }
+    if (config.learning) {
+        mergedConfig.learning = config.learning;
+    }
+    if (config.competitors && typeof config.competitors === 'object') {
+        mergedConfig.competitors = config.competitors;
+    }
+    return mergedConfig;
+}
+/**
+ * Load FRAIM configuration from the workspace FRAIM config file.
+ * Falls back to defaults if the file doesn't exist.
+ */
+function loadFraimConfig(configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(process.cwd())) {
+    const displayPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json');
+    if (!(0, fs_1.existsSync)(configPath)) {
+        console.log(`No ${displayPath} found, using defaults`);
+        return { ...types_1.DEFAULT_FRAIM_CONFIG };
+    }
+    try {
+        const configContent = (0, fs_1.readFileSync)(configPath, 'utf-8');
+        const config = JSON.parse(configContent);
+        const mergedConfig = normalizeFraimConfig(config);
+        console.log(`Loaded FRAIM config from ${displayPath} (version ${mergedConfig.version})`);
+        if (config.git && !config.repository) {
+            console.warn('Deprecated: "git" config detected. Consider migrating to "repository" config.');
+        }
+        return mergedConfig;
+    }
+    catch (error) {
+        console.warn(`Failed to load ${displayPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        console.warn('Using default configuration');
+        return { ...types_1.DEFAULT_FRAIM_CONFIG };
+    }
+}
+function getConfigValue(config, path) {
+    const parts = path.split('.');
+    let value = config;
+    for (const part of parts) {
+        if (value && typeof value === 'object' && part in value) {
+            value = value[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return value;
+}
+function getRepositoryInfo(config) {
+    if (config.repository) {
+        return {
+            owner: config.repository.owner || config.repository.organization || config.repository.namespace,
+            name: config.repository.name,
+            provider: config.repository.provider,
+            defaultBranch: config.repository.defaultBranch
+        };
+    }
+    if (config.git) {
+        return {
+            owner: config.git.repoOwner,
+            name: config.git.repoName,
+            provider: config.git.provider || 'github',
+            defaultBranch: config.git.defaultBranch
+        };
+    }
+    return {};
+}

package/dist/src/core/config-writer.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFraimConfigRaw = readFraimConfigRaw;
+exports.mergeFraimConfig = mergeFraimConfig;
+exports.writeFraimConfigUpdate = writeFraimConfigUpdate;
+exports.writeFraimConfig = writeFraimConfig;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_loader_1 = require("./config-loader");
+const types_1 = require("./types");
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function deepMerge(baseValue, updateValue) {
+    if (updateValue === undefined) {
+        return baseValue;
+    }
+    if (Array.isArray(updateValue)) {
+        return [...updateValue];
+    }
+    if (!isPlainObject(updateValue)) {
+        return updateValue;
+    }
+    const baseObject = isPlainObject(baseValue) ? baseValue : {};
+    const merged = { ...baseObject };
+    for (const [key, value] of Object.entries(updateValue)) {
+        merged[key] = deepMerge(baseObject[key], value);
+    }
+    return merged;
+}
+function ensureWritableFraimConfigShape(rawConfig) {
+    const config = { ...rawConfig };
+    if (typeof config.version !== 'string' || config.version.trim().length === 0) {
+        config.version = types_1.DEFAULT_FRAIM_CONFIG.version;
+    }
+    const projectConfig = isPlainObject(config.project) ? config.project : {};
+    config.project = {
+        ...types_1.DEFAULT_FRAIM_CONFIG.project,
+        ...projectConfig
+    };
+    const customizationsConfig = isPlainObject(config.customizations) ? config.customizations : {};
+    config.customizations = {
+        ...types_1.DEFAULT_FRAIM_CONFIG.customizations,
+        ...customizationsConfig
+    };
+    return config;
+}
+function readFraimConfigRaw(configPath) {
+    if (!(0, fs_1.existsSync)(configPath)) {
+        return {};
+    }
+    const parsed = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf8'));
+    if (!isPlainObject(parsed)) {
+        throw new Error('FRAIM config must contain a JSON object at the top level.');
+    }
+    return parsed;
+}
+function mergeFraimConfig(existingRawConfig, update) {
+    const rawConfig = ensureWritableFraimConfigShape(deepMerge(existingRawConfig, update));
+    return {
+        config: (0, config_loader_1.normalizeFraimConfig)(rawConfig),
+        created: Object.keys(existingRawConfig).length === 0,
+        rawConfig
+    };
+}
+function writeFraimConfigUpdate(configPath, update) {
+    const existingRawConfig = readFraimConfigRaw(configPath);
+    const result = mergeFraimConfig(existingRawConfig, update);
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(configPath), { recursive: true });
+    (0, fs_1.writeFileSync)(configPath, JSON.stringify(result.rawConfig, null, 2));
+    return result;
+}
+function writeFraimConfig(configPath, config) {
+    return writeFraimConfigUpdate(configPath, config);
+}