codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/planned-overlap-actions.js

@@ -0,0 +1,200 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var planned_overlap_actions_exports = {};
+__export(planned_overlap_actions_exports, {
+  OverlapActionError: () => OverlapActionError,
+  approvalNotices: () => approvalNotices,
+  leaveOverlap: () => leaveOverlap,
+  markNoticeSeen: () => markNoticeSeen,
+  noteApproval: () => noteApproval,
+  plannedOverlapNoticeFor: () => plannedOverlapNoticeFor,
+  resequence: () => resequence,
+  tellAgents: () => tellAgents
+});
+module.exports = __toCommonJS(planned_overlap_actions_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_play_forward = require("./play-forward");
+var import_plan_item_service = require("./plan-item-service");
+class OverlapActionError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+}
+const rows = (sql, params = []) => (0, import_database.getDb)().exec(sql, params)[0]?.values ?? [];
+function find(projectRoot, overlapId) {
+  const forward = (0, import_play_forward.buildPlayForward)(projectRoot);
+  const overlap = forward.overlaps.find((o) => o.id === overlapId);
+  if (!overlap) throw new OverlapActionError(404, "No such planned overlap: the plans may have changed since. Play forward again.");
+  return { forward, overlap };
+}
+function record(projectRoot, overlapId, action, words, by, now) {
+  (0, import_database.getDb)().run(
+    "INSERT INTO planned_overlap_decisions (overlap_id, project_root, action, words, by_name, by_type, at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+    [overlapId, projectRoot, action, words, by.author, by.authorType, now]
+  );
+  (0, import_persistence.markDirty)();
+}
+function waitsOn(from, to, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(from)) return false;
+  seen.add(from);
+  for (const d of (0, import_plan_item_service.getItem)(from)?.dependencies ?? []) {
+    if (to.has(d) || waitsOn(d, to, seen)) return true;
+  }
+  return false;
+}
+function resequence(projectRoot, overlapId, firstPlanUid, by, now = Date.now()) {
+  const { overlap } = find(projectRoot, overlapId);
+  const first = overlap.plans.find((p) => p.uid === firstPlanUid);
+  if (!first) throw new OverlapActionError(400, `That plan is not in this planned overlap. Choose one of: ${overlap.plans.map((p) => p.label).join(", ")}.`);
+  const firstTasks = first.tasks.map((t) => t.uid);
+  const later = overlap.plans.filter((p) => p.uid !== firstPlanUid).flatMap((p) => p.tasks);
+  const laterSet = new Set(later.map((t) => t.uid));
+  const loop = firstTasks.find((t) => waitsOn(t, laterSet));
+  if (loop) {
+    throw new OverlapActionError(409, `${first.label} cannot go first: its task "${(0, import_plan_item_service.getItem)(loop)?.title ?? loop}" already waits on the other plan's work, so they would wait on each other.`);
+  }
+  const waiting = [];
+  for (const t of later) {
+    const item = (0, import_plan_item_service.getItem)(t.uid);
+    if (!item) continue;
+    const deps = [.../* @__PURE__ */ new Set([...item.dependencies ?? [], ...firstTasks])];
+    if (deps.length === (item.dependencies ?? []).length) continue;
+    (0, import_plan_item_service.updateItem)(item.uid, {
+      dependencies: deps,
+      author: by.author,
+      authorType: by.authorType,
+      changeSummary: `Waits on ${first.label} (re-sequenced over a planned overlap on ${overlap.subject})`
+    });
+    waiting.push({ uid: item.uid, title: item.title });
+  }
+  const others = overlap.plans.filter((p) => p.uid !== firstPlanUid).map((p) => p.label).join(", ");
+  record(projectRoot, overlapId, "resequence", `${first.label} goes first; ${others} waits`, by, now);
+  return { overlap: find(projectRoot, overlapId).overlap, waiting };
+}
+function tellText(o, sessionTaskUids, by) {
+  const mine = o.plans.flatMap((p) => p.tasks.filter((t) => sessionTaskUids.has(t.uid)).map((t) => `"${t.title}" (${p.label})`));
+  const theirs = o.plans.flatMap((p) => p.tasks.filter((t) => !sessionTaskUids.has(t.uid)).map((t) => `"${t.title}" in ${p.label}`));
+  return [
+    "\u2500\u2500 CodeTrellis: planned overlap \u2500\u2500",
+    `${by} asks you to know: ${o.words.replace(/^◇ planned overlap: /, "")}.`,
+    theirs.length ? `Your ${mine.length === 1 ? "task" : "tasks"} ${mine.join(", ")} and ${theirs.join(", ")} both plan to touch ${o.kind === "material" ? "it" : o.subject}.` : `Your tasks ${mine.join(", ")} all plan to touch ${o.kind === "material" ? "it" : o.subject}.`,
+    `${o.serious ? "This one is serious. " : ""}Agree an order before changing it: get_play_forward shows the plans, and a person can re-sequence them.`
+  ].join("\n");
+}
+function tellAgents(projectRoot, overlapId, by, now = Date.now()) {
+  const { overlap } = find(projectRoot, overlapId);
+  const bySession = /* @__PURE__ */ new Map();
+  const without = [];
+  for (const p of overlap.plans) {
+    for (const t of p.tasks) {
+      const session = (0, import_plan_item_service.getItem)(t.uid)?.assigneeSession ?? null;
+      if (!session) {
+        without.push(t.title);
+        continue;
+      }
+      bySession.set(session, (bySession.get(session) ?? /* @__PURE__ */ new Set()).add(t.uid));
+    }
+  }
+  for (const [session, taskUids] of bySession) {
+    (0, import_database.getDb)().run(
+      `INSERT INTO planned_overlap_tells (overlap_id, session_id, text, created_at, read_at) VALUES (?, ?, ?, ?, NULL)
+       ON CONFLICT(overlap_id, session_id) DO UPDATE SET text = excluded.text, created_at = excluded.created_at, read_at = NULL`,
+      [overlapId, session, tellText(overlap, taskUids, by.author), now]
+    );
+  }
+  const n = bySession.size;
+  record(
+    projectRoot,
+    overlapId,
+    "tell",
+    n === 0 ? "No agent holds these tasks yet: nobody was told" : `Told ${n} ${n === 1 ? "agent" : "agents"}${without.length ? `; ${without.length} ${without.length === 1 ? "task has" : "tasks have"} no agent yet` : ""}`,
+    by,
+    now
+  );
+  return { told: n, tasksWithoutAgent: without };
+}
+function leaveOverlap(projectRoot, overlapId, by, now = Date.now()) {
+  find(projectRoot, overlapId);
+  record(projectRoot, overlapId, "leave", `Left as it is by ${by.author}`, by, now);
+}
+function plannedOverlapNoticeFor(sessionId, now = Date.now()) {
+  try {
+    const unread = rows("SELECT overlap_id, text FROM planned_overlap_tells WHERE session_id = ? AND read_at IS NULL ORDER BY created_at", [sessionId]);
+    if (unread.length === 0) return null;
+    (0, import_database.getDb)().run("UPDATE planned_overlap_tells SET read_at = ? WHERE session_id = ? AND read_at IS NULL", [now, sessionId]);
+    (0, import_persistence.markDirty)();
+    return unread.map((r) => String(r[1])).join("\n\n");
+  } catch (err) {
+    console.warn("[PlayForward] planned overlap notice failed:", err instanceof Error ? err.message : err);
+    return null;
+  }
+}
+function noteApproval(projectRoot, planUid, now = Date.now()) {
+  try {
+    const forward = (0, import_play_forward.buildPlayForward)(projectRoot);
+    const label = forward.plans.find((p) => p.uid === planUid)?.label ?? planUid;
+    const open = forward.overlaps.filter((o) => !o.sequenced && !o.left && o.plans.some((p) => p.uid === planUid));
+    if (open.length === 0) return { overlaps: [], noticeId: null };
+    const words = open.map((o) => o.words);
+    (0, import_database.getDb)().run(
+      "INSERT INTO planned_overlap_notices (project_root, plan_uid, plan_label, words_json, at) VALUES (?, ?, ?, ?, ?)",
+      [projectRoot, planUid, label, JSON.stringify(words), now]
+    );
+    const id = Number(rows("SELECT MAX(id) FROM planned_overlap_notices")[0]?.[0] ?? 0);
+    (0, import_persistence.markDirty)();
+    return { overlaps: words, noticeId: id };
+  } catch (err) {
+    console.warn("[PlayForward] approval notice failed:", err instanceof Error ? err.message : err);
+    return { overlaps: [], noticeId: null };
+  }
+}
+const noticeTitle = (label, n) => `Approving ${label} puts it in ${n === 1 ? "a planned overlap" : `${n} planned overlaps`}`;
+function approvalNotices(projectRoot) {
+  return rows(
+    "SELECT id, plan_uid, plan_label, words_json, at FROM planned_overlap_notices WHERE project_root = ? AND seen_at IS NULL ORDER BY at DESC, id DESC",
+    [projectRoot]
+  ).map((r) => {
+    let overlaps = [];
+    try {
+      overlaps = JSON.parse(String(r[3]));
+    } catch {
+    }
+    return { id: Number(r[0]), planUid: String(r[1]), planLabel: String(r[2]), title: noticeTitle(String(r[2]), overlaps.length), overlaps, at: Number(r[4]) };
+  });
+}
+function markNoticeSeen(projectRoot, id, by, now = Date.now()) {
+  const open = rows("SELECT 1 FROM planned_overlap_notices WHERE id = ? AND project_root = ? AND seen_at IS NULL", [id, projectRoot]).length > 0;
+  if (!open) return false;
+  (0, import_database.getDb)().run("UPDATE planned_overlap_notices SET seen_at = ?, seen_by = ? WHERE id = ?", [now, by.author, id]);
+  (0, import_persistence.markDirty)();
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OverlapActionError,
+  approvalNotices,
+  leaveOverlap,
+  markNoticeSeen,
+  noteApproval,
+  plannedOverlapNoticeFor,
+  resequence,
+  tellAgents
+});

package/src/backend/services/plans-home.js

@@ -0,0 +1,224 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plans_home_exports = {};
+__export(plans_home_exports, {
+  PlansFolderError: () => PlansFolderError,
+  folderWords: () => folderWords,
+  getPlansFolder: () => getPlansFolder,
+  linkPlansFolder: () => linkPlansFolder,
+  linkedPlansHomes: () => linkedPlansHomes,
+  matchesRef: () => matchesRef,
+  namePlansFolder: () => namePlansFolder,
+  normaliseRemote: () => normaliseRemote,
+  plansHome: () => plansHome,
+  projectOfPlansHome: () => projectOfPlansHome,
+  unlinkPlansFolder: () => unlinkPlansFolder
+});
+module.exports = __toCommonJS(plans_home_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_project_config_service = require("./project-config-service");
+var import_cloud_files = require("./cloud-files");
+const MAX_WALK = 2e4;
+function countPlaceholders(home) {
+  let n = 0;
+  let seen = 0;
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (++seen > MAX_WALK) return;
+      const p = import_node_path.default.join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.isFile() && (0, import_cloud_files.isPlaceholder)(p)) n++;
+    }
+  };
+  walk(import_node_path.default.join(home, ".codetrellis"));
+  return n;
+}
+class PlansFolderError extends Error {
+}
+function linkRow(projectRoot) {
+  const db = (0, import_database.getDb)();
+  let v = db.exec(
+    "SELECT local_path, ref, confirmed_at, confirmed_by FROM linked_plans_folder WHERE project_root = ?",
+    [projectRoot]
+  )[0]?.values[0];
+  if (!v) {
+    const want = canonical(projectRoot);
+    if (want) {
+      v = (db.exec("SELECT project_root, local_path, ref, confirmed_at, confirmed_by FROM linked_plans_folder")[0]?.values ?? []).find((r) => canonical(String(r[0])) === want)?.slice(1);
+    }
+  }
+  return v ? { path: String(v[0]), ref: String(v[1]), confirmedAt: Number(v[2]), confirmedBy: String(v[3]) } : null;
+}
+const refKey = (ref) => JSON.stringify(ref);
+function folderWords(ref) {
+  if (ref.kind === "git") return `the planning repository ${normaliseRemote(ref.remote)}`;
+  const provider = ref.provider === "onedrive" ? "OneDrive" : ref.provider === "sharepoint" ? "SharePoint" : "a synced folder";
+  return `${provider}: ${ref.place}`;
+}
+function stateOf(projectRoot) {
+  const named = (0, import_project_config_service.getProjectConfig)(projectRoot).plans?.folder ?? null;
+  const row = linkRow(projectRoot);
+  if (!named) return { named, state: "here", row };
+  if (!row) return { named, state: "unlinked", row };
+  if (row.ref !== refKey(named)) return { named, state: "changed", row };
+  let dir = false;
+  try {
+    dir = import_node_fs.default.statSync(row.path).isDirectory();
+  } catch {
+  }
+  return { named, state: dir ? "linked" : "missing", row };
+}
+function plansHome(projectRoot) {
+  const { state, row } = stateOf(projectRoot);
+  if (state === "here") return projectRoot;
+  return state === "linked" ? row.path : null;
+}
+function projectOfPlansHome(dir) {
+  const canon = canonical(dir);
+  if (!canon) return null;
+  for (const r of (0, import_database.getDb)().exec("SELECT project_root, local_path FROM linked_plans_folder")[0]?.values ?? []) {
+    if (canonical(String(r[1])) === canon && plansHome(String(r[0])) !== null) return String(r[0]);
+  }
+  return null;
+}
+function linkedPlansHomes() {
+  return ((0, import_database.getDb)().exec("SELECT project_root FROM linked_plans_folder")[0]?.values ?? []).map((r) => String(r[0])).map((project) => ({ project, home: plansHome(project) })).filter((x) => !!x.home && x.home !== x.project);
+}
+function getPlansFolder(projectRoot) {
+  const { named, state, row } = stateOf(projectRoot);
+  const linked = row && state !== "unlinked" ? { path: row.path, confirmedAt: row.confirmedAt, confirmedBy: row.confirmedBy } : null;
+  const where = named ? folderWords(named) : "";
+  const says = {
+    here: "This project's plans live in the project itself, under .codetrellis/plans.",
+    linked: `This project's plans live in ${where}. On this device that is ${row?.path}.`,
+    unlinked: `This project's plans live in ${where}. Link your copy of it on this device to see them; until then nothing there is read.`,
+    changed: `The project now names ${where} for its plans, not the folder linked on this device. Link your copy of it; until then nothing is read.`,
+    missing: `This project's plans live in ${where}, linked on this device at ${row?.path}, which is not there now. Nothing is read until it is back or linked again.`
+  }[state];
+  const home = state === "linked" ? row.path : state === "here" ? projectRoot : null;
+  const notOnDevice = home ? countPlaceholders(home) : 0;
+  const roots = (0, import_cloud_files.cloudRoots)();
+  const found = named?.kind === "synced" && named.provider !== "folder" && state !== "linked" ? (0, import_cloud_files.findPlace)(named.provider, named.place, roots) : null;
+  const keep = notOnDevice ? ` ${notOnDevice} ${notOnDevice === 1 ? "file in it is" : "files in it are"} not on this device yet and ${notOnDevice === 1 ? "is" : "are"} not read until ${notOnDevice === 1 ? "it is" : "they are"}: set the folder to "Always keep on this device" in OneDrive.` : "";
+  return { project: projectRoot, named, state, linked, says: says + keep, roots, found, notOnDevice };
+}
+function namePlansFolder(projectRoot, ref) {
+  (0, import_project_config_service.updateProjectConfig)(projectRoot, { plans: { folder: ref ?? void 0 } });
+  return getPlansFolder(projectRoot);
+}
+function canonical(p) {
+  try {
+    return import_node_fs.default.realpathSync.native(import_node_path.default.resolve(p));
+  } catch {
+    return null;
+  }
+}
+function normaliseRemote(remote) {
+  let r = remote.trim();
+  const scp = /^[^@/\s]+@([^:/\s]+):(.+)$/.exec(r);
+  if (scp) r = `${scp[1]}/${scp[2]}`;
+  else r = r.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/^[^@/]*@/, "");
+  r = r.replace(/\.git\/?$/i, "").replace(/\/+$/, "");
+  const slash = r.indexOf("/");
+  return slash < 0 ? r.toLowerCase() : r.slice(0, slash).toLowerCase() + r.slice(slash);
+}
+function remotesOf(dir) {
+  try {
+    const out = (0, import_node_child_process.execFileSync)("git", ["-C", dir, "remote", "-v"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 });
+    return [...new Set(out.split("\n").map((l) => l.split(/\s+/)[1]).filter((x) => !!x))];
+  } catch {
+    return [];
+  }
+}
+function matchesRef(dir, ref) {
+  if (ref.kind === "git") {
+    const want = normaliseRemote(ref.remote);
+    const have = remotesOf(dir);
+    if (have.length === 0) return { ok: false, why: "it is not a git repository with a remote" };
+    return have.some((r) => normaliseRemote(r) === want) ? { ok: true } : { ok: false, why: `its remote is ${normaliseRemote(have[0])}, not ${want}` };
+  }
+  const tail = ref.place.split("/");
+  const segs = dir.split(/[\\/]/).filter(Boolean);
+  const same = (a, b) => process.platform === "linux" ? a === b : a.toLowerCase() === b.toLowerCase();
+  const ends = segs.length >= tail.length && tail.every((t, i) => same(segs[segs.length - tail.length + i], t));
+  return ends ? { ok: true } : { ok: false, why: `it is not a folder named ${ref.place}` };
+}
+function linkPlansFolder(projectRoot, localPath, by) {
+  const named = (0, import_project_config_service.getProjectConfig)(projectRoot).plans?.folder;
+  if (!named) throw new PlansFolderError("This project keeps its plans in the project itself, so there is no folder to link.");
+  if (typeof localPath !== "string" || !import_node_path.default.isAbsolute(localPath)) throw new PlansFolderError("Choose the folder on this device: a full path.");
+  const dir = canonical(localPath);
+  if (!dir) throw new PlansFolderError(`${localPath} is not on this device.`);
+  let isDir = false;
+  try {
+    isDir = import_node_fs.default.statSync(dir).isDirectory();
+  } catch {
+  }
+  if (!isDir) throw new PlansFolderError(`${localPath} is not a folder.`);
+  const project = canonical(projectRoot);
+  if (project && dir === project) throw new PlansFolderError("That is the project itself. Choose your copy of the plans folder.");
+  const match = matchesRef(dir, named);
+  if (!match.ok) throw new PlansFolderError(`${localPath} is not ${folderWords(named)}: ${match.why}.`);
+  (0, import_database.getDb)().run(
+    `INSERT INTO linked_plans_folder (project_root, local_path, ref, confirmed_at, confirmed_by) VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(project_root) DO UPDATE SET local_path = excluded.local_path, ref = excluded.ref,
+       confirmed_at = excluded.confirmed_at, confirmed_by = excluded.confirmed_by`,
+    [projectRoot, dir, refKey(named), Date.now(), by]
+  );
+  (0, import_persistence.markDirty)();
+  return getPlansFolder(projectRoot);
+}
+function unlinkPlansFolder(projectRoot) {
+  (0, import_database.getDb)().run("DELETE FROM linked_plans_folder WHERE project_root = ?", [projectRoot]);
+  (0, import_persistence.markDirty)();
+  return getPlansFolder(projectRoot);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlansFolderError,
+  folderWords,
+  getPlansFolder,
+  linkPlansFolder,
+  linkedPlansHomes,
+  matchesRef,
+  namePlansFolder,
+  normaliseRemote,
+  plansHome,
+  projectOfPlansHome,
+  unlinkPlansFolder
+});