@lumenflow/core 3.2.0 → 3.2.1

package/dist/wu-lock-manager.js

@@ -0,0 +1,164 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * WU Lock Manager (WU-2013)
+ *
+ * File-level locking with stale detection for concurrent access to
+ * wu-events.jsonl. Uses PID checks on same host and timeout-based
+ * expiry across hosts.
+ *
+ * Single responsibility: file locking and stale lock detection.
+ *
+ * WU-2240: Prepared for proper-lockfile integration.
+ *
+ * @see {@link ./wu-state-store.ts} - Facade that delegates to this service
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, openSync, closeSync, fsyncSync, } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { MS_PER_MINUTE } from './constants/duration-constants.js';
+/**
+ * Stale lock timeout in milliseconds (5 minutes).
+ * WU-2048: Renamed from LOCK_TIMEOUT_MS to disambiguate from
+ * lock-constants.ts LOCK_TIMEOUT_MS (30s acquisition timeout).
+ */
+const WU_LOCK_STALE_TIMEOUT_MS = 5 * MS_PER_MINUTE;
+/**
+ * Lock retry configuration
+ */
+const LOCK_RETRY_DELAY_MS = 50;
+const LOCK_MAX_RETRIES = 100; // 5 seconds total
+/**
+ * Check if a process with given PID is running
+ */
+function isProcessRunning(pid) {
+    try {
+        // Sending signal 0 checks if process exists without affecting it
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a lock is stale (expired or dead process)
+ *
+ * WU-2240: Prepared for proper-lockfile integration
+ */
+export function isLockStale(lockData) {
+    const now = Date.now();
+    const lockAge = now - lockData.timestamp;
+    // Check timeout first (5 minutes)
+    if (lockAge > WU_LOCK_STALE_TIMEOUT_MS) {
+        return true;
+    }
+    // Check if on same host - if different host, can't check PID
+    if (lockData.hostname !== os.hostname()) {
+        // Different host, only rely on timeout
+        return false;
+    }
+    // Same host - check if process is still alive
+    return !isProcessRunning(lockData.pid);
+}
+/**
+ * Safely remove a lock file, ignoring errors
+ */
+function safeUnlink(lockPath) {
+    try {
+        unlinkSync(lockPath);
+    }
+    catch {
+        // Ignore removal errors
+    }
+}
+/**
+ * Read and parse existing lock file
+ */
+function readLockFile(lockPath) {
+    try {
+        const content = readFileSync(lockPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Handle existing lock file - returns true if should retry
+ */
+async function handleExistingLock(lockPath) {
+    const existingLock = readLockFile(lockPath);
+    if (!existingLock) {
+        // Corrupted lock file - remove and retry
+        safeUnlink(lockPath);
+        return true;
+    }
+    if (isLockStale(existingLock)) {
+        safeUnlink(lockPath);
+        return true;
+    }
+    // Lock is held by active process - wait and retry
+    await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_DELAY_MS));
+    return true;
+}
+/**
+ * Try to create a lock file atomically
+ */
+async function tryCreateLock(lockPath, lockData) {
+    try {
+        mkdirSync(path.dirname(lockPath), { recursive: true });
+        const fd = openSync(lockPath, 'wx');
+        const content = JSON.stringify(lockData);
+        writeFileSync(fd, content, 'utf-8');
+        fsyncSync(fd);
+        closeSync(fd);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'EEXIST') {
+            await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_DELAY_MS));
+            return false;
+        }
+        throw error;
+    }
+}
+/**
+ * Acquire a file lock for the events file
+ *
+ * Uses a JSON lock file containing PID, timestamp, and hostname.
+ * Implements stale lock detection via:
+ * - PID check (on same host)
+ * - 5-minute timeout (across hosts)
+ *
+ * WU-2240: Prepared for proper-lockfile integration
+ *
+ * @throws Error If lock cannot be acquired after retries
+ */
+export async function acquireLock(lockPath) {
+    const lockData = {
+        pid: process.pid,
+        timestamp: Date.now(),
+        hostname: os.hostname(),
+    };
+    for (let attempt = 0; attempt < LOCK_MAX_RETRIES; attempt++) {
+        if (existsSync(lockPath)) {
+            const shouldRetry = await handleExistingLock(lockPath);
+            if (shouldRetry)
+                continue;
+        }
+        const acquired = await tryCreateLock(lockPath, lockData);
+        if (acquired)
+            return;
+    }
+    throw new Error(`Failed to acquire lock after ${LOCK_MAX_RETRIES} attempts`);
+}
+/**
+ * Release a file lock
+ *
+ * WU-2240: Prepared for proper-lockfile integration
+ */
+export function releaseLock(lockPath) {
+    safeUnlink(lockPath);
+}
+//# sourceMappingURL=wu-lock-manager.js.map

package/dist/wu-lock-manager.js.map

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

package/dist/wu-paths-constants.d.ts

@@ -0,0 +1,264 @@
+/**
+ * WU-1548: Shared Node.js filesystem error interface.
+ *
+ * Consolidates duplicated NodeFsError definitions that existed across
+ * memory-store.ts, mem-triage-core.ts, mem-signal-core.ts, mem-ready-core.ts,
+ * signal-cleanup-core.ts, and wu-events-cleanup.ts.
+ *
+ * Use this interface when catching fs errors and checking the `code` property
+ * (e.g., 'ENOENT', 'EACCES', 'EPERM').
+ */
+export interface NodeFsError extends Error {
+    code?: string;
+}
+/**
+ * File system constants
+ *
+ * WU-923: Centralized to eliminate hardcoded strings
+ */
+export declare const FILE_SYSTEM: {
+    /** Standard file encoding */
+    ENCODING: "utf8";
+    /** UTF-8 encoding (alias for compatibility) */
+    UTF8: "utf8";
+};
+/**
+ * Configuration file paths
+ *
+ * WU-923: Centralized config file names
+ */
+export declare const CONFIG_FILES: {
+    /** Canonical workspace config */
+    WORKSPACE_CONFIG: string;
+    /** Lane inference taxonomy */
+    LANE_INFERENCE: string;
+};
+/**
+ * Directory paths within the monorepo
+ *
+ * Centralized directory path strings.
+ */
+export declare const DIRECTORIES: {
+    APPS_WEB: string;
+    WORKTREES: string;
+    AI: string;
+    CLAUDE: string;
+    CLAUDE_HOOKS: string;
+    DOCS: string;
+    PACKAGES: string;
+    TOOLS: string;
+    MEMORY_BANK: string;
+    WU_DIR: string;
+    INITIATIVES_DIR: string;
+    BACKLOG_PATH: string;
+    STATUS_PATH: string;
+};
+/**
+ * Build artifact cleanup globs
+ *
+ * Centralized glob patterns for worktree artifact cleanup.
+ */
+export declare const BUILD_ARTIFACT_GLOBS: {
+    /** Common dist directories inside worktrees */
+    DIST_DIRS: string[];
+    /** TypeScript build info files */
+    TSBUILDINFO_FILES: string[];
+};
+/**
+ * Build artifact cleanup ignore patterns
+ *
+ * Centralized ignore globs for artifact cleanup.
+ */
+export declare const BUILD_ARTIFACT_IGNORES: string[];
+/**
+ * Script file paths
+ *
+ * Centralized paths to validation scripts.
+ */
+export declare const SCRIPT_PATHS: {
+    /** Prompt registry validation */
+    VALIDATE_PROMPT_REGISTRY: string;
+};
+/**
+ * File extensions
+ *
+ * Centralized file extension strings to avoid magic strings.
+ */
+export declare const FILE_EXTENSIONS: {
+    /** Newline-delimited JSON format */
+    NDJSON: string;
+    /** Markdown format */
+    MARKDOWN: string;
+    /** YAML format */
+    YAML: string;
+    /** Log format */
+    LOG: string;
+    /** Stamp files (completion markers) */
+    STAMP: string;
+};
+/**
+ * Path patterns for WU-related files
+ */
+export declare const PATH_PATTERNS: {
+    /** Matches WU YAML paths in both legacy and current locations */
+    WU_YAML: RegExp;
+    /** Matches stamp file paths */
+    STAMP: RegExp;
+};
+/**
+ * Path-related constants
+ *
+ * WU-1062: Centralized path literals for lumenflow-home and spec-branch operations.
+ */
+export declare const PATH_LITERALS: {
+    /** Tilde prefix for home directory expansion (e.g., ~/path) */
+    TILDE_PREFIX: string;
+    /** Tilde character for home directory */
+    TILDE: string;
+    /** Plan file suffix for WU plans */
+    PLAN_FILE_SUFFIX: string;
+    /** Trailing slash regex pattern */
+    TRAILING_SLASH_REGEX: RegExp;
+    /** .lumenflow path prefix for internal path detection (WU-1430) */
+    LUMENFLOW_PREFIX: string;
+    /** Current directory prefix for repo-internal paths (WU-1430) */
+    CURRENT_DIR_PREFIX: string;
+};
+/**
+ * Slice lengths for path operations
+ *
+ * WU-1062: Magic numbers extracted for path manipulation.
+ */
+export declare const PATH_SLICE_LENGTHS: {
+    /** Length of '~/' prefix for tilde expansion */
+    TILDE_PREFIX_LENGTH: number;
+    /** Length of '/' for leading slash removal */
+    LEADING_SLASH_LENGTH: number;
+};
+/**
+ * WU-1174: Lock directory name constant
+ *
+ * Defined separately so it can be used both in LUMENFLOW_PATHS.LOCK_DIR
+ * and for test isolation in cleanup-lock.ts/merge-lock.ts.
+ */
+export declare const LOCK_DIR_NAME = ".lumenflow-locks";
+/**
+ * LumenFlow directory paths
+ *
+ * Centralized paths for .lumenflow directory structure to eliminate hardcoded strings.
+ * Used by telemetry, agent-session, agent-incidents, memory, and commands-logger modules.
+ */
+export declare const LUMENFLOW_PATHS: {
+    /** Base directory for all LumenFlow runtime data */
+    BASE: string;
+    /** WU state store directory */
+    STATE_DIR: string;
+    /** Stamp directory (WU completion markers) */
+    STAMPS_DIR: string;
+    /** Archive directory for old WU events (WU-1430) */
+    ARCHIVE_DIR: string;
+    /** Merge lock file (runtime coordination, WU-1747) */
+    MERGE_LOCK: string;
+    /** Base telemetry directory */
+    TELEMETRY: string;
+    /** Flow log file (WU flow events) */
+    FLOW_LOG: string;
+    /** Agent sessions directory */
+    SESSIONS: string;
+    /** Agent incidents directory */
+    INCIDENTS: string;
+    /** Git commands log file */
+    COMMANDS_LOG: string;
+    /** Memory layer directory */
+    MEMORY_DIR: string;
+    /** Memory layer JSONL file */
+    MEMORY_JSONL: string;
+    /** WU-1539: Memory signals JSONL file */
+    MEMORY_SIGNALS: string;
+    /** Audit log for tool calls */
+    AUDIT_LOG: string;
+    /** Feedback drafts directory */
+    FEEDBACK_DRAFTS: string;
+    /** Feedback index file */
+    FEEDBACK_INDEX: string;
+    /** Current session file */
+    SESSION_CURRENT: string;
+    /** WU events log */
+    WU_EVENTS: string;
+    /** Lock files directory (lane locks - persisted) */
+    LOCKS_DIR: string;
+    /** Force bypass audit log */
+    FORCE_BYPASSES: string;
+    /** WU-1539: Skip-gates audit log */
+    SKIP_GATES_AUDIT: string;
+    /** WU-1539: Skip-COS-gates audit log */
+    SKIP_COS_GATES_AUDIT: string;
+    /** Test baseline file for ratchet pattern (WU-1430) */
+    TEST_BASELINE: string;
+    /** Templates directory (WU-1430) */
+    TEMPLATES_DIR: string;
+    /** Delegation prompt templates (WU-1674) */
+    DELEGATION_PROMPT_DIR: string;
+    /** Template manifest file (WU-1430) */
+    TEMPLATE_MANIFEST: string;
+    /** Skills directory for agent skills (WU-1430) */
+    SKILLS_DIR: string;
+    /** Agents directory for agent definitions (WU-1430) */
+    AGENTS_DIR: string;
+    /** Methodology log for delegation telemetry (WU-1430) */
+    METHODOLOGY_LOG: string;
+    /** Prompt metrics cache (WU-1430) */
+    PROMPT_METRICS: string;
+    /** Prompt lint results (WU-1430) */
+    PROMPT_LINT: string;
+    /** Recovery markers directory (WU-1430) */
+    RECOVERY_DIR: string;
+    /** Checkpoints directory (WU-1430) */
+    CHECKPOINTS_DIR: string;
+    /** WU-1471: Hook counters directory for auto-checkpoint interval tracking */
+    HOOK_COUNTERS_DIR: string;
+    /** Cache directory under user home (WU-1430) */
+    HOME_CACHE: string;
+    /**
+     * WU-1174: Runtime lock directory for merge/cleanup locks
+     *
+     * These locks are transient and should NOT be created in the main checkout
+     * because wu:done runs from main. Using os.tmpdir() ensures:
+     * 1. Locks don't pollute the git working tree
+     * 2. Locks work across processes on the same machine
+     * 3. No "Working tree is not clean" errors if process crashes
+     *
+     * Note: Lane locks still use LOCKS_DIR (.lumenflow/locks) because they need
+     * to persist across sessions and be visible to other agents.
+     */
+    LOCK_DIR: string;
+};
+/**
+ * File tool constants (WU-1403)
+ *
+ * Centralized strings for file:read, file:write, file:edit tools.
+ * Prevents duplicate string literals and hardcoded magic values.
+ */
+export declare const FILE_TOOLS: {
+    /** Tool name prefixes */
+    NAMES: {
+        READ: string;
+        WRITE: string;
+        EDIT: string;
+        DELETE: string;
+    };
+    /** Tool domain */
+    DOMAIN: string;
+    /** Permission levels */
+    PERMISSIONS: {
+        READ: string;
+        WRITE: string;
+    };
+    /** Worktree instruction templates (WU-1403: provides reusable instruction strings) */
+    WORKTREE_INSTRUCTIONS: {
+        CLAIM_COMMAND: string;
+        CD_COMMAND: string;
+        DOC_REFERENCE: string;
+    };
+};
+//# sourceMappingURL=wu-paths-constants.d.ts.map

package/dist/wu-paths-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wu-paths-constants.d.ts","sourceRoot":"","sources":["../src/wu-paths-constants.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAY,SAAQ,KAAK;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAID;;;;GAIG;AACH,eAAO,MAAM,WAAW;IACtB,6BAA6B;;IAG7B,+CAA+C;;CAEhD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY;IACvB,iCAAiC;;IAGjC,8BAA8B;;CAE/B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;CAevB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;IAC/B,+CAA+C;;IAU/C,kCAAkC;;CAEnC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,UAAuD,CAAC;AAE3F;;;;GAIG;AACH,eAAO,MAAM,YAAY;IACvB,iCAAiC;;CAElC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe;IAC1B,oCAAoC;;IAGpC,sBAAsB;;IAGtB,kBAAkB;;IAGlB,iBAAiB;;IAGjB,uCAAuC;;CAExC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa;IACxB,iEAAiE;;IAGjE,+BAA+B;;CAEhC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa;IACxB,+DAA+D;;IAG/D,yCAAyC;;IAGzC,oCAAoC;;IAGpC,mCAAmC;;IAGnC,mEAAmE;;IAGnE,iEAAiE;;CAElE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;IAC7B,gDAAgD;;IAGhD,8CAA8C;;CAE/C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,qBAAqB,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,eAAe;IAC1B,oDAAoD;;IAGpD,+BAA+B;;IAG/B,8CAA8C;;IAG9C,oDAAoD;;IAGpD,sDAAsD;;IAGtD,+BAA+B;;IAG/B,qCAAqC;;IAGrC,+BAA+B;;IAG/B,gCAAgC;;IAGhC,4BAA4B;;IAG5B,6BAA6B;;IAG7B,8BAA8B;;IAG9B,yCAAyC;;IAGzC,+BAA+B;;IAG/B,gCAAgC;;IAGhC,0BAA0B;;IAG1B,2BAA2B;;IAG3B,oBAAoB;;IAGpB,oDAAoD;;IAGpD,6BAA6B;;IAG7B,oCAAoC;;IAGpC,wCAAwC;;IAGxC,uDAAuD;;IAGvD,oCAAoC;;IAGpC,4CAA4C;;IAG5C,uCAAuC;;IAGvC,kDAAkD;;IAGlD,uDAAuD;;IAGvD,yDAAyD;;IAGzD,qCAAqC;;IAGrC,oCAAoC;;IAGpC,2CAA2C;;IAG3C,sCAAsC;;IAGtC,6EAA6E;;IAG7E,gDAAgD;;IAGhD;;;;;;;;;;;OAWG;;CAEJ,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU;IACrB,yBAAyB;;;;;;;IAQzB,kBAAkB;;IAGlB,wBAAwB;;;;;IAMxB,sFAAsF;;;;;;CAMvF,CAAC"}