clay-server 4.0.0-beta.8 → 4.0.0

package/lib/project-log-context.js

@@ -0,0 +1,172 @@
+// Stable project knowledge and Git worktree change-set identities.
+//
+// Existing projects freeze their current path-derived scope so every opaque
+// log ref remains valid. New projects receive a path-independent id. A linked
+// worktree stores its generated change-set marker in Git's administrative
+// directory, which survives daemon restarts and branch renames but disappears
+// with the worktree itself; the durable log records retain the id afterward.
+
+var crypto = require("crypto");
+var fs = require("fs");
+var path = require("path");
+var { runGitSync } = require("./git-cli");
+var { fsAsUser } = require("./os-users");
+var logsRoot = require("./project-logs-root");
+var utils = require("./utils");
+
+var ID_PATTERN = /^[A-Za-z0-9_-]{1,120}$/;
+
+function newId(prefix) {
+  return prefix + "_" + crypto.randomBytes(16).toString("base64url");
+}
+
+function validId(value, prefix) {
+  return typeof value === "string" && ID_PATTERN.test(value) && (!prefix || value.indexOf(prefix + "_") === 0);
+}
+
+function legacyKnowledgeId(cwd) {
+  return utils.encodeCwd(logsRoot.resolveProjectRoot(cwd));
+}
+
+function ensureProjectKnowledgeId(project) {
+  if (!project || typeof project !== "object") return false;
+  if (validId(project.projectKnowledgeId)) return false;
+  project.projectKnowledgeId = project.path ? legacyKnowledgeId(project.path) : newId("pk");
+  return true;
+}
+
+function initializeProjectKnowledge(config) {
+  var changed = false;
+  var projects = config && Array.isArray(config.projects) ? config.projects : [];
+  for (var i = 0; i < projects.length; i++) {
+    if (ensureProjectKnowledgeId(projects[i])) changed = true;
+  }
+  return changed;
+}
+
+function createProjectKnowledgeId() {
+  return newId("pk");
+}
+
+function git(cwd, args, osUserInfo) {
+  return runGitSync(cwd, args, null, osUserInfo).trim();
+}
+
+function commit(cwd, ref, osUserInfo) {
+  try { return git(cwd, ["rev-parse", ref || "HEAD"], osUserInfo); }
+  catch (e) { return null; }
+}
+
+function markerPath(cwd, osUserInfo) {
+  try {
+    var gitDir = git(cwd, ["rev-parse", "--git-dir"], osUserInfo);
+    return path.join(path.resolve(cwd, gitDir), "clay-change-set.json");
+  } catch (e) {
+    return null;
+  }
+}
+
+function readMarker(filePath, knowledgeId) {
+  if (!filePath) return null;
+  try {
+    var parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (!parsed || parsed.projectKnowledgeId !== knowledgeId || !validId(parsed.changeSetId, "cs")) return null;
+    return parsed;
+  } catch (e) {
+    return null;
+  }
+}
+
+function deterministicFallback(knowledgeId, cwd) {
+  var digest = crypto.createHash("sha256").update(knowledgeId + "\u0000" + logsRoot.canonicalPath(cwd)).digest("base64url");
+  return "cs_" + digest.substring(0, 22);
+}
+
+function writeMarker(filePath, marker, osUserInfo) {
+  var content = JSON.stringify(marker, null, 2) + "\n";
+  if (osUserInfo) {
+    fsAsUser("write", { file: filePath, content: content, flag: "wx", mode: 0o600 }, osUserInfo);
+    return;
+  }
+  fs.writeFileSync(filePath, content, { flag: "wx", mode: 0o600 });
+}
+
+function resolveWorktreeContext(cwd, knowledgeId, details, osUserInfo) {
+  var input = details || {};
+  var filePath = markerPath(cwd, osUserInfo);
+  var marker = readMarker(filePath, knowledgeId);
+  if (!marker) {
+    marker = {
+      projectKnowledgeId: knowledgeId,
+      changeSetId: newId("cs"),
+      baseCommit: input.baseCommit || null,
+      createdAt: Date.now(),
+    };
+    if (filePath) {
+      try {
+        writeMarker(filePath, marker, osUserInfo);
+      } catch (e) {
+        marker = readMarker(filePath, knowledgeId) || marker;
+      }
+    }
+  }
+  if (!filePath || !readMarker(filePath, knowledgeId)) {
+    marker.changeSetId = deterministicFallback(knowledgeId, cwd);
+  }
+  return {
+    kind: "worktree",
+    changeSetId: marker.changeSetId,
+    branch: input.branch || null,
+    baseCommit: marker.baseCommit || input.baseCommit || null,
+    headCommit: commit(cwd, "HEAD", osUserInfo),
+    status: "active",
+  };
+}
+
+function isMerged(parentCwd, worktreeCwd, osUserInfo) {
+  var head = commit(worktreeCwd, "HEAD", osUserInfo);
+  if (!head) return false;
+  try {
+    runGitSync(parentCwd, ["merge-base", "--is-ancestor", head, "HEAD"], null, osUserInfo);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function cleanCommit(value) {
+  return typeof value === "string" && /^[0-9a-f]{7,64}$/i.test(value) ? value : null;
+}
+
+function cleanBranch(value) {
+  if (typeof value !== "string") return null;
+  var cleaned = value.trim().substring(0, 200);
+  return cleaned && cleaned.indexOf("\n") === -1 && cleaned.indexOf("\r") === -1 ? cleaned : null;
+}
+
+function normalizeRecordContext(value) {
+  if (!value || value.kind !== "worktree" || !validId(value.changeSetId, "cs")) {
+    return { kind: "project", changeSetId: null, branch: null, baseCommit: null, headCommit: null, status: "active" };
+  }
+  return {
+    kind: "worktree",
+    changeSetId: value.changeSetId,
+    branch: cleanBranch(value.branch),
+    baseCommit: cleanCommit(value.baseCommit),
+    headCommit: cleanCommit(value.headCommit),
+    status: value.status === "merged" || value.status === "archived" ? value.status : "active",
+  };
+}
+
+module.exports = {
+  ID_PATTERN: ID_PATTERN,
+  validId: validId,
+  legacyKnowledgeId: legacyKnowledgeId,
+  ensureProjectKnowledgeId: ensureProjectKnowledgeId,
+  initializeProjectKnowledge: initializeProjectKnowledge,
+  createProjectKnowledgeId: createProjectKnowledgeId,
+  resolveWorktreeContext: resolveWorktreeContext,
+  commit: commit,
+  isMerged: isMerged,
+  normalizeRecordContext: normalizeRecordContext,
+};

package/lib/project-log-feedback-delivery.js

@@ -0,0 +1,118 @@
+// Deliver new Project Log comments to the session responsible for the
+// canonical entry. A busy Driver gets an isolated hidden reviewer so feedback
+// never waits behind unrelated work in the visible conversation.
+
+function attachProjectLogFeedbackDelivery(ctx) {
+  var sm = ctx.sm;
+  var getSdk = ctx.getSdk;
+  var onProcessingChanged = ctx.onProcessingChanged || function () {};
+  var getLinuxUserForSession = ctx.getLinuxUserForSession || function () { return null; };
+
+  function sessionForAuthor(author) {
+    if (!author || author.type !== "session" || !author.sessionKey) return null;
+    var match = null;
+    sm.sessions.forEach(function (session) {
+      if (match || !session || session.destroying || session.hidden) return;
+      if (session.cliSessionId !== author.sessionKey && "local:" + session.localId !== author.sessionKey) return;
+      if ((session.ownerId || null) !== (author.userId || null)) return;
+      if (sm.sessions.get(session.localId) !== session) return;
+      match = session;
+    });
+    return match;
+  }
+
+  function findAuthorSession(entry) {
+    return sessionForAuthor(entry && entry.updatedBy) || sessionForAuthor(entry && entry.createdBy);
+  }
+
+  function startImmediateReviewer(source, entry, text, sdk) {
+    if (!sm.createSessionRaw || !sm.deleteSessionQuiet) return false;
+    var reviewer = sm.createSessionRaw({
+      ownerId: source.ownerId || null,
+      sessionVisibility: "private",
+      vendor: source.vendor || null,
+      model: source.model || null,
+      effort: source.effort || null,
+      permissionMode: source.permissionMode || null,
+    });
+    reviewer.hidden = true;
+    reviewer.title = "Project Log review";
+    reviewer.singleTurn = true;
+    reviewer.projectLogReview = { ref: entry.ref };
+    reviewer.isProcessing = true;
+    reviewer.sentToolResults = {};
+    reviewer.onQueryComplete = function () {
+      setImmediate(function () { sm.deleteSessionQuiet(reviewer.localId); });
+    };
+    sm.sendAndRecord(reviewer, {
+      type: "user_message",
+      text: text,
+      _internal: true,
+      projectLogFeedback: true,
+      projectLogRef: entry.ref,
+    });
+    Promise.resolve(sdk.startQuery(reviewer, text, null, getLinuxUserForSession(reviewer))).catch(function (error) {
+      reviewer.isProcessing = false;
+      sm.sendAndRecord(reviewer, {
+        type: "error",
+        text: "Could not review Project Log feedback: " + (error.message || String(error)),
+        _internal: true,
+      });
+      sm.deleteSessionQuiet(reviewer.localId);
+    });
+    return true;
+  }
+
+  function feedbackPrompt(entry) {
+    return "[Project Log feedback]\n" +
+      "A user added a comment to " + entry.ref + ". Review the pending feedback now with list_log_feedback, " +
+      "then resolve this specific comment through review_log_comment. Apply supported corrections to the canonical " +
+      "entry; otherwise clarify or decline with a concise reason. Do not treat this internal notification as user " +
+      "chat or answer it only in the conversation.\n" +
+      "[End Project Log feedback]";
+  }
+
+  function deliver(entry) {
+    if (!entry || !entry.ref || !entry.pendingFeedbackCount) return false;
+    var session = findAuthorSession(entry);
+    var sdk = getSdk();
+    if (!session || !sdk) return false;
+    var text = feedbackPrompt(entry);
+    if (session.isProcessing && startImmediateReviewer(session, entry, text, sdk)) return true;
+    sm.sendAndRecord(session, {
+      type: "user_message",
+      text: text,
+      _internal: true,
+      projectLogFeedback: true,
+      projectLogRef: entry.ref,
+    });
+    session.lastActivity = Date.now();
+    if (!session.isProcessing) {
+      session.isProcessing = true;
+      session.sentToolResults = {};
+      onProcessingChanged();
+      sm.sendToSession(session, { type: "status", status: "processing" });
+    }
+    if (!sdk.pushMessage(session, text)) {
+      session._queryStartTs = Date.now();
+      Promise.resolve(sdk.startQuery(session, text, null, getLinuxUserForSession(session))).catch(function (error) {
+        session.isProcessing = false;
+        sm.sendAndRecord(session, {
+          type: "error",
+          text: "Could not deliver Project Log feedback: " + (error.message || String(error)),
+          _internal: true,
+        });
+        onProcessingChanged();
+      });
+    }
+    sm.broadcastSessionList();
+    return true;
+  }
+
+  return {
+    deliver: deliver,
+    findAuthorSession: findAuthorSession,
+  };
+}
+
+module.exports = { attachProjectLogFeedbackDelivery: attachProjectLogFeedbackDelivery };

package/lib/project-logs-comments.js

@@ -0,0 +1,137 @@
+// Comment and review projection for Project Logs.
+//
+// Split from project-logs-store.js so the store stays inside the module size
+// limit.
+//
+// A user comment is a revision proposal, never an automatic canonical
+// mutation. It starts `pending` and stays that way until the project's own
+// Driver session reviews it. Reviews are append-only records that reference a
+// comment id; nothing is ever edited in place, and a comment written before
+// reviews existed simply projects as `pending`.
+
+var STATUS_PENDING = "pending";
+var STATUS_CLARIFICATION = "clarification-needed";
+var STATUS_INCORPORATED = "incorporated";
+var STATUS_DECLINED = "declined";
+
+var STATUSES = [STATUS_PENDING, STATUS_CLARIFICATION, STATUS_INCORPORATED, STATUS_DECLINED];
+
+// Actions the Driver may take. `incorporate` is the only one that produces a
+// canonical revision.
+var ACTIONS = ["incorporate", "clarify", "decline"];
+
+var ACTION_STATUS = {
+  incorporate: STATUS_INCORPORATED,
+  clarify: STATUS_CLARIFICATION,
+  decline: STATUS_DECLINED,
+};
+
+// Waiting on the Driver. Only an unreviewed comment qualifies.
+//
+// A clarification is deliberately NOT Driver work: the Driver has already
+// answered, and the ball is with the user. Because a comment is settled once
+// and never re-reviewed, counting a clarification as pending would leave it in
+// the queue forever with no way out. The user's reply is a new comment, which
+// is pending in its own right and can be incorporated or declined.
+function isPendingReview(status) {
+  return status === STATUS_PENDING;
+}
+
+// Answered by the Driver and now waiting on the person who commented. Shown
+// permanently on the original comment; never counted as Driver work.
+function isAwaitingUser(status) {
+  return status === STATUS_CLARIFICATION;
+}
+
+function isAction(value) {
+  return ACTIONS.indexOf(value) !== -1;
+}
+
+// Project the comment thread of one entry, folding review records onto the
+// comments they resolve. `revisionForRecordId` maps an incorporating review
+// record id to the canonical revision number it produced, so an incorporated
+// comment can point at its result.
+function comments(chain, options) {
+  var settings = options || {};
+  var maxComments = settings.maxComments || 200;
+  var revisionForRecordId = settings.revisionForRecordId || {};
+  var byId = {};
+  var order = [];
+
+  var i;
+  for (i = 0; i < chain.length; i++) {
+    var record = chain[i];
+    if (record.op !== "comment") continue;
+    if (order.length >= maxComments) break;
+    var comment = {
+      id: record.id,
+      body: record.body || "",
+      at: record.at || 0,
+      author: record.author || null,
+      // A comment with no review yet is pending, which is also how every
+      // comment written before reviews existed projects.
+      status: STATUS_PENDING,
+      review: null,
+    };
+    byId[record.id] = comment;
+    order.push(comment);
+  }
+
+  for (i = 0; i < chain.length; i++) {
+    var review = chain[i];
+    if (review.op !== "review") continue;
+    var target = byId[review.commentId];
+    if (!target) continue;
+    if (!isAction(review.action)) continue;
+    // Append-only: the first review of a comment settles it. A later review of
+    // the same comment is ignored rather than silently overwriting the record
+    // of what was decided.
+    if (target.review) continue;
+    target.status = ACTION_STATUS[review.action];
+    target.review = {
+      action: review.action,
+      response: typeof review.response === "string" ? review.response : "",
+      at: review.at || 0,
+      reviewer: review.author || null,
+      revision: review.action === "incorporate"
+        ? (revisionForRecordId[review.id] || null)
+        : null,
+    };
+  }
+
+  return order;
+}
+
+// How many comments are still waiting on the Driver. Used for the ledger row
+// count and for the system-prompt signal, neither of which carries any body.
+function pendingReviewCount(list) {
+  var count = 0;
+  for (var i = 0; i < (list || []).length; i++) {
+    if (isPendingReview(list[i].status)) count++;
+  }
+  return count;
+}
+
+function pendingReviewComments(list) {
+  var out = [];
+  for (var i = 0; i < (list || []).length; i++) {
+    if (isPendingReview(list[i].status)) out.push(list[i]);
+  }
+  return out;
+}
+
+module.exports = {
+  STATUS_PENDING: STATUS_PENDING,
+  STATUS_CLARIFICATION: STATUS_CLARIFICATION,
+  STATUS_INCORPORATED: STATUS_INCORPORATED,
+  STATUS_DECLINED: STATUS_DECLINED,
+  STATUSES: STATUSES,
+  ACTIONS: ACTIONS,
+  ACTION_STATUS: ACTION_STATUS,
+  isPendingReview: isPendingReview,
+  isAwaitingUser: isAwaitingUser,
+  isAction: isAction,
+  comments: comments,
+  pendingReviewCount: pendingReviewCount,
+  pendingReviewComments: pendingReviewComments,
+};

package/lib/project-logs-context-state.js

@@ -0,0 +1,42 @@
+// Append-only lifecycle projection for worktree-scoped Project Log entries.
+
+var recordStore = require("./knowledge-record-store");
+var logContext = require("./project-log-context");
+
+function attachContextState(store, scopeId) {
+  function states() {
+    var out = {};
+    var records = store.all();
+    for (var i = 0; i < records.length; i++) {
+      var record = records[i];
+      if (record.op !== "context-state" || !record.changeSetId) continue;
+      if (record.status !== "archived" && record.status !== "merged" && record.status !== "active") continue;
+      out[record.changeSetId] = record.status;
+    }
+    return out;
+  }
+
+  function set(context, status) {
+    var normalized = logContext.normalizeRecordContext(context);
+    if (!normalized.changeSetId) return false;
+    if (status !== "active" && status !== "archived" && status !== "merged") {
+      throw new Error("Invalid Project Log change-set status.");
+    }
+    if (states()[normalized.changeSetId] === status) return false;
+    store.append({
+      id: recordStore.newRecordId(),
+      rootId: "context-" + normalized.changeSetId,
+      op: "context-state",
+      scope: scopeId,
+      changeSetId: normalized.changeSetId,
+      status: status,
+      context: normalized,
+      at: Date.now(),
+    });
+    return true;
+  }
+
+  return { states: states, set: set };
+}
+
+module.exports = { attachContextState: attachContextState };