fraim 2.0.100

package/dist/src/cli/setup/provider-prompts.js

@@ -0,0 +1,339 @@
+"use strict";
+// Generic provider prompt system - no hardcoded provider knowledge
+// All provider information comes from the server via ProviderClient
+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 });
+exports.promptForProviders = promptForProviders;
+exports.promptForSingleProvider = promptForSingleProvider;
+exports.promptForProviderToken = promptForProviderToken;
+exports.promptForProviderConfig = promptForProviderConfig;
+exports.promptForProviderCredentials = promptForProviderCredentials;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+/**
+ * Prompt user to select multiple providers
+ */
+async function promptForProviders(client, preselectedIds) {
+    console.log(chalk_1.default.blue('\n🔧 Platform Selection'));
+    console.log(chalk_1.default.gray('Which platforms do you want to integrate with?\n'));
+    // Get providers that support integrated mode
+    const integratedProviders = await client.getProvidersWithCapability('integrated');
+    // Default to first integrated provider (typically GitHub)
+    const defaultProviderId = integratedProviders[0]?.id;
+    const choices = integratedProviders.map(provider => ({
+        title: provider.displayName,
+        value: provider.id,
+        selected: preselectedIds?.includes(provider.id) ?? provider.id === defaultProviderId
+    }));
+    if (process.env.FRAIM_NON_INTERACTIVE) {
+        console.log(chalk_1.default.yellow(`\nℹ️  Non-interactive mode: defaulting to ${integratedProviders[0]?.displayName || 'first available provider'}`));
+        return [defaultProviderId];
+    }
+    const response = await (0, prompts_1.default)({
+        type: 'multiselect',
+        name: 'providers',
+        message: 'Select platforms (Space to select, Enter to confirm)',
+        choices,
+        min: 1
+    });
+    if (!response.providers || response.providers.length === 0) {
+        const defaultProvider = await client.getProvider(defaultProviderId);
+        console.log(chalk_1.default.yellow(`\nℹ️  No platforms selected, defaulting to ${defaultProvider?.displayName || 'first available provider'}`));
+        return [defaultProviderId];
+    }
+    console.log(chalk_1.default.blue('\n✓ Selected platforms:'));
+    for (const id of response.providers) {
+        const provider = await client.getProvider(id);
+        if (provider) {
+            console.log(chalk_1.default.gray(`  - ${provider.displayName}`));
+        }
+    }
+    console.log();
+    return response.providers;
+}
+/**
+ * Prompt user to select a single provider (for code repo or issue tracking)
+ */
+async function promptForSingleProvider(client, purpose, availableIds) {
+    const purposeLabel = purpose === 'code' ? 'Code Repository' : 'Issue Tracking';
+    const purposeDesc = purpose === 'code' ? 'code hosting' : 'issue tracking';
+    console.log(chalk_1.default.blue(`\n📦 ${purposeLabel} Platform`));
+    console.log(chalk_1.default.gray(`Select the platform for ${purposeDesc}:\n`));
+    // Use capability-based filtering if no explicit filter provided
+    let providers;
+    if (availableIds) {
+        providers = [];
+        for (const id of availableIds) {
+            const provider = await client.getProvider(id);
+            if (provider)
+                providers.push(provider);
+        }
+    }
+    else {
+        providers = await client.getProvidersWithCapability(purpose);
+    }
+    // Default to first available provider
+    const defaultProviderId = providers[0]?.id;
+    const choices = providers.map(provider => ({
+        title: provider.displayName,
+        value: provider.id
+    }));
+    if (process.env.FRAIM_NON_INTERACTIVE) {
+        console.log(chalk_1.default.yellow(`\nℹ️  Non-interactive mode: defaulting to ${providers[0]?.displayName || 'first available provider'}`));
+        return defaultProviderId;
+    }
+    const response = await (0, prompts_1.default)({
+        type: 'select',
+        name: 'provider',
+        message: `Select ${purposeDesc} platform`,
+        choices,
+        initial: 0
+    });
+    if (!response.provider) {
+        const defaultProvider = await client.getProvider(defaultProviderId);
+        console.log(chalk_1.default.yellow(`\nℹ️  No platform selected, defaulting to ${defaultProvider?.displayName || 'first available provider'}`));
+        return defaultProviderId;
+    }
+    const provider = await client.getProvider(response.provider);
+    if (provider) {
+        console.log(chalk_1.default.blue(`\n✓ ${purposeLabel}: ${provider.displayName}\n`));
+    }
+    return response.provider;
+}
+/**
+ * Prompt for a provider's token
+ */
+async function promptForProviderToken(client, providerId) {
+    let provider;
+    try {
+        provider = await client.getProvider(providerId);
+    }
+    catch (error) {
+        // Server unavailable - use local fallback
+        const { getLocalProvider } = await Promise.resolve().then(() => __importStar(require('../providers/local-provider-registry')));
+        provider = getLocalProvider(providerId);
+    }
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    console.log(chalk_1.default.blue(`\n🔧 ${provider.displayName} Integration Setup`));
+    console.log(`FRAIM requires a ${provider.displayName} token for integration.\n`);
+    if (process.env.FRAIM_NON_INTERACTIVE) {
+        throw new Error(`Non-interactive mode: ${provider.displayName} token is missing and cannot prompt.`);
+    }
+    const hasToken = await (0, prompts_1.default)({
+        type: 'confirm',
+        name: 'hasToken',
+        message: `Do you have a ${provider.displayName} token?`,
+        initial: false
+    });
+    if (!hasToken.hasToken) {
+        if (providerId === 'github') {
+            const loginChoice = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'login',
+                message: `Would you like to login to ${provider.displayName} now using your browser? (Recommended)`,
+                initial: true
+            });
+            if (loginChoice.login) {
+                const { DeviceFlowService } = await Promise.resolve().then(() => __importStar(require('../internal/device-flow-service')));
+                if (!provider.deviceFlowConfig) {
+                    throw new Error(`Device flow configuration not found for provider: ${providerId}`);
+                }
+                const deviceFlow = new DeviceFlowService(provider.deviceFlowConfig);
+                try {
+                    return await deviceFlow.login();
+                }
+                catch (e) {
+                    console.log(chalk_1.default.yellow('\nBrowser login failed or was cancelled. Fallback to manual token entry.'));
+                }
+            }
+        }
+        console.log(chalk_1.default.yellow(`\n📝 To create a ${provider.displayName} token:`));
+        console.log(chalk_1.default.gray(`   ${provider.setupInstructions}`));
+        console.log(chalk_1.default.gray(`   Visit: ${provider.docsUrl}\n`));
+    }
+    let token = null;
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (!token && attempts < maxAttempts) {
+        const tokenResponse = await (0, prompts_1.default)({
+            type: 'password',
+            name: 'token',
+            message: attempts === 0
+                ? `Enter your ${provider.displayName} token`
+                : `Enter your ${provider.displayName} token (attempt ${attempts + 1}/${maxAttempts})`,
+            validate: (value) => {
+                if (!value)
+                    return `${provider.displayName} token is required`;
+                return true;
+            }
+        });
+        if (!tokenResponse.token) {
+            console.log(chalk_1.default.red(`\n❌ ${provider.displayName} token is required.`));
+            attempts++;
+            if (attempts < maxAttempts) {
+                const retry = await (0, prompts_1.default)({
+                    type: 'confirm',
+                    name: 'retry',
+                    message: 'Would you like to try entering the token again?',
+                    initial: true
+                });
+                if (!retry.retry)
+                    break;
+            }
+            continue;
+        }
+        token = tokenResponse.token;
+        console.log(chalk_1.default.green(`✅ ${provider.displayName} token received\n`));
+    }
+    if (!token) {
+        throw new Error(`Failed to get ${provider.displayName} token`);
+    }
+    return token;
+}
+/**
+ * Prompt for additional provider configuration (e.g., Jira URL and email)
+ */
+async function promptForProviderConfig(client, providerId) {
+    let provider;
+    let schema;
+    try {
+        provider = await client.getProvider(providerId);
+        schema = await client.getProviderSchema(providerId);
+    }
+    catch (error) {
+        // Server unavailable - use local fallback
+        const { getLocalProvider, getLocalProviderConfigRequirements } = await Promise.resolve().then(() => __importStar(require('../providers/local-provider-registry')));
+        provider = getLocalProvider(providerId);
+        if (!provider) {
+            throw new Error(`Unknown provider: ${providerId}`);
+        }
+        schema = { configRequirements: getLocalProviderConfigRequirements(providerId) };
+    }
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    const requirements = schema.configRequirements;
+    if (requirements.length === 0) {
+        return {};
+    }
+    console.log(chalk_1.default.blue(`\n🔧 ${provider.displayName} Configuration`));
+    console.log(`Additional configuration required for ${provider.displayName}.\n`);
+    const config = {};
+    for (const req of requirements) {
+        if (process.env.FRAIM_NON_INTERACTIVE) {
+            if (req.required) {
+                throw new Error(`Non-interactive mode: Required configuration "${req.displayName}" for ${provider.displayName} is missing.`);
+            }
+            console.log(chalk_1.default.yellow(`\nℹ️  Non-interactive mode: skipping optional configuration "${req.displayName}"`));
+            continue;
+        }
+        const response = await (0, prompts_1.default)({
+            type: req.type === 'email' ? 'text' : req.type === 'url' ? 'text' : 'text',
+            name: 'value',
+            message: `Enter ${req.displayName}`,
+            validate: (value) => {
+                if (req.required && !value) {
+                    return `${req.displayName} is required`;
+                }
+                if (req.type === 'email' && value && !value.includes('@')) {
+                    return 'Please enter a valid email address';
+                }
+                if (req.type === 'url' && value) {
+                    try {
+                        new URL(value.startsWith('http') ? value : `https://${value}`);
+                    }
+                    catch {
+                        return 'Please enter a valid URL';
+                    }
+                }
+                return true;
+            }
+        });
+        if (!response.value && req.required) {
+            throw new Error(`${req.displayName} is required`);
+        }
+        config[req.key] = response.value;
+    }
+    console.log(chalk_1.default.green(`✅ ${provider.displayName} configuration received\n`));
+    return config;
+}
+/**
+ * Get token and config for a provider (handles both token and additional config)
+ */
+async function promptForProviderCredentials(client, providerId, existingToken, existingConfig) {
+    let provider;
+    let schema;
+    try {
+        provider = await client.getProvider(providerId);
+        schema = await client.getProviderSchema(providerId);
+    }
+    catch (error) {
+        // Server unavailable - use local fallback
+        const { getLocalProvider, getLocalProviderConfigRequirements } = await Promise.resolve().then(() => __importStar(require('../providers/local-provider-registry')));
+        provider = getLocalProvider(providerId);
+        if (!provider) {
+            throw new Error(`Unknown provider: ${providerId}`);
+        }
+        schema = { configRequirements: getLocalProviderConfigRequirements(providerId) };
+    }
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    // Get token if not provided
+    const token = existingToken || await promptForProviderToken(client, providerId);
+    // Get additional config if needed
+    const requirements = schema.configRequirements;
+    let config;
+    if (requirements.length > 0) {
+        // Check if we have all required config
+        const hasAllConfig = existingConfig && requirements.every(req => !req.required || existingConfig[req.key]);
+        if (!hasAllConfig) {
+            config = await promptForProviderConfig(client, providerId);
+            // Merge with existing config
+            if (existingConfig) {
+                config = { ...existingConfig, ...config };
+            }
+        }
+        else {
+            config = existingConfig;
+        }
+    }
+    return { token, config };
+}

package/dist/src/cli/utils/agent-adapters.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAgentAdapterFiles = ensureAgentAdapterFiles;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const START_MARKER = '<!-- FRAIM_AGENT_ADAPTER_START -->';
+const END_MARKER = '<!-- FRAIM_AGENT_ADAPTER_END -->';
+const CURSOR_RULE_PATH = path_1.default.join('.cursor', 'rules', 'fraim.mdc');
+const CURSOR_FRONTMATTER = `---
+description: FRAIM discovery and execution contract
+alwaysApply: true
+---`;
+function buildManagedSection(body) {
+    return `${START_MARKER}
+${body.trim()}
+${END_MARKER}
+`;
+}
+function mergeManagedSection(existingContent, managedSection) {
+    const normalized = existingContent.replace(/\r\n/g, '\n');
+    const startIndex = normalized.indexOf(START_MARKER);
+    const endIndex = normalized.indexOf(END_MARKER);
+    if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+        const before = normalized.slice(0, startIndex).trimEnd();
+        const after = normalized.slice(endIndex + END_MARKER.length).trimStart();
+        const pieces = [before, managedSection.trim(), after].filter(Boolean);
+        return `${pieces.join('\n\n').trim()}\n`;
+    }
+    if (!normalized.trim()) {
+        return `${managedSection.trim()}\n`;
+    }
+    return `${normalized.trimEnd()}\n\n${managedSection.trim()}\n`;
+}
+function mergeCursorRule(existingContent, managedSection) {
+    const normalized = existingContent.replace(/\r\n/g, '\n').trimStart();
+    const bodyWithoutLeadingFrontmatter = normalized.replace(/^(?:---\n[\s\S]*?\n---(?:\n+)?)*/, '');
+    const mergedBody = mergeManagedSection(bodyWithoutLeadingFrontmatter, managedSection).trim();
+    return `${CURSOR_FRONTMATTER}\n\n${mergedBody}\n`;
+}
+function getAdapterFiles() {
+    const fraimRoot = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)().replace(/\/$/, '');
+    const employeeJobsPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('ai-employee/jobs');
+    const managerJobsPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('ai-manager/jobs');
+    const employeeSkillsPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('ai-employee/skills');
+    const employeeRulesPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('ai-employee/rules');
+    const personalizedRootPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('personalized-employee');
+    const projectRulesPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('personalized-employee/rules/project_rules.md');
+    const markdownBody = buildManagedSection(`
+## FRAIM
+
+This repository uses FRAIM.
+
+- The FRAIM discovery catalog lives under \`${fraimRoot}/\`.
+- Jobs under \`${employeeJobsPath}/\` and \`${managerJobsPath}/\` are FRAIM's primary execution units. Treat them like first-class workflows when deciding how to execute work.
+- Skills under \`${employeeSkillsPath}/\` are reusable capabilities that jobs compose.
+- Rules under \`${employeeRulesPath}/\` are always-on constraints and conventions.
+- Repo-specific overrides and learning artifacts live under \`${personalizedRootPath}/\` and take precedence over synced baseline content.
+- Use stub filenames and summaries to discover what to invoke. Once you identify a relevant job, call \`get_fraim_job({ job: "<job-name>" })\`.
+- For deeper capability detail, call \`get_fraim_file({ path: "skills/<category>/<skill-name>.md" })\` or \`get_fraim_file({ path: "rules/<category>/<rule-name>.md" })\`.
+- Read \`${projectRulesPath}\` if it exists before doing work.
+`);
+    const cursorManagedBody = buildManagedSection(`
+Use FRAIM as the repo's execution framework.
+
+- Discover available jobs, skills, and rules under \`${fraimRoot}/\`.
+- Jobs are the primary execution units; treat them like first-class workflows.
+- Skills are reusable capability modules jobs compose.
+- Rules are always-on constraints.
+- Repo-specific overrides and learnings under \`${personalizedRootPath}/\` take precedence.
+- Choose a relevant job from the stubs, then call \`get_fraim_job(...)\` for the full phased instructions.
+`);
+    const copilotBody = buildManagedSection(`
+## FRAIM
+
+- Use \`${fraimRoot}/\` as the repository's FRAIM catalog.
+- FRAIM jobs are the primary execution units and should be treated like first-class workflows.
+- FRAIM skills are reusable capabilities jobs compose.
+- FRAIM rules are always-on constraints and conventions.
+- Repo-specific overrides and learnings live under \`${personalizedRootPath}/\`.
+- Use the stubs to identify which job to invoke before fetching full content with FRAIM MCP tools.
+`);
+    const fraimReadme = `# FRAIM Catalog
+
+This directory is the repository-visible FRAIM surface.
+
+- \`ai-employee/jobs/\`: employee job stubs
+- \`ai-manager/jobs/\`: manager job stubs
+- \`ai-employee/skills/\`: skill stubs
+- \`ai-employee/rules/\`: rule stubs
+- \`personalized-employee/\`: repo-specific overrides and learnings
+
+Use the stubs here to discover which FRAIM job, skill, or rule is relevant, then load the full content through FRAIM MCP tools.
+`;
+    return [
+        { path: 'AGENTS.md', content: markdownBody },
+        { path: 'CLAUDE.md', content: markdownBody },
+        { path: path_1.default.join('.github', 'copilot-instructions.md'), content: copilotBody },
+        { path: CURSOR_RULE_PATH, content: cursorManagedBody },
+        { path: path_1.default.join(project_fraim_paths_1.WORKSPACE_FRAIM_DIRNAME, 'README.md'), content: fraimReadme }
+    ];
+}
+function ensureAgentAdapterFiles(projectRoot) {
+    const updatedPaths = [];
+    for (const file of getAdapterFiles()) {
+        const fullPath = path_1.default.join(projectRoot, file.path);
+        const dir = path_1.default.dirname(fullPath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        const existing = fs_1.default.existsSync(fullPath) ? fs_1.default.readFileSync(fullPath, 'utf8') : '';
+        const next = file.path === CURSOR_RULE_PATH
+            ? mergeCursorRule(existing, file.content)
+            : file.path.endsWith('README.md')
+                ? file.content
+                : mergeManagedSection(existing, file.content);
+        if (existing !== next) {
+            fs_1.default.writeFileSync(fullPath, next, 'utf8');
+            updatedPaths.push(file.path.replace(/\\/g, '/'));
+        }
+    }
+    return updatedPaths;
+}

package/dist/src/cli/utils/digest-utils.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDigest = generateDigest;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Generates a digest (hash) for a directory or file.
+ * This is used to compare the framework's registry with the project's local stubs.
+ */
+async function generateDigest(targetPath) {
+    if (!fs_1.default.existsSync(targetPath)) {
+        return '';
+    }
+    const stats = fs_1.default.statSync(targetPath);
+    if (stats.isFile()) {
+        const content = fs_1.default.readFileSync(targetPath);
+        return crypto_1.default.createHash('md5').update(content).digest('hex');
+    }
+    if (stats.isDirectory()) {
+        const getAllFiles = (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()) {
+                    files = files.concat(getAllFiles(fullPath));
+                }
+                else {
+                    files.push(fullPath);
+                }
+            }
+            return files;
+        };
+        const allFiles = getAllFiles(targetPath);
+        const hashes = [];
+        for (const file of allFiles.sort()) {
+            const content = fs_1.default.readFileSync(file);
+            hashes.push(crypto_1.default.createHash('md5').update(content).digest('hex'));
+        }
+        return crypto_1.default.createHash('md5').update(hashes.join('')).digest('hex');
+    }
+    return '';
+}

package/dist/src/cli/utils/fraim-gitignore.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFraimSyncedContentIgnored = exports.FRAIM_SYNC_GITIGNORE_ENTRIES = exports.FRAIM_SYNC_GITIGNORE_END = exports.FRAIM_SYNC_GITIGNORE_START = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.FRAIM_SYNC_GITIGNORE_START = '# BEGIN FRAIM SYNCED CONTENT';
+exports.FRAIM_SYNC_GITIGNORE_END = '# END FRAIM SYNCED CONTENT';
+exports.FRAIM_SYNC_GITIGNORE_ENTRIES = [
+    'fraim/ai-employee/',
+    'fraim/ai-manager/',
+    'fraim/docs/',
+];
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const ensureFraimSyncedContentIgnored = (projectRoot) => {
+    const gitignorePath = path_1.default.join(projectRoot, '.gitignore');
+    const existingRaw = fs_1.default.existsSync(gitignorePath)
+        ? fs_1.default.readFileSync(gitignorePath, 'utf8')
+        : '';
+    const newline = existingRaw.includes('\r\n') ? '\r\n' : '\n';
+    const normalized = existingRaw.replace(/\r\n/g, '\n');
+    const managedBlock = `${exports.FRAIM_SYNC_GITIGNORE_START}\n${exports.FRAIM_SYNC_GITIGNORE_ENTRIES.join('\n')}\n${exports.FRAIM_SYNC_GITIGNORE_END}`;
+    const blockPattern = new RegExp(`\\n?${escapeRegExp(exports.FRAIM_SYNC_GITIGNORE_START)}[\\s\\S]*?${escapeRegExp(exports.FRAIM_SYNC_GITIGNORE_END)}\\n?`, 'm');
+    const withoutManagedBlock = normalized.replace(blockPattern, '\n').trimEnd();
+    const cleaned = withoutManagedBlock
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/^\n+/, '')
+        .trimEnd();
+    const next = cleaned.length > 0
+        ? `${cleaned}\n\n${managedBlock}\n`
+        : `${managedBlock}\n`;
+    if (next !== normalized) {
+        fs_1.default.writeFileSync(gitignorePath, next.replace(/\n/g, newline), 'utf8');
+        return true;
+    }
+    return false;
+};
+exports.ensureFraimSyncedContentIgnored = ensureFraimSyncedContentIgnored;