fraim-framework 2.0.167 → 2.0.169

package/dist/src/cli/commands/init-project.js

@@ -3,13 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initProjectCommand = exports.runInitProject = exports.findProjectFile = void 0;
+exports.initProjectCommand = exports.runInitProject = void 0;
 const commander_1 = require("commander");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const chalk_1 = __importDefault(require("chalk"));
-const child_process_1 = require("child_process");
 const sync_1 = require("./sync");
 const platform_detection_1 = require("../utils/platform-detection");
 const ide_detector_1 = require("../setup/ide-detector");
@@ -19,8 +18,6 @@ const fraim_gitignore_1 = require("../utils/fraim-gitignore");
 const agent_adapters_1 = require("../utils/agent-adapters");
 const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
 const project_bootstrap_1 = require("../utils/project-bootstrap");
-const config_loader_1 = require("../../core/config-loader");
-const github_workflow_sync_1 = require("../utils/github-workflow-sync");
 const checkGlobalSetup = () => {
     const fraimUserDir = process.env.FRAIM_USER_DIR || path_1.default.join(os_1.default.homedir(), '.fraim');
     const globalConfigPath = path_1.default.join(fraimUserDir, 'config.json');
@@ -40,93 +37,6 @@ const checkGlobalSetup = () => {
         return { exists: true, mode: 'integrated', tokens: {} };
     }
 };
-// Robust path resolution utility - walks up directory tree to find target
-const findProjectFile = (filename) => {
-    let currentDir = __dirname;
-    // Walk up the directory tree to find the target file/directory
-    for (let i = 0; i < 10; i++) { // Limit to prevent infinite loop
-        const targetPath = path_1.default.join(currentDir, filename);
-        if (fs_1.default.existsSync(targetPath)) {
-            return targetPath;
-        }
-        const parentDir = path_1.default.dirname(currentDir);
-        if (parentDir === currentDir)
-            break; // Reached root
-        currentDir = parentDir;
-    }
-    // Fallback: try from process.cwd()
-    const cwdTarget = path_1.default.join(process.cwd(), filename);
-    if (fs_1.default.existsSync(cwdTarget)) {
-        return cwdTarget;
-    }
-    // Last resort: use relative path from __dirname
-    return path_1.default.join(__dirname, '..', '..', '..', filename);
-};
-exports.findProjectFile = findProjectFile;
-;
-const installGitHubWorkflows = (projectRoot) => {
-    const registryDir = (0, exports.findProjectFile)('registry');
-    const sourceDir = path_1.default.join(registryDir, 'github', 'workflows');
-    if (!fs_1.default.existsSync(sourceDir)) {
-        console.log(chalk_1.default.yellow(`Warning: GitHub workflows source directory not found: ${sourceDir}`));
-        console.log(chalk_1.default.gray(`Registry directory: ${registryDir}`));
-        console.log(chalk_1.default.gray(`Current __dirname: ${__dirname}`));
-        console.log(chalk_1.default.gray(`Process cwd: ${process.cwd()}`));
-        return;
-    }
-    const config = fs_1.default.existsSync((0, project_fraim_paths_1.getWorkspaceConfigPath)(projectRoot))
-        ? (0, config_loader_1.loadFraimConfig)((0, project_fraim_paths_1.getWorkspaceConfigPath)(projectRoot))
-        : null;
-    if (!(0, github_workflow_sync_1.isGitHubWorkflowAutomationEnabled)(config)) {
-        console.log(chalk_1.default.gray('GitHub workflow automation disabled or not configured; skipping managed workflow install.'));
-        return;
-    }
-    const bundle = (0, github_workflow_sync_1.loadLocalGitHubWorkflowBundle)(registryDir);
-    const result = (0, github_workflow_sync_1.reconcileGitHubWorkflowAssets)({
-        projectRoot,
-        files: bundle,
-        config
-    });
-    for (const line of (0, github_workflow_sync_1.formatGitHubWorkflowSyncSummary)(result)) {
-        console.log(chalk_1.default.green(line));
-    }
-};
-const createGitHubLabels = (projectRoot) => {
-    try {
-        (0, child_process_1.execSync)('gh --version', { stdio: 'ignore' });
-    }
-    catch {
-        console.log(chalk_1.default.yellow('GitHub CLI (gh) not found. Skipping label creation.'));
-        console.log(chalk_1.default.gray('Install gh CLI to enable automatic label creation: https://cli.github.com/'));
-        return;
-    }
-    const labelsPath = (0, exports.findProjectFile)('labels.json');
-    if (!fs_1.default.existsSync(labelsPath)) {
-        console.log(chalk_1.default.yellow('labels.json not found. Skipping label creation.'));
-        console.log(chalk_1.default.gray(`Searched from: ${__dirname}`));
-        return;
-    }
-    try {
-        const labels = JSON.parse(fs_1.default.readFileSync(labelsPath, 'utf8'));
-        labels.forEach((label) => {
-            try {
-                (0, child_process_1.execSync)(`gh label create "${label.name}" --color "${label.color}" --description "${label.description}"`, { cwd: projectRoot, stdio: 'ignore' });
-                console.log(chalk_1.default.green(`Created label: ${label.name}`));
-            }
-            catch (error) {
-                if (error.message && error.message.includes('already exists')) {
-                    console.log(chalk_1.default.gray(`Label already exists: ${label.name}`));
-                }
-                else {
-                    console.log(chalk_1.default.yellow(`Could not create label ${label.name}: ${error.message}`));
-                }
-            }
-        });
-    }
-    catch (error) {
-        console.log(chalk_1.default.yellow(`Error reading labels.json: ${error.message}`));
-    }
-};
 function formatPlatformLabel(provider) {
     switch (provider) {
         case 'ado':
@@ -261,13 +171,6 @@ const runInitProject = async (options = {}) => {
     if (ignoreUpdate.gitignoreUpdated && !isMinimalConversationMode(result.mode)) {
         console.log(chalk_1.default.green('Removed legacy FRAIM sync block from .gitignore'));
     }
-    const detection = (0, platform_detection_1.detectPlatformFromGit)();
-    if (detection.provider === 'github' && !isMinimalConversationMode(result.mode)) {
-        console.log(chalk_1.default.blue('\nSetting up GitHub labels...'));
-        installGitHubWorkflows(projectRoot);
-        createGitHubLabels(projectRoot);
-        result.repositoryDetected = true;
-    }
     if (!process.env.FRAIM_SKIP_SYNC) {
         await (0, sync_1.runSync)({ projectRoot, failHard });
         result.syncPerformed = true;

package/dist/src/cli/commands/manager.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.managerCommand = void 0;
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const manager_publish_1 = require("../utils/manager-publish");
+exports.managerCommand = new commander_1.Command('manager')
+    .description('Manage your portable personal manager context');
+exports.managerCommand
+    .command('publish')
+    .description('Publish manager context/rules/learnings files to the configured manager backend')
+    .argument('<files...>', 'Local files to publish: manager_context.md, manager_rules.md, and/or personal learning files')
+    .action(async (files) => {
+    try {
+        const artifacts = files.map((filePath) => {
+            if (!fs_1.default.existsSync(filePath))
+                throw new Error(`File not found: ${filePath}`);
+            return { relativePath: (0, manager_publish_1.managerPackRelativePathFor)(filePath), content: fs_1.default.readFileSync(filePath, 'utf8') };
+        });
+        const result = await (0, manager_publish_1.publishManagerArtifacts)(artifacts);
+        if (result.backend === 'fraim-cloud') {
+            console.log(chalk_1.default.green(`Published ${artifacts.length} manager artifact(s) to your FRAIM account (version ${result.version}).`));
+            console.log(chalk_1.default.gray('Run "fraim sync" on each machine to pull the update.'));
+        }
+        else {
+            console.log(chalk_1.default.green(`Pushed ${artifacts.length} manager artifact(s) to branch "${result.branch}" in your manager repo.`));
+            if (result.prUrl)
+                console.log(chalk_1.default.cyan(`Open the pull request: ${result.prUrl}`));
+            console.log(chalk_1.default.gray('After it merges, run "fraim sync" to pull the update.'));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`manager publish failed: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/src/cli/commands/sync.js

@@ -48,7 +48,6 @@ const git_utils_1 = require("../../core/utils/git-utils");
 const agent_adapters_1 = require("../utils/agent-adapters");
 const fraim_gitignore_1 = require("../utils/fraim-gitignore");
 const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
-const github_workflow_sync_1 = require("../utils/github-workflow-sync");
 function resolveExplicitLocalSyncUrl() {
     const candidates = [
         process.env.FRAIM_TEST_SERVER_URL,
@@ -180,6 +179,21 @@ const runSync = async (options) => {
             }
         }
     };
+    const refreshManagerCache = async (remoteUrl, apiKey) => {
+        if (process.env.TEST_MODE === 'true')
+            return;
+        const { syncManagerCache } = await Promise.resolve().then(() => __importStar(require('../utils/manager-pack-sync')));
+        const outcome = await syncManagerCache({ remoteUrl, apiKey });
+        if (outcome.status === 'synced') {
+            console.log(chalk_1.default.green(`Manager context synced (${outcome.metadata.backend}, version ${outcome.metadata.version.slice(0, 12)})`));
+        }
+        else if (outcome.status === 'stale') {
+            console.log(chalk_1.default.yellow(`Manager source unreachable. Using cached manager context from ${Math.round(outcome.ageHours)}h ago. Will refresh when reachable.`));
+        }
+        else if (outcome.status === 'absent') {
+            console.log(chalk_1.default.yellow(`Manager context not synced: ${outcome.error}`));
+        }
+    };
     const isNpx = process.env.npm_config_prefix === undefined || process.env.npm_lifecycle_event === 'npx';
     const isGlobal = !isNpx && (process.env.npm_config_global === 'true' || process.env.npm_config_prefix);
     if (isGlobal && !options.skipUpdates) {
@@ -214,17 +228,8 @@ const runSync = async (options) => {
             if (adapterUpdates.length > 0) {
                 console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${adapterUpdates.join(', ')}`));
             }
-            if (config.repository?.provider === 'github' && (0, github_workflow_sync_1.isGitHubWorkflowAutomationEnabled)(config)) {
-                const workflowBundle = await (0, github_workflow_sync_1.fetchGitHubWorkflowBundle)({
-                    remoteUrl: localUrl,
-                    apiKey: 'local-dev'
-                });
-                const workflowResult = (0, github_workflow_sync_1.reconcileGitHubWorkflowAssets)({ projectRoot, files: workflowBundle, config });
-                for (const line of (0, github_workflow_sync_1.formatGitHubWorkflowSyncSummary)(workflowResult)) {
-                    console.log(chalk_1.default.green(line));
-                }
-            }
             await refreshOrgCache(localUrl, 'local-dev');
+            await refreshManagerCache(localUrl, 'local-dev');
             return;
         }
         console.error(chalk_1.default.red(`Local sync failed: ${result.error}`));
@@ -264,21 +269,12 @@ const runSync = async (options) => {
     removeLegacyVersionFromConfig(fraimDir);
     writeSyncMetadata(fraimDir, 'remote', config.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me');
     refreshLocalIgnoreConfig();
-    if (config.repository?.provider === 'github' && (0, github_workflow_sync_1.isGitHubWorkflowAutomationEnabled)(config)) {
-        const workflowBundle = await (0, github_workflow_sync_1.fetchGitHubWorkflowBundle)({
-            remoteUrl: config.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me',
-            apiKey
-        });
-        const workflowResult = (0, github_workflow_sync_1.reconcileGitHubWorkflowAssets)({ projectRoot, files: workflowBundle, config });
-        for (const line of (0, github_workflow_sync_1.formatGitHubWorkflowSyncSummary)(workflowResult)) {
-            console.log(chalk_1.default.green(line));
-        }
-    }
     const adapterUpdates = (0, agent_adapters_1.ensureAgentAdapterFiles)(projectRoot);
     if (adapterUpdates.length > 0) {
         console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${adapterUpdates.join(', ')}`));
     }
     await refreshOrgCache(config.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me', apiKey);
+    await refreshManagerCache(config.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me', apiKey);
 };
 exports.runSync = runSync;
 exports.syncCommand = new commander_1.Command('sync')

package/dist/src/cli/fraim.js

@@ -54,6 +54,7 @@ const hub_1 = require("./commands/hub");
 const first_run_1 = require("./commands/first-run");
 const workspace_config_1 = require("./commands/workspace-config");
 const org_1 = require("./commands/org");
+const manager_1 = require("./commands/manager");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
@@ -97,6 +98,7 @@ program.addCommand(hub_1.hubCommand);
 program.addCommand(first_run_1.firstRunCommand);
 program.addCommand(workspace_config_1.workspaceConfigCommand);
 program.addCommand(org_1.orgCommand);
+program.addCommand(manager_1.managerCommand);
 // Wait for async command initialization before parsing
 (async () => {
     // Import the initialization promise from setup command

package/dist/src/cli/utils/github-workflow-sync.js

@@ -3,67 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GITHUB_WORKFLOW_ASSET_PREFIX = exports.GITHUB_WORKFLOW_HEADER = exports.GITHUB_WORKFLOW_MANIFEST_RELATIVE_PATH = void 0;
-exports.isGitHubWorkflowAutomationEnabled = isGitHubWorkflowAutomationEnabled;
-exports.decorateManagedGitHubWorkflow = decorateManagedGitHubWorkflow;
-exports.isFraimManagedGitHubWorkflow = isFraimManagedGitHubWorkflow;
-exports.loadGitHubWorkflowManifest = loadGitHubWorkflowManifest;
 exports.loadLocalGitHubWorkflowBundle = loadLocalGitHubWorkflowBundle;
 exports.fetchGitHubWorkflowBundle = fetchGitHubWorkflowBundle;
-exports.reconcileGitHubWorkflowAssets = reconcileGitHubWorkflowAssets;
+exports.installGitHubWorkflowAssets = installGitHubWorkflowAssets;
 exports.formatGitHubWorkflowSyncSummary = formatGitHubWorkflowSyncSummary;
 const axios_1 = __importDefault(require("axios"));
-const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_loader_1 = require("../../core/config-loader");
 const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
-exports.GITHUB_WORKFLOW_MANIFEST_RELATIVE_PATH = path_1.default.join('fraim', 'managed-assets', 'github-workflows.json');
-exports.GITHUB_WORKFLOW_HEADER = '# FRAIM-MANAGED: github-workflow';
-exports.GITHUB_WORKFLOW_ASSET_PREFIX = '# FRAIM-ASSET-ID: ';
-function sha256(content) {
-    return `sha256:${crypto_1.default.createHash('sha256').update(content).digest('hex')}`;
-}
-function getManifestPath(projectRoot) {
-    return path_1.default.join(projectRoot, exports.GITHUB_WORKFLOW_MANIFEST_RELATIVE_PATH);
-}
-function isGitHubWorkflowAutomationEnabled(config) {
-    return config?.customizations?.githubWorkflows?.enabled === true;
-}
-function decorateManagedGitHubWorkflow(assetId, content) {
-    const normalized = content.replace(/^\uFEFF/, '');
-    const assetHeader = `${exports.GITHUB_WORKFLOW_HEADER}\n${exports.GITHUB_WORKFLOW_ASSET_PREFIX}${assetId}`;
-    if (normalized.includes(exports.GITHUB_WORKFLOW_HEADER) && normalized.includes(`${exports.GITHUB_WORKFLOW_ASSET_PREFIX}${assetId}`)) {
-        return normalized;
-    }
-    return `${assetHeader}\n${normalized}`;
-}
-function isFraimManagedGitHubWorkflow(content, assetId) {
-    if (!content.includes(exports.GITHUB_WORKFLOW_HEADER)) {
-        return false;
-    }
-    if (!assetId) {
-        return true;
-    }
-    return content.includes(`${exports.GITHUB_WORKFLOW_ASSET_PREFIX}${assetId}`);
-}
-function loadGitHubWorkflowManifest(projectRoot) {
-    const manifestPath = getManifestPath(projectRoot);
-    if (!fs_1.default.existsSync(manifestPath)) {
-        return {
-            version: 1,
-            enabled: true,
-            provider: 'github',
-            managedFiles: []
-        };
-    }
-    return JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
-}
-function writeGitHubWorkflowManifest(projectRoot, manifest) {
-    const manifestPath = getManifestPath(projectRoot);
-    fs_1.default.mkdirSync(path_1.default.dirname(manifestPath), { recursive: true });
-    fs_1.default.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
-}
 function loadLocalGitHubWorkflowBundle(registryRoot) {
     const workflowsRoot = path_1.default.join(registryRoot, 'github', 'workflows');
     if (!fs_1.default.existsSync(workflowsRoot)) {
@@ -77,8 +25,7 @@ function loadLocalGitHubWorkflowBundle(registryRoot) {
         return {
             path: entry.name,
             content,
-            type: 'github-workflow',
-            digest: sha256(content)
+            type: 'github-workflow'
         };
     });
     return files.sort((a, b) => a.path.localeCompare(b.path));
@@ -98,7 +45,7 @@ function readProjectConfig(projectRoot, config) {
     }
     return (0, config_loader_1.loadFraimConfig)((0, project_fraim_paths_1.getWorkspaceConfigPath)(projectRoot));
 }
-function reconcileGitHubWorkflowAssets(options) {
+function installGitHubWorkflowAssets(options) {
     const config = readProjectConfig(options.projectRoot, options.config);
     const provider = config.repository?.provider || null;
     if (provider !== 'github') {
@@ -109,108 +56,27 @@ function reconcileGitHubWorkflowAssets(options) {
             results: []
         };
     }
-    if (!isGitHubWorkflowAutomationEnabled(config)) {
-        return {
-            enabled: false,
-            provider,
-            skippedReason: 'GitHub workflow automation disabled',
-            results: []
-        };
-    }
-    const manifest = loadGitHubWorkflowManifest(options.projectRoot);
-    const manifestEntries = new Map(manifest.managedFiles.map((entry) => [entry.path, entry]));
     const workflowsDir = path_1.default.join(options.projectRoot, '.github', 'workflows');
     fs_1.default.mkdirSync(workflowsDir, { recursive: true });
     const results = [];
-    const nextManagedFiles = [];
     for (const file of options.files) {
-        const assetId = path_1.default.basename(file.path);
         const relativeWorkflowPath = path_1.default.join('.github', 'workflows', file.path).replace(/[\\/]/g, '/');
-        const destinationPath = path_1.default.join(options.projectRoot, '.github', 'workflows', file.path);
-        const desiredContent = decorateManagedGitHubWorkflow(assetId, file.content);
-        const desiredInstalledDigest = sha256(desiredContent);
-        const previousEntry = manifestEntries.get(relativeWorkflowPath);
-        if (!fs_1.default.existsSync(destinationPath)) {
-            fs_1.default.mkdirSync(path_1.default.dirname(destinationPath), { recursive: true });
-            fs_1.default.writeFileSync(destinationPath, desiredContent, 'utf8');
-            nextManagedFiles.push({
-                path: relativeWorkflowPath,
-                assetId,
-                sourceDigest: file.digest,
-                installedDigest: desiredInstalledDigest
-            });
-            results.push({
-                path: relativeWorkflowPath,
-                assetId,
-                status: 'installed'
-            });
-            continue;
-        }
-        const currentContent = fs_1.default.readFileSync(destinationPath, 'utf8');
-        const currentDigest = sha256(currentContent);
-        const ownedByFraim = isFraimManagedGitHubWorkflow(currentContent, assetId) || Boolean(previousEntry);
-        if (!ownedByFraim) {
-            if (previousEntry) {
-                nextManagedFiles.push(previousEntry);
-            }
-            results.push({
-                path: relativeWorkflowPath,
-                assetId,
-                status: 'conflict',
-                reason: 'same-named file exists without FRAIM ownership marker'
-            });
-            continue;
-        }
-        if (currentDigest === desiredInstalledDigest) {
-            nextManagedFiles.push({
-                path: relativeWorkflowPath,
-                assetId,
-                sourceDigest: file.digest,
-                installedDigest: desiredInstalledDigest
-            });
+        const destinationPath = path_1.default.join(workflowsDir, file.path);
+        if (fs_1.default.existsSync(destinationPath)) {
             results.push({
                 path: relativeWorkflowPath,
-                assetId,
-                status: 'already current'
+                status: 'skipped',
+                reason: 'already exists'
             });
             continue;
         }
-        if (previousEntry && currentDigest === previousEntry.installedDigest) {
-            fs_1.default.writeFileSync(destinationPath, desiredContent, 'utf8');
-            nextManagedFiles.push({
-                path: relativeWorkflowPath,
-                assetId,
-                sourceDigest: file.digest,
-                installedDigest: desiredInstalledDigest
-            });
-            results.push({
-                path: relativeWorkflowPath,
-                assetId,
-                status: 'updated'
-            });
-            continue;
-        }
-        nextManagedFiles.push(previousEntry || {
-            path: relativeWorkflowPath,
-            assetId,
-            sourceDigest: file.digest,
-            installedDigest: currentDigest
-        });
+        fs_1.default.mkdirSync(path_1.default.dirname(destinationPath), { recursive: true });
+        fs_1.default.writeFileSync(destinationPath, file.content, 'utf8');
         results.push({
             path: relativeWorkflowPath,
-            assetId,
-            status: 'conflict',
-            reason: previousEntry
-                ? 'managed file has local edits that do not match the last installed digest'
-                : 'FRAIM-managed header exists without manifest baseline'
+            status: 'installed'
         });
     }
-    writeGitHubWorkflowManifest(options.projectRoot, {
-        version: 1,
-        enabled: true,
-        provider: 'github',
-        managedFiles: nextManagedFiles.sort((a, b) => a.path.localeCompare(b.path))
-    });
     return {
         enabled: true,
         provider,
@@ -219,10 +85,10 @@ function reconcileGitHubWorkflowAssets(options) {
 }
 function formatGitHubWorkflowSyncSummary(result) {
     if (!result.enabled) {
-        return [`GitHub workflow reconciliation skipped: ${result.skippedReason || 'not enabled'}`];
+        return [`GitHub workflow install skipped: ${result.skippedReason || 'not enabled'}`];
     }
     if (result.results.length === 0) {
-        return ['GitHub workflow reconciliation: no workflow assets found'];
+        return ['GitHub workflow install: no workflow assets found'];
     }
     return result.results.map((item) => {
         const suffix = item.reason ? ` (${item.reason})` : '';

package/dist/src/cli/utils/manager-pack-sync.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANAGER_CACHE_MANAGED_HEADER = exports.MANAGER_SYNC_METADATA_FILE = exports.MANAGER_CACHE_DIRNAME = void 0;
+exports.getManagerCacheDir = getManagerCacheDir;
+exports.readManagerCacheMetadata = readManagerCacheMetadata;
+exports.getManagerCacheAgeHours = getManagerCacheAgeHours;
+exports.syncManagerCache = syncManagerCache;
+/**
+ * Manager cache sync (issue #580).
+ *
+ * Materializes the manager's personal context/rules/learnings into the managed
+ * cache at ~/.fraim/manager/, from either backend:
+ *   - git: shallow snapshot of a manager-owned repo
+ *   - fraim-cloud: GET /api/manager/pack from the FRAIM server
+ *
+ * Cache files are managed content: marked, overwritten on every sync, and
+ * never a direct write target for agents.
+ */
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const manager_pack_1 = require("../../core/manager-pack");
+const git_org_sync_1 = require("./git-org-sync");
+const user_config_1 = require("./user-config");
+exports.MANAGER_CACHE_DIRNAME = 'manager';
+exports.MANAGER_SYNC_METADATA_FILE = '.manager-sync-metadata.json';
+exports.MANAGER_CACHE_MANAGED_HEADER = '<!-- FRAIM_MANAGER_SYNC_MANAGED_CONTENT -->';
+const MANAGER_PACK_DIRS = ['context', 'rules', 'learnings'];
+function getManagerCacheDir() {
+    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), exports.MANAGER_CACHE_DIRNAME);
+}
+function readManagerCacheMetadata() {
+    try {
+        const metadataPath = path_1.default.join(getManagerCacheDir(), exports.MANAGER_SYNC_METADATA_FILE);
+        if (!fs_1.default.existsSync(metadataPath))
+            return null;
+        return JSON.parse(fs_1.default.readFileSync(metadataPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getManagerCacheAgeHours() {
+    const metadata = readManagerCacheMetadata();
+    if (!metadata?.syncedAt)
+        return null;
+    const syncedAt = Date.parse(metadata.syncedAt);
+    if (Number.isNaN(syncedAt))
+        return null;
+    return Math.max(0, (Date.now() - syncedAt) / 3_600_000);
+}
+function decorateManagedManagerFile(content, backend) {
+    const normalized = content.replace(/^\uFEFF/, '');
+    if (normalized.startsWith(exports.MANAGER_CACHE_MANAGED_HEADER))
+        return normalized;
+    const writePath = backend === 'git'
+        ? 'open a pull request against your manager storage repo'
+        : 'publish the change through your FRAIM manager storage flow';
+    const marker = [
+        exports.MANAGER_CACHE_MANAGED_HEADER,
+        '> [!IMPORTANT]',
+        '> Synced from your personal manager storage. Local edits are overwritten on the next sync.',
+        `> To change this content, ${writePath}.`,
+        ''
+    ].join('\n');
+    return `${marker}\n${normalized}`;
+}
+function collectGitPackFiles(snapshotDir) {
+    const files = [];
+    for (const dirName of MANAGER_PACK_DIRS) {
+        const dirPath = path_1.default.join(snapshotDir, dirName);
+        if (!fs_1.default.existsSync(dirPath))
+            continue;
+        for (const entry of fs_1.default.readdirSync(dirPath, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            files.push({
+                relativePath: `${dirName}/${entry.name}`,
+                content: fs_1.default.readFileSync(path_1.default.join(dirPath, entry.name), 'utf8')
+            });
+        }
+    }
+    return files;
+}
+async function fetchCloudPack(remoteUrl, apiKey) {
+    const response = await axios_1.default.get(`${remoteUrl.replace(/\/$/, '')}/api/manager/pack`, {
+        headers: { 'x-api-key': apiKey },
+        timeout: 30_000
+    });
+    const files = Array.isArray(response.data?.files) ? response.data.files : [];
+    return {
+        files: files.filter((f) => typeof f?.relativePath === 'string' &&
+            (0, manager_pack_1.isManagerPackRelativePath)(f.relativePath) &&
+            typeof f?.content === 'string'),
+        version: String(response.data?.version ?? '0')
+    };
+}
+function materializeCache(files, metadata) {
+    const cacheDir = getManagerCacheDir();
+    const stagingDir = `${cacheDir}.staging-${process.pid}`;
+    fs_1.default.rmSync(stagingDir, { recursive: true, force: true });
+    fs_1.default.mkdirSync(stagingDir, { recursive: true });
+    for (const file of files) {
+        if (!(0, manager_pack_1.isManagerPackRelativePath)(file.relativePath))
+            continue;
+        const destination = path_1.default.join(stagingDir, file.relativePath);
+        fs_1.default.mkdirSync(path_1.default.dirname(destination), { recursive: true });
+        fs_1.default.writeFileSync(destination, decorateManagedManagerFile(file.content, metadata.backend));
+    }
+    fs_1.default.writeFileSync(path_1.default.join(stagingDir, exports.MANAGER_SYNC_METADATA_FILE), JSON.stringify(metadata, null, 2));
+    fs_1.default.rmSync(cacheDir, { recursive: true, force: true });
+    fs_1.default.renameSync(stagingDir, cacheDir);
+}
+async function discoverCloudManagerStorage(options) {
+    try {
+        const apiKey = options?.apiKey || (0, user_config_1.readUserFraimConfig)().apiKey;
+        if (!apiKey || apiKey === 'local-dev' || apiKey === 'test-mode-key')
+            return null;
+        const remoteUrl = options?.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+        const pack = await fetchCloudPack(remoteUrl, apiKey);
+        if (pack.files.length === 0)
+            return null;
+        (0, user_config_1.writeUserFraimConfig)({ managerStorage: { backend: 'fraim-cloud' } });
+        return (0, user_config_1.getManagerStorageConfig)();
+    }
+    catch {
+        return null;
+    }
+}
+function failureOutcome(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const existing = readManagerCacheMetadata();
+    if (existing) {
+        return {
+            status: 'stale',
+            metadata: existing,
+            ageHours: getManagerCacheAgeHours() ?? 0,
+            error: message
+        };
+    }
+    return { status: 'absent', error: message };
+}
+async function syncManagerCache(options) {
+    let managerStorage = (0, user_config_1.getManagerStorageConfig)();
+    if (!managerStorage) {
+        managerStorage = await discoverCloudManagerStorage(options);
+        if (!managerStorage)
+            return { status: 'disabled' };
+    }
+    try {
+        if (managerStorage.backend === 'git') {
+            const snapshot = (0, git_org_sync_1.fetchOrgRepoSnapshot)(managerStorage.gitUrl);
+            try {
+                const metadata = {
+                    version: snapshot.sha,
+                    backend: 'git',
+                    source: managerStorage.gitUrl,
+                    syncedAt: new Date().toISOString()
+                };
+                materializeCache(collectGitPackFiles(snapshot.dir), metadata);
+                return { status: 'synced', metadata };
+            }
+            finally {
+                snapshot.cleanup();
+            }
+        }
+        const remoteUrl = options?.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+        const apiKey = options?.apiKey || (0, user_config_1.readUserFraimConfig)().apiKey;
+        if (!apiKey)
+            throw new Error('No FRAIM API key available for the fraim-cloud manager backend.');
+        const pack = await fetchCloudPack(remoteUrl, apiKey);
+        const metadata = {
+            version: pack.version,
+            backend: 'fraim-cloud',
+            source: remoteUrl,
+            syncedAt: new Date().toISOString()
+        };
+        materializeCache(pack.files, metadata);
+        return { status: 'synced', metadata };
+    }
+    catch (error) {
+        return failureOutcome(error);
+    }
+}