@lumenflow/core 3.2.0 → 3.2.2

package/dist/resolve-policy.js

@@ -0,0 +1,269 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Resolve Policy - Single Source of Truth for Methodology Decisions
+ *
+ * WU-1259: Provides a unified policy resolver that both wu:spawn and gates use.
+ *
+ * This module:
+ * - Defines the methodology.* config schema
+ * - Implements resolvePolicy() to produce ResolvedPolicy
+ * - Applies precedence: template defaults -> methodology.overrides -> explicit gates.* -> CLI flags
+ *
+ * @module resolve-policy
+ */
+import { z } from 'zod';
+/**
+ * Testing methodology options
+ */
+export const TESTING_METHODOLOGY = {
+    TDD: 'tdd',
+    TEST_AFTER: 'test-after',
+    NONE: 'none',
+};
+/**
+ * Architecture methodology options
+ */
+export const ARCHITECTURE_METHODOLOGY = {
+    HEXAGONAL: 'hexagonal',
+    LAYERED: 'layered',
+    NONE: 'none',
+};
+/**
+ * Coverage mode options
+ */
+export const COVERAGE_MODE = {
+    BLOCK: 'block',
+    WARN: 'warn',
+    OFF: 'off',
+};
+/**
+ * Zod schema for testing methodology enum
+ */
+export const TestingMethodologySchema = z.enum(['tdd', 'test-after', 'none']);
+/**
+ * Zod schema for architecture methodology enum
+ */
+export const ArchitectureMethodologySchema = z.enum(['hexagonal', 'layered', 'none']);
+/**
+ * Zod schema for coverage mode enum
+ */
+export const CoverageModeSchema = z.enum(['block', 'warn', 'off']);
+/**
+ * Methodology overrides schema
+ *
+ * These allow tweaking template defaults without changing methodology.
+ */
+export const MethodologyOverridesSchema = z.object({
+    /** Override the default coverage threshold from the testing methodology */
+    coverage_threshold: z.number().min(0).max(100).optional(),
+    /** Override the default coverage mode from the testing methodology */
+    coverage_mode: CoverageModeSchema.optional(),
+});
+/**
+ * WU-1899: Work classification UI pattern configuration
+ *
+ * Allows extending default UI detection patterns with project-specific
+ * code path patterns and lane hints. Custom values EXTEND defaults,
+ * they do not replace them.
+ *
+ * @example
+ * ```yaml
+ * methodology:
+ *   work_classification:
+ *     ui:
+ *       code_path_patterns:
+ *         - 'src/widgets/*.tsx'
+ *       lane_hints:
+ *         - 'Design'
+ * ```
+ */
+export const WorkClassificationUiSchema = z.object({
+    /**
+     * Additional glob patterns for detecting UI work via code paths.
+     * These extend the built-in defaults (CSS, SCSS, LESS, components, pages, etc.).
+     * Uses minimatch glob syntax.
+     */
+    code_path_patterns: z.array(z.string()).optional(),
+    /**
+     * Additional lane parent hints for detecting UI work.
+     * These extend the built-in defaults (Experience, Frontend, UI, Design).
+     * Matched case-insensitively against the lane parent (part before the colon).
+     */
+    lane_hints: z.array(z.string()).optional(),
+});
+/**
+ * WU-1899: Work classification configuration schema
+ *
+ * Controls signal-based work domain detection for code-path-aware
+ * UI/backend/docs/infra classification.
+ *
+ * @example
+ * ```yaml
+ * methodology:
+ *   work_classification:
+ *     ui:
+ *       code_path_patterns:
+ *         - 'src/widgets/*.tsx'
+ *       lane_hints:
+ *         - 'Design'
+ * ```
+ */
+export const WorkClassificationConfigSchema = z.object({
+    /** UI detection pattern overrides (extend defaults) */
+    ui: WorkClassificationUiSchema.optional(),
+});
+/**
+ * Main methodology configuration schema
+ *
+ * Config example in workspace.yaml:
+ * ```yaml
+ * methodology:
+ *   testing: 'tdd'              # tdd | test-after | none
+ *   architecture: 'hexagonal'   # hexagonal | layered | none
+ *   overrides:
+ *     coverage_threshold: 85    # Override TDD's default 90%
+ *     coverage_mode: 'warn'     # Override TDD's default 'block'
+ *   work_classification:
+ *     ui:
+ *       code_path_patterns:
+ *         - 'src/widgets/*.tsx'
+ *       lane_hints:
+ *         - 'Design'
+ * ```
+ */
+export const MethodologyConfigSchema = z.object({
+    /** Testing methodology (default: 'tdd') */
+    testing: TestingMethodologySchema.default('tdd'),
+    /** Architecture methodology (default: 'hexagonal') */
+    architecture: ArchitectureMethodologySchema.default('hexagonal'),
+    /** Optional overrides for template defaults */
+    overrides: MethodologyOverridesSchema.optional(),
+    /**
+     * WU-1899: Work classification configuration.
+     * Extends default signal patterns for UI/backend/docs/infra detection.
+     * Custom patterns extend defaults, they do not replace them.
+     */
+    work_classification: WorkClassificationConfigSchema.optional(),
+});
+const TESTING_TEMPLATE_DEFAULTS = {
+    tdd: {
+        coverage_threshold: 90,
+        coverage_mode: 'block',
+        tests_required: true,
+    },
+    'test-after': {
+        coverage_threshold: 70,
+        coverage_mode: 'warn',
+        tests_required: true,
+    },
+    none: {
+        coverage_threshold: 0,
+        coverage_mode: 'off',
+        tests_required: false,
+    },
+};
+/**
+ * Resolve the effective policy from configuration
+ *
+ * Precedence (highest to lowest):
+ * 1. CLI flags (not handled here - handled by command layer)
+ * 2. Explicit gates.* configuration (only if rawConfig provided to detect explicit vs default)
+ * 3. methodology.overrides
+ * 4. methodology template defaults
+ *
+ * This ensures backwards compatibility: existing users with explicit
+ * gates.* config see no change, while new users can use methodology
+ * config for a higher-level abstraction.
+ *
+ * @param config - The full LumenFlow configuration
+ * @param options - Options including rawConfig for explicit detection
+ * @returns The resolved policy for use by wu:spawn and gates
+ *
+ * @example
+ * ```typescript
+ * import { getConfig } from './lumenflow-config.js';
+ * import { resolvePolicy } from './resolve-policy.js';
+ *
+ * const config = getConfig();
+ * const policy = resolvePolicy(config);
+ *
+ * console.log(policy.coverage_threshold); // 90 (or configured value)
+ * console.log(policy.testing); // 'tdd' (or configured value)
+ * ```
+ *
+ * @example With raw config for explicit detection
+ * ```typescript
+ * const rawConfig = { methodology: { testing: 'test-after' } };
+ * const config = parseConfig(rawConfig);
+ * const policy = resolvePolicy(config, { rawConfig });
+ * // policy.coverage_threshold will be 70 (test-after template default)
+ * // because gates.minCoverage wasn't EXPLICITLY set
+ * ```
+ */
+export function resolvePolicy(config, options = {}) {
+    const { rawConfig } = options;
+    // Parse methodology config (provides defaults if not specified)
+    const methodology = MethodologyConfigSchema.parse(config.methodology ?? {});
+    // Get template defaults based on testing methodology
+    const templateDefaults = TESTING_TEMPLATE_DEFAULTS[methodology.testing];
+    // Layer 1: Start with template defaults
+    let coverage_threshold = templateDefaults.coverage_threshold;
+    let coverage_mode = templateDefaults.coverage_mode;
+    const tests_required = templateDefaults.tests_required;
+    // Layer 2: Apply methodology.overrides (if specified)
+    if (methodology.overrides?.coverage_threshold !== undefined) {
+        coverage_threshold = methodology.overrides.coverage_threshold;
+    }
+    if (methodology.overrides?.coverage_mode !== undefined) {
+        coverage_mode = methodology.overrides.coverage_mode;
+    }
+    // Layer 3: Apply explicit gates.* configuration (highest precedence)
+    // This ensures backwards compatibility with existing gates config
+    //
+    // Key insight: We only want EXPLICIT gates.* to override methodology.
+    // If rawConfig is provided, we check if gates values were explicitly set.
+    // If rawConfig is NOT provided (legacy mode), we check if methodology
+    // was specified - if so, methodology controls unless gates differ from default.
+    const gates = config.gates;
+    // Determine if gates.minCoverage was explicitly set
+    const gatesMinCoverageExplicit = rawConfig !== undefined ? rawConfig.gates?.minCoverage !== undefined : false;
+    // Determine if gates.enableCoverage was explicitly set
+    const gatesEnableCoverageExplicit = rawConfig !== undefined ? rawConfig.gates?.enableCoverage !== undefined : false;
+    // Apply gates.minCoverage only if explicitly set, or if no methodology was specified
+    // (for backwards compatibility with pre-methodology configs)
+    const methodologySpecified = config.methodology !== undefined;
+    if (gatesMinCoverageExplicit || (!methodologySpecified && rawConfig === undefined)) {
+        // gates.minCoverage overrides methodology coverage_threshold
+        coverage_threshold = gates.minCoverage;
+    }
+    // gates.enableCoverage: false effectively sets coverage_mode to 'off'
+    if (gatesEnableCoverageExplicit || (!methodologySpecified && rawConfig === undefined)) {
+        if (gates?.enableCoverage === false) {
+            coverage_mode = 'off';
+        }
+    }
+    return {
+        testing: methodology.testing,
+        architecture: methodology.architecture,
+        coverage_threshold,
+        coverage_mode,
+        tests_required,
+    };
+}
+/**
+ * Create a default resolved policy
+ *
+ * Convenience function for when no config is available.
+ * Returns strict TDD defaults.
+ */
+export function getDefaultPolicy() {
+    return {
+        testing: 'tdd',
+        architecture: 'hexagonal',
+        coverage_threshold: 90,
+        coverage_mode: 'block',
+        tests_required: true,
+    };
+}
+//# sourceMappingURL=resolve-policy.js.map

package/dist/resolve-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-policy.js","sourceRoot":"","sources":["../src/resolve-policy.ts"],"names":[],"mappings":"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"}

package/dist/retry-strategy.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Error message patterns that are considered retryable for wu:done operations
+ * Exported for test consistency
+ */
+export declare const RETRYABLE_ERROR_PATTERNS: Readonly<{
+    FAST_FORWARD: "fast-forward";
+    NOT_POSSIBLE: "not possible";
+    CANNOT_LOCK_REF: "Cannot lock ref";
+    FETCH: "fetch";
+    PUSH: "push";
+    ETIMEDOUT: "ETIMEDOUT";
+    ECONNRESET: "ECONNRESET";
+}>;
+/**
+ * @typedef {Object} RetryConfig
+ * @property {number} maxAttempts - Maximum number of attempts (default: 5)
+ * @property {number} baseDelayMs - Base delay in milliseconds (default: 1000)
+ * @property {number} maxDelayMs - Maximum delay cap in milliseconds (default: 30000)
+ * @property {number} multiplier - Exponential multiplier (default: 2)
+ * @property {number} jitter - Jitter factor 0-1 (default: 0.1 for 10%)
+ * @property {function} [shouldRetry] - Optional function(error) => boolean to determine if error is retryable
+ * @property {function} [onRetry] - Optional callback(attempt, error, delay) before each retry
+ */
+/**
+ * Default retry configuration
+ * Balanced for typical wu:done operations
+ */
+export declare const DEFAULT_RETRY_CONFIG: Readonly<{
+    maxAttempts: 5;
+    baseDelayMs: 1000;
+    maxDelayMs: 30000;
+    multiplier: 2;
+    jitter: 0.1;
+    shouldRetry: (_error?: unknown) => true;
+    onRetry: null;
+}>;
+/**
+ * Pre-configured retry presets for common scenarios
+ */
+export declare const RETRY_PRESETS: Readonly<{
+    /**
+     * Preset for wu:done merge operations
+     * Higher attempts and longer delays for handling concurrent load
+     */
+    wu_done: Readonly<{
+        maxAttempts: 6;
+        baseDelayMs: 2000;
+        maxDelayMs: 60000;
+        multiplier: 2;
+        jitter: 0.15;
+        shouldRetry: (error: UnsafeAny) => boolean;
+        onRetry: null;
+    }>;
+    /**
+     * Preset for zombie state recovery
+     * More attempts with shorter delays
+     */
+    recovery: Readonly<{
+        maxAttempts: 4;
+        baseDelayMs: 500;
+        maxDelayMs: 10000;
+        multiplier: 2;
+        jitter: 0.1;
+        shouldRetry: () => true;
+        onRetry: null;
+    }>;
+    /**
+     * Preset for quick operations (file I/O, local git)
+     * Fast retries for transient errors
+     */
+    quick: Readonly<{
+        maxAttempts: 3;
+        baseDelayMs: 100;
+        maxDelayMs: 2000;
+        multiplier: 2;
+        jitter: 0.05;
+        shouldRetry: () => true;
+        onRetry: null;
+    }>;
+}>;
+/**
+ * Create a retry configuration by merging defaults with custom options
+ *
+ * @param {string|Object} [presetOrOptions] - Preset name or custom options
+ * @param {Object} [options] - Additional options to merge (when first arg is preset name)
+ * @returns {RetryConfig} Complete retry configuration
+ *
+ * @example
+ * // Use defaults
+ * const config = createRetryConfig();
+ *
+ * @example
+ * // Customize defaults
+ * const config = createRetryConfig({ maxAttempts: 10 });
+ *
+ * @example
+ * // Use preset
+ * const config = createRetryConfig('wu_done');
+ *
+ * @example
+ * // Customize preset
+ * const config = createRetryConfig('wu_done', { maxAttempts: 10 });
+ */
+export declare function createRetryConfig(presetOrOptions: UnsafeAny, options: UnsafeAny): {
+    maxAttempts: 5;
+    baseDelayMs: 1000;
+    maxDelayMs: 30000;
+    multiplier: 2;
+    jitter: 0.1;
+    shouldRetry: (_error?: unknown) => true;
+    onRetry: null;
+} | {
+    maxAttempts: 6;
+    baseDelayMs: 2000;
+    maxDelayMs: 60000;
+    multiplier: 2;
+    jitter: 0.15;
+    shouldRetry: (error: UnsafeAny) => boolean;
+    onRetry: null;
+} | {
+    maxAttempts: 4;
+    baseDelayMs: 500;
+    maxDelayMs: 10000;
+    multiplier: 2;
+    jitter: 0.1;
+    shouldRetry: () => true;
+    onRetry: null;
+} | {
+    maxAttempts: 3;
+    baseDelayMs: 100;
+    maxDelayMs: 2000;
+    multiplier: 2;
+    jitter: 0.05;
+    shouldRetry: () => true;
+    onRetry: null;
+};
+/**
+ * Calculate the backoff delay for a given attempt number
+ *
+ * Uses exponential backoff formula: baseDelay * (multiplier ^ attempt)
+ * with optional jitter to spread concurrent retry attempts
+ *
+ * @param {number} attempt - Zero-based attempt number (0 = first attempt)
+ * @param {RetryConfig} config - Retry configuration
+ * @returns {number} Delay in milliseconds
+ */
+export declare function calculateBackoffDelay(attempt: UnsafeAny, config: UnsafeAny): number;
+/**
+ * Execute a function with retry logic and exponential backoff
+ *
+ * @template T
+ * @param {function(): Promise<T>} fn - Async function to execute
+ * @param {RetryConfig} [config] - Retry configuration (uses defaults if not provided)
+ * @returns {Promise<T>} Result of successful execution
+ * @throws {Error} Last error if all attempts fail
+ *
+ * @example
+ * const result = await withRetry(
+ *   async () => await mergeBranch(),
+ *   createRetryConfig('wu_done')
+ * );
+ */
+export declare function withRetry(fn: UnsafeAny, config?: UnsafeAny): Promise<any>;
+/**
+ * Higher-order function to wrap a function with retry logic
+ *
+ * @template T
+ * @param {function(...args): Promise<T>} fn - Function to wrap
+ * @param {RetryConfig} [config] - Retry configuration
+ * @returns {function(...args): Promise<T>} Wrapped function with retry logic
+ *
+ * @example
+ * const retryableMerge = withRetryWrapper(mergeBranch, createRetryConfig('wu_done'));
+ * await retryableMerge(branch);
+ */
+export declare function withRetryWrapper(fn: UnsafeAny, config?: UnsafeAny): (...args: unknown[]) => Promise<any>;
+/**
+ * Determine if an error is a git conflict error (non-retryable)
+ *
+ * @param {Error} error - Error to check
+ * @returns {boolean} True if conflict error
+ */
+export declare function isConflictError(error: UnsafeAny): any;
+/**
+ * Determine if an error is a network/transient error (retryable)
+ *
+ * @param {Error} error - Error to check
+ * @returns {boolean} True if likely transient
+ */
+export declare function isTransientError(error: UnsafeAny): any;
+//# sourceMappingURL=retry-strategy.d.ts.map

package/dist/retry-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-strategy.d.ts","sourceRoot":"","sources":["../src/retry-strategy.ts"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;EAQnC,CAAC;AAEH;;;;;;;;;GASG;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;2BAMR,OAAO;;EAE9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;IACxB;;;OAGG;;;;;;;6BAOoB,SAAS;;;IAQhC;;;OAGG;;;;;;;;;;IAWH;;;OAGG;;;;;;;;;;EAUH,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS;;;;;;2BA9EvD,OAAO;;;;;;;;yBAkBP,SAAS;;;;;;;;;;;;;;;;;;EAyFjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,UAkB1E;AAYD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,GAAE,SAAgC,gBAsDtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,GAAE,SAAgC,IACxE,GAAG,MAAM,OAAO,EAAE,kBAGjC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,OAQ/C;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,OAUhD"}