@pennyfarthing/core 7.4.1 → 7.5.0

package/{packages/core/dist → dist}/workflow/index.d.ts

@@ -13,4 +13,3 @@ export { validateWorkflow, type WorkflowDefinition, type WorkflowPhase, type Wor
 export { loadWorkflowFile, loadWorkflowsFromDir, type WorkflowLoadResult, type WorkflowLoadResults, } from './workflow-loader.js';
 export { routeStoryToWorkflow, type StoryMetadata, type RoutingResult, } from './workflow-router.js';
 export { checkWorkflowPermissions, type WorkflowPermissionCheckResult, } from './workflow-permissions.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/workflow/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Workflow Module Exports
+ *
+ * Provides workflow loading, validation, routing, and permission checking.
+ *
+ * Stories:
+ * - 31-1: Workflow schema validation
+ * - 31-2: Workflow loader
+ * - 31-3: Story-to-workflow routing
+ * - MSSCI-11710: Permission presets by workflow
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkWorkflowPermissions = exports.routeStoryToWorkflow = exports.loadWorkflowsFromDir = exports.loadWorkflowFile = exports.validateWorkflow = void 0;
+// Schema validation and types
+var workflow_schema_js_1 = require("./workflow-schema.js");
+Object.defineProperty(exports, "validateWorkflow", { enumerable: true, get: function () { return workflow_schema_js_1.validateWorkflow; } });
+// Workflow loading
+var workflow_loader_js_1 = require("./workflow-loader.js");
+Object.defineProperty(exports, "loadWorkflowFile", { enumerable: true, get: function () { return workflow_loader_js_1.loadWorkflowFile; } });
+Object.defineProperty(exports, "loadWorkflowsFromDir", { enumerable: true, get: function () { return workflow_loader_js_1.loadWorkflowsFromDir; } });
+// Story-to-workflow routing
+var workflow_router_js_1 = require("./workflow-router.js");
+Object.defineProperty(exports, "routeStoryToWorkflow", { enumerable: true, get: function () { return workflow_router_js_1.routeStoryToWorkflow; } });
+// Permission checking (Story MSSCI-11710)
+var workflow_permissions_js_1 = require("./workflow-permissions.js");
+Object.defineProperty(exports, "checkWorkflowPermissions", { enumerable: true, get: function () { return workflow_permissions_js_1.checkWorkflowPermissions; } });
+// Note: WorkflowPermissionPreset is exported from workflow-schema.ts
+// to keep all workflow definition types in one place.
+// The workflow-permissions.ts module has its own copy for backwards
+// compatibility but workflow-schema.ts is the canonical source.

package/{packages/core/dist → dist}/workflow/workflow-loader.d.ts

@@ -73,4 +73,3 @@ export declare function loadWorkflowFile(filePath: string): WorkflowLoadResult;
  */
 export declare function loadWorkflowsFromDir(dirPath: string): WorkflowLoadResults;
 export type { WorkflowDefinition, WorkflowPhase, WorkflowTriggers, WorkflowValidationError, WorkflowValidationResult } from './workflow-schema.js';
-//# sourceMappingURL=workflow-loader.d.ts.map

package/{packages/core/dist → dist}/workflow/workflow-loader.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Workflow Loader
  *
@@ -10,10 +11,13 @@
  *
  * Uses validateWorkflow() from workflow-schema.ts (Story 31-1)
  */
-import { readFileSync, readdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { parse as parseYaml } from 'yaml';
-import { validateWorkflow } from './workflow-schema.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadWorkflowFile = loadWorkflowFile;
+exports.loadWorkflowsFromDir = loadWorkflowsFromDir;
+var node_fs_1 = require("node:fs");
+var node_path_1 = require("node:path");
+var yaml_1 = require("yaml");
+var workflow_schema_js_1 = require("./workflow-schema.js");
 /**
  * Load and validate a single workflow YAML file
  *
@@ -30,52 +34,52 @@ import { validateWorkflow } from './workflow-schema.js';
  * }
  * ```
  */
-export function loadWorkflowFile(filePath) {
+function loadWorkflowFile(filePath) {
     // 1. Read file from disk
-    let content;
+    var content;
     try {
-        content = readFileSync(filePath, 'utf-8');
+        content = (0, node_fs_1.readFileSync)(filePath, 'utf-8');
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : 'Unknown file read error';
+        var message = err instanceof Error ? err.message : 'Unknown file read error';
         return {
             success: false,
-            filePath,
+            filePath: filePath,
             errors: [{
                     field: 'file',
-                    message: message.includes('ENOENT') ? `File not found: ${filePath}` : message
+                    message: message.includes('ENOENT') ? "File not found: ".concat(filePath) : message
                 }]
         };
     }
     // 2. Parse YAML
-    let parsed;
+    var parsed;
     try {
-        parsed = parseYaml(content);
+        parsed = (0, yaml_1.parse)(content);
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : 'Unknown YAML parse error';
+        var message = err instanceof Error ? err.message : 'Unknown YAML parse error';
         return {
             success: false,
-            filePath,
+            filePath: filePath,
             errors: [{
                     field: 'yaml',
-                    message: `YAML parse error: ${message}`
+                    message: "YAML parse error: ".concat(message)
                 }]
         };
     }
     // 3. Call validateWorkflow()
-    const result = validateWorkflow(parsed);
+    var result = (0, workflow_schema_js_1.validateWorkflow)(parsed);
     // 4. Return result
     if (result.valid && result.workflow) {
         return {
             success: true,
-            filePath,
+            filePath: filePath,
             workflow: result.workflow
         };
     }
     return {
         success: false,
-        filePath,
+        filePath: filePath,
         errors: result.errors
     };
 }
@@ -97,37 +101,39 @@ export function loadWorkflowFile(filePath) {
  * }
  * ```
  */
-export function loadWorkflowsFromDir(dirPath) {
-    const workflows = [];
-    const errors = [];
+function loadWorkflowsFromDir(dirPath) {
+    var workflows = [];
+    var errors = [];
     // 1. Check directory exists
-    if (!existsSync(dirPath)) {
-        return { workflows, errors };
+    if (!(0, node_fs_1.existsSync)(dirPath)) {
+        return { workflows: workflows, errors: errors };
     }
     // 2. List files and filter for .yaml/.yml extensions
-    let files;
+    var files;
     try {
-        files = readdirSync(dirPath);
+        files = (0, node_fs_1.readdirSync)(dirPath);
     }
-    catch {
-        return { workflows, errors };
+    catch (_a) {
+        return { workflows: workflows, errors: errors };
     }
-    const yamlFiles = files.filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+    var yamlFiles = files.filter(function (f) {
+        return f.endsWith('.yaml') || f.endsWith('.yml');
+    });
     // 3. Call loadWorkflowFile() for each
-    for (const file of yamlFiles) {
-        const filePath = join(dirPath, file);
-        const result = loadWorkflowFile(filePath);
+    for (var _i = 0, yamlFiles_1 = yamlFiles; _i < yamlFiles_1.length; _i++) {
+        var file = yamlFiles_1[_i];
+        var filePath = (0, node_path_1.join)(dirPath, file);
+        var result = loadWorkflowFile(filePath);
         // 4. Aggregate results
         if (result.success && result.workflow) {
             workflows.push(result.workflow);
         }
         else if (result.errors) {
             errors.push({
-                filePath,
+                filePath: filePath,
                 errors: result.errors
             });
         }
     }
-    return { workflows, errors };
+    return { workflows: workflows, errors: errors };
 }
-//# sourceMappingURL=workflow-loader.js.map

package/{packages/core/dist → dist}/workflow/workflow-permissions.d.ts

@@ -52,4 +52,3 @@ export interface WorkflowPermissionCheckResult {
  * ```
  */
 export declare function checkWorkflowPermissions(workflowPermissions: WorkflowPermissionPreset[], cachedGrants: PermissionGrant[]): WorkflowPermissionCheckResult;
-//# sourceMappingURL=workflow-permissions.d.ts.map

package/{packages/core/dist → dist}/workflow/workflow-permissions.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Workflow Permission Presets
  *
@@ -6,6 +7,8 @@
  * This module provides permission checking for workflow presets.
  * Workflows can define required permissions that are checked at startup.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkWorkflowPermissions = checkWorkflowPermissions;
 /**
  * Check if a permission preset is covered by a cached grant
  *
@@ -42,23 +45,26 @@ function isGranted(preset, grant) {
  * }
  * ```
  */
-export function checkWorkflowPermissions(workflowPermissions, cachedGrants) {
-    const missing = [];
-    const granted = [];
-    for (const preset of workflowPermissions) {
+function checkWorkflowPermissions(workflowPermissions, cachedGrants) {
+    var missing = [];
+    var granted = [];
+    var _loop_1 = function (preset) {
         // Check if any cached grant covers this preset
-        const hasGrant = cachedGrants.some((grant) => isGranted(preset, grant));
+        var hasGrant = cachedGrants.some(function (grant) { return isGranted(preset, grant); });
         if (hasGrant) {
             granted.push(preset);
         }
         else {
             missing.push(preset);
         }
+    };
+    for (var _i = 0, workflowPermissions_1 = workflowPermissions; _i < workflowPermissions_1.length; _i++) {
+        var preset = workflowPermissions_1[_i];
+        _loop_1(preset);
     }
     return {
         allGranted: missing.length === 0,
-        missing,
-        granted,
+        missing: missing,
+        granted: granted,
     };
 }
-//# sourceMappingURL=workflow-permissions.js.map

package/{packages/core/dist → dist}/workflow/workflow-router.d.ts

@@ -52,4 +52,3 @@ export interface RoutingResult {
  * ```
  */
 export declare function routeStoryToWorkflow(story: StoryMetadata, workflows: WorkflowDefinition[]): RoutingResult | null;
-//# sourceMappingURL=workflow-router.d.ts.map

package/{packages/core/dist → dist}/workflow/workflow-router.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Workflow Router
  *
@@ -11,6 +12,8 @@
  * 4. Points match (story points within workflow trigger range)
  * 5. Default workflow fallback
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeStoryToWorkflow = routeStoryToWorkflow;
 /**
  * Helper to check if a trigger's constraints are satisfied by a story
  * This ensures ALL constraints in a trigger must match (AND logic within a trigger)
@@ -35,9 +38,9 @@ function doesStoryMatchTrigger(story, triggers, matchType) {
         if (story.points === undefined) {
             return false;
         }
-        const { min, max } = triggers.points;
-        const hasMin = min !== undefined;
-        const hasMax = max !== undefined;
+        var _a = triggers.points, min = _a.min, max = _a.max;
+        var hasMin = min !== undefined;
+        var hasMax = max !== undefined;
         if (hasMin && story.points < min) {
             return false;
         }
@@ -64,32 +67,32 @@ function doesStoryMatchTrigger(story, triggers, matchType) {
  * }
  * ```
  */
-export function routeStoryToWorkflow(story, workflows) {
+function routeStoryToWorkflow(story, workflows) {
     if (workflows.length === 0) {
         return null;
     }
     // Priority 1: Explicit workflow:xyz tag
-    const explicitMatch = findExplicitTagMatch(story, workflows);
+    var explicitMatch = findExplicitTagMatch(story, workflows);
     if (explicitMatch) {
         return explicitMatch;
     }
     // Priority 2: Trigger tag match
-    const tagMatch = findTriggerTagMatch(story, workflows);
+    var tagMatch = findTriggerTagMatch(story, workflows);
     if (tagMatch) {
         return tagMatch;
     }
     // Priority 3: Type match
-    const typeMatch = findTypeMatch(story, workflows);
+    var typeMatch = findTypeMatch(story, workflows);
     if (typeMatch) {
         return typeMatch;
     }
     // Priority 4: Points match
-    const pointsMatch = findPointsMatch(story, workflows);
+    var pointsMatch = findPointsMatch(story, workflows);
     if (pointsMatch) {
         return pointsMatch;
     }
     // Priority 5: Default fallback
-    const defaultMatch = findDefaultWorkflow(workflows);
+    var defaultMatch = findDefaultWorkflow(workflows);
     if (defaultMatch) {
         return defaultMatch;
     }
@@ -102,19 +105,25 @@ function findExplicitTagMatch(story, workflows) {
     if (!story.tags || story.tags.length === 0) {
         return null;
     }
-    // Find first workflow: tag
-    for (const tag of story.tags) {
+    var _loop_1 = function (tag) {
         if (tag.startsWith('workflow:')) {
-            const workflowName = tag.slice('workflow:'.length);
-            const workflow = workflows.find(w => w.name === workflowName);
+            var workflowName_1 = tag.slice('workflow:'.length);
+            var workflow = workflows.find(function (w) { return w.name === workflowName_1; });
             if (workflow) {
-                return {
-                    workflow,
-                    reason: `Matched explicit tag 'workflow:${workflowName}' to workflow '${workflow.name}'`
-                };
+                return { value: {
+                        workflow: workflow,
+                        reason: "Matched explicit tag 'workflow:".concat(workflowName_1, "' to workflow '").concat(workflow.name, "'")
+                    } };
             }
             // Explicit tag didn't match any workflow - continue to other matching rules
         }
+    };
+    // Find first workflow: tag
+    for (var _i = 0, _a = story.tags; _i < _a.length; _i++) {
+        var tag = _a[_i];
+        var state_1 = _loop_1(tag);
+        if (typeof state_1 === "object")
+            return state_1.value;
     }
     return null;
 }
@@ -122,30 +131,37 @@ function findExplicitTagMatch(story, workflows) {
  * Find workflow by trigger tags (story tags intersect workflow trigger.tags)
  */
 function findTriggerTagMatch(story, workflows) {
+    var _a;
     if (!story.tags || story.tags.length === 0) {
         return null;
     }
     // Filter out workflow: tags (those are handled by explicit match)
-    const storyTags = story.tags.filter(t => !t.startsWith('workflow:'));
+    var storyTags = story.tags.filter(function (t) { return !t.startsWith('workflow:'); });
     if (storyTags.length === 0) {
         return null;
     }
-    for (const workflow of workflows) {
-        const triggerTags = workflow.triggers?.tags;
+    var _loop_2 = function (workflow) {
+        var triggerTags = (_a = workflow.triggers) === null || _a === void 0 ? void 0 : _a.tags;
         if (!triggerTags || triggerTags.length === 0) {
-            continue;
+            return "continue";
         }
         // Check if any story tag matches any trigger tag
-        const matchingTag = storyTags.find(t => triggerTags.includes(t));
+        var matchingTag = storyTags.find(function (t) { return triggerTags.includes(t); });
         if (matchingTag) {
             // Verify all other constraints are met
             if (doesStoryMatchTrigger(story, workflow.triggers, 'trigger-tag')) {
-                return {
-                    workflow,
-                    reason: `Matched tag '${matchingTag}' to workflow '${workflow.name}'`
-                };
+                return { value: {
+                        workflow: workflow,
+                        reason: "Matched tag '".concat(matchingTag, "' to workflow '").concat(workflow.name, "'")
+                    } };
             }
         }
+    };
+    for (var _i = 0, workflows_1 = workflows; _i < workflows_1.length; _i++) {
+        var workflow = workflows_1[_i];
+        var state_2 = _loop_2(workflow);
+        if (typeof state_2 === "object")
+            return state_2.value;
     }
     return null;
 }
@@ -158,14 +174,16 @@ function findTriggerTagMatch(story, workflows) {
  * (which has no points constraint).
  */
 function findTypeMatch(story, workflows) {
+    var _a, _b;
     if (!story.type) {
         return null;
     }
     // Collect all type matches, sorted by specificity
     // Specificity: workflows with points constraints > workflows without
-    const typeMatches = [];
-    for (const workflow of workflows) {
-        const triggerTypes = workflow.triggers?.types;
+    var typeMatches = [];
+    for (var _i = 0, workflows_2 = workflows; _i < workflows_2.length; _i++) {
+        var workflow = workflows_2[_i];
+        var triggerTypes = (_a = workflow.triggers) === null || _a === void 0 ? void 0 : _a.types;
         if (!triggerTypes || triggerTypes.length === 0) {
             continue;
         }
@@ -173,19 +191,19 @@ function findTypeMatch(story, workflows) {
             // Verify all constraints are met (including points if specified)
             if (doesStoryMatchTrigger(story, workflow.triggers, 'type')) {
                 // Calculate specificity: workflows with points constraints are more specific
-                const hasPointsConstraint = workflow.triggers?.points !== undefined;
-                const specificity = hasPointsConstraint ? 1 : 0;
-                typeMatches.push({ workflow, specificity });
+                var hasPointsConstraint = ((_b = workflow.triggers) === null || _b === void 0 ? void 0 : _b.points) !== undefined;
+                var specificity = hasPointsConstraint ? 1 : 0;
+                typeMatches.push({ workflow: workflow, specificity: specificity });
             }
         }
     }
     // Sort by specificity descending, then return the first match
     if (typeMatches.length > 0) {
-        typeMatches.sort((a, b) => b.specificity - a.specificity);
-        const match = typeMatches[0];
+        typeMatches.sort(function (a, b) { return b.specificity - a.specificity; });
+        var match = typeMatches[0];
         return {
             workflow: match.workflow,
-            reason: `Matched type '${story.type}' to workflow '${match.workflow.name}'`
+            reason: "Matched type '".concat(story.type, "' to workflow '").concat(match.workflow.name, "'")
         };
     }
     return null;
@@ -194,35 +212,37 @@ function findTypeMatch(story, workflows) {
  * Find workflow by points range (story.points within workflow.triggers.points min/max)
  */
 function findPointsMatch(story, workflows) {
+    var _a;
     if (story.points === undefined) {
         return null;
     }
-    for (const workflow of workflows) {
-        const triggerPoints = workflow.triggers?.points;
+    for (var _i = 0, workflows_3 = workflows; _i < workflows_3.length; _i++) {
+        var workflow = workflows_3[_i];
+        var triggerPoints = (_a = workflow.triggers) === null || _a === void 0 ? void 0 : _a.points;
         if (!triggerPoints) {
             continue;
         }
-        const { min, max } = triggerPoints;
-        const hasMin = min !== undefined;
-        const hasMax = max !== undefined;
+        var min = triggerPoints.min, max = triggerPoints.max;
+        var hasMin = min !== undefined;
+        var hasMax = max !== undefined;
         // Must have at least one constraint
         if (!hasMin && !hasMax) {
             continue;
         }
         // Check constraints
-        const meetsMin = !hasMin || story.points >= min;
-        const meetsMax = !hasMax || story.points <= max;
+        var meetsMin = !hasMin || story.points >= min;
+        var meetsMax = !hasMax || story.points <= max;
         if (meetsMin && meetsMax) {
             // Verify all constraints are met
             if (doesStoryMatchTrigger(story, workflow.triggers, 'points')) {
-                const rangeDesc = hasMin && hasMax
-                    ? `${min}-${max}`
+                var rangeDesc = hasMin && hasMax
+                    ? "".concat(min, "-").concat(max)
                     : hasMin
-                        ? `>=${min}`
-                        : `<=${max}`;
+                        ? ">=".concat(min)
+                        : "<=".concat(max);
                 return {
-                    workflow,
-                    reason: `Matched points ${story.points} (range: ${rangeDesc}) to workflow '${workflow.name}'`
+                    workflow: workflow,
+                    reason: "Matched points ".concat(story.points, " (range: ").concat(rangeDesc, ") to workflow '").concat(workflow.name, "'")
                 };
             }
         }
@@ -233,13 +253,12 @@ function findPointsMatch(story, workflows) {
  * Find default workflow (triggers.default: true)
  */
 function findDefaultWorkflow(workflows) {
-    const defaultWorkflow = workflows.find(w => w.triggers?.default === true);
+    var defaultWorkflow = workflows.find(function (w) { var _a; return ((_a = w.triggers) === null || _a === void 0 ? void 0 : _a.default) === true; });
     if (defaultWorkflow) {
         return {
             workflow: defaultWorkflow,
-            reason: `Using default workflow '${defaultWorkflow.name}'`
+            reason: "Using default workflow '".concat(defaultWorkflow.name, "'")
         };
     }
     return null;
 }
-//# sourceMappingURL=workflow-router.js.map

package/{packages/core/dist → dist}/workflow/workflow-schema.d.ts

@@ -154,4 +154,3 @@ export interface WorkflowValidationResult {
  * ```
  */
 export declare function validateWorkflow(input: unknown): WorkflowValidationResult;
-//# sourceMappingURL=workflow-schema.d.ts.map