principles-disciple 1.127.0 → 1.128.0

package/src/utils/io.ts

@@ -1,176 +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: string, data: string): void {
-    const tmpPath = filePath + '.tmp';
-    fs.writeFileSync(tmpPath, data, 'utf8');
-
-    let lastError: Error | undefined;
-    for (let attempt = 0; attempt < RENAME_MAX_RETRIES; attempt++) {
-        try {
-            fs.renameSync(tmpPath, filePath);
-            return;
-        } catch (err) {
-            lastError = err as Error;
-            const code = (err as NodeJS.ErrnoException).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: string, projectDir: string): string {
-  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: string;
-  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: string): string {
-  let normalized = p.replace(/\\/g, '/');
-  if (normalized.endsWith('/')) {
-    normalized = normalized.slice(0, -1);
-  }
-  return normalized;
-}
-
-export function isRisky(relPath: string, riskPaths: string[]): boolean {
-  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: string): Record<string, string> {
-  const result: Record<string, string> = {};
-  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: Record<string, any>): string {
-  const lines: string[] = [];
-  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: string | string[] | undefined): string {
-  if (args === undefined || args === null) return '';
-  if (Array.isArray(args)) return args.join(' ');
-  return args;
-}