projectstore-codex 0.28.2 → 0.29.0

package/node_modules/projectstore/scripts/term.mjs

@@ -0,0 +1,147 @@
+// projectstore — term.mjs: terminal presentation for the write verbs, with no
+// dependency (the zero-dependency property the MCP and link-graph ADRs keep).
+//
+// One question decides everything here: is this a person at a terminal? Then
+// colour and in-place step lines. Otherwise — a pipe, an agent's tool call,
+// CI — the same layout as plain text, so a reader that is not a terminal loses
+// nothing but the escapes (install spec, contract 18).
+//
+//   caps(stream, env)            → { color, live, width, ascii }
+//   painter(caps)                → paint(style, text)
+//   icon(caps, name)             → the glyph for an action or a result
+//   duration(ms)                 → "0.4s", "12s", "1m 03s"
+//   wrap(text, width, indent)    → prose broken at spaces, hanging indent
+//   stepReporter(stream, caps)   → { start(label), end(ok, note), abort() }
+//   askLine(question, in, out)   → the answer, or null on end of input
+
+import { createInterface } from "node:readline/promises";
+
+// FORCE_COLOR decides when it is set, as Node's own tty reads it: "", "1",
+// "2", "3" or "true" turn colour on even without a terminal, anything else
+// ("0", "false") turns it off. Otherwise NO_COLOR (https://no-color.org) turns
+// colour off when set to anything non-empty, and TERM=dumb means a terminal
+// that understands no escapes.
+export function caps(stream = process.stdout, env = process.env) {
+  const tty = Boolean(stream && stream.isTTY);
+  const dumb = env.TERM === "dumb";
+  const off = env.NO_COLOR !== undefined && env.NO_COLOR !== "";
+  const color = env.FORCE_COLOR !== undefined ? ["", "1", "2", "3", "true"].includes(String(env.FORCE_COLOR)) : tty && !dumb && !off;
+  const columns = tty && Number(stream.columns) > 0 ? Number(stream.columns) : 100;
+  // `width` lays out prose (never below 40); `columns` is the terminal's
+  // real width, which a live line must not reach.
+  return { color, live: tty && !dumb, width: Math.max(40, Math.min(columns, 120)), columns, ascii: dumb };
+}
+
+const SGR = {
+  bold: [1, 22], dim: [2, 22], red: [31, 39], green: [32, 39], yellow: [33, 39],
+  blue: [34, 39], magenta: [35, 39], cyan: [36, 39], gray: [90, 39],
+};
+
+// Raw SGR rather than util.styleText: that arrived in Node 20.12 and 21.7, and
+// the package promises >=20.0.0.
+export function painter(c) {
+  return (style, text) => {
+    const s = String(text);
+    if (!c.color || !SGR[style] || !s) return s;
+    return `\x1b[${SGR[style][0]}m${s}\x1b[${SGR[style][1]}m`;
+  };
+}
+
+const ICONS = {
+  create: ["+", "+"], update: ["↻", "~"], migrate: ["↻", "~"], refresh: ["↻", "~"],
+  remove: ["✕", "x"], cleanup: ["✕", "x"], skip: ["·", "."], refuse: ["!", "!"],
+  ok: ["✓", "ok"], fail: ["✗", "FAIL"], running: ["…", "..."], note: ["!", "!"],
+};
+export function icon(c, name) {
+  const pair = ICONS[name] || ICONS.update;
+  return c.ascii ? pair[1] : pair[0];
+}
+
+export function duration(ms) {
+  if (ms < 10_000) return `${(ms / 1000).toFixed(1)}s`;
+  if (ms < 60_000) return `${Math.round(ms / 1000)}s`;
+  const m = Math.floor(ms / 60_000), s = Math.round((ms % 60_000) / 1000);
+  return `${m}m ${String(s).padStart(2, "0")}s`;
+}
+
+// Strip SGR escapes — for measuring a painted string and for tests.
+export const plain = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, "");
+
+// Prose only: broken at spaces to `width` columns, every line after the first
+// indented by `indent`. A word longer than the line — a path, a command — is
+// never broken: a path cut in two cannot be copied back. Width 0 is a reader
+// that is not a terminal: nothing is broken, so a search never meets a split.
+export function wrap(text, width, indent = "") {
+  if (!width) return String(text);
+  const room = Math.max(20, width - indent.length);
+  const lines = [];
+  let line = "";
+  for (const word of String(text).split(" ")) {
+    if (line && plain(line).length + 1 + plain(word).length > room) { lines.push(line); line = word; }
+    else line = line ? `${line} ${word}` : word;
+  }
+  lines.push(line);
+  return lines.map((l, k) => (k ? indent + l : l)).join("\n");
+}
+
+// A live line must fit one physical row: "\r\x1b[2K" clears only the row the
+// cursor is on, so a label that wrapped would leave its first half behind.
+const fit = (text, room) => (text.length <= room ? text : text.slice(0, Math.max(1, room - 1)) + "…");
+
+// One line per step. On a live terminal the line appears when the step starts
+// (ending in "…") and is rewritten in place with the result and duration when
+// it ends; anything else gets the finished line only. Steps run synchronously
+// (spawnSync), so nothing animates in between — the "…" is the honest state.
+export function stepReporter(stream = process.stdout, c = caps(stream), { indent = 2 } = {}) {
+  const paint = painter(c);
+  let open = null;
+  // One column short of the terminal: a line that fills the last column
+  // leaves some terminals waiting to wrap.
+  const width = Math.min(c.width, c.columns || c.width, 100) - 1;
+  const line = (mark, label, right) => {
+    const room = width - indent - 2 - plain(right).length - 1;
+    const left = `${" ".repeat(indent)}${mark} ${c.live ? fit(label, room) : label}`;
+    const gap = Math.max(1, width - plain(left).length - plain(right).length);
+    return left + " ".repeat(gap) + right;
+  };
+  const self = {
+    start(label) {
+      // A step started while another is still open (a host command run by a
+      // rollback) closes the open line where it stands rather than overwrite it.
+      if (open && c.live) stream.write("\n");
+      open = { label, t0: Date.now() };
+      if (c.live) stream.write(line(paint("gray", icon(c, "running")), label, ""));
+    },
+    end(ok = true, note = "", { kept = false } = {}) {
+      if (!open) return;
+      const ms = Date.now() - open.t0;
+      // A step that ran and left its target in place is neither ✓ nor ✗.
+      const mark = !ok ? paint("red", icon(c, "fail")) : kept ? paint("gray", icon(c, "skip")) : paint("green", icon(c, "ok"));
+      const right = paint("gray", [note, duration(ms)].filter(Boolean).join("  "));
+      const text = line(mark, open.label, right);
+      stream.write((c.live ? "\r\x1b[2K" : "") + text + "\n");
+      open = null;
+    },
+    // An exception left a step open: end its line as failed, so whatever is
+    // printed next starts on a line of its own.
+    abort() { if (open) self.end(false); },
+  };
+  return self;
+}
+
+// One line of input, read the way a shell's own prompt is: in the terminal's
+// line mode, so readline writes nothing but the question (no cursor escapes),
+// the terminal does the editing, and Ctrl+C is a real SIGINT (exit 130, before
+// anything is written). End of input — Ctrl+D, a closed pipe — is null, which
+// every caller reads as no; it never leaves the question pending (an unsettled
+// promise is exit 13 with a warning). The promise API rejects on close in
+// some Node versions and stays pending in others; both settle here.
+export async function askLine(question, input, output) {
+  const rl = createInterface({ input, output, terminal: false });
+  return await new Promise((settle) => {
+    let done = false;
+    const finish = (answer) => { if (done) return; done = true; settle(answer); rl.close(); };
+    rl.on("close", () => finish(null));
+    rl.question(question).then((a) => finish(a), () => finish(null));
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "projectstore-codex",
-  "version": "0.28.2",
+  "version": "0.29.0",
   "description": "ProjectStore for Codex: portable project memory, rendered workflow skills and lifecycle hooks, with the core pinned and bundled.",
   "keywords": [
     "projectstore",
@@ -40,7 +40,7 @@
     "hooks/"
   ],
   "dependencies": {
-    "projectstore": "=0.28.2"
+    "projectstore": "=0.29.0"
   },
   "bundleDependencies": [
     "projectstore"

package/skills/projectstore-agents/SKILL.md

@@ -26,10 +26,11 @@ You are managing ProjectStore's Codex agent integration. Require a bound project
 
 ## register / unregister
 
-Preview the requested change and ask for explicit approval. On approval, run the
-core's `install` or `uninstall` verb with `--harness codex --surface
-agents_block --project "$PWD"`. Print its output verbatim. Never edit the
-managed block by hand.
+Preview the requested change with `plan --harness codex --surface agents_block
+--project "$PWD"` and ask for explicit approval. On approval, run the core's
+`install` or `uninstall` verb with `--harness codex --surface agents_block
+--project "$PWD" --json` — `--json` never waits on a terminal's question — and
+report the envelope's result. Never edit the managed block by hand.
 
 ## status
 

package/skills/projectstore-doctor/SKILL.md

@@ -28,6 +28,8 @@ arguments and `--json`. Summarize every finding without re-deriving it.
 When `--fix` is absent, remain read-only. When it is present, separate fixes
 by owner: derived vault views use `$projectstore-reconcile`; Codex plugin or
 agents-block drift uses the core's `upgrade --harness codex` path. Preview
-each mutation and ask for explicit approval before running it. Unsupported
+each mutation with `plan --harness codex` and ask for explicit approval before
+running it; then run `upgrade --harness codex --json`, whose envelope is the
+result — `--json` never waits on a terminal's question. Unsupported
 surfaces remain unsupported; do not create host configuration by hand. Never
 claim a fix after a non-zero exit.