speclock 1.1.0

package/src/core/git.js

@@ -0,0 +1,110 @@
+import fs from "fs";
+import path from "path";
+import { spawnSync } from "child_process";
+
+// Safe git command execution — uses spawnSync with args array (no shell injection)
+export function safeGit(root, args) {
+  try {
+    const res = spawnSync("git", args, {
+      cwd: root,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 10000,
+    });
+    if (res.status !== 0) {
+      const stderr = res.stderr ? String(res.stderr).trim() : "git error";
+      return { ok: false, stdout: "", stderr };
+    }
+    return { ok: true, stdout: String(res.stdout).trim(), stderr: "" };
+  } catch (e) {
+    return { ok: false, stdout: "", stderr: e.message || "git error" };
+  }
+}
+
+export function hasGit(root) {
+  const gitDir = path.join(root, ".git");
+  if (!fs.existsSync(gitDir)) return false;
+  const res = safeGit(root, ["rev-parse", "--is-inside-work-tree"]);
+  return res.ok;
+}
+
+export function getHead(root) {
+  const branch = safeGit(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  const commit = safeGit(root, ["rev-parse", "HEAD"]);
+  if (!branch.ok || !commit.ok) {
+    return { gitBranch: "", gitCommit: "" };
+  }
+  return {
+    gitBranch: branch.stdout,
+    gitCommit: commit.stdout,
+  };
+}
+
+export function getDefaultBranch(root) {
+  const res = safeGit(root, ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+  if (res.ok) {
+    const parts = res.stdout.split("/");
+    return parts[parts.length - 1] || "";
+  }
+  const head = getHead(root);
+  return head.gitBranch || "";
+}
+
+export function captureDiff(root) {
+  const res = safeGit(root, ["diff"]);
+  if (!res.ok) return null;
+  return res.stdout;
+}
+
+export function captureDiffStaged(root) {
+  const res = safeGit(root, ["diff", "--cached"]);
+  if (!res.ok) return null;
+  return res.stdout;
+}
+
+// Parse git status --porcelain into structured data
+export function captureStatus(root) {
+  const branchRes = safeGit(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  const commitRes = safeGit(root, ["rev-parse", "--short", "HEAD"]);
+  const statusRes = safeGit(root, ["status", "--porcelain"]);
+
+  const branch = branchRes.ok ? branchRes.stdout : "";
+  const commit = commitRes.ok ? commitRes.stdout : "";
+  const changedFiles = [];
+
+  if (statusRes.ok && statusRes.stdout) {
+    const lines = statusRes.stdout.split("\n").filter(Boolean);
+    for (const line of lines.slice(0, 50)) {
+      const status = line.substring(0, 2).trim();
+      const file = line.substring(3);
+      changedFiles.push({ status, file });
+    }
+  }
+
+  return { branch, commit, changedFiles };
+}
+
+export function createTag(root, tagName) {
+  const res = safeGit(root, ["tag", tagName]);
+  if (!res.ok) {
+    return { ok: false, tag: "", error: res.stderr };
+  }
+  return { ok: true, tag: tagName, error: "" };
+}
+
+export function getRecentCommits(root, n = 10) {
+  const res = safeGit(root, ["log", `--oneline`, `-${n}`]);
+  if (!res.ok || !res.stdout) return [];
+  return res.stdout.split("\n").filter(Boolean).map((line) => {
+    const spaceIdx = line.indexOf(" ");
+    return {
+      hash: line.substring(0, spaceIdx),
+      message: line.substring(spaceIdx + 1),
+    };
+  });
+}
+
+export function getDiffSummary(root) {
+  const res = safeGit(root, ["diff", "--stat"]);
+  if (!res.ok) return "";
+  return res.stdout;
+}

package/src/core/storage.js

@@ -0,0 +1,186 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+export function speclockDir(root) {
+  return path.join(root, ".speclock");
+}
+
+export function ensureSpeclockDirs(root) {
+  const base = speclockDir(root);
+  fs.mkdirSync(base, { recursive: true });
+  fs.mkdirSync(path.join(base, "patches"), { recursive: true });
+  fs.mkdirSync(path.join(base, "context"), { recursive: true });
+}
+
+export function brainPath(root) {
+  return path.join(speclockDir(root), "brain.json");
+}
+
+export function eventsPath(root) {
+  return path.join(speclockDir(root), "events.log");
+}
+
+export function newId(prefix) {
+  return `${prefix}_${crypto.randomBytes(6).toString("hex")}`;
+}
+
+// Brain v2 factory
+export function makeBrain(root, hasGitRepo, defaultBranch) {
+  const createdAt = nowIso();
+  const folderName = path.basename(root);
+  return {
+    version: 2,
+    project: {
+      id: newId("sl"),
+      name: folderName,
+      root,
+      createdAt,
+      updatedAt: createdAt,
+    },
+    goal: { text: "", updatedAt: createdAt },
+    specLock: {
+      items: [],
+    },
+    decisions: [],
+    notes: [],
+    facts: {
+      deploy: {
+        provider: "unknown",
+        autoDeploy: false,
+        branch: "",
+        url: "",
+        notes: "",
+      },
+      repo: {
+        defaultBranch: defaultBranch || "",
+        hasGit: !!hasGitRepo,
+      },
+    },
+    sessions: {
+      current: null,
+      history: [],
+    },
+    state: {
+      head: {
+        gitBranch: "",
+        gitCommit: "",
+        capturedAt: createdAt,
+      },
+      recentChanges: [],
+      reverts: [],
+    },
+    events: { lastEventId: "", count: 0 },
+  };
+}
+
+// Migrate v1 brain to v2
+export function migrateBrainV1toV2(brain) {
+  if (brain.version >= 2) return brain;
+
+  // Add notes array
+  if (!brain.notes) {
+    brain.notes = [];
+  }
+
+  // Add sessions
+  if (!brain.sessions) {
+    brain.sessions = { current: null, history: [] };
+  }
+
+  // Add active flag to all existing locks
+  if (brain.specLock && brain.specLock.items) {
+    for (const lock of brain.specLock.items) {
+      if (lock.active === undefined) lock.active = true;
+    }
+  }
+
+  // Add deploy.url
+  if (brain.facts && brain.facts.deploy && brain.facts.deploy.url === undefined) {
+    brain.facts.deploy.url = "";
+  }
+
+  // Remove old importance field
+  delete brain.importance;
+
+  brain.version = 2;
+  return brain;
+}
+
+export function readBrain(root) {
+  const p = brainPath(root);
+  if (!fs.existsSync(p)) return null;
+  const raw = fs.readFileSync(p, "utf8");
+  let brain = JSON.parse(raw);
+  if (brain.version < 2) {
+    brain = migrateBrainV1toV2(brain);
+    writeBrain(root, brain);
+  }
+  return brain;
+}
+
+export function writeBrain(root, brain) {
+  brain.project.updatedAt = nowIso();
+  const p = brainPath(root);
+  fs.writeFileSync(p, JSON.stringify(brain, null, 2));
+}
+
+export function appendEvent(root, event) {
+  const line = JSON.stringify(event);
+  fs.appendFileSync(eventsPath(root), `${line}\n`);
+}
+
+// Read events.log with optional filtering
+export function readEvents(root, opts = {}) {
+  const p = eventsPath(root);
+  if (!fs.existsSync(p)) return [];
+
+  const raw = fs.readFileSync(p, "utf8").trim();
+  if (!raw) return [];
+
+  let events = raw.split("\n").map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+
+  // Filter by type
+  if (opts.type) {
+    events = events.filter((e) => e.type === opts.type);
+  }
+
+  // Filter by since (ISO timestamp)
+  if (opts.since) {
+    events = events.filter((e) => e.at >= opts.since);
+  }
+
+  // Return most recent first, apply limit
+  events.reverse();
+  if (opts.limit && opts.limit > 0) {
+    events = events.slice(0, opts.limit);
+  }
+
+  return events;
+}
+
+export function bumpEvents(brain, eventId) {
+  brain.events.lastEventId = eventId;
+  brain.events.count += 1;
+}
+
+export function addRecentChange(brain, item) {
+  brain.state.recentChanges.unshift(item);
+  if (brain.state.recentChanges.length > 20) {
+    brain.state.recentChanges = brain.state.recentChanges.slice(0, 20);
+  }
+}
+
+export function addRevert(brain, item) {
+  brain.state.reverts.unshift(item);
+}