fraim-framework 2.0.171 → 2.0.174

package/dist/src/core/fraim-config-schema.generated.js

@@ -269,7 +269,8 @@ exports.FRAIM_CONFIG_SCHEMA = {
                     "kind": "enum",
                     "values": [
                         "salesforce",
-                        "customereq"
+                        "customereq",
+                        "attio"
                     ]
                 }
             }
@@ -457,7 +458,8 @@ exports.FRAIM_CONFIG_SCHEMA = {
                                     "kind": "enum",
                                     "values": [
                                         "servicenow",
-                                        "fixture"
+                                        "fixture",
+                                        "facebook_messenger"
                                     ]
                                 },
                                 "table": {
@@ -489,6 +491,9 @@ exports.FRAIM_CONFIG_SCHEMA = {
                                 },
                                 "closeState": {
                                     "kind": "string"
+                                },
+                                "accessScript": {
+                                    "kind": "string"
                                 }
                             }
                         },
@@ -678,6 +683,7 @@ exports.SUPPORTED_FRAIM_CONFIG_PATHS = [
     "automation.support.queue.successState",
     "automation.support.queue.failureState",
     "automation.support.queue.closeState",
+    "automation.support.queue.accessScript",
     "automation.support.requestTypes",
     "automation.support.requestTypes.password_reset",
     "automation.support.requestTypes.password_reset.mode",

package/dist/src/core/utils/local-registry-resolver.js

@@ -225,6 +225,23 @@ class LocalRegistryResolver {
             return null;
         }
     }
+    readWorkspaceRegistryFile(path) {
+        const normalizedPath = path.replace(/\\/g, '/').replace(/^\/+/, '');
+        const registryPath = (0, path_1.join)(this.workspaceRoot, 'registry', ...normalizedPath.split('/'));
+        if (!(0, fs_1.existsSync)(registryPath)) {
+            return null;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(registryPath, 'utf-8');
+            if (this.shouldFilter && this.shouldFilter(content)) {
+                return null;
+            }
+            return content;
+        }
+        catch {
+            return null;
+        }
+    }
     normalizeRegistryPath(path) {
         const normalized = path.trim().replace(/\\/g, '/').replace(/^\/+/, '');
         return normalized.endsWith('.md') ? normalized : `${normalized}.md`;
@@ -379,6 +396,15 @@ class LocalRegistryResolver {
                     inherited: false
                 };
             }
+            const workspaceRegistryContent = this.readWorkspaceRegistryFile(path);
+            if (workspaceRegistryContent !== null) {
+                return {
+                    content: workspaceRegistryContent,
+                    source: 'local',
+                    personalized: false,
+                    inherited: false
+                };
+            }
             // No useful override or synced content, fetch from remote
             try {
                 const rawContent = await this.fetchRemoteWithFallback(path);

package/dist/src/core/utils/project-fraim-paths.js

@@ -8,6 +8,10 @@ exports.getWorkspaceFraimDir = getWorkspaceFraimDir;
 exports.workspaceFraimExists = workspaceFraimExists;
 exports.getWorkspaceConfigPath = getWorkspaceConfigPath;
 exports.getWorkspaceFraimPath = getWorkspaceFraimPath;
+exports.assertWorkspaceFraimRoot = assertWorkspaceFraimRoot;
+exports.assertWorkspaceFraimPath = assertWorkspaceFraimPath;
+exports.createWorkspaceFraimPathAsserter = createWorkspaceFraimPathAsserter;
+exports.assertExactWorkspaceFraimPath = assertExactWorkspaceFraimPath;
 exports.getWorkspaceFraimDisplayPath = getWorkspaceFraimDisplayPath;
 exports.getUserFraimDisplayPath = getUserFraimDisplayPath;
 exports.getUserFraimDirPath = getUserFraimDirPath;
@@ -35,8 +39,38 @@ function normalizeDisplayPath(fullPath) {
 function getWorkspaceFraimDir(projectRoot = process.cwd()) {
     return (0, path_1.join)(projectRoot, exports.WORKSPACE_FRAIM_DIRNAME);
 }
+function isPathInsideOrEqual(parentPath, childPath) {
+    const relativePath = (0, path_1.relative)(parentPath, childPath);
+    return relativePath === '' || (relativePath.length > 0 &&
+        !relativePath.startsWith('..') &&
+        !(0, path_1.isAbsolute)(relativePath));
+}
+function realpathIfExists(fullPath) {
+    try {
+        return fs_1.realpathSync.native(fullPath);
+    }
+    catch {
+        return null;
+    }
+}
+function deepestExistingAncestor(fullPath) {
+    let current = (0, path_1.resolve)(fullPath);
+    while (!(0, fs_1.existsSync)(current)) {
+        const parent = (0, path_1.dirname)(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+    return current;
+}
 function workspaceFraimExists(projectRoot = process.cwd()) {
-    return (0, fs_1.existsSync)(getWorkspaceFraimDir(projectRoot));
+    try {
+        return (0, fs_1.readdirSync)(projectRoot, { withFileTypes: true }).some((entry) => entry.isDirectory() && entry.name === exports.WORKSPACE_FRAIM_DIRNAME);
+    }
+    catch {
+        return false;
+    }
 }
 function getWorkspaceConfigPath(projectRoot = process.cwd()) {
     return (0, path_1.join)(getWorkspaceFraimDir(projectRoot), 'config.json');
@@ -44,6 +78,59 @@ function getWorkspaceConfigPath(projectRoot = process.cwd()) {
 function getWorkspaceFraimPath(projectRoot = process.cwd(), ...parts) {
     return (0, path_1.join)(getWorkspaceFraimDir(projectRoot), ...parts);
 }
+function assertWorkspaceFraimRoot(projectRoot = process.cwd()) {
+    const resolvedProjectRoot = (0, path_1.resolve)(projectRoot);
+    const fraimDir = getWorkspaceFraimDir(resolvedProjectRoot);
+    if (!workspaceFraimExists(resolvedProjectRoot)) {
+        throw new Error(`Refusing to use FRAIM workspace root "${resolvedProjectRoot}": expected exact lowercase fraim directory at "${fraimDir}".`);
+    }
+    const projectRootRealPath = realpathIfExists(resolvedProjectRoot);
+    const fraimRealPath = realpathIfExists(fraimDir);
+    if (projectRootRealPath &&
+        fraimRealPath &&
+        !isPathInsideOrEqual(projectRootRealPath, fraimRealPath)) {
+        throw new Error(`Refusing to use FRAIM workspace root "${resolvedProjectRoot}": "${fraimDir}" resolves outside the project root.`);
+    }
+    return fraimDir;
+}
+function assertWorkspaceFraimPath(projectRoot = process.cwd(), targetPath) {
+    createWorkspaceFraimPathAsserter(projectRoot)(targetPath);
+}
+function createWorkspaceFraimPathAsserter(projectRoot = process.cwd()) {
+    const fraimDir = assertWorkspaceFraimRoot(projectRoot);
+    const resolvedFraimDir = (0, path_1.resolve)(fraimDir);
+    const fraimRealPath = realpathIfExists(fraimDir);
+    const realpathCache = new Map();
+    const cachedRealpath = (fullPath) => {
+        const resolvedPath = (0, path_1.resolve)(fullPath);
+        if (!realpathCache.has(resolvedPath)) {
+            realpathCache.set(resolvedPath, realpathIfExists(resolvedPath));
+        }
+        return realpathCache.get(resolvedPath) ?? null;
+    };
+    return (targetPath) => {
+        const resolvedTargetPath = (0, path_1.resolve)(targetPath);
+        if (resolvedTargetPath === resolvedFraimDir ||
+            !isPathInsideOrEqual(resolvedFraimDir, resolvedTargetPath)) {
+            throw new Error(`Refusing to use FRAIM workspace path "${resolvedTargetPath}": expected a path under "${resolvedFraimDir}".`);
+        }
+        const existingAncestor = deepestExistingAncestor(resolvedTargetPath);
+        const ancestorRealPath = existingAncestor ? cachedRealpath(existingAncestor) : null;
+        if (fraimRealPath &&
+            ancestorRealPath &&
+            !isPathInsideOrEqual(fraimRealPath, ancestorRealPath)) {
+            throw new Error(`Refusing to use FRAIM workspace path "${resolvedTargetPath}": existing path "${existingAncestor}" resolves outside "${fraimDir}".`);
+        }
+    };
+}
+function assertExactWorkspaceFraimPath(projectRoot = process.cwd(), targetPath, ...parts) {
+    const expectedPath = (0, path_1.resolve)(getWorkspaceFraimDir((0, path_1.resolve)(projectRoot)), ...parts);
+    const resolvedTargetPath = (0, path_1.resolve)(targetPath);
+    if (resolvedTargetPath !== expectedPath) {
+        throw new Error(`Refusing to use FRAIM workspace path "${resolvedTargetPath}": expected exact managed path "${expectedPath}".`);
+    }
+    assertWorkspaceFraimPath(projectRoot, targetPath);
+}
 function getWorkspaceFraimDisplayPath(relativePath = '') {
     const normalized = normalizeRelativePath(relativePath);
     return normalized.length > 0
@@ -120,7 +207,7 @@ function getConfiguredPortableLearningsDisplayPath(projectRoot = process.cwd())
 function getEffectiveFraimDir(projectRoot = process.cwd(), userFraimDir) {
     // 1. Check for project-level fraim/ directory
     const projectFraimDir = getWorkspaceFraimDir(projectRoot);
-    if ((0, fs_1.existsSync)(projectFraimDir)) {
+    if (workspaceFraimExists(projectRoot)) {
         return projectFraimDir;
     }
     // 2. Fall back to user-level ~/.fraim/

package/dist/src/first-run/session-service.js

@@ -547,6 +547,15 @@ class FirstRunSessionService {
             this.persist();
             return this.respond('Fake-mode fraim ok.', true);
         }
+        // FRAIM_SKIP_SYNC signals an isolated/test environment. Skip all external
+        // writes (MCP config files, global config.json, slash commands) so tests
+        // that auto-trigger this path cannot corrupt the real user config.
+        if (process.env.FRAIM_SKIP_SYNC) {
+            row.status = 'ok';
+            row.verb = 'Ready.';
+            this.persist();
+            return this.respond('FRAIM configured.', true);
+        }
         try {
             if (!forceConfigure && !commandVersion('fraim')) {
                 const prefix = path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'node');

package/dist/src/local-mcp-server/artifact-retention-cleanup.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARTIFACT_RETENTION_CATEGORIES = void 0;
+exports.resolveArtifactRetentionConfig = resolveArtifactRetentionConfig;
+exports.runArtifactCleanup = runArtifactCleanup;
+exports.planArtifactCleanup = planArtifactCleanup;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+exports.ARTIFACT_RETENTION_CATEGORIES = [
+    'learning_archive',
+    'retrospectives',
+    'evidence',
+    'feedback',
+    'cleanup_manifests',
+];
+function readWorkspaceConfig(workspaceRoot) {
+    try {
+        const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(workspaceRoot);
+        if (!node_fs_1.default.existsSync(configPath))
+            return {};
+        return JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function validRetentionValue(value) {
+    return Number.isInteger(value) && value >= -1;
+}
+function normalizeRelative(workspaceRoot, absolutePath) {
+    return node_path_1.default.relative(workspaceRoot, absolutePath).replace(/\\/g, '/');
+}
+function parseRetentionValue(category, value, fallback, invalidValues) {
+    if (validRetentionValue(value))
+        return value;
+    invalidValues.push({
+        category,
+        value,
+        fallback,
+        reason: 'Retention values must be integers greater than or equal to -1.',
+    });
+    return fallback;
+}
+function resolveArtifactRetentionConfig(workspaceRoot) {
+    const config = readWorkspaceConfig(workspaceRoot);
+    const configuredRetention = config?.artifact_retention_period;
+    const rawRetention = configuredRetention && typeof configuredRetention === 'object' && !Array.isArray(configuredRetention)
+        ? configuredRetention
+        : {};
+    const invalidValues = [];
+    const rawDefault = rawRetention?.default;
+    const defaultValue = validRetentionValue(rawDefault)
+        ? rawDefault
+        : parseRetentionValue('default', rawDefault, -1, invalidValues);
+    const values = {};
+    for (const category of exports.ARTIFACT_RETENTION_CATEGORIES) {
+        values[category] = category in rawRetention
+            ? parseRetentionValue(category, rawRetention[category], defaultValue, invalidValues)
+            : defaultValue;
+    }
+    return { values, defaultValue, invalidValues };
+}
+function listFiles(dirPath) {
+    if (!node_fs_1.default.existsSync(dirPath))
+        return [];
+    const out = [];
+    const stack = [dirPath];
+    while (stack.length) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory())
+                stack.push(fullPath);
+            else if (entry.isFile())
+                out.push(fullPath);
+        }
+    }
+    return out;
+}
+function fileMtime(absolutePath) {
+    try {
+        return node_fs_1.default.statSync(absolutePath).mtime;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseDate(value) {
+    if (!value)
+        return undefined;
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+function loadGitLastChangeDates(workspaceRoot, relativeDir) {
+    const dates = new Map();
+    try {
+        const output = (0, node_child_process_1.execFileSync)('git', ['log', '--format=__FRAIM_CLEANUP_DATE__%cI', '--name-only', '--', relativeDir], {
+            cwd: workspaceRoot,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 10_000,
+            maxBuffer: 80 * 1024 * 1024,
+        });
+        let currentDate;
+        for (const rawLine of output.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            if (line.startsWith('__FRAIM_CLEANUP_DATE__')) {
+                currentDate = parseDate(line.slice('__FRAIM_CLEANUP_DATE__'.length));
+                continue;
+            }
+            const relativePath = line.replace(/\\/g, '/');
+            if (currentDate && !dates.has(relativePath))
+                dates.set(relativePath, currentDate);
+        }
+    }
+    catch {
+        return new Map();
+    }
+    return dates;
+}
+function readFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return {};
+    const values = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (kv)
+            values[kv[1]] = kv[2].trim();
+    }
+    return values;
+}
+function synthesizedDate(absolutePath) {
+    try {
+        const frontmatter = readFrontmatter(node_fs_1.default.readFileSync(absolutePath, 'utf8'));
+        const value = frontmatter.synthesized;
+        if (!value)
+            return undefined;
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function userScoped(fileName, activeUserEmail) {
+    return fileName.startsWith(`${activeUserEmail}-`);
+}
+function evidenceEligibilityDate(workspaceRoot, absolutePath, gitDates) {
+    const relativePath = normalizeRelative(workspaceRoot, absolutePath);
+    return gitDates.get(relativePath) ?? fileMtime(absolutePath);
+}
+function collectCandidates(workspaceRoot, activeUserEmail) {
+    const candidates = [];
+    const add = (category, absolutePath, eligible, reason, eligibilityDate) => {
+        candidates.push({
+            category,
+            absolutePath,
+            relativePath: normalizeRelative(workspaceRoot, absolutePath),
+            eligible,
+            reason,
+            eligibilityDate,
+        });
+    };
+    const archiveDir = node_path_1.default.join(workspaceRoot, 'fraim', 'personalized-employee', 'learnings', 'archive');
+    for (const filePath of listFiles(archiveDir)) {
+        const fileName = node_path_1.default.basename(filePath);
+        if (!fileName.endsWith('.md') || !userScoped(fileName, activeUserEmail))
+            continue;
+        add('learning_archive', filePath, true, 'Archived learning source for active user.', fileMtime(filePath));
+    }
+    const retrospectivesDir = node_path_1.default.join(workspaceRoot, 'docs', 'retrospectives');
+    for (const filePath of listFiles(retrospectivesDir)) {
+        const fileName = node_path_1.default.basename(filePath);
+        if (!fileName.endsWith('.md') || !userScoped(fileName, activeUserEmail))
+            continue;
+        const date = synthesizedDate(filePath);
+        if (date)
+            add('retrospectives', filePath, true, 'Retrospective has synthesized frontmatter.', date);
+        else
+            add('retrospectives', filePath, false, 'Retrospective has no synthesized frontmatter.');
+    }
+    const evidenceDir = node_path_1.default.join(workspaceRoot, 'docs', 'evidence');
+    const evidenceGitDates = loadGitLastChangeDates(workspaceRoot, 'docs/evidence');
+    for (const filePath of listFiles(evidenceDir)) {
+        const fileName = node_path_1.default.basename(filePath);
+        const isMarkdown = fileName.endsWith('.md');
+        const isJson = fileName.endsWith('.json');
+        const eligibilityDate = evidenceEligibilityDate(workspaceRoot, filePath, evidenceGitDates);
+        if (fileName.includes('cleanup-manifest') || fileName.includes('cleanup_manifest')) {
+            if (isMarkdown || isJson) {
+                add('cleanup_manifests', filePath, true, 'Cleanup manifest file.', eligibilityDate);
+            }
+            else {
+                add('evidence', filePath, true, 'Evidence file.', eligibilityDate);
+            }
+            continue;
+        }
+        if (fileName.endsWith('-feedback.md')) {
+            add('feedback', filePath, true, 'Feedback evidence file.', eligibilityDate);
+            continue;
+        }
+        add('evidence', filePath, true, 'Evidence file.', eligibilityDate);
+    }
+    return candidates;
+}
+function daysBetween(from, to) {
+    return Math.floor((to.getTime() - from.getTime()) / 86_400_000);
+}
+function shouldDelete(candidate, retentionValue, now) {
+    if (!candidate.eligible)
+        return { delete: false, reason: candidate.reason };
+    if (retentionValue === -1)
+        return { delete: false, reason: 'Retention value -1 means never cleanup.' };
+    if (!candidate.eligibilityDate || Number.isNaN(candidate.eligibilityDate.getTime())) {
+        return { delete: false, reason: 'Eligibility date is unavailable or invalid.' };
+    }
+    if (retentionValue === 0)
+        return { delete: true, reason: 'Retention value 0 means cleanup immediately when eligible.' };
+    const ageDays = daysBetween(candidate.eligibilityDate, now);
+    if (ageDays >= retentionValue) {
+        return { delete: true, reason: `Eligible artifact age ${ageDays} days meets retention ${retentionValue} days.` };
+    }
+    return { delete: false, reason: `Eligible artifact age ${ageDays} days is below retention ${retentionValue} days.` };
+}
+function incrementCount(report, action) {
+    if (action === 'would_delete')
+        report.counts.wouldDelete++;
+    else
+        report.counts[action]++;
+}
+function runArtifactCleanup(workspaceRoot, options) {
+    const now = options.now ?? new Date();
+    const retention = resolveArtifactRetentionConfig(workspaceRoot);
+    const candidates = collectCandidates(workspaceRoot, options.activeUserEmail);
+    const report = {
+        generatedAt: now.toISOString(),
+        apply: options.apply,
+        retention: retention.values,
+        invalidConfig: retention.invalidValues,
+        counts: { retained: 0, wouldDelete: 0, deleted: 0, skipped: 0, failed: 0 },
+        items: [],
+    };
+    for (const candidate of candidates) {
+        const retentionValue = retention.values[candidate.category];
+        const decision = shouldDelete(candidate, retentionValue, now);
+        let action;
+        let error;
+        if (!candidate.eligible) {
+            action = 'skipped';
+        }
+        else if (!decision.delete) {
+            action = 'retained';
+        }
+        else if (!options.apply) {
+            action = 'would_delete';
+        }
+        else {
+            try {
+                node_fs_1.default.unlinkSync(candidate.absolutePath);
+                action = 'deleted';
+            }
+            catch (err) {
+                action = 'failed';
+                error = err instanceof Error ? err.message : String(err);
+            }
+        }
+        incrementCount(report, action);
+        report.items.push({
+            category: candidate.category,
+            path: candidate.relativePath,
+            action,
+            reason: error ? `Deletion failed: ${decision.reason}` : decision.reason,
+            retentionValue,
+            eligibilityDate: candidate.eligibilityDate?.toISOString().slice(0, 10),
+            cleanupDate: action === 'deleted' || action === 'would_delete' ? now.toISOString().slice(0, 10) : undefined,
+            error,
+        });
+    }
+    return report;
+}
+function planArtifactCleanup(workspaceRoot, options) {
+    return runArtifactCleanup(workspaceRoot, { ...options, apply: false });
+}