@bastani/atomic 0.5.0-1

package/src/services/system/file-lock.ts

@@ -0,0 +1,289 @@
+/**
+ * File Locking Utility
+ *
+ * Provides a simple file-based locking mechanism to prevent concurrent
+ * writes to shared files like progress.txt, feature-list.json, etc.
+ *
+ * Uses lock files (.lock suffix) with process info to track ownership.
+ */
+
+import { existsSync, writeFileSync, readFileSync, unlinkSync, readdirSync } from "node:fs";
+import { join, dirname } from "path";
+import { ensureDirSync } from "@/services/system/copy.ts";
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+/**
+ * Lock file content structure.
+ */
+interface LockInfo {
+  /** Process ID that holds the lock */
+  pid: number;
+  /** Session ID (if available) */
+  sessionId?: string;
+  /** Timestamp when lock was acquired */
+  acquiredAt: number;
+  /** Hostname where the lock was acquired */
+  hostname?: string;
+}
+
+/**
+ * Result of a lock acquisition attempt.
+ */
+export interface LockResult {
+  /** Whether the lock was acquired */
+  acquired: boolean;
+  /** Lock file path */
+  lockPath: string;
+  /** Error message if lock wasn't acquired */
+  error?: string;
+  /** Info about the process holding the lock (if not acquired) */
+  holder?: LockInfo;
+}
+
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+/** Lock file suffix */
+const LOCK_SUFFIX = ".lock";
+
+/** Default lock timeout in milliseconds (30 seconds) */
+const DEFAULT_LOCK_TIMEOUT_MS = 30000;
+
+/** Retry interval for lock acquisition */
+const LOCK_RETRY_INTERVAL_MS = 100;
+
+// ============================================================================
+// LOCK FUNCTIONS
+// ============================================================================
+
+/**
+ * Get the lock file path for a given file.
+ */
+export function getLockPath(filePath: string): string {
+  return `${filePath}${LOCK_SUFFIX}`;
+}
+
+/**
+ * Try to acquire a lock on a file.
+ *
+ * @param filePath - Path to the file to lock
+ * @param sessionId - Optional session ID for tracking
+ * @returns Lock result
+ */
+export function tryAcquireLock(filePath: string, sessionId?: string): LockResult {
+  const lockPath = getLockPath(filePath);
+
+  // Check if lock file exists
+  if (existsSync(lockPath)) {
+    try {
+      const content = readFileSync(lockPath, "utf-8");
+      const holder = JSON.parse(content) as LockInfo;
+
+      // Check if the lock holder process is still alive
+      if (isProcessAlive(holder.pid)) {
+        return {
+          acquired: false,
+          lockPath,
+          error: `File is locked by process ${holder.pid}`,
+          holder,
+        };
+      }
+
+      // Lock holder process is dead, remove stale lock
+      unlinkSync(lockPath);
+    } catch {
+      // Invalid lock file, remove it
+      try {
+        unlinkSync(lockPath);
+      } catch {
+        // Ignore removal errors
+      }
+    }
+  }
+
+  // Try to create lock file
+  const lockInfo: LockInfo = {
+    pid: process.pid,
+    sessionId,
+    acquiredAt: Date.now(),
+    hostname: process.env.HOSTNAME,
+  };
+
+  try {
+    // Ensure directory exists
+    const dir = dirname(lockPath);
+    if (!existsSync(dir)) {
+      ensureDirSync(dir);
+    }
+
+    // Write lock file with exclusive flag to prevent race conditions
+    writeFileSync(lockPath, JSON.stringify(lockInfo, null, 2), { flag: "wx" });
+    return { acquired: true, lockPath };
+  } catch (error) {
+    // Another process might have created the lock
+    return {
+      acquired: false,
+      lockPath,
+      error: `Failed to acquire lock: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Acquire a lock with retry and timeout.
+ *
+ * @param filePath - Path to the file to lock
+ * @param options - Lock options
+ * @returns Lock result
+ */
+export async function acquireLock(
+  filePath: string,
+  options: {
+    sessionId?: string;
+    timeoutMs?: number;
+  } = {}
+): Promise<LockResult> {
+  const { sessionId, timeoutMs = DEFAULT_LOCK_TIMEOUT_MS } = options;
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeoutMs) {
+    const result = tryAcquireLock(filePath, sessionId);
+    if (result.acquired) {
+      return result;
+    }
+
+    // Wait before retry
+    await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
+  }
+
+  // Timeout
+  return tryAcquireLock(filePath, sessionId);
+}
+
+/**
+ * Release a lock on a file.
+ *
+ * @param filePath - Path to the file to unlock
+ * @param options - Release options
+ * @returns True if lock was released
+ */
+export function releaseLock(
+  filePath: string,
+  options: { force?: boolean } = {}
+): boolean {
+  const lockPath = getLockPath(filePath);
+
+  if (!existsSync(lockPath)) {
+    return true; // Already unlocked
+  }
+
+  // Verify we own the lock (unless force)
+  if (!options.force) {
+    try {
+      const content = readFileSync(lockPath, "utf-8");
+      const holder = JSON.parse(content) as LockInfo;
+      if (holder.pid !== process.pid) {
+        return false; // We don't own this lock
+      }
+    } catch {
+      // Invalid lock file, safe to remove
+    }
+  }
+
+  try {
+    unlinkSync(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Execute a function while holding a lock on a file.
+ *
+ * @param filePath - Path to the file to lock
+ * @param fn - Function to execute while holding the lock
+ * @param options - Lock options
+ * @returns Result of the function
+ */
+export async function withLock<T>(
+  filePath: string,
+  fn: () => T | Promise<T>,
+  options: {
+    sessionId?: string;
+    timeoutMs?: number;
+  } = {}
+): Promise<T> {
+  const lockResult = await acquireLock(filePath, options);
+
+  if (!lockResult.acquired) {
+    throw new Error(lockResult.error ?? `Failed to acquire lock for ${filePath}`);
+  }
+
+  try {
+    return await fn();
+  } finally {
+    releaseLock(filePath);
+  }
+}
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+/**
+ * Check if a process is still alive.
+ */
+function isProcessAlive(pid: number): boolean {
+  try {
+    // Sending signal 0 doesn't kill the process, just checks if it exists
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Clean up stale locks for a directory.
+ * Removes lock files whose holder processes are no longer alive.
+ *
+ * @param directory - Directory to clean up
+ * @returns Number of stale locks removed
+ */
+export function cleanupStaleLocks(directory: string): number {
+  let removed = 0;
+
+  try {
+    const files = readdirSync(directory) as string[];
+    for (const file of files) {
+      if (file.endsWith(LOCK_SUFFIX)) {
+        const lockPath = join(directory, file);
+        try {
+          const content = readFileSync(lockPath, "utf-8");
+          const holder = JSON.parse(content) as LockInfo;
+          if (!isProcessAlive(holder.pid)) {
+            unlinkSync(lockPath);
+            removed++;
+          }
+        } catch {
+          // Invalid lock file, remove it
+          try {
+            unlinkSync(lockPath);
+            removed++;
+          } catch {
+            // Ignore
+          }
+        }
+      }
+    }
+  } catch {
+    // Ignore directory read errors
+  }
+
+  return removed;
+}

package/src/services/system/skills.ts

@@ -0,0 +1,67 @@
+/**
+ * Global skills installation.
+ *
+ * Installs bundled agent skills globally via `npx skills`, then removes
+ * source-control skill variants so `atomic init` can install them
+ * locally per-project based on the user's selected SCM + active agent.
+ */
+
+const SKILLS_REPO = "https://github.com/flora131/atomic.git";
+const SKILLS_AGENTS = ["claude-code", "opencode", "github-copilot"] as const;
+const SCM_SKILLS_TO_REMOVE_GLOBALLY = [
+  "gh-commit",
+  "gh-create-pr",
+  "sl-commit",
+  "sl-submit-diff",
+] as const;
+
+async function runNpxSkills(args: string[]): Promise<boolean> {
+  const npxPath = Bun.which("npx");
+  if (!npxPath) {
+    console.warn("npx not found on PATH — skipping skills install");
+    return false;
+  }
+
+  const proc = Bun.spawn([npxPath, "--yes", "skills", ...args], {
+    stdio: ["ignore", "inherit", "inherit"],
+  });
+  const exitCode = await proc.exited;
+  return exitCode === 0;
+}
+
+export async function installGlobalSkills(): Promise<void> {
+  const agentFlags = SKILLS_AGENTS.flatMap((agent) => ["-a", agent]);
+
+  console.log("Installing bundled skills globally...");
+  const addOk = await runNpxSkills([
+    "add",
+    SKILLS_REPO,
+    "--skill",
+    "*",
+    "-g",
+    ...agentFlags,
+    "-y",
+  ]);
+  if (!addOk) {
+    console.warn("Warning: 'npx skills add' exited non-zero (non-fatal)");
+    return;
+  }
+
+  const removeSkillFlags = SCM_SKILLS_TO_REMOVE_GLOBALLY.flatMap((skill) => [
+    "--skill",
+    skill,
+  ]);
+  console.log(
+    "Removing source-control skill variants globally (added per-project by `atomic init`)...",
+  );
+  const removeOk = await runNpxSkills([
+    "remove",
+    ...removeSkillFlags,
+    "-g",
+    ...agentFlags,
+    "-y",
+  ]);
+  if (!removeOk) {
+    console.warn("Warning: 'npx skills remove' exited non-zero (non-fatal)");
+  }
+}

package/src/theme/colors.ts

@@ -0,0 +1,25 @@
+import { supportsColor } from "@/services/system/detect.ts";
+
+/**
+ * ANSI color and formatting codes for CLI output
+ * Respects the NO_COLOR environment variable
+ */
+const ANSI_CODES = {
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  reset: "\x1b[0m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+} as const;
+
+const NO_COLORS = {
+  bold: "",
+  dim: "",
+  reset: "",
+  red: "",
+  green: "",
+  yellow: "",
+} as const;
+
+export const COLORS = supportsColor() ? ANSI_CODES : NO_COLORS;

package/src/version.ts

@@ -0,0 +1,7 @@
+/**
+ * Version - read from package.json
+ */
+import packageJson from "../package.json";
+
+export const VERSION = packageJson.version;
+// test marker