youiyoux 0.1.2 → 0.1.3

package/dist/chunks/{src-7ENJHYG4.js → chunk-OIHNEGWH.js}

@@ -1,5 +1,6 @@
 import { createRequire as __youiRequire } from "node:module"; const require = __youiRequire(import.meta.url);
 import {
+  PICTURE_SCALE,
   SCANNER_VERSION,
   buildTokens,
   checkInputFor,
@@ -12,10 +13,10 @@ import {
   ruleCapability,
   runChecks,
   scanProject,
+  screenSlug,
   systemPairs,
   tokenImpact
-} from "./chunk-3ZHGONNA.js";
-import "./chunk-S7UV34H5.js";
+} from "./chunk-L5BV4PI7.js";
 import {
   BUILT_IN_CHECKS,
   COMPONENT_STATES,
@@ -23,6 +24,10 @@ import {
   ElementId,
   LIBRARY_DIR,
   LibraryEntry,
+  REQUEST_ID,
+  REQUEST_STATUSES,
+  RequestDoc,
+  RequestTarget,
   RuleCheck,
   RuleRollout,
   RuleSpec,
@@ -38,7 +43,7 @@ import {
   toPosix,
   tokenValueProblems,
   writeFileAtomic
-} from "./chunk-ZLRFD5JI.js";
+} from "./chunk-C3TSTYP7.js";
 import {
   __toESM
 } from "./chunk-E4HNK7VF.js";
@@ -805,7 +810,7 @@ import { readFile as readFile2, stat } from "node:fs/promises";
 import { extname, join as join3, normalize, resolve, sep } from "node:path";
 
 // ../workflow/src/policy.ts
-var PERSON_ONLY = /* @__PURE__ */ new Set(["approve", "handoff"]);
+var PERSON_ONLY = /* @__PURE__ */ new Set(["approve", "handoff", "close"]);
 var WorkflowError = class extends Error {
   name = "WorkflowError";
   code;
@@ -817,7 +822,7 @@ var WorkflowError = class extends Error {
   }
 };
 function authorize(actor, action) {
-  if (PERSON_ONLY.has(action) && actor.kind !== "person") throw new WorkflowError("forbidden", `an ${actor.kind} cannot ${action}: approving a design change is a person's decision`);
+  if (PERSON_ONLY.has(action) && actor.kind !== "person") throw new WorkflowError("forbidden", action === "close" ? `an ${actor.kind} cannot close or reopen a request: mark it addressed, and a person closes it` : `an ${actor.kind} cannot ${action}: approving a design change is a person's decision`);
 }
 
 // ../workflow/src/http.ts
@@ -846,6 +851,9 @@ var CreateInput = external_exports.union([
   external_exports.discriminatedUnion("mode", [external_exports.object({ kind: external_exports.literal("rule").optional(), mode: external_exports.literal("edit"), ruleId: ElementId }), external_exports.object({ kind: external_exports.literal("rule").optional(), mode: external_exports.literal("create") })])
 ]);
 var SaveInput = external_exports.object({ revision: external_exports.number().int().positive(), content: external_exports.union([DraftContentInput, StyleContentInput, LibraryContentInput]) });
+var RequestInput = external_exports.object({ kind: external_exports.enum(["comment", "change"]), body: external_exports.string().min(1).max(4e3), target: RequestTarget });
+var ReplyInput = external_exports.object({ body: external_exports.string().min(1).max(4e3) });
+var StatusInput = external_exports.object({ status: external_exports.enum(REQUEST_STATUSES), body: external_exports.string().max(4e3).optional() });
 function styleContent(content) {
   return { ...content, tokens: content.tokens.map((t) => Object.fromEntries(Object.entries(t).filter(([, v]) => v !== void 0))) };
 }
@@ -927,6 +935,31 @@ async function api(req, res, path, options) {
     if ("kind" in input && input.kind === "library") return send(res, 201, await workflow.create(actor, { kind: "library", content: input.content }));
     return send(res, 201, await workflow.create(actor, "kind" in input && input.kind === "style" ? { kind: "style", ...input.content ? { content: styleContent(input.content) } : {} } : input));
   }
+  if (path === "/api/requests" && method === "GET") return send(res, 200, await (await workflow.requests()).list());
+  if (path === "/api/requests" && method === "POST") return send(res, 201, await (await workflow.requests()).create(actor, parse2(RequestInput, await readJson(req))));
+  const request = /^\/api\/requests\/(r-[0-9a-f]{10})(?:\/(replies|status|compare|before\.webp|after\.webp))?$/.exec(path);
+  if (request) {
+    const [, id, action] = request;
+    const store = await workflow.requests();
+    if (!action && method === "GET") return send(res, 200, await store.get(id));
+    if (action === "compare" && method === "GET") {
+      const { before, after } = await store.compare(id);
+      const view = (picture, which) => picture ? { ...picture, file: void 0, url: `/api/requests/${id}/${which}.webp` } : null;
+      return send(res, 200, { before: view(before, "before"), after: view(after, "after") });
+    }
+    if ((action === "before.webp" || action === "after.webp") && method === "GET") {
+      const picture = (await store.compare(id))[action === "before.webp" ? "before" : "after"];
+      if (!picture) throw new WorkflowError("not-found", `${id} has no ${action.replace(".webp", "")} picture`);
+      res.writeHead(200, { ...BASE_HEADERS, "content-type": "image/webp", "cache-control": "no-store" });
+      res.end(await readFile2(picture.file));
+      return;
+    }
+    if (action === "replies" && method === "POST") return send(res, 200, await store.reply(actor, id, parse2(ReplyInput, await readJson(req)).body));
+    if (action === "status" && method === "POST") {
+      const input = parse2(StatusInput, await readJson(req));
+      return send(res, 200, await store.setStatus(actor, id, input.status, input.body ?? ""));
+    }
+  }
   const match = /^\/api\/drafts\/(d-[0-9a-f]{10})(?:\/(preview|approve|rebase|handoff))?$/.exec(path);
   if (match) {
     const id = match[1];
@@ -1101,20 +1134,178 @@ function comparePreview(input) {
   };
 }
 
-// ../workflow/src/service.ts
+// ../workflow/src/requests.ts
 import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, readdir, readFile as readFile3, stat as stat2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var REQUESTS_DIR = ".youi/requests";
+var FILE = /^(r-[0-9a-f]{10})\.json$/;
+var authorOf = (actor) => ({ kind: actor.kind, name: actor.name });
+var screensDir = (root) => join4(root, ".youi/screens");
+var RequestStore = class {
+  dir;
+  root;
+  project;
+  options;
+  /** `root`: the product's root, where `.youi/` lives; `project`: its id. */
+  constructor(root, project, options = {}) {
+    this.dir = join4(root, REQUESTS_DIR);
+    this.root = root;
+    this.project = project;
+    this.options = options;
+  }
+  now() {
+    return (this.options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  }
+  file(id) {
+    if (!REQUEST_ID.test(id)) throw new WorkflowError("bad-request", `"${id.slice(0, 40)}" is not a request id (r-<10 hex>)`);
+    return join4(this.dir, `${id}.json`);
+  }
+  async write(request) {
+    const checked = RequestDoc.parse(request);
+    await writeFileAtomic(this.file(checked.id), `${JSON.stringify(checked, null, 2)}
+`);
+    return checked;
+  }
+  /** Every request, newest first. */
+  async list() {
+    const names = await readdir(this.dir).catch(() => []);
+    const requests = [];
+    const unreadable = [];
+    for (const name of names.sort()) {
+      const match = FILE.exec(name);
+      if (!match) continue;
+      const file = join4(REQUESTS_DIR, name);
+      let value;
+      try {
+        value = JSON.parse(await readFile3(join4(this.dir, name), "utf8"));
+      } catch (error) {
+        unreadable.push({ file, reason: error instanceof Error ? error.message.split("\n")[0] : String(error) });
+        continue;
+      }
+      const result = RequestDoc.safeParse(value);
+      if (!result.success) unreadable.push({ file, reason: result.error.issues.map((i) => `${i.path.join(".") || "file"}: ${i.message}`).join("; ") });
+      else if (result.data.id !== match[1]) unreadable.push({ file, reason: "its id is not its file name" });
+      else requests.push(result.data);
+    }
+    requests.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || a.id.localeCompare(b.id));
+    return { requests, unreadable };
+  }
+  async get(id) {
+    const text = await readFile3(this.file(id), "utf8").catch(() => null);
+    if (text === null) throw new WorkflowError("not-found", `no request ${id}`);
+    const parsed = RequestDoc.safeParse(JSON.parse(text));
+    if (!parsed.success) throw new WorkflowError("invalid", `${REQUESTS_DIR}/${id}.json is not a valid youi.request/v1`, parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`));
+    return parsed.data;
+  }
+  async create(actor, input) {
+    authorize(actor, "draft");
+    const body = input.body.trim();
+    if (!body) throw new WorkflowError("invalid", "a request needs words: what to look at, or what to change");
+    const at = this.now();
+    const id = (this.options.newId ?? (() => `r-${randomBytes(5).toString("hex")}`))();
+    const shot = join4(screensDir(this.root), `${screenSlug(input.target.route)}.light.webp`);
+    let before;
+    if (existsSync(shot)) {
+      before = `${id}.before.webp`;
+      await mkdir(this.dir, { recursive: true });
+      await copyFile(shot, join4(this.dir, before));
+    }
+    return this.write({ schema: "youi.request/v1", id, project: this.project, kind: input.kind, status: "open", body, author: authorOf(actor), createdAt: at, updatedAt: at, target: input.target, ...before ? { before } : {}, thread: [] });
+  }
+  async reply(actor, id, body) {
+    authorize(actor, "draft");
+    const text = body.trim();
+    if (!text) throw new WorkflowError("invalid", "a reply needs words");
+    const request = await this.get(id);
+    const at = this.now();
+    return this.write({ ...request, updatedAt: at, thread: [...request.thread, { author: authorOf(actor), at, body: text }] });
+  }
+  /**
+   * Before and after for a request: the picture kept when it was filed, and the screen's picture
+   * now, with the component found again on it by its file and line (from the new capture's places).
+   */
+  async compare(id) {
+    const request = await this.get(id);
+    const t = request.target;
+    const before = request.before === `${request.id}.before.webp` && existsSync(join4(this.dir, request.before)) ? { file: join4(this.dir, request.before), box: t.box ?? null, page: t.page ?? null, at: request.createdAt } : null;
+    const slug = screenSlug(t.route);
+    const shot = join4(screensDir(this.root), `${slug}.light.webp`);
+    const info = await stat2(shot).catch(() => null);
+    if (!info) return { before, after: null };
+    let box = t.box ?? null;
+    let page = t.page ?? null;
+    let found = false;
+    try {
+      const places = JSON.parse(await readFile3(join4(screensDir(this.root), `${slug}.places.json`), "utf8"));
+      const again = t.file && t.line ? places.places?.find((p) => p.file === t.file && p.line === t.line && p.name === t.name) : void 0;
+      if (places.size) page = places.size;
+      if (again) {
+        box = again.box;
+        found = true;
+      }
+    } catch {
+    }
+    const since = request.thread.filter((e) => e.status === "open").at(-1)?.at ?? request.createdAt;
+    const at = info.mtime.toISOString();
+    return { before, after: { file: shot, box, page, at, sinceFiled: at > since, found } };
+  }
+  /**
+   * Move a request on: `addressed` (anyone; an agent says what it did), or `closed` and `open`
+   * (a person's: closing accepts the work, reopening says it is not done).
+   */
+  async setStatus(actor, id, status, body = "") {
+    if (status !== "addressed") authorize(actor, "close");
+    else authorize(actor, "draft");
+    const request = await this.get(id);
+    if (request.status === status) throw new WorkflowError("conflict", `${id} is already ${status}`);
+    if (status === "addressed" && request.status === "closed") throw new WorkflowError("conflict", `${id} is closed: a person reopens it first`);
+    const at = this.now();
+    return this.write({ ...request, status, updatedAt: at, thread: [...request.thread, { author: authorOf(actor), at, body: body.trim(), status }] });
+  }
+};
+function requestBrief(request, root) {
+  const t = request.target;
+  const picture = join4(root, ".youi/screens", `${screenSlug(t.route)}.light.webp`);
+  const at = t.file && t.line ? `${t.file}:${t.line}` : null;
+  const every = t.scope === "element" && t.element;
+  const where = every ? `every use of ${t.element} (system_where_used lists them)` : at ? `${at}` : `the ${t.name} on ${t.route} (its line was not captured: find it from the picture and the route)`;
+  const next = request.status === "closed" ? "Closed by a person: nothing to do." : request.status === "addressed" ? "Marked addressed: a person checks it and closes or reopens it. Reply only if asked." : request.kind === "comment" ? `A comment on ${where}: reply with request_reply if it asks something; change code only if it asks for a change.` : `Make the change at ${where}${t.lookalike && t.element ? `, using the System's ${t.element} rather than the hand-built lookalike where that is the fix` : ""}; capture the screen again (youiyoux screens capture --base <the app in development> --route ${t.route}) so the person sees it after; then call request_addressed with what you changed (file:line). Ask with request_reply first if it is unclear. A person closes it.`;
+  return {
+    id: request.id,
+    kind: request.kind,
+    status: request.status,
+    ask: request.body,
+    from: `${request.author.kind} ${request.author.name}`,
+    createdAt: request.createdAt,
+    route: t.route,
+    component: t.name,
+    element: t.element ?? null,
+    lookalike: t.lookalike === true,
+    at,
+    scope: every ? `everywhere ${t.element} is used` : "this one, on this screen",
+    picture: existsSync(picture) ? picture : null,
+    box: t.box ? { x: Math.round(t.box.x * PICTURE_SCALE), y: Math.round(t.box.y * PICTURE_SCALE), width: Math.round(t.box.width * PICTURE_SCALE), height: Math.round(t.box.height * PICTURE_SCALE) } : null,
+    thread: request.thread.map((e) => `${e.author.kind} ${e.author.name}${e.status ? ` (marked ${e.status})` : ""}: ${e.body || "(no words)"}`),
+    next
+  };
+}
+
+// ../workflow/src/service.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
 
 // ../workflow/src/style-preview.ts
-import { mkdir, mkdtemp as mkdtemp2, rm as rm2, writeFile } from "node:fs/promises";
+import { mkdir as mkdir2, mkdtemp as mkdtemp2, rm as rm2, writeFile } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname, join as join4 } from "node:path";
+import { dirname, join as join5 } from "node:path";
 var MAX_LISTED = 5e3;
 async function buildFrom(project, tree) {
-  const root = await mkdtemp2(join4(tmpdir2(), "youi-style-"));
+  const root = await mkdtemp2(join5(tmpdir2(), "youi-style-"));
   try {
     for (const [path, text] of tree) {
-      await mkdir(dirname(join4(root, path)), { recursive: true });
-      await writeFile(join4(root, path), text);
+      await mkdir2(dirname(join5(root, path)), { recursive: true });
+      await writeFile(join5(root, path), text);
     }
     return (await buildTokens(root, project.system.config, project.config.outputs)).tokens;
   } finally {
@@ -1271,7 +1462,7 @@ function previewSummary(draft) {
   const p = draft.preview;
   return p ? `changes ${p.totals.tokens} token(s) and ${p.totals.contracts} component(s): ${p.totals.sites} site(s) and ${p.totals.direct} direct use(s) in ${p.totals.files} file(s) on ${p.totals.routes} screen(s)` : "no preview";
 }
-var randomId = (prefix) => `${prefix}-${randomBytes(5).toString("hex")}`;
+var randomId = (prefix) => `${prefix}-${randomBytes2(5).toString("hex")}`;
 var RuleWorkflow = class {
   options;
   execution;
@@ -1282,6 +1473,12 @@ var RuleWorkflow = class {
     this.options = options;
     this.execution = options.execution ?? scannerExecution;
   }
+  /** The product's comments and change requests on its captured screens (requests.ts), in its `.youi/requests`. */
+  async requests() {
+    const { projectRoot, configPath, designRoot, productRoot } = this.options;
+    const project = await loadProject(projectRoot, { ...configPath ? { configPath } : {}, ...designRoot ? { designRoot } : {}, ...productRoot ? { productRoot } : {} });
+    return new RequestStore(project.root, project.config.id, this.options.now ? { now: this.options.now } : {});
+  }
   now() {
     return (this.options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
   }
@@ -1925,8 +2122,8 @@ function shellQuote(path) {
 }
 
 // ../workflow/src/store.ts
-import { mkdir as mkdir2, readdir, readFile as readFile3 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 var DRAFT_ID = /^d-[0-9a-f]{10}$/;
 var FORMAT = "youiyoux.draft/v1";
 var COMMIT = /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/;
@@ -1951,18 +2148,18 @@ var FileStore = class {
   artifacts;
   constructor(dir) {
     this.location = dir;
-    this.drafts = join5(dir, "drafts");
-    this.artifacts = join5(dir, "handoffs");
+    this.drafts = join6(dir, "drafts");
+    this.artifacts = join6(dir, "handoffs");
   }
   async list() {
-    await mkdir2(this.drafts, { recursive: true });
-    const names = (await readdir(this.drafts)).filter((name) => /^d-[0-9a-f]{10}\.json$/.test(name)).sort();
+    await mkdir3(this.drafts, { recursive: true });
+    const names = (await readdir2(this.drafts)).filter((name) => /^d-[0-9a-f]{10}\.json$/.test(name)).sort();
     const drafts = [];
     const unreadable = [];
     for (const name of names) {
-      const file = join5(this.drafts, name);
+      const file = join6(this.drafts, name);
       try {
-        drafts.push(decode(await readFile3(file, "utf8"), file));
+        drafts.push(decode(await readFile4(file, "utf8"), file));
       } catch (error) {
         unreadable.push({ file, reason: error instanceof Error ? error.message : String(error) });
       }
@@ -1971,10 +2168,10 @@ var FileStore = class {
   }
   async get(id) {
     checkId(id);
-    const file = join5(this.drafts, `${id}.json`);
+    const file = join6(this.drafts, `${id}.json`);
     let text;
     try {
-      text = await readFile3(file, "utf8");
+      text = await readFile4(file, "utf8");
     } catch (error) {
       if (error.code === "ENOENT") return null;
       throw error;
@@ -1983,12 +2180,12 @@ var FileStore = class {
   }
   async put(draft) {
     checkId(draft.id);
-    await writeFileAtomic(join5(this.drafts, `${draft.id}.json`), `${JSON.stringify({ schema: FORMAT, draft }, null, 2)}
+    await writeFileAtomic(join6(this.drafts, `${draft.id}.json`), `${JSON.stringify({ schema: FORMAT, draft }, null, 2)}
 `);
   }
   async putArtifact(name, content) {
     if (!/^[a-z0-9][a-z0-9.-]*$/.test(name)) throw new Error(`not an artifact name: ${name}`);
-    const file = join5(this.artifacts, name);
+    const file = join6(this.artifacts, name);
     await writeFileAtomic(file, content);
     return file;
   }
@@ -2012,72 +2209,75 @@ var MemoryStore = class {
     return `memory:${name}`;
   }
 };
+
 export {
-  DEFAULT_FILES,
-  DRAFT_ID,
-  DesignFiles,
-  RuleWorkflow as DesignWorkflow,
-  FileStore,
-  GitError,
   JsonEditError,
-  MAX_FINDINGS,
-  MAX_LISTED,
-  MAX_TITLE,
-  MemoryStore,
-  RuleWorkflow,
-  SESSION_HEADER,
-  WORKFLOW_VERSION,
-  WorkflowError,
-  adoptionRefusal,
-  authorize,
-  branchTip,
-  changesDigest,
-  comparePreview,
-  componentChanges,
-  contentDigest,
-  createHandler,
-  createReviewBranch,
-  defaultBranch,
+  readJsonPath,
+  setJsonPath,
   deleteJsonPath,
-  describeContrast,
-  describeLibrary,
-  describeStyle,
-  draftStatus,
-  effectiveStateEdits,
-  effectiveTokenEdits,
-  emptyStyleContent,
+  DEFAULT_FILES,
   fieldsFromRule,
+  newRuleFields,
+  toRuleSpec,
+  validateContent,
+  contentDigest,
+  renderRuleYaml,
+  renderContract,
+  draftStatus,
+  componentChanges,
+  GitError,
   git,
-  hasChanges,
+  locate,
+  defaultBranch,
+  branchTip,
   headCommit,
+  readAt,
   isAncestor,
-  libraryDigest,
-  libraryPath,
-  librarySlug,
   listAt,
   listTreeAt,
-  locate,
-  newContrastFailures,
-  newRuleFields,
-  normalizeLibraryContent,
+  hasChanges,
+  changesDigest,
+  createReviewBranch,
+  MAX_TITLE,
+  emptyStyleContent,
   normalizeStyleContent,
-  previewStyle,
-  previewSummary,
-  readAt,
-  readJsonPath,
-  renderContract,
-  renderContractStates,
-  renderLibraryEntry,
-  renderRuleYaml,
+  styleDigest,
+  tokenPathOf,
+  effectiveTokenEdits,
+  validateStyleContent,
+  effectiveStateEdits,
   renderTokenEdits,
+  renderContractStates,
+  styleSlug,
+  describeStyle,
+  DesignFiles,
   scannerExecution,
+  WorkflowError,
+  authorize,
+  SESSION_HEADER,
+  createHandler,
   serveWorkflow,
-  setJsonPath,
-  styleDigest,
-  styleSlug,
-  toRuleSpec,
-  tokenPathOf,
-  validateContent,
+  normalizeLibraryContent,
+  libraryDigest,
+  libraryPath,
+  librarySlug,
+  adoptionRefusal,
   validateLibraryContent,
-  validateStyleContent
+  renderLibraryEntry,
+  describeLibrary,
+  MAX_FINDINGS,
+  comparePreview,
+  REQUESTS_DIR,
+  RequestStore,
+  requestBrief,
+  MAX_LISTED,
+  previewStyle,
+  WORKFLOW_VERSION,
+  previewSummary,
+  RuleWorkflow,
+  describeContrast,
+  newContrastFailures,
+  DRAFT_ID,
+  FileStore,
+  MemoryStore
 };