@caseyharalson/orrery 0.10.0 → 0.12.0

package/lib/utils/git.js

@@ -22,7 +22,9 @@ function git(command, cwd) {
   } catch (error) {
     // Return stderr if available, otherwise throw
     if (error.stderr) {
-      throw new Error(`git ${command} failed: ${error.stderr.trim()}`);
+      throw new Error(`git ${command} failed: ${error.stderr.trim()}`, {
+        cause: error
+      });
     }
     throw error;
   }
@@ -34,7 +36,12 @@ function git(command, cwd) {
  * @returns {string} - Current branch name
  */
 function getCurrentBranch(cwd) {
-  return git("rev-parse --abbrev-ref HEAD", cwd);
+  try {
+    return git("rev-parse --abbrev-ref HEAD", cwd);
+  } catch {
+    // Unborn branch (no commits yet) — symbolic-ref still works
+    return git("symbolic-ref --short HEAD", cwd);
+  }
 }
 
 /**

package/lib/utils/lock.js

@@ -0,0 +1,170 @@
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const { getWorkDir } = require("./paths");
+
+const LOCK_FILE = "exec.lock";
+
+function getLockPath() {
+  return path.join(getWorkDir(), LOCK_FILE);
+}
+
+/**
+ * Check if a process with the given PID is running.
+ * @param {number} pid - Process ID
+ * @returns {boolean}
+ */
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a PID belongs to an orrery process.
+ * @param {number} pid - Process ID
+ * @returns {boolean}
+ */
+function isOrreryProcess(pid) {
+  try {
+    // Linux: read /proc/<pid>/cmdline (null-separated args)
+    const cmdlinePath = `/proc/${pid}/cmdline`;
+    if (fs.existsSync(cmdlinePath)) {
+      const raw = fs.readFileSync(cmdlinePath, "utf8");
+      const args = raw.split("\0").filter(Boolean);
+      // Check if any argument ends with the orrery binary (bin/orrery.js or bin/orrery)
+      return args.some(
+        (arg) => arg.endsWith("bin/orrery.js") || arg.endsWith("bin/orrery")
+      );
+    }
+
+    // macOS/other: use ps
+    const args = execSync(`ps -p ${pid} -o args=`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return args.includes("bin/orrery.js") || args.includes("bin/orrery ");
+  } catch {
+    // Cannot determine — treat as stale (safe default)
+    return false;
+  }
+}
+
+/**
+ * Read and parse the lock file.
+ * @returns {{pid: number, startedAt: string, command: string}|null}
+ */
+function readLock() {
+  const lockPath = getLockPath();
+  try {
+    const content = fs.readFileSync(lockPath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Attempt to acquire the execution lock.
+ * @returns {{acquired: boolean, reason?: string, pid?: number}}
+ */
+function acquireLock() {
+  const lockPath = getLockPath();
+  const lockData = {
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    command: process.argv.slice(2).join(" ")
+  };
+
+  // Check for existing lock
+  const existing = readLock();
+  if (existing) {
+    const running = isProcessRunning(existing.pid);
+    if (running && isOrreryProcess(existing.pid)) {
+      return {
+        acquired: false,
+        reason: `Another orrery process is running (PID ${existing.pid}, started ${existing.startedAt})`,
+        pid: existing.pid
+      };
+    }
+
+    // Stale lock — remove it
+    try {
+      fs.unlinkSync(lockPath);
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+
+  // Atomic create
+  try {
+    fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2) + "\n", {
+      flag: "wx"
+    });
+    return { acquired: true };
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      // Race condition — another process acquired between check and write
+      const raceWinner = readLock();
+      return {
+        acquired: false,
+        reason: `Another orrery process just started (PID ${raceWinner?.pid || "unknown"})`,
+        pid: raceWinner?.pid
+      };
+    }
+    return {
+      acquired: false,
+      reason: `Failed to create lock file: ${err.message}`
+    };
+  }
+}
+
+/**
+ * Release the execution lock (only if owned by current process).
+ */
+function releaseLock() {
+  const lockPath = getLockPath();
+  const existing = readLock();
+
+  if (existing && existing.pid === process.pid) {
+    try {
+      fs.unlinkSync(lockPath);
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+/**
+ * Get the current lock status (read-only).
+ * @returns {{locked: boolean, pid?: number, startedAt?: string, stale: boolean}}
+ */
+function getLockStatus() {
+  const existing = readLock();
+
+  if (!existing) {
+    return { locked: false, stale: false };
+  }
+
+  const running = isProcessRunning(existing.pid);
+  const isOrrery = running && isOrreryProcess(existing.pid);
+
+  return {
+    locked: isOrrery,
+    pid: existing.pid,
+    startedAt: existing.startedAt,
+    stale: !isOrrery
+  };
+}
+
+module.exports = {
+  acquireLock,
+  releaseLock,
+  getLockStatus,
+  isProcessRunning,
+  isOrreryProcess
+};

package/lib/utils/paths.js

@@ -1,3 +1,4 @@
+const crypto = require("crypto");
 const fs = require("fs");
 const path = require("path");
 
@@ -10,10 +11,28 @@ function ensureDir(dirPath) {
   return dirPath;
 }
 
+/**
+ * Generate a deterministic project identifier from the current working directory.
+ * Format: <sanitized-basename>-<hash8>
+ * @returns {string} - Project identifier
+ */
+function getProjectId() {
+  const cwd = path.resolve(process.cwd());
+  const basename = path.basename(cwd) || "root";
+  const sanitized = basename.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const hash = crypto
+    .createHash("sha256")
+    .update(cwd)
+    .digest("hex")
+    .slice(0, 8);
+  return `${sanitized}-${hash}`;
+}
+
 function getWorkDir() {
   const envDir = process.env[WORK_DIR_ENV];
   if (envDir && envDir.trim()) {
-    return ensureDir(envDir.trim());
+    const projectScoped = path.join(envDir.trim(), getProjectId());
+    return ensureDir(projectScoped);
   }
   return ensureDir(path.join(process.cwd(), ".agent-work"));
 }
@@ -34,10 +53,18 @@ function getTempDir() {
   return ensureDir(path.join(getWorkDir(), "temp"));
 }
 
+function isWorkDirExternal() {
+  const workDir = path.resolve(getWorkDir());
+  const cwd = path.resolve(process.cwd());
+  return !workDir.startsWith(cwd + path.sep) && workDir !== cwd;
+}
+
 module.exports = {
   getWorkDir,
   getPlansDir,
   getCompletedDir,
   getReportsDir,
-  getTempDir
+  getTempDir,
+  getProjectId,
+  isWorkDirExternal
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caseyharalson/orrery",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Workflow planning and orchestration CLI for AI agents",
   "license": "MIT",
   "author": "Casey Haralson",
@@ -41,6 +41,7 @@
     ".devcontainer.example",
     "agent",
     "bin",
+    "HELP.md",
     "lib",
     "LICENSE",
     "README.md",
@@ -51,7 +52,8 @@
     "yaml": "^2.8.2"
   },
   "devDependencies": {
-    "eslint": "^9.39.2",
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.0.1",
     "eslint-config-prettier": "^10.1.8",
     "prettier": "^3.8.1"
   }