fraim 2.0.100

package/dist/src/cli/utils/platform-detection.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Platform Detection Utilities
+ *
+ * Detects development platform (GitHub, ADO) from git remote URLs
+ * and provides repository information extraction.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPlatformFromGit = detectPlatformFromGit;
+exports.getGitRemoteUrl = getGitRemoteUrl;
+exports.detectPlatformFromUrl = detectPlatformFromUrl;
+exports.validateRepositoryConfig = validateRepositoryConfig;
+exports.getCurrentBranch = getCurrentBranch;
+exports.isGitRepository = isGitRepository;
+const child_process_1 = require("child_process");
+/**
+ * Detect platform from git remote URL
+ */
+function detectPlatformFromGit() {
+    try {
+        const remoteUrl = getGitRemoteUrl();
+        if (!remoteUrl) {
+            return { provider: 'unknown', confidence: 'low' };
+        }
+        return detectPlatformFromUrl(remoteUrl);
+    }
+    catch (error) {
+        console.warn('⚠️ Failed to detect platform from git:', error);
+        return { provider: 'unknown', confidence: 'low' };
+    }
+}
+/**
+ * Get git remote URL
+ */
+function getGitRemoteUrl() {
+    try {
+        // Try origin first
+        const originUrl = (0, child_process_1.execSync)('git remote get-url origin', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        }).trim();
+        if (originUrl)
+            return originUrl;
+    }
+    catch (e) {
+        // Ignore error, try alternative methods
+    }
+    try {
+        // Try any remote
+        const remotes = (0, child_process_1.execSync)('git remote', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        }).trim().split('\n');
+        if (remotes.length > 0 && remotes[0]) {
+            const firstRemoteUrl = (0, child_process_1.execSync)(`git remote get-url ${remotes[0]}`, {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore']
+            }).trim();
+            return firstRemoteUrl;
+        }
+    }
+    catch (e) {
+        // Ignore error
+    }
+    return null;
+}
+/**
+ * Detect platform from URL
+ */
+function detectPlatformFromUrl(url) {
+    const normalizedUrl = url.toLowerCase();
+    // GitHub detection
+    if (normalizedUrl.includes('github.com')) {
+        const repository = extractGitHubInfo(url);
+        return {
+            provider: 'github',
+            repository,
+            confidence: 'high'
+        };
+    }
+    // GitLab detection
+    if (normalizedUrl.includes('gitlab.com') || normalizedUrl.includes('gitlab.')) {
+        const repository = extractGitLabInfo(url);
+        return {
+            provider: 'gitlab',
+            repository,
+            confidence: 'high'
+        };
+    }
+    // ADO detection
+    if (normalizedUrl.includes('dev.azure.com') ||
+        normalizedUrl.includes('visualstudio.com') ||
+        normalizedUrl.includes('azure.com')) {
+        const repository = extractAdoInfo(url);
+        return {
+            provider: 'ado',
+            repository,
+            confidence: 'high'
+        };
+    }
+    return { provider: 'unknown', confidence: 'low' };
+}
+/**
+ * Extract GitHub repository information from URL
+ */
+function extractGitHubInfo(url) {
+    // Handle both HTTPS and SSH URLs
+    // HTTPS: https://github.com/owner/repo.git
+    // SSH: git@github.com:owner/repo.git
+    let match;
+    // HTTPS format
+    match = url.match(/github\.com[\/:]([^\/]+)\/([^\/\.]+)/i);
+    if (match) {
+        return {
+            provider: 'github',
+            owner: match[1],
+            name: match[2],
+            url: url,
+            defaultBranch: 'main'
+        };
+    }
+    // Fallback - just mark as GitHub
+    return {
+        provider: 'github',
+        url: url,
+        defaultBranch: 'main'
+    };
+}
+/**
+ * Extract GitLab repository information from URL
+ */
+function extractGitLabInfo(url) {
+    // GitLab URL formats:
+    // HTTPS: https://gitlab.com/group/subgroup/repo.git
+    // SSH: git@gitlab.com:group/subgroup/repo.git
+    const match = url.match(/gitlab[^\/:]*[\/:]([^?\s#]+?)(?:\.git)?$/i);
+    if (match) {
+        const projectPath = match[1].replace(/^\/+/, '');
+        const segments = projectPath.split('/').filter(Boolean);
+        const name = segments[segments.length - 1];
+        const namespace = segments.slice(0, -1).join('/');
+        return {
+            provider: 'gitlab',
+            namespace: namespace || undefined,
+            name,
+            projectPath,
+            url,
+            defaultBranch: 'main'
+        };
+    }
+    // Fallback - just mark as GitLab
+    return {
+        provider: 'gitlab',
+        url,
+        defaultBranch: 'main'
+    };
+}
+/**
+ * Extract ADO repository information from URL
+ */
+function extractAdoInfo(url) {
+    // ADO URL formats:
+    // https://dev.azure.com/organization/project/_git/repository
+    // https://organization.visualstudio.com/project/_git/repository
+    let match;
+    // dev.azure.com format
+    match = url.match(/dev\.azure\.com\/([^\/]+)\/([^\/]+)\/_git\/([^\/\.]+)/i);
+    if (match) {
+        return {
+            provider: 'ado',
+            organization: match[1],
+            project: match[2],
+            name: match[3],
+            url: url,
+            defaultBranch: 'main'
+        };
+    }
+    // visualstudio.com format
+    match = url.match(/https?:\/\/([^\.]+)\.visualstudio\.com\/([^\/]+)\/_git\/([^\/\.]+)/i);
+    if (match) {
+        return {
+            provider: 'ado',
+            organization: match[1],
+            project: match[2],
+            name: match[3],
+            url: url,
+            defaultBranch: 'main'
+        };
+    }
+    // Fallback - just mark as ADO
+    return {
+        provider: 'ado',
+        url: url,
+        defaultBranch: 'main'
+    };
+}
+/**
+ * Validate repository configuration
+ */
+function validateRepositoryConfig(config) {
+    const errors = [];
+    if (!config.provider) {
+        errors.push('Provider is required');
+    }
+    if (config.provider === 'github') {
+        if (!config.owner)
+            errors.push('GitHub owner is required');
+        if (!config.name)
+            errors.push('GitHub repository name is required');
+    }
+    if (config.provider === 'ado') {
+        if (!config.organization)
+            errors.push('ADO organization is required');
+        if (!config.project)
+            errors.push('ADO project is required');
+        if (!config.name)
+            errors.push('ADO repository name is required');
+    }
+    if (config.provider === 'gitlab') {
+        const hasProjectPath = typeof config.projectPath === 'string' && config.projectPath.length > 0;
+        const hasNamespaceAndName = typeof config.namespace === 'string' && config.namespace.length > 0 && typeof config.name === 'string' && config.name.length > 0;
+        if (!hasProjectPath && !hasNamespaceAndName) {
+            errors.push('GitLab repository requires projectPath or namespace + name');
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Get current git branch
+ */
+function getCurrentBranch() {
+    try {
+        return (0, child_process_1.execSync)('git branch --show-current', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        }).trim();
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Check if we're in a git repository
+ */
+function isGitRepository() {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --git-dir', {
+            stdio: ['ignore', 'ignore', 'ignore']
+        });
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}

package/dist/src/cli/utils/project-bootstrap.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitProjectResult = createInitProjectResult;
+exports.recordPathStatus = recordPathStatus;
+exports.buildInitProjectSummary = buildInitProjectSummary;
+exports.printInitProjectSummary = printInitProjectSummary;
+const chalk_1 = __importDefault(require("chalk"));
+function formatModeLabel(mode) {
+    switch (mode) {
+        case 'conversational':
+            return 'Conversational';
+        case 'split':
+            return 'Split';
+        default:
+            return 'Integrated';
+    }
+}
+function getModeSpecificNextStep(mode) {
+    switch (mode) {
+        case 'conversational':
+            return 'The agent will focus on project context, validation commands, and durable repo rules.';
+        case 'split':
+            return 'The agent will confirm the code-host and issue-tracker split, then ask only for the missing project details.';
+        default:
+            return 'The agent will review the detected repo setup, then ask only for the highest-value missing project details.';
+    }
+}
+function createInitProjectResult(projectName, mode) {
+    return {
+        mode,
+        projectName,
+        repositoryDetected: false,
+        issueTrackingDetected: false,
+        createdPaths: [],
+        reusedPaths: [],
+        warnings: [],
+        syncPerformed: false,
+        bootstrapNeeded: false
+    };
+}
+function recordPathStatus(result, relativePath, created) {
+    if (created) {
+        result.createdPaths.push(relativePath);
+        return;
+    }
+    result.reusedPaths.push(relativePath);
+}
+function buildInitProjectSummary(result) {
+    return {
+        status: 'FRAIM project initialized.',
+        fields: {
+            mode: formatModeLabel(result.mode),
+            project: result.projectName,
+            repositoryDetection: result.repositoryDetected ? 'detected' : 'not detected',
+            issueTracking: result.issueTrackingDetected ? 'detected' : 'not detected',
+            sync: result.syncPerformed ? 'completed' : 'skipped for this run',
+            createdPaths: [...result.createdPaths],
+            reusedPaths: [...result.reusedPaths]
+        },
+        warnings: [...result.warnings],
+        nextStep: {
+            prompt: 'Tell your AI agent "Onboard this project".',
+            explanation: getModeSpecificNextStep(result.mode)
+        }
+    };
+}
+function printInitProjectSummary(result) {
+    const summary = buildInitProjectSummary(result);
+    console.log(chalk_1.default.green(`\n${summary.status}`));
+    console.log(chalk_1.default.blue('Project summary:'));
+    console.log(chalk_1.default.gray(`   Mode: ${summary.fields.mode}`));
+    console.log(chalk_1.default.gray(`   Project: ${summary.fields.project}`));
+    console.log(chalk_1.default.gray(`   Repository detection: ${summary.fields.repositoryDetection}`));
+    console.log(chalk_1.default.gray(`   Issue tracking: ${summary.fields.issueTracking}`));
+    console.log(chalk_1.default.gray(`   Sync: ${summary.fields.sync}`));
+    if (summary.fields.createdPaths.length > 0) {
+        console.log(chalk_1.default.gray(`   Created: ${summary.fields.createdPaths.join(', ')}`));
+    }
+    if (summary.fields.reusedPaths.length > 0) {
+        console.log(chalk_1.default.gray(`   Reused: ${summary.fields.reusedPaths.join(', ')}`));
+    }
+    if (summary.warnings.length > 0) {
+        console.log(chalk_1.default.yellow('\nWarnings:'));
+        summary.warnings.forEach((warning) => {
+            console.log(chalk_1.default.yellow(`   - ${warning}`));
+        });
+    }
+    console.log(chalk_1.default.cyan(`\nNext step: ${summary.nextStep.prompt}`));
+    console.log(chalk_1.default.gray(summary.nextStep.explanation));
+}

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

@@ -0,0 +1,315 @@
+"use strict";
+/**
+ * Remote Registry Sync
+ *
+ * Fetches jobs and scripts from the remote FRAIM server
+ * instead of bundling them in the npm package.
+ *
+ * Issue: #83 - Minimize client package by fetching registry remotely
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncFromRemote = syncFromRemote;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const chalk_1 = __importDefault(require("chalk"));
+const script_sync_utils_1 = require("./script-sync-utils");
+const fraim_gitignore_1 = require("./fraim-gitignore");
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const LOCK_SYNCED_CONTENT_ENV = 'FRAIM_LOCK_SYNCED_CONTENT';
+const SYNCED_CONTENT_BANNER_MARKER = '<!-- FRAIM_SYNC_MANAGED_CONTENT -->';
+function shouldLockSyncedContent() {
+    const raw = process.env[LOCK_SYNCED_CONTENT_ENV];
+    if (!raw) {
+        return true;
+    }
+    const normalized = raw.trim().toLowerCase();
+    return !['0', 'false', 'off', 'no'].includes(normalized);
+}
+function getSyncedContentLockTargets(projectRoot) {
+    return fraim_gitignore_1.FRAIM_SYNC_GITIGNORE_ENTRIES
+        .map((entry) => entry.replace(/[\\/]+$/, ''))
+        .filter((entry) => entry.length > 0)
+        .map((entry) => (0, path_1.join)(projectRoot, entry));
+}
+function setFileWriteLockRecursively(dirPath, readOnly) {
+    if (!(0, fs_1.existsSync)(dirPath)) {
+        return;
+    }
+    const entries = (0, fs_1.readdirSync)(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = (0, path_1.join)(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            setFileWriteLockRecursively(fullPath, readOnly);
+            continue;
+        }
+        try {
+            // Cross-platform write lock for text files:
+            // - Unix: mode bits
+            // - Windows: toggles read-only attribute behavior for file writes
+            (0, fs_1.chmodSync)(fullPath, readOnly ? 0o444 : 0o666);
+        }
+        catch {
+            // Best-effort permission adjustment; keep sync non-blocking.
+        }
+    }
+}
+function getBannerRegistryPath(file) {
+    if (file.type === 'job') {
+        return `jobs/${file.path}`;
+    }
+    if (file.type === 'skill') {
+        return `skills/${file.path}`;
+    }
+    if (file.type === 'rule') {
+        return `rules/${file.path}`;
+    }
+    return null;
+}
+function insertAfterFrontmatter(content, banner) {
+    const normalized = content.replace(/^\uFEFF/, '');
+    const frontmatterMatch = normalized.match(/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n)?/);
+    if (!frontmatterMatch) {
+        return `${banner}${normalized}`;
+    }
+    const frontmatter = frontmatterMatch[0];
+    const body = normalized.slice(frontmatter.length);
+    return `${frontmatter}${banner}${body}`;
+}
+function buildSyncedContentBanner(typeLabel) {
+    return `${SYNCED_CONTENT_BANNER_MARKER}\r\n> [!IMPORTANT]\r\n> This ${typeLabel} is synced from FRAIM and will be overwritten on the next \`fraim sync\`.\r\n> Do not edit this file.\r\n`;
+}
+function applySyncedContentBanner(file) {
+    const registryPath = getBannerRegistryPath(file);
+    if (!registryPath) {
+        return file.content;
+    }
+    const typeLabel = file.type === 'job' || file.type === 'skill' || file.type === 'rule'
+        ? `${file.type} stub`
+        : `${file.type} file`;
+    const banner = buildSyncedContentBanner(typeLabel);
+    return insertAfterFrontmatter(file.content, banner);
+}
+/**
+ * Sync jobs and scripts from remote FRAIM server
+ */
+async function syncFromRemote(options) {
+    const remoteUrl = options.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+    const apiKey = options.apiKey || process.env.FRAIM_API_KEY || '';
+    if (!apiKey) {
+        return {
+            success: false,
+            employeeJobsSynced: 0,
+            managerJobsSynced: 0,
+            skillsSynced: 0,
+            rulesSynced: 0,
+            scriptsSynced: 0,
+            docsSynced: 0,
+            error: 'FRAIM_API_KEY not set'
+        };
+    }
+    try {
+        console.log(chalk_1.default.blue('🔄 Syncing from remote FRAIM server...'));
+        console.log(chalk_1.default.gray(`   Remote: ${remoteUrl}`));
+        // Fetch registry files from remote server
+        const response = await axios_1.default.get(`${remoteUrl}/api/registry/sync`, {
+            headers: {
+                'x-api-key': apiKey
+            },
+            timeout: 30000
+        });
+        const files = response.data.files || [];
+        if (!files || files.length === 0) {
+            console.log(chalk_1.default.yellow('⚠️  No files received from remote server'));
+            return {
+                success: false,
+                employeeJobsSynced: 0,
+                managerJobsSynced: 0,
+                skillsSynced: 0,
+                rulesSynced: 0,
+                scriptsSynced: 0,
+                docsSynced: 0,
+                error: 'No files received'
+            };
+        }
+        const lockTargets = getSyncedContentLockTargets(options.projectRoot);
+        if (shouldLockSyncedContent()) {
+            // If previous sync locked these paths read-only, temporarily unlock before cleanup/write.
+            for (const target of lockTargets) {
+                setFileWriteLockRecursively(target, false);
+            }
+        }
+        // Sync job stubs to role-specific folders under fraim/
+        const allJobFiles = files.filter(f => f.type === 'job');
+        const managerJobFiles = allJobFiles.filter(f => f.path.startsWith('ai-manager/'));
+        const jobFiles = allJobFiles.filter(f => !f.path.startsWith('ai-manager/'));
+        const employeeJobsDir = (0, project_fraim_paths_1.getWorkspaceFraimPath)(options.projectRoot, 'ai-employee', 'jobs');
+        if (!(0, fs_1.existsSync)(employeeJobsDir)) {
+            (0, fs_1.mkdirSync)(employeeJobsDir, { recursive: true });
+        }
+        cleanDirectory(employeeJobsDir);
+        for (const file of jobFiles) {
+            // Strip "jobs/" prefix and "ai-employee/" role prefix
+            let relPath = file.path;
+            if (relPath.startsWith('jobs/'))
+                relPath = relPath.substring('jobs/'.length);
+            relPath = relPath.replace(/^ai-employee\//, '');
+            const filePath = (0, path_1.join)(employeeJobsDir, relPath);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, applySyncedContentBanner(file), 'utf8');
+            console.log(chalk_1.default.gray(`  + ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`ai-employee/jobs/${relPath}`)}`));
+        }
+        // Sync ai-manager job stubs to fraim/ai-manager/jobs/
+        const managerJobsDir = (0, project_fraim_paths_1.getWorkspaceFraimPath)(options.projectRoot, 'ai-manager', 'jobs');
+        if (!(0, fs_1.existsSync)(managerJobsDir)) {
+            (0, fs_1.mkdirSync)(managerJobsDir, { recursive: true });
+        }
+        cleanDirectory(managerJobsDir);
+        for (const file of managerJobFiles) {
+            // Strip "jobs/" prefix and "ai-manager/" role prefix
+            let relPath = file.path;
+            if (relPath.startsWith('jobs/'))
+                relPath = relPath.substring('jobs/'.length);
+            relPath = relPath.replace(/^ai-manager\//, '');
+            const filePath = (0, path_1.join)(managerJobsDir, relPath);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, applySyncedContentBanner(file), 'utf8');
+            console.log(chalk_1.default.gray(`  + ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`ai-manager/jobs/${relPath}`)}`));
+        }
+        // Sync skill STUBS to fraim/ai-employee/skills/
+        const skillFiles = files.filter(f => f.type === 'skill');
+        const skillsDir = (0, project_fraim_paths_1.getWorkspaceFraimPath)(options.projectRoot, 'ai-employee', 'skills');
+        if (!(0, fs_1.existsSync)(skillsDir)) {
+            (0, fs_1.mkdirSync)(skillsDir, { recursive: true });
+        }
+        cleanDirectory(skillsDir);
+        for (const file of skillFiles) {
+            // Strip "skills/" prefix to avoid redundant nesting in fraim/ai-employee/skills/
+            let relPath = file.path;
+            if (relPath.startsWith('skills/'))
+                relPath = relPath.substring('skills/'.length);
+            const filePath = (0, path_1.join)(skillsDir, relPath);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, applySyncedContentBanner(file), 'utf8');
+            console.log(chalk_1.default.gray(`  + ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`ai-employee/skills/${relPath}`)} (stub)`));
+        }
+        // Sync rule STUBS to fraim/ai-employee/rules/
+        const ruleFiles = files.filter(f => f.type === 'rule');
+        const rulesDir = (0, project_fraim_paths_1.getWorkspaceFraimPath)(options.projectRoot, 'ai-employee', 'rules');
+        if (!(0, fs_1.existsSync)(rulesDir)) {
+            (0, fs_1.mkdirSync)(rulesDir, { recursive: true });
+        }
+        cleanDirectory(rulesDir);
+        for (const file of ruleFiles) {
+            // Strip "rules/" prefix to avoid redundant nesting in fraim/ai-employee/rules/
+            let relPath = file.path;
+            if (relPath.startsWith('rules/'))
+                relPath = relPath.substring('rules/'.length);
+            const filePath = (0, path_1.join)(rulesDir, relPath);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, applySyncedContentBanner(file), 'utf8');
+            console.log(chalk_1.default.gray(`  + ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`ai-employee/rules/${relPath}`)} (stub)`));
+        }
+        // Sync scripts to user directory
+        const scriptFiles = files.filter(f => f.type === 'script');
+        const userDir = (0, script_sync_utils_1.getUserFraimDir)();
+        const scriptsDir = (0, path_1.join)(userDir, 'scripts');
+        if (!(0, fs_1.existsSync)(scriptsDir)) {
+            (0, fs_1.mkdirSync)(scriptsDir, { recursive: true });
+        }
+        // Clean existing scripts
+        cleanDirectory(scriptsDir);
+        // Write script files
+        for (const file of scriptFiles) {
+            const filePath = (0, path_1.join)(scriptsDir, file.path);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, file.content, 'utf8');
+            console.log(chalk_1.default.gray(`  + ${file.path}`));
+        }
+        // Sync docs to fraim/docs/
+        const docsFiles = files.filter(f => f.type === 'docs');
+        const docsDir = (0, project_fraim_paths_1.getWorkspaceFraimPath)(options.projectRoot, 'docs');
+        if (!(0, fs_1.existsSync)(docsDir)) {
+            (0, fs_1.mkdirSync)(docsDir, { recursive: true });
+        }
+        cleanDirectory(docsDir);
+        for (const file of docsFiles) {
+            const filePath = (0, path_1.join)(docsDir, file.path);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, file.content, 'utf8');
+            console.log(chalk_1.default.gray(`  + ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`docs/${file.path}`)}`));
+        }
+        if (shouldLockSyncedContent()) {
+            for (const target of lockTargets) {
+                setFileWriteLockRecursively(target, true);
+            }
+            console.log(chalk_1.default.gray(`  🔒 Synced FRAIM content locked as read-only (set ${LOCK_SYNCED_CONTENT_ENV}=false to disable)`));
+        }
+        return {
+            success: true,
+            employeeJobsSynced: jobFiles.length,
+            managerJobsSynced: managerJobFiles.length,
+            skillsSynced: skillFiles.length,
+            rulesSynced: ruleFiles.length,
+            scriptsSynced: scriptFiles.length,
+            docsSynced: docsFiles.length
+        };
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`❌ Remote sync failed: ${error.message}`));
+        return {
+            success: false,
+            employeeJobsSynced: 0,
+            managerJobsSynced: 0,
+            skillsSynced: 0,
+            rulesSynced: 0,
+            scriptsSynced: 0,
+            docsSynced: 0,
+            error: error.message
+        };
+    }
+}
+/**
+ * Clean directory contents (but keep the directory itself)
+ */
+function cleanDirectory(dirPath) {
+    if (!(0, fs_1.existsSync)(dirPath))
+        return;
+    const entries = (0, fs_1.readdirSync)(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = (0, path_1.join)(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            cleanDirectory(fullPath);
+            try {
+                (0, fs_1.rmdirSync)(fullPath);
+            }
+            catch (e) {
+                // Directory not empty, skip
+            }
+        }
+        else {
+            (0, fs_1.unlinkSync)(fullPath);
+        }
+    }
+}