zmemory 0.1.0

package/src/lib/lock.js

@@ -0,0 +1,103 @@
+import fs from "fs";
+import { getRunFile } from "./run.js";
+
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err && err.code === "EPERM") return true;
+    return false;
+  }
+}
+
+export function acquireLock(run) {
+  const p = getRunFile(run, "lock");
+  const ttl = 30 * 60 * 1000;
+
+  function tryAcquire() {
+    try {
+      const fd = fs.openSync(p, "wx");
+      try {
+        const meta = { pid: process.pid, created_at: Date.now() };
+        fs.writeFileSync(fd, JSON.stringify(meta));
+      } catch (err) {
+        try { fs.closeSync(fd); } catch {}
+        try {
+          if (fs.existsSync(p)) fs.unlinkSync(p);
+        } catch {}
+        throw err;
+      }
+      fs.closeSync(fd);
+      return true;
+    } catch (err) {
+      if (err && err.code === "EEXIST") return false;
+      throw err;
+    }
+  }
+
+  if (tryAcquire()) return;
+
+  if (fs.existsSync(p)) {
+    try {
+      const stat = fs.statSync(p);
+      const raw = fs.readFileSync(p, "utf8").trim();
+      let stale = false;
+
+      if (/^\d+$/.test(raw)) {
+        const pid = Number(raw);
+        if (Number.isSafeInteger(pid) && pid > 0) {
+          if (!processAlive(pid)) stale = true;
+        } else {
+          const age = Date.now() - stat.mtimeMs;
+          if (age > ttl) stale = true;
+        }
+      } else {
+        let parsed = false;
+        try {
+          const meta = JSON.parse(raw);
+          if (
+            meta &&
+            typeof meta === "object" &&
+            !Array.isArray(meta) &&
+            typeof meta.pid === "number" &&
+            meta.pid > 0 &&
+            typeof meta.created_at === "number"
+          ) {
+            parsed = true;
+            const age = Date.now() - meta.created_at;
+            if (!processAlive(meta.pid) || age > ttl) stale = true;
+          }
+        } catch {}
+
+        if (!parsed) {
+          const age = Date.now() - stat.mtimeMs;
+          if (age > ttl) stale = true;
+        }
+      }
+
+      if (stale) {
+        fs.unlinkSync(p);
+        if (tryAcquire()) return;
+      }
+    } catch {}
+  }
+
+  throw new Error("run locked by another agent");
+}
+
+export function releaseLock(run) {
+  const p = getRunFile(run, "lock");
+  if (!fs.existsSync(p)) return;
+
+  try {
+    const raw = fs.readFileSync(p, "utf8");
+    try {
+      const meta = JSON.parse(raw);
+      if (meta.pid === process.pid) fs.unlinkSync(p);
+    } catch {
+      const pid = Number(raw);
+      if (pid === process.pid || !processAlive(pid)) fs.unlinkSync(p);
+    }
+  } catch {}
+}

package/src/lib/repoScan.js

@@ -0,0 +1,19 @@
+import fs from "fs";
+import path from "path";
+
+// Simple repo scanner to detect top-level modules for planning
+export function scanModules(root = "src") {
+  if (!fs.existsSync(root)) return [];
+
+  const entries = fs.readdirSync(root, { withFileTypes: true });
+  const modules = [];
+
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      modules.push(path.join(root, e.name));
+    }
+  }
+
+  return modules;
+}
+

package/src/lib/run.js

@@ -0,0 +1,63 @@
+import fs from "fs";
+import path from "path";
+
+const ACTIVE_ROOT = path.resolve(".zmemory/runs/active");
+const ARCHIVE_ROOT = path.resolve(".zmemory/runs/archived");
+
+const RUN_ID_REGEX = /^run_\d{4}_\d{1,2}_\d{1,2}_\d+$/;
+
+export function isValidRunId(run) {
+  if (!run || typeof run !== "string") return false;
+  if (run.includes("..") || run.includes("/") || run.includes("\\")) return false;
+  if (path.isAbsolute(run)) return false;
+  return RUN_ID_REGEX.test(run);
+}
+
+export function assertValidRunId(run) {
+  if (!isValidRunId(run)) {
+    throw new Error("invalid run id");
+  }
+}
+
+function ensureInside(base, target) {
+  const resolved = path.resolve(target);
+  if (!(resolved === base || resolved.startsWith(base + path.sep))) {
+    throw new Error("invalid run path");
+  }
+  return resolved;
+}
+
+export function getRunBase(run) {
+  assertValidRunId(run);
+  const p = path.join(ACTIVE_ROOT, run);
+  return ensureInside(ACTIVE_ROOT, p);
+}
+
+export function getArchivedRunBase(run) {
+  assertValidRunId(run);
+  const p = path.join(ARCHIVE_ROOT, run);
+  return ensureInside(ARCHIVE_ROOT, p);
+}
+
+export function getRunFile(run, file) {
+  const base = getRunBase(run);
+  const p = path.join(base, file);
+  return ensureInside(base, p);
+}
+
+export function ensureRunExists(run) {
+  const base = getRunBase(run);
+  if (!fs.existsSync(base)) {
+    throw new Error("run not found");
+  }
+  return base;
+}
+
+export function readRunState(run) {
+  ensureRunExists(run);
+  const statePath = getRunFile(run, "state.json");
+  if (!fs.existsSync(statePath)) {
+    throw new Error("state.json missing for run");
+  }
+  return JSON.parse(fs.readFileSync(statePath, "utf8"));
+}

package/src/lib/sqlite.js

@@ -0,0 +1,7 @@
+// Optional SQLite backend (future scope)
+// Currently acts as a stub so the system can evolve
+
+export function initSQLite() {
+  console.log("SQLite backend not yet enabled. Using file backend.");
+}
+

package/src/lib/tasks.js

@@ -0,0 +1,77 @@
+import { readJSON, writeJSON, withFileLock } from "./fs.js";
+
+const TASK_FILE = ".zmemory/tasks.json";
+const LOCK = ".zmemory/tasks.json.lock";
+
+function readTasks() {
+  return readJSON(TASK_FILE) || [];
+}
+
+function writeTasks(tasks) {
+  writeJSON(TASK_FILE, tasks);
+}
+
+export function addTask(title, files = []) {
+  return withFileLock(LOCK, () => {
+    const tasks = readTasks();
+    const task = {
+      id: `task_${Date.now()}`,
+      title,
+      files,
+      status: "pending",
+      worker: null,
+      file_locks: files,
+      depends_on: [],
+      file_scope: files
+    };
+    tasks.push(task);
+    writeTasks(tasks);
+    return task;
+  });
+}
+
+export function addTaskWithDeps(title, deps = []) {
+  return withFileLock(LOCK, () => {
+    const tasks = readTasks();
+    const task = {
+      id: `task_${Date.now()}`,
+      title,
+      files: [],
+      status: "pending",
+      worker: null,
+      file_locks: [],
+      depends_on: deps
+    };
+    tasks.push(task);
+    writeTasks(tasks);
+    return task;
+  });
+}
+
+export function listTasks() {
+  return readTasks();
+}
+
+export function claimTask(id, worker) {
+  return withFileLock(LOCK, () => {
+    const tasks = readTasks();
+    const t = tasks.find((x) => x.id === id);
+    if (!t) return null;
+    if (t.worker) return null;
+    t.worker = worker;
+    t.status = "in_progress";
+    writeTasks(tasks);
+    return t;
+  });
+}
+
+export function completeTask(id) {
+  return withFileLock(LOCK, () => {
+    const tasks = readTasks();
+    const t = tasks.find((x) => x.id === id);
+    if (!t) return null;
+    t.status = "done";
+    writeTasks(tasks);
+    return t;
+  });
+}

package/src/lib/teamSync.js

@@ -0,0 +1,36 @@
+import fs from "fs";
+
+// Very simple optional team sync mechanism using a shared directory.
+// This is intentionally lightweight and local-first.
+
+export function syncPush(remoteDir = ".zmemory-remote") {
+  if (!fs.existsSync(".zmemory")) return;
+  if (!fs.existsSync(remoteDir)) fs.mkdirSync(remoteDir, { recursive: true });
+
+  const files = fs.readdirSync(".zmemory");
+
+  files.forEach((f) => {
+    const src = `.zmemory/${f}`;
+    const dst = `${remoteDir}/${f}`;
+
+    if (fs.lstatSync(src).isDirectory()) return;
+
+    fs.copyFileSync(src, dst);
+  });
+}
+
+export function syncPull(remoteDir = ".zmemory-remote") {
+  if (!fs.existsSync(remoteDir)) return;
+
+  const files = fs.readdirSync(remoteDir);
+
+  files.forEach((f) => {
+    const src = `${remoteDir}/${f}`;
+    const dst = `.zmemory/${f}`;
+
+    if (fs.lstatSync(src).isDirectory()) return;
+
+    fs.copyFileSync(src, dst);
+  });
+}
+

package/src/lib/workspaces.js

@@ -0,0 +1,29 @@
+import { readJSON, writeJSON, withFileLock } from "./fs.js";
+
+const FILE = ".zmemory/workspaces.json";
+const LOCK = ".zmemory/workspaces.json.lock";
+
+function read() {
+  try {
+    return readJSON(FILE, []) || [];
+  } catch {
+    return [];
+  }
+}
+
+function write(data) {
+  writeJSON(FILE, data);
+}
+
+export function addWorkspace(path) {
+  return withFileLock(LOCK, () => {
+    const list = read();
+    if (!list.includes(path)) list.push(path);
+    write(list);
+    return list;
+  });
+}
+
+export function listWorkspaces() {
+  return read();
+}

package/src/mcp/autostart.js

@@ -0,0 +1,12 @@
+import { spawn } from "child_process";
+
+export function startMCP() {
+  const proc = spawn("node", ["bin/zmemory.js", "mcp"], {
+    stdio: "inherit"
+  });
+
+  proc.on("error", (err) => {
+    console.error("Failed to start MCP server", err);
+  });
+}
+