aiwcli 0.12.6 → 0.12.8

package/dist/templates/_shared/lib-ts/base/atomic-write.ts

@@ -1,138 +1,138 @@
-/**
- * Cross-platform atomic file writes with security.
- * Crash-safe writes by writing to temp file then renaming.
- * NOT for concurrent access — assumes single-session-per-context.
- * See SPEC.md §4
- */
-
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as _os from "node:os";
-import * as path from "node:path";
-
-/**
- * Write file atomically with retry logic.
- * Creates temp file, writes, fsyncs, renames.
- * Returns [success, error].
- * See SPEC.md §4.2
- */
-export function atomicWrite(
-  filePath: string,
-  content: string,
-  maxAttempts = 2,
-  backoffMs: number[] = [500, 1000],
-): [boolean, null | string] {
-  // Ensure parent directory exists
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true });
-
-  const stem = path.basename(filePath, path.extname(filePath));
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const tmpName = `.${stem}_${crypto.randomBytes(4).toString("hex")}.tmp`;
-    const tmpPath = path.join(dir, tmpName);
-
-    try {
-      // Write to temp file
-      const fd = fs.openSync(tmpPath, "w");
-      try {
-        fs.writeSync(fd, content, undefined, "utf-8");
-        fs.fsyncSync(fd);
-      } finally {
-        fs.closeSync(fd);
-      }
-
-      // Set restrictive permissions (best-effort)
-      try {
-        fs.chmodSync(tmpPath, 0o600);
-      } catch {
-        // May fail on some filesystems
-      }
-
-      // Atomic rename (cross-platform on modern Node/Bun)
-      fs.renameSync(tmpPath, filePath);
-
-      return [true, null];
-    } catch (error: any) {
-      // Clean up temp file
-      try {
-        fs.unlinkSync(tmpPath);
-      } catch {
-        // Best-effort cleanup
-      }
-
-      if (attempt < maxAttempts - 1) {
-        const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? backoffMs.at(-1) ?? 500;
-        sleepSync(waitMs);
-      } else {
-        const errType = error?.constructor?.name ?? "Error";
-        const errMsg = String(error).split("\n")[0]?.slice(0, 200) ?? "";
-        return [false, `${errType}: ${errMsg}`];
-      }
-    }
-  }
-
-  return [false, "Max retry attempts exceeded"];
-}
-
-/**
- * Append to file with retry logic.
- * For JSONL files where each line is independent.
- * See SPEC.md §4.3
- */
-export function atomicAppend(
-  filePath: string,
-  content: string,
-  maxAttempts = 2,
-  backoffMs: number[] = [500, 1000],
-): [boolean, null | string] {
-  // Ensure parent directory exists
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true });
-
-  const isNewFile = !fs.existsSync(filePath);
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      const fd = fs.openSync(filePath, "a");
-      try {
-        fs.writeSync(fd, content, undefined, "utf-8");
-        fs.fsyncSync(fd);
-      } finally {
-        fs.closeSync(fd);
-      }
-
-      // Set permissions on newly created files (best-effort)
-      if (isNewFile) {
-        try {
-          fs.chmodSync(filePath, 0o600);
-        } catch {
-          // May fail on some filesystems
-        }
-      }
-
-      return [true, null];
-    } catch (error: any) {
-      if (attempt < maxAttempts - 1) {
-        const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? backoffMs.at(-1) ?? 500;
-        sleepSync(waitMs);
-      } else {
-        const errType = error?.constructor?.name ?? "Error";
-        const errMsg = String(error).split("\n")[0]?.slice(0, 200) ?? "";
-        return [false, `${errType}: ${errMsg}`];
-      }
-    }
-  }
-
-  return [false, "Max retry attempts exceeded"];
-}
-
-/**
- * Synchronous sleep for retry backoff.
- * Uses Atomics.wait() for CPU-friendly blocking instead of busy-wait.
- */
-function sleepSync(ms: number): void {
-  const sab = new SharedArrayBuffer(4);
-  const i32 = new Int32Array(sab);
-  Atomics.wait(i32, 0, 0, ms);
-}
+/**
+ * Cross-platform atomic file writes with security.
+ * Crash-safe writes by writing to temp file then renaming.
+ * NOT for concurrent access — assumes single-session-per-context.
+ * See SPEC.md §4
+ */
+
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as _os from "node:os";
+import * as path from "node:path";
+
+/**
+ * Write file atomically with retry logic.
+ * Creates temp file, writes, fsyncs, renames.
+ * Returns [success, error].
+ * See SPEC.md §4.2
+ */
+export function atomicWrite(
+  filePath: string,
+  content: string,
+  maxAttempts = 2,
+  backoffMs: number[] = [500, 1000],
+): [boolean, null | string] {
+  // Ensure parent directory exists
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const stem = path.basename(filePath, path.extname(filePath));
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const tmpName = `.${stem}_${crypto.randomBytes(4).toString("hex")}.tmp`;
+    const tmpPath = path.join(dir, tmpName);
+
+    try {
+      // Write to temp file
+      const fd = fs.openSync(tmpPath, "w");
+      try {
+        fs.writeSync(fd, content, undefined, "utf-8");
+        fs.fsyncSync(fd);
+      } finally {
+        fs.closeSync(fd);
+      }
+
+      // Set restrictive permissions (best-effort)
+      try {
+        fs.chmodSync(tmpPath, 0o600);
+      } catch {
+        // May fail on some filesystems
+      }
+
+      // Atomic rename (cross-platform on modern Node/Bun)
+      fs.renameSync(tmpPath, filePath);
+
+      return [true, null];
+    } catch (error: any) {
+      // Clean up temp file
+      try {
+        fs.unlinkSync(tmpPath);
+      } catch {
+        // Best-effort cleanup
+      }
+
+      if (attempt < maxAttempts - 1) {
+        const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? backoffMs.at(-1) ?? 500;
+        sleepSync(waitMs);
+      } else {
+        const errType = error?.constructor?.name ?? "Error";
+        const errMsg = String(error).split("\n")[0]?.slice(0, 200) ?? "";
+        return [false, `${errType}: ${errMsg}`];
+      }
+    }
+  }
+
+  return [false, "Max retry attempts exceeded"];
+}
+
+/**
+ * Append to file with retry logic.
+ * For JSONL files where each line is independent.
+ * See SPEC.md §4.3
+ */
+export function atomicAppend(
+  filePath: string,
+  content: string,
+  maxAttempts = 2,
+  backoffMs: number[] = [500, 1000],
+): [boolean, null | string] {
+  // Ensure parent directory exists
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const isNewFile = !fs.existsSync(filePath);
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const fd = fs.openSync(filePath, "a");
+      try {
+        fs.writeSync(fd, content, undefined, "utf-8");
+        fs.fsyncSync(fd);
+      } finally {
+        fs.closeSync(fd);
+      }
+
+      // Set permissions on newly created files (best-effort)
+      if (isNewFile) {
+        try {
+          fs.chmodSync(filePath, 0o600);
+        } catch {
+          // May fail on some filesystems
+        }
+      }
+
+      return [true, null];
+    } catch (error: any) {
+      if (attempt < maxAttempts - 1) {
+        const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)] ?? backoffMs.at(-1) ?? 500;
+        sleepSync(waitMs);
+      } else {
+        const errType = error?.constructor?.name ?? "Error";
+        const errMsg = String(error).split("\n")[0]?.slice(0, 200) ?? "";
+        return [false, `${errType}: ${errMsg}`];
+      }
+    }
+  }
+
+  return [false, "Max retry attempts exceeded"];
+}
+
+/**
+ * Synchronous sleep for retry backoff.
+ * Uses Atomics.wait() for CPU-friendly blocking instead of busy-wait.
+ */
+function sleepSync(ms: number): void {
+  const sab = new SharedArrayBuffer(4);
+  const i32 = new Int32Array(sab);
+  Atomics.wait(i32, 0, 0, ms);
+}

package/dist/templates/_shared/lib-ts/base/constants.ts

@@ -4,7 +4,7 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
+import * as path from "node:path";
 
 import { logWarn } from "./logger.js";
 
@@ -87,9 +87,27 @@ export function validateContextId(contextId: string): string {
   return sanitizeContextId(contextId);
 }
 
+/**
+ * Walk up from startDir until a directory containing `.aiwcli/` is found.
+ * Returns startDir itself if no anchor is found (fail-safe).
+ * See SPEC.md §2.2
+ */
+function findProjectRoot(startDir: string): string {
+  let dir = startDir;
+  while (true) {
+    if (fs.existsSync(path.join(dir, ".aiwcli"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break; // filesystem root reached
+    dir = parent;
+  }
+  return startDir; // fallback: no .aiwcli anchor found
+}
+
 /**
  * Get project root from environment or cwd.
- * Priority: CLAUDE_PROJECT_DIR > payload cwd > process.cwd()
+ * Priority: CLAUDE_PROJECT_DIR > walk up from payload cwd > walk up from process.cwd()
+ * Walks upward to find the nearest .aiwcli/ anchor, so cwd drift (e.g. after
+ * `cd packages/cli` in a Bash tool call) doesn't break hook resolution.
  * See SPEC.md §2.2
  */
 export function getProjectRoot(payloadCwd?: string): string {
@@ -102,10 +120,10 @@ export function getProjectRoot(payloadCwd?: string): string {
     } else {
       return envDir;
     }
-  }
+  }
 
-  if (payloadCwd) return payloadCwd;
-  return process.cwd();
+  if (payloadCwd) return findProjectRoot(payloadCwd);
+  return findProjectRoot(process.cwd());
 }
 
 // §2.4 — Path functions
@@ -236,7 +254,7 @@ export function getHandoffFolderPath(
   while (fs.existsSync(folder)) {
     folder = path.join(handoffsDir, `${ts}-${counter}`);
     counter++;
-  }
+  }
 
   return folder;
 }

package/dist/templates/_shared/lib-ts/base/git-state.ts

@@ -1,58 +1,58 @@
-import { execFileSync } from "node:child_process";
-
-/**
- * Capture current git state for session snapshots.
- * All fields are optional — failures are silently ignored.
- */
-export function getGitState(projectRoot: string): Record<string, any> {
-  const gitState: Record<string, any> = {};
-  const isWin = process.platform === "win32";
-  const opts = {
-    cwd: projectRoot,
-    timeout: 5000,
-    encoding: "utf-8" as const,
-    stdio: ["pipe", "pipe", "pipe"] as ["pipe", "pipe", "pipe"],
-    shell: isWin,
-  };
-
-  try {
-    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], opts);
-    if (branch) gitState.branch = branch.trim();
-  } catch { /* non-fatal */ }
-
-  try {
-    const status = execFileSync("git", ["status", "--short"], opts);
-    if (status) {
-      const files = status.trim().split(/\r?\n/)
-        .filter(Boolean)
-        .slice(0, 10)
-        .map(line => line.trimStart().split(/\s+/).slice(1).join(" "));
-      if (files.length > 0) gitState.uncommitted_files = files;
-    }
-  } catch { /* non-fatal */ }
-
-  try {
-    const log = execFileSync("git", ["log", "-1", "--oneline"], opts);
-    if (log) gitState.last_commit_short = log.trim();
-  } catch { /* non-fatal */ }
-
-  return gitState;
-}
-
-/**
- * Get short git status string for display (e.g., in handoff documents).
- */
-export function getGitStatusShort(projectRoot?: string): string {
-  try {
-    const result = execFileSync("git", ["status", "--short"], {
-      encoding: "utf-8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
-      ...(projectRoot ? { cwd: projectRoot } : {}),
-      shell: process.platform === "win32",
-    });
-    return result.trim() || "(no changes)";
-  } catch {
-    return "(git status unavailable)";
-  }
-}
+import { execFileSync } from "node:child_process";
+
+/**
+ * Capture current git state for session snapshots.
+ * All fields are optional — failures are silently ignored.
+ */
+export function getGitState(projectRoot: string): Record<string, any> {
+  const gitState: Record<string, any> = {};
+  const isWin = process.platform === "win32";
+  const opts = {
+    cwd: projectRoot,
+    timeout: 5000,
+    encoding: "utf-8" as const,
+    stdio: ["pipe", "pipe", "pipe"] as ["pipe", "pipe", "pipe"],
+    shell: isWin,
+  };
+
+  try {
+    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], opts);
+    if (branch) gitState.branch = branch.trim();
+  } catch { /* non-fatal */ }
+
+  try {
+    const status = execFileSync("git", ["status", "--short"], opts);
+    if (status) {
+      const files = status.trim().split(/\r?\n/)
+        .filter(Boolean)
+        .slice(0, 10)
+        .map(line => line.trimStart().split(/\s+/).slice(1).join(" "));
+      if (files.length > 0) gitState.uncommitted_files = files;
+    }
+  } catch { /* non-fatal */ }
+
+  try {
+    const log = execFileSync("git", ["log", "-1", "--oneline"], opts);
+    if (log) gitState.last_commit_short = log.trim();
+  } catch { /* non-fatal */ }
+
+  return gitState;
+}
+
+/**
+ * Get short git status string for display (e.g., in handoff documents).
+ */
+export function getGitStatusShort(projectRoot?: string): string {
+  try {
+    const result = execFileSync("git", ["status", "--short"], {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+      ...(projectRoot ? { cwd: projectRoot } : {}),
+      shell: process.platform === "win32",
+    });
+    return result.trim() || "(no changes)";
+  } catch {
+    return "(git status unavailable)";
+  }
+}