fraim 2.0.154 → 2.0.160

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

@@ -25,10 +25,69 @@ function normalizeCustomerCommunication(config) {
         deliveryProvider: current.deliveryProvider
     };
 }
+function normalizeIntegrations(config) {
+    const current = config?.integrations;
+    if (!current || typeof current !== 'object')
+        return undefined;
+    return {
+        itsm: current.itsm && typeof current.itsm === 'object'
+            ? {
+                provider: current.itsm.provider,
+                instanceUrl: current.itsm.instanceUrl
+            }
+            : undefined,
+        identity: current.identity && typeof current.identity === 'object'
+            ? { provider: current.identity.provider }
+            : undefined
+    };
+}
+function normalizeAutomation(config) {
+    const support = config?.automation?.support;
+    if (!support || typeof support !== 'object')
+        return undefined;
+    return {
+        support: {
+            startMode: support.startMode,
+            defaultDecisionMode: support.defaultDecisionMode,
+            contextResolver: support.contextResolver && typeof support.contextResolver === 'object'
+                ? {
+                    scriptPath: support.contextResolver.scriptPath,
+                    arguments: Array.isArray(support.contextResolver.arguments) ? support.contextResolver.arguments : undefined,
+                    timeoutMs: support.contextResolver.timeoutMs
+                }
+                : undefined,
+            queue: support.queue && typeof support.queue === 'object'
+                ? {
+                    provider: support.queue.provider,
+                    table: support.queue.table,
+                    assignmentGroup: support.queue.assignmentGroup,
+                    claimField: support.queue.claimField,
+                    fixturePath: support.queue.fixturePath,
+                    eligibleStates: Array.isArray(support.queue.eligibleStates) ? support.queue.eligibleStates : undefined,
+                    pollIntervalSeconds: support.queue.pollIntervalSeconds,
+                    successState: support.queue.successState,
+                    failureState: support.queue.failureState,
+                    closeState: support.queue.closeState
+                }
+                : undefined,
+            requestTypes: support.requestTypes && typeof support.requestTypes === 'object'
+                ? support.requestTypes
+                : undefined,
+            communication: support.communication && typeof support.communication === 'object'
+                ? {
+                    channel: support.communication.channel,
+                    deliveryMode: support.communication.deliveryMode,
+                    recipientField: support.communication.recipientField,
+                    includeTemporaryPassword: support.communication.includeTemporaryPassword,
+                    messageTemplate: support.communication.messageTemplate
+                }
+                : undefined
+        }
+    };
+}
 function normalizeFraimConfig(config) {
     // Handle backward compatibility and migration
     const mergedConfig = {
-        version: config.version || types_1.DEFAULT_FRAIM_CONFIG.version,
         project: {
             ...types_1.DEFAULT_FRAIM_CONFIG.project,
             ...(config.project || {})
@@ -70,6 +129,14 @@ function normalizeFraimConfig(config) {
     if (customerCommunication) {
         mergedConfig.customerCommunication = customerCommunication;
     }
+    const integrations = normalizeIntegrations(config);
+    if (integrations) {
+        mergedConfig.integrations = integrations;
+    }
+    const automation = normalizeAutomation(config);
+    if (automation) {
+        mergedConfig.automation = automation;
+    }
     return mergedConfig;
 }
 /**
@@ -86,7 +153,7 @@ function loadFraimConfig(configPath = (0, project_fraim_paths_1.getWorkspaceConf
         const configContent = (0, fs_1.readFileSync)(configPath, 'utf-8');
         const config = JSON.parse(configContent);
         const mergedConfig = normalizeFraimConfig(config);
-        console.log(`Loaded FRAIM config from ${displayPath} (version ${mergedConfig.version})`);
+        console.log(`Loaded FRAIM config from ${displayPath}`);
         if (config.git && !config.repository) {
             console.warn('Deprecated: "git" config detected. Consider migrating to "repository" config.');
         }

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

@@ -8,10 +8,6 @@ exports.SUPPORTED_FRAIM_CONFIG_PATHS = exports.FRAIM_CONFIG_SCHEMA = void 0;
 exports.FRAIM_CONFIG_SCHEMA = {
     "kind": "object",
     "properties": {
-        "version": {
-            "kind": "string",
-            "required": true
-        },
         "project": {
             "kind": "object",
             "properties": {
@@ -142,6 +138,14 @@ exports.FRAIM_CONFIG_SCHEMA = {
                         }
                     }
                 },
+                "githubWorkflows": {
+                    "kind": "object",
+                    "properties": {
+                        "enabled": {
+                            "kind": "boolean"
+                        }
+                    }
+                },
                 "validation": {
                     "kind": "object",
                     "properties": {
@@ -198,6 +202,9 @@ exports.FRAIM_CONFIG_SCHEMA = {
                 },
                 "scoreThreshold": {
                     "kind": "number"
+                },
+                "globalPath": {
+                    "kind": "string"
                 }
             }
         },
@@ -262,12 +269,220 @@ exports.FRAIM_CONFIG_SCHEMA = {
                     ]
                 }
             }
+        },
+        "crm": {
+            "kind": "object",
+            "properties": {
+                "provider": {
+                    "kind": "enum",
+                    "values": [
+                        "salesforce",
+                        "customereq"
+                    ]
+                }
+            }
+        },
+        "integrations": {
+            "kind": "object",
+            "properties": {
+                "itsm": {
+                    "kind": "object",
+                    "properties": {
+                        "provider": {
+                            "kind": "enum",
+                            "values": [
+                                "servicenow"
+                            ]
+                        },
+                        "instanceUrl": {
+                            "kind": "string"
+                        }
+                    }
+                },
+                "identity": {
+                    "kind": "object",
+                    "properties": {
+                        "provider": {
+                            "kind": "enum",
+                            "values": [
+                                "microsoft365"
+                            ]
+                        }
+                    }
+                }
+            }
+        },
+        "automation": {
+            "kind": "object",
+            "properties": {
+                "support": {
+                    "kind": "object",
+                    "properties": {
+                        "startMode": {
+                            "kind": "enum",
+                            "values": [
+                                "manual",
+                                "autonomous"
+                            ]
+                        },
+                        "defaultDecisionMode": {
+                            "kind": "enum",
+                            "values": [
+                                "hitl",
+                                "autonomous"
+                            ]
+                        },
+                        "contextResolver": {
+                            "kind": "object",
+                            "properties": {
+                                "scriptPath": {
+                                    "kind": "string"
+                                },
+                                "arguments": {
+                                    "kind": "array",
+                                    "element": {
+                                        "kind": "string"
+                                    }
+                                },
+                                "timeoutMs": {
+                                    "kind": "number"
+                                }
+                            }
+                        },
+                        "queue": {
+                            "kind": "object",
+                            "properties": {
+                                "provider": {
+                                    "kind": "enum",
+                                    "values": [
+                                        "servicenow",
+                                        "fixture"
+                                    ]
+                                },
+                                "table": {
+                                    "kind": "string"
+                                },
+                                "assignmentGroup": {
+                                    "kind": "string"
+                                },
+                                "claimField": {
+                                    "kind": "string"
+                                },
+                                "fixturePath": {
+                                    "kind": "string"
+                                },
+                                "eligibleStates": {
+                                    "kind": "array",
+                                    "element": {
+                                        "kind": "string"
+                                    }
+                                },
+                                "pollIntervalSeconds": {
+                                    "kind": "number"
+                                },
+                                "successState": {
+                                    "kind": "string"
+                                },
+                                "failureState": {
+                                    "kind": "string"
+                                },
+                                "closeState": {
+                                    "kind": "string"
+                                }
+                            }
+                        },
+                        "requestTypes": {
+                            "kind": "object",
+                            "properties": {
+                                "password_reset": {
+                                    "kind": "object",
+                                    "properties": {
+                                        "mode": {
+                                            "kind": "enum",
+                                            "values": [
+                                                "hitl",
+                                                "autonomous"
+                                            ]
+                                        },
+                                        "requireApprovalState": {
+                                            "kind": "string"
+                                        },
+                                        "selector": {
+                                            "kind": "object",
+                                            "properties": {
+                                                "shortDescriptionContains": {
+                                                    "kind": "array",
+                                                    "element": {
+                                                        "kind": "string"
+                                                    }
+                                                }
+                                            }
+                                        },
+                                        "microsoftPasswordReset": {
+                                            "kind": "object",
+                                            "properties": {
+                                                "resetType": {
+                                                    "kind": "enum",
+                                                    "values": [
+                                                        "temporary_generated",
+                                                        "temporary_provided",
+                                                        "permanent_provided"
+                                                    ]
+                                                },
+                                                "providedPasswordEnvVar": {
+                                                    "kind": "string"
+                                                },
+                                                "forceChangePasswordNextSignIn": {
+                                                    "kind": "boolean"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "communication": {
+                            "kind": "object",
+                            "properties": {
+                                "channel": {
+                                    "kind": "enum",
+                                    "values": [
+                                        "email",
+                                        "sms",
+                                        "teams",
+                                        "manual-handoff"
+                                    ]
+                                },
+                                "deliveryMode": {
+                                    "kind": "enum",
+                                    "values": [
+                                        "direct",
+                                        "operator-relay"
+                                    ]
+                                },
+                                "recipientField": {
+                                    "kind": "enum",
+                                    "values": [
+                                        "requested_for",
+                                        "requested_by"
+                                    ]
+                                },
+                                "includeTemporaryPassword": {
+                                    "kind": "boolean"
+                                },
+                                "messageTemplate": {
+                                    "kind": "string"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
     },
     "required": true
 };
 exports.SUPPORTED_FRAIM_CONFIG_PATHS = [
-    "version",
     "project",
     "project.name",
     "project.industry",
@@ -302,6 +517,8 @@ exports.SUPPORTED_FRAIM_CONFIG_PATHS = [
     "customizations.designSystem",
     "customizations.designSystem.path",
     "customizations.designSystem.brand",
+    "customizations.githubWorkflows",
+    "customizations.githubWorkflows.enabled",
     "customizations.validation",
     "customizations.validation.buildCommand",
     "customizations.validation.testSuiteCommand",
@@ -316,6 +533,7 @@ exports.SUPPORTED_FRAIM_CONFIG_PATHS = [
     "learning",
     "learning.lastSynthesisDate",
     "learning.scoreThreshold",
+    "learning.globalPath",
     "customer-communication",
     "customer-communication.productName",
     "customer-communication.productUrl",
@@ -329,5 +547,48 @@ exports.SUPPORTED_FRAIM_CONFIG_PATHS = [
     "stakeholderUpdate.cadence",
     "stakeholderUpdate.historyPath",
     "operatingReview",
-    "operatingReview.cadence"
+    "operatingReview.cadence",
+    "crm",
+    "crm.provider",
+    "integrations",
+    "integrations.itsm",
+    "integrations.itsm.provider",
+    "integrations.itsm.instanceUrl",
+    "integrations.identity",
+    "integrations.identity.provider",
+    "automation",
+    "automation.support",
+    "automation.support.startMode",
+    "automation.support.defaultDecisionMode",
+    "automation.support.contextResolver",
+    "automation.support.contextResolver.scriptPath",
+    "automation.support.contextResolver.arguments",
+    "automation.support.contextResolver.timeoutMs",
+    "automation.support.queue",
+    "automation.support.queue.provider",
+    "automation.support.queue.table",
+    "automation.support.queue.assignmentGroup",
+    "automation.support.queue.claimField",
+    "automation.support.queue.fixturePath",
+    "automation.support.queue.eligibleStates",
+    "automation.support.queue.pollIntervalSeconds",
+    "automation.support.queue.successState",
+    "automation.support.queue.failureState",
+    "automation.support.queue.closeState",
+    "automation.support.requestTypes",
+    "automation.support.requestTypes.password_reset",
+    "automation.support.requestTypes.password_reset.mode",
+    "automation.support.requestTypes.password_reset.requireApprovalState",
+    "automation.support.requestTypes.password_reset.selector",
+    "automation.support.requestTypes.password_reset.selector.shortDescriptionContains",
+    "automation.support.requestTypes.password_reset.microsoftPasswordReset",
+    "automation.support.requestTypes.password_reset.microsoftPasswordReset.resetType",
+    "automation.support.requestTypes.password_reset.microsoftPasswordReset.providedPasswordEnvVar",
+    "automation.support.requestTypes.password_reset.microsoftPasswordReset.forceChangePasswordNextSignIn",
+    "automation.support.communication",
+    "automation.support.communication.channel",
+    "automation.support.communication.deliveryMode",
+    "automation.support.communication.recipientField",
+    "automation.support.communication.includeTemporaryPassword",
+    "automation.support.communication.messageTemplate"
 ];

package/dist/src/core/types.js

@@ -9,7 +9,6 @@ exports.DEFAULT_FRAIM_CONFIG = void 0;
  * Default configuration values
  */
 exports.DEFAULT_FRAIM_CONFIG = {
-    version: '2.0.47',
     project: {
         name: 'Untitled Project'
     },

package/dist/src/core/utils/fraim-labels.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRAIM_STATUS_LABELS = exports.FRAIM_PHASE_LABELS = exports.LEGACY_FRAIM_STATUS_LABELS = void 0;
+exports.isFraimPhaseLabel = isFraimPhaseLabel;
+exports.isFraimStatusLabel = isFraimStatusLabel;
+exports.isLegacyFraimStatusLabel = isLegacyFraimStatusLabel;
+exports.normalizeFraimPhaseLabel = normalizeFraimPhaseLabel;
+exports.normalizeFraimStatusLabel = normalizeFraimStatusLabel;
+exports.partitionFraimLabels = partitionFraimLabels;
+exports.mergeFraimGitHubLabels = mergeFraimGitHubLabels;
+exports.applyIssueStatusTransition = applyIssueStatusTransition;
+exports.applyIssuePhaseTransition = applyIssuePhaseTransition;
+exports.applyIssuePhaseAndStatusTransition = applyIssuePhaseAndStatusTransition;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const REQUIRED_FRAIM_PHASE_LABELS = [
+    'phase:spec',
+    'phase:design',
+    'phase:tests',
+    'phase:impl'
+];
+const REQUIRED_FRAIM_STATUS_LABELS = [
+    'status:wip',
+    'status:needs-review',
+    'status:complete'
+];
+exports.LEGACY_FRAIM_STATUS_LABELS = [
+    'status:in-progress',
+    'status:design-review-passed'
+];
+function normalizeLabel(label) {
+    return label.trim().toLowerCase();
+}
+function findLabelsCatalogPath() {
+    let currentDir = __dirname;
+    for (let i = 0; i < 10; i++) {
+        const candidate = path_1.default.join(currentDir, 'labels.json');
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+        const parentDir = path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    const cwdCandidate = path_1.default.join(process.cwd(), 'labels.json');
+    if (fs_1.default.existsSync(cwdCandidate)) {
+        return cwdCandidate;
+    }
+    throw new Error('labels.json not found; FRAIM GitHub label helpers require the repo label catalog.');
+}
+function loadCatalogLabels() {
+    const catalogPath = findLabelsCatalogPath();
+    try {
+        const parsed = JSON.parse(fs_1.default.readFileSync(catalogPath, 'utf8'));
+        return new Set(parsed
+            .map((entry) => (typeof entry?.name === 'string' ? normalizeLabel(entry.name) : ''))
+            .filter(Boolean));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read labels.json for FRAIM GitHub label helpers: ${message}`);
+    }
+}
+function requireCatalogLabels(expected, kind) {
+    const catalogLabels = loadCatalogLabels();
+    const missing = expected.filter((label) => !catalogLabels.has(label));
+    if (missing.length > 0) {
+        throw new Error(`labels.json is missing canonical FRAIM ${kind} labels: ${missing.join(', ')}`);
+    }
+    return expected;
+}
+exports.FRAIM_PHASE_LABELS = requireCatalogLabels(REQUIRED_FRAIM_PHASE_LABELS, 'phase');
+exports.FRAIM_STATUS_LABELS = requireCatalogLabels(REQUIRED_FRAIM_STATUS_LABELS, 'status');
+const FRAIM_PHASE_LABEL_SET = new Set(exports.FRAIM_PHASE_LABELS);
+const FRAIM_STATUS_LABEL_SET = new Set(exports.FRAIM_STATUS_LABELS);
+const LEGACY_FRAIM_STATUS_LABEL_SET = new Set(exports.LEGACY_FRAIM_STATUS_LABELS);
+function dedupeLabels(labels) {
+    const seen = new Set();
+    const deduped = [];
+    for (const rawLabel of labels) {
+        const trimmed = rawLabel.trim();
+        if (!trimmed)
+            continue;
+        const normalized = normalizeLabel(trimmed);
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        deduped.push(trimmed);
+    }
+    return deduped;
+}
+function mapLegacyStatus(label) {
+    const normalized = normalizeLabel(label);
+    switch (normalized) {
+        case 'status:in-progress':
+            return 'status:wip';
+        case 'status:design-review-passed':
+            return 'status:complete';
+        default:
+            return null;
+    }
+}
+function isFraimPhaseLabel(label) {
+    return FRAIM_PHASE_LABEL_SET.has(normalizeLabel(label));
+}
+function isFraimStatusLabel(label) {
+    return FRAIM_STATUS_LABEL_SET.has(normalizeLabel(label));
+}
+function isLegacyFraimStatusLabel(label) {
+    return LEGACY_FRAIM_STATUS_LABEL_SET.has(normalizeLabel(label));
+}
+function normalizeFraimPhaseLabel(label) {
+    const normalized = normalizeLabel(label);
+    if (!FRAIM_PHASE_LABEL_SET.has(normalized)) {
+        throw new Error(`Unsupported FRAIM phase label: ${label}`);
+    }
+    return normalized;
+}
+function normalizeFraimStatusLabel(label) {
+    const normalized = normalizeLabel(label);
+    if (FRAIM_STATUS_LABEL_SET.has(normalized)) {
+        return normalized;
+    }
+    const mappedLegacy = mapLegacyStatus(normalized);
+    if (mappedLegacy) {
+        return mappedLegacy;
+    }
+    throw new Error(`Unsupported FRAIM status label: ${label}`);
+}
+function partitionFraimLabels(labels) {
+    const nonFraimLabels = [];
+    const phaseLabels = [];
+    const statusLabels = [];
+    for (const label of dedupeLabels(labels)) {
+        if (isFraimPhaseLabel(label)) {
+            phaseLabels.push(normalizeFraimPhaseLabel(label));
+            continue;
+        }
+        if (isFraimStatusLabel(label) || isLegacyFraimStatusLabel(label)) {
+            statusLabels.push(normalizeFraimStatusLabel(label));
+            continue;
+        }
+        nonFraimLabels.push(label);
+    }
+    return {
+        nonFraimLabels,
+        phaseLabels,
+        statusLabels
+    };
+}
+function mergeFraimGitHubLabels(labels, updates) {
+    const { nonFraimLabels, phaseLabels, statusLabels } = partitionFraimLabels(labels);
+    const nextPhase = updates.phase
+        ? normalizeFraimPhaseLabel(updates.phase)
+        : phaseLabels[0];
+    const nextStatus = updates.status
+        ? normalizeFraimStatusLabel(updates.status)
+        : statusLabels[0];
+    const merged = [...nonFraimLabels];
+    if (nextPhase)
+        merged.push(nextPhase);
+    if (nextStatus)
+        merged.push(nextStatus);
+    return dedupeLabels(merged);
+}
+function applyIssueStatusTransition(labels, status) {
+    return mergeFraimGitHubLabels(labels, { status });
+}
+function applyIssuePhaseTransition(labels, phase) {
+    return mergeFraimGitHubLabels(labels, {
+        phase,
+        status: 'status:wip'
+    });
+}
+function applyIssuePhaseAndStatusTransition(labels, phase, status) {
+    return mergeFraimGitHubLabels(labels, { phase, status });
+}

package/dist/src/core/utils/git-utils.js

@@ -32,11 +32,32 @@ function isExplicitLocalRepoPath(repoUrl) {
         trimmed.startsWith('../') ||
         trimmed.startsWith('file://'));
 }
+function readExplicitPortFromEnv() {
+    for (const value of [
+        process.env.PLAYWRIGHT_FRAIM_MCP_PORT,
+        process.env.PLAYWRIGHT_WEBSITE_PORT,
+        process.env.FRAIM_MCP_PORT,
+        process.env.PORT,
+        process.env.WEBSITES_PORT
+    ]) {
+        const port = Number(value);
+        if (Number.isFinite(port) && port > 0) {
+            return port;
+        }
+    }
+    return null;
+}
 /**
  * Gets a unique port based on the current git branch name (if it's an issue branch)
  * Default to 15302 if not on an issue branch
  */
 function getPort() {
+    // Explicit runtime ports must win so tests and subprocesses all resolve the
+    // same active server instead of drifting back to a branch-derived default.
+    const explicitPort = readExplicitPortFromEnv();
+    if (explicitPort) {
+        return explicitPort;
+    }
     try {
         const branchName = process.env.FRAIM_BRANCH || (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
         // Match issue-123 or 123-feature-name or feature/123-name
@@ -50,7 +71,7 @@ function getPort() {
     catch (e) {
         // Silently fail and use default
     }
-    return Number(process.env.PORT) || Number(process.env.WEBSITES_PORT) || Number(process.env.FRAIM_MCP_PORT) || 15302;
+    return 15302;
 }
 /**
  * Determines the database name based on the git branch