create-principles-disciple 1.103.0 → 1.104.1

package/plugin/dist/utils/file-lock.js

@@ -1,310 +0,0 @@
-/**
- * Reliable File Lock - 可靠的文件锁实现
- *
- * 设计原则：
- * 1. 使用 O_EXCL | O_CREAT 实现真正的原子锁获取
- * 2. PID 存活检测避免死锁
- * 3. 带退避的重试机制
- * 4. 锁获取后二次验证
- * 5. 数据不丢失：失败时抛出异常而非静默返回
- */
-/* global NodeJS */
-import * as fs from 'fs';
-import * as path from 'path';
-export class LockAcquisitionError extends Error {
-    filePath;
-    lockPath;
-    constructor(message, filePath, lockPath) {
-        super(message);
-        this.name = 'LockAcquisitionError';
-        this.filePath = filePath;
-        this.lockPath = lockPath;
-    }
-}
-/** 默认锁选项 */
-const DEFAULT_OPTIONS = {
-    maxRetries: 50,
-    baseRetryDelayMs: 10,
-    maxRetryDelayMs: 500,
-    lockStaleMs: 10000,
-    lockSuffix: '.lock',
-};
-/**
- * 检查进程是否存活
- */
-function isProcessAlive(pid) {
-    try {
-        // 发送信号 0 不会真正发送信号，只检查进程是否存在
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * 原子创建锁文件
- * 使用 O_EXCL | O_CREAT 确保原子性
- *
- * @returns true 表示成功获取锁，false 表示锁被占用
- */
-function tryAcquireLock(lockPath, pid) {
-    try {
-        // 确保锁文件的目录存在
-        const lockDir = path.dirname(lockPath);
-        if (!fs.existsSync(lockDir)) {
-            fs.mkdirSync(lockDir, { recursive: true });
-        }
-        // 使用 fs.constants 获取正确的 flag 值
-        // O_EXCL: 排他创建 - 与 O_CREAT 一起使用时，如果文件存在则失败
-        // O_CREAT: 文件不存在时创建
-        // O_WRONLY: 只写模式
-        const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL;
-        // 使用底层的 openSync 实现真正的原子操作
-        // 如果文件已存在，会抛出 EEXIST 错误
-        const fd = fs.openSync(lockPath, flags);
-        // 写入 PID
-        fs.writeSync(fd, String(pid));
-        fs.fsyncSync(fd); // 确保数据落盘
-        fs.closeSync(fd);
-        return true;
-    }
-    catch (err) {
-        if (err.code === 'EEXIST') {
-            return false; // 锁已被占用
-        }
-        // 其他错误（权限、磁盘满等）向上抛出
-        throw err;
-    }
-}
-/**
- * 读取锁文件中的 PID
- * @returns PID 或 null（如果文件不存在或无法解析）
- */
-function readLockPid(lockPath) {
-    try {
-        const content = fs.readFileSync(lockPath, 'utf8');
-        const pid = parseInt(content.trim(), 10);
-        return Number.isNaN(pid) ? null : pid;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * 安全删除锁文件
- * 只有当锁文件包含当前进程的 PID 时才删除
- */
-function safeReleaseLock(lockPath, expectedPid) {
-    try {
-        const pid = readLockPid(lockPath);
-        if (pid === expectedPid) {
-            fs.unlinkSync(lockPath);
-        }
-        // 如果 PID 不匹配，说明锁已被其他进程重新获取，不删除
-    }
-    catch {
-        // 忽略删除错误
-    }
-}
-/**
- * 检查并清理过期锁
- */
-function cleanupStaleLock(lockPath, staleMs) {
-    try {
-        const stat = fs.statSync(lockPath);
-        const pid = readLockPid(lockPath);
-        // 检查是否过期
-        const isStale = Date.now() - stat.mtimeMs > staleMs;
-        // 检查持有者是否已死亡
-        // PID 为 null 表示锁文件损坏，应视为无效锁
-        const isDead = pid === null || !isProcessAlive(pid);
-        // 满足任一条件即可清理：过期、持有者死亡、PID 无效
-        if (isStale || isDead) {
-            try {
-                fs.unlinkSync(lockPath);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * 计算退避延迟（指数退避 + 抖动）
- */
-function calculateBackoff(attempt, baseMs, maxMs) {
-    // 指数退避：10, 20, 40, 80, 160, 320, 500, 500, ...
-    const exponentialDelay = Math.min(baseMs * Math.pow(2, attempt), maxMs);
-    // 添加 20% 的随机抖动，避免多个进程同时重试
-    const jitter = exponentialDelay * 0.2 * Math.random();
-    return Math.floor(exponentialDelay + jitter);
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function sleepSync(ms) {
-    const end = Date.now() + ms;
-    while (Date.now() < end) {
-        // busy wait for synchronous retry
-    }
-}
-function buildLockError(filePath, lockPath) {
-    const holderPid = readLockPid(lockPath);
-    const holderStatus = holderPid !== null
-        ? (isProcessAlive(holderPid) ? `alive (PID ${holderPid})` : `dead (PID ${holderPid})`)
-        : 'unknown';
-    return new LockAcquisitionError(`Failed to acquire lock for ${filePath}. Lock holder: ${holderStatus}.`, filePath, lockPath);
-}
-function tryAcquireWithStaleCleanup(filePath, opts, pid) {
-    const lockPath = filePath + opts.lockSuffix;
-    if (tryAcquireLock(lockPath, pid)) {
-        const actualPid = readLockPid(lockPath);
-        if (actualPid === pid) {
-            return { lockPath, pid, acquiredAt: Date.now() };
-        }
-    }
-    cleanupStaleLock(lockPath, opts.lockStaleMs);
-    if (tryAcquireLock(lockPath, pid)) {
-        const actualPid = readLockPid(lockPath);
-        if (actualPid === pid) {
-            return { lockPath, pid, acquiredAt: Date.now() };
-        }
-    }
-    return null;
-}
-/**
- * 获取文件锁
- *
- * @param filePath 要锁定的文件路径
- * @param options 锁选项
- * @returns 锁上下文（用于后续释放）
- * @throws Error 如果无法获取锁
- */
-export function acquireLock(filePath, options = {}) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const { pid } = process;
-    for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-        const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
-        if (ctx) {
-            return ctx;
-        }
-        if (attempt < opts.maxRetries - 1) {
-            const delay = calculateBackoff(attempt, opts.baseRetryDelayMs, opts.maxRetryDelayMs);
-            sleepSync(delay);
-        }
-    }
-    throw buildLockError(filePath, filePath + opts.lockSuffix);
-}
-export async function acquireLockAsync(filePath, options = {}) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const { pid } = process;
-    for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-        const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
-        if (ctx) {
-            return ctx;
-        }
-        if (attempt < opts.maxRetries - 1) {
-            const delay = calculateBackoff(attempt, opts.baseRetryDelayMs, opts.maxRetryDelayMs);
-            await sleep(delay);
-        }
-    }
-    throw buildLockError(filePath, filePath + opts.lockSuffix);
-}
-/**
- * 释放文件锁
- *
- * @param ctx 锁上下文（由 acquireLock 返回）
- */
-export function releaseLock(ctx) {
-    safeReleaseLock(ctx.lockPath, ctx.pid);
-}
-/**
- * 使用锁执行操作（自动获取和释放）
- *
- * @param filePath 要锁定的文件路径
- * @param fn 要执行的操作
- * @param options 锁选项
- * @returns 操作的返回值
- */
-export function withLock(filePath, fn, options = {}) {
-    const ctx = acquireLock(filePath, options);
-    try {
-        return fn();
-    }
-    finally {
-        releaseLock(ctx);
-    }
-}
-export async function withLockAsync(filePath, fn, options = {}) {
-    const ctx = await acquireLockAsync(filePath, options);
-    try {
-        return await fn();
-    }
-    finally {
-        releaseLock(ctx);
-    }
-}
-/**
- * 异步版本的文件锁（使用 Promise 链）
- *
- * 注意：这是一个简化的实现，适用于单进程内的异步并发控制
- * 对于多进程场景，应使用同步版本的 acquireLock
- */
-export const asyncLockQueues = new Map();
-export async function withAsyncLock(filePath, fn) {
-    const lockPath = filePath + '.async';
-    // 获取或创建该文件的任务队列
-    let queue = asyncLockQueues.get(lockPath);
-    // 创建新的 Promise 链
-    let resolveRelease;
-    const releasePromise = new Promise(resolve => {
-        resolveRelease = resolve;
-    });
-    // 将当前任务加入队列
-    const previousQueue = queue || Promise.resolve();
-    const currentQueue = previousQueue.then(() => releasePromise);
-    asyncLockQueues.set(lockPath, currentQueue);
-    // 等待前面的任务完成
-    await previousQueue;
-    try {
-        return await fn();
-    }
-    finally {
-        resolveRelease();
-        // 清理已完成的队列
-        if (asyncLockQueues.get(lockPath) === currentQueue) {
-            asyncLockQueues.delete(lockPath);
-        }
-    }
-}
-/**
- * 检查锁状态（用于调试）
- */
-export function getLockStatus(filePath, options = {}) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const lockPath = filePath + opts.lockSuffix;
-    try {
-        const stat = fs.statSync(lockPath);
-        const pid = readLockPid(lockPath);
-        return {
-            locked: true,
-            holderPid: pid,
-            holderAlive: pid !== null && isProcessAlive(pid),
-            lockAge: Date.now() - stat.mtimeMs,
-        };
-    }
-    catch {
-        return {
-            locked: false,
-            holderPid: null,
-            holderAlive: false,
-            lockAge: null,
-        };
-    }
-}

package/plugin/dist/utils/hashing.js

@@ -1,25 +0,0 @@
-import { createHash } from 'crypto';
-/**
- * Strips timestamps, UUIDs, and hex memory addresses from error messages
- * to allow for consistent loop detection even if the raw text varies slightly.
- */
-export function denoiseError(text) {
-    if (!text || typeof text !== 'string')
-        return '';
-    return text
-        // Strip ISO timestamps and common date formats
-        .replace(/\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}(\.\d+)?Z?/g, '[TIME]')
-        // Strip common log timestamps [12:45:03]
-        .replace(/\[\d{2}:\d{2}:\d{2}\]/g, '[TIME]')
-        // Strip Hex addresses (0x...)
-        .replace(/0x[0-9a-fA-F]+/g, '[ADDR]')
-        // Strip UUIDs
-        .replace(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/g, '[UUID]')
-        .trim();
-}
-/**
- * Computes a simple SHA-256 hash of the given string.
- */
-export function computeHash(text) {
-    return createHash('sha256').update(text).digest('hex');
-}

package/plugin/dist/utils/io.js

@@ -1,174 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-/**
- * Atomic file write — write to temp then rename to prevent partial writes on crash.
- *
- * On Windows, renameSync can fail with EPERM/EBUSY if the file is temporarily
- * locked by antivirus software or another process. Retries with exponential
- * backoff to handle transient locks.
- */
-const RENAME_MAX_RETRIES = 3;
-const RENAME_BASE_DELAY_MS = 50;
-export function atomicWriteFileSync(filePath, data) {
-    const tmpPath = filePath + '.tmp';
-    fs.writeFileSync(tmpPath, data, 'utf8');
-    let lastError;
-    for (let attempt = 0; attempt < RENAME_MAX_RETRIES; attempt++) {
-        try {
-            fs.renameSync(tmpPath, filePath);
-            return;
-        }
-        catch (err) {
-            lastError = err;
-            const code = err.code;
-            // Only retry on Windows transient lock errors
-            if (code === 'EPERM' || code === 'EBUSY' || code === 'EACCES') {
-                if (attempt < RENAME_MAX_RETRIES - 1) {
-                    const delay = RENAME_BASE_DELAY_MS * Math.pow(2, attempt);
-                    // Bounded spin-wait with CPU yield — materially different from
-                    // tight infinite spin; only 50-200ms total across retries.
-                    const waitUntil = Date.now() + delay;
-                    let yielded = false;
-                    while (Date.now() < waitUntil) {
-                        if (!yielded && Date.now() >= waitUntil - 10) {
-                            // Last few ms: yield to give other sync code a chance to run
-                            try {
-                                require('fs').accessSync?.(tmpPath);
-                            }
-                            catch { /* ignore */ }
-                            yielded = true;
-                        }
-                    }
-                }
-                continue;
-            }
-            // Non-retryable error — throw immediately
-            break;
-        }
-    }
-    // Clean up temp file on failure
-    try {
-        fs.unlinkSync(tmpPath);
-    }
-    catch { /* best effort */ }
-    throw lastError;
-}
-export function normalizePath(filePath, projectDir) {
-    if (!filePath)
-        return '';
-    const projectIsWin = projectDir.includes('\\') || (projectDir.length >= 2 && projectDir[1] === ':');
-    const fileIsWin = filePath.includes('\\') || (filePath.length >= 2 && filePath[1] === ':');
-    let normalizedFilePath = filePath;
-    if (projectIsWin !== fileIsWin) {
-        if (fileIsWin) {
-            // Basic WSL conversion D:\path -> /mnt/d/path
-            normalizedFilePath = `/mnt/${filePath.charAt(0).toLowerCase()}${filePath.slice(2).replace(/\\/g, '/')}`;
-        }
-    }
-    // POSIX absolute paths (e.g., /etc/passwd) are NOT recognized as absolute
-    // by path.isAbsolute() on Windows. When both the project dir and the file
-    // path are POSIX paths, use path.posix for relative computation.
-    const isPosixAbsolute = normalizedFilePath.startsWith('/') && !fileIsWin;
-    const projectIsPosix = !projectIsWin;
-    let rel;
-    if (projectIsWin) {
-        const projectAbs = path.resolve(projectDir);
-        if (isPosixAbsolute) {
-            // POSIX absolute path on Windows project: cannot resolve relative to project,
-            // return as-is (path is outside the project directory).
-            rel = normalizedFilePath;
-        }
-        else {
-            const fileAbs = path.isAbsolute(normalizedFilePath)
-                ? normalizedFilePath
-                : path.join(projectAbs, normalizedFilePath);
-            rel = path.relative(projectAbs, fileAbs);
-        }
-    }
-    else if (projectIsPosix && isPosixAbsolute) {
-        // Both project and file are POSIX → use path.posix
-        const projectPosix = projectDir.replace(/\\/g, '/');
-        rel = path.posix.relative(projectPosix, normalizedFilePath);
-    }
-    else {
-        const projectPosix = projectDir.replace(/\\/g, '/');
-        const filePosix = path.isAbsolute(normalizedFilePath)
-            ? normalizedFilePath
-            : path.posix.join(projectPosix, normalizedFilePath.replace(/\\/g, '/'));
-        rel = path.posix.relative(projectPosix, filePosix);
-    }
-    rel = rel.replace(/\\/g, '/');
-    if (rel.startsWith('../')) {
-        return normalizedFilePath;
-    }
-    return rel;
-}
-export function normalizeRiskPath(p) {
-    let normalized = p.replace(/\\/g, '/');
-    if (normalized.endsWith('/')) {
-        normalized = normalized.slice(0, -1);
-    }
-    return normalized;
-}
-export function isRisky(relPath, riskPaths) {
-    if (!relPath || !riskPaths || riskPaths.length === 0)
-        return false;
-    const normalizedRel = normalizeRiskPath(relPath);
-    for (const pattern of riskPaths) {
-        const normalizedPattern = normalizeRiskPath(pattern);
-        if (normalizedRel.startsWith(normalizedPattern)) {
-            // If it starts with the pattern, and either they are exactly equal OR the next char is a slash
-            // (prevents "src/db_backup" matching "src/db")
-            if (normalizedRel === normalizedPattern || normalizedRel.charAt(normalizedPattern.length) === '/') {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-export function parseKvLines(text) {
-    const result = {};
-    const lines = text.split('\n');
-    for (const line of lines) {
-        const idx = line.indexOf(':');
-        if (idx !== -1) {
-            const key = line.slice(0, idx).trim();
-            const value = line.slice(idx + 1).trim();
-            result[key] = value;
-        }
-    }
-    return result;
-}
-export function serializeKvLines(data) {
-    const lines = [];
-    const keys = Object.keys(data).sort();
-    for (const k of keys) {
-        const v = data[k];
-        // Skip empty/undefined values — prevents writing blank lines that cause
-        // agent confusion (SKILL.md lists fields that aren't actually present on disk)
-        if (v === '' || v === undefined || v === null) {
-            continue;
-        }
-        if (Array.isArray(v)) {
-            lines.push(`${k}: ${v.join(',')}`);
-        }
-        else if (typeof v === 'object' && v !== null) {
-            lines.push(`${k}: ${JSON.stringify(v)}`);
-        }
-        else {
-            lines.push(`${k}: ${v}`);
-        }
-    }
-    return lines.join('\n');
-}
-/**
- * Normalize command arguments from PluginCommandContext.args.
- * Handles string | string[] | undefined union by joining arrays with spaces.
- */
-export function normalizeCommandArgs(args) {
-    if (args === undefined || args === null)
-        return '';
-    if (Array.isArray(args))
-        return args.join(' ');
-    return args;
-}

package/plugin/dist/utils/node-vm-polyfill.js

@@ -1,9 +0,0 @@
-/**
- * Node VM Polyfill — Thin wrapper around node:vm module
- *
- * PURPOSE: Provide a single import point for vm compilation functionality
- * used by the Rule Host. Isolates the node:vm dependency so it can be
- * easily mocked in tests.
- */
-import * as vm from 'node:vm';
-export const nodeVm = vm;