@plannotator/pi-extension 0.28.50 → 0.28.51

package/generated/shape/store.ts

@@ -46,8 +46,10 @@ import {
   shapeNoteId,
   shapeNoteWaits,
   shapeParts,
+  shapeViewNow,
   type ShapeBoard,
   type ShapeNote,
+  type ShapeProject,
   type ShapeRecord,
   type ShapeSession,
   type ShapeState,
@@ -65,7 +67,7 @@ const MESSAGE_ID_RE = /^msg_[0-9A-HJKMNP-TV-Z]{26}$/;
 export interface ShapeSummary {
   id: string;
   title: string;
-  project: { name: string; root: string };
+  project: ShapeProject;
   thread: string | null;
   state: ShapeState;
   updated: string;
@@ -92,7 +94,7 @@ export interface ShapeUpdateInput {
   thread?: string | null;
   /** The last thread message this version took in. */
   through?: string | null;
-  project: { name: string; root: string };
+  project: ShapeProject;
   session?: ShapeSession | null;
   /** The folder the board file is in: image references by relative path are read from here. */
   sourceDir?: string | null;
@@ -263,6 +265,25 @@ export function shapesDirOf(dataDir: string): string {
   return join(dataDir, "shapes");
 }
 
+export type { ShapeProject };
+
+/** A linked worktree's `.git` is a file saying `gitdir: <path>`, and that path exists; a main checkout's is a folder. */
+export function isLinkedWorktree(folder: string): boolean {
+  try {
+    const dotGit = join(folder, ".git");
+    if (!statSync(dotGit).isFile()) return false;
+    const gitdir = /^gitdir: (.+)$/.exec(readFileSync(dotGit, "utf8").trim())?.[1];
+    return !!gitdir && existsSync(resolve(folder, gitdir));
+  } catch {
+    return false;
+  }
+}
+
+/** The checkout a board's code lives in: the linked worktree of its latest write while that is still one, else the project's root. */
+export function shapeCodeRoot(project: ShapeProject): string {
+  return project.worktree && isLinkedWorktree(project.worktree) ? project.worktree : project.root;
+}
+
 export function createShapeStore(options: { dataDir: string; now?: () => number }): ShapeStore {
   const dir = shapesDirOf(options.dataDir);
   const now = options.now ?? (() => Date.now());
@@ -287,68 +308,128 @@ export function createShapeStore(options: { dataDir: string; now?: () => number
   }
 
   const recordOf = (folder: string) => readJson<ShapeRecord>(join(folder, "shape.json"));
-  const versionsOf = (folder: string) => readLines<ShapeVersion>(join(folder, "versions.jsonl"));
+  // A version or note saved when What to know was Requirements says "reqs": read it as the view it is now. The file stays as written.
+  const nowKnow = <T extends { view: unknown }>(x: T): T => (shapeViewNow(x.view) === x.view ? x : { ...x, view: "know" });
+  const versionsOf = (folder: string) => readLines<ShapeVersion>(join(folder, "versions.jsonl")).map((v) => (v.parts ? { ...v, parts: v.parts.map(nowKnow) } : v));
 
   function notesOf(folder: string): ShapeNote[] {
     const byId = new Map<string, ShapeNote>();
     for (const note of readLines<ShapeNote>(join(folder, "chat.jsonl"))) {
-      if (note && typeof note.id === "string") byId.set(note.id, note);
+      if (note && typeof note.id === "string") byId.set(note.id, nowKnow(note));
     }
     return [...byId.values()];
   }
 
   const drawingNow = (record: ShapeRecord) => !!record.drawing && Date.parse(record.drawing.until) > now();
 
+  /** Where an image comes from and its name in files/. Null: it stays as written (a files/ name, a data:image) or an error was recorded. */
+  function imageFile(src: string, field: string, sourceDir: string | null | undefined, errors: string[]): { path: string; name: string } | null {
+    // files/… is a picture the board keeps, unless the board's own folder really has one by that name: that one is copied.
+    const local = src.startsWith("files/") && sourceDir ? resolve(sourceDir, src) : null;
+    if (src.startsWith("files/") && !(local && existsSync(local))) {
+      if (!/^files\/[^/\\%?#.][^/\\%?#]*$/.test(src)) errors.push(`${field}: "${src.slice(0, 80)}" is not one file under files/`);
+      return null;
+    }
+    if (/^data:image\/(?:png|jpeg|gif|webp)[;,]/i.test(src)) return null;
+    // A board loads nothing from outside: an image is a file on this computer, copied in.
+    if (/^[a-z][a-z0-9+.-]+:|^\/\/|^\\\\/i.test(src)) {
+      errors.push(`${field}: "${src.slice(0, 80)}" is a URL; an image must be a file on this computer (it is copied into the board)`);
+      return null;
+    }
+    const path = isAbsolute(src) ? src : sourceDir ? resolve(sourceDir, src) : null;
+    if (!path) {
+      errors.push(`${field}: a relative image path needs the board file's folder`);
+      return null;
+    }
+    if (!IMAGE_EXT.has(extname(path).toLowerCase())) {
+      errors.push(`${field}: "${src}" is not a PNG, JPEG, GIF or WebP image`);
+      return null;
+    }
+    let size: number;
+    let real: string;
+    try {
+      const stat = statSync(path);
+      if (!stat.isFile()) throw new Error("not a file");
+      size = stat.size;
+      real = realpathSync(path);
+    } catch {
+      errors.push(`${field}: "${src}" was not found`);
+      return null;
+    }
+    // A link named .png is what it points at.
+    if (!IMAGE_EXT.has(extname(real).toLowerCase())) {
+      errors.push(`${field}: "${src}" is not a PNG, JPEG, GIF or WebP image`);
+      return null;
+    }
+    if (size > SHAPE_IMAGE_MAX_BYTES) {
+      errors.push(`${field}: "${src}" is ${size} bytes; at most ${SHAPE_IMAGE_MAX_BYTES}`);
+      return null;
+    }
+    return { path, name: `${createHash("sha256").update(readFileSync(path)).digest("hex").slice(0, 10)}-${basename(path).replace(/[^\w.-]+/g, "_")}` };
+  }
+
+  function copyImage(file: { path: string; name: string }, folder: string): void {
+    const files = join(folder, "files");
+    ensureDir(files);
+    const dest = join(files, file.name);
+    if (!existsSync(dest)) copyFileSync(file.path, dest);
+  }
+
+  /**
+   * A picture a drawing names by its path (`<img src>`, SVG `<image href>`) gets
+   * its files/ name before the board is checked; the file is copied once the
+   * board's folder is known. A URL stays as written, for the check to refuse.
+   */
+  function drawnImages(input: unknown, sourceDir: string | null | undefined): { board: unknown; files: { path: string; name: string }[]; errors: string[] } {
+    const errors: string[] = [];
+    const files: { path: string; name: string }[] = [];
+    const views = (input as { views?: unknown } | null)?.views;
+    if (!views || typeof views !== "object") return { board: input, files, errors };
+    const inHtml = (html: unknown, field: string): unknown =>
+      typeof html !== "string"
+        ? html
+        // Attribute by attribute, so words inside another attribute's value (alt="x src=y") are left alone.
+        : html.replace(/(<(?:img|image)\b(?:\s+(?!(?:xlink:href|src|href)\s*=)[\w:.-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'>]+))?)*\s+)(xlink:href|src|href)\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s"'>]+))/gi, (all, head: string, attr: string, q2?: string, q1?: string, bare?: string) => {
+            const src = (q2 ?? q1 ?? bare)!;
+            if (/^(?:#|[a-z][a-z0-9+.-]+:|\/\/|\\\\)/i.test(src)) return all;
+            const name = attr.toLowerCase() === "xlink:href" ? "href" : attr;
+            const file = imageFile(src, field, sourceDir, errors);
+            if (!file) return src.startsWith("files/") ? `${head}${name}="${src}"` : all;
+            files.push(file);
+            return `${head}${name}="files/${file.name}"`;
+          });
+    const next: Record<string, unknown> = {};
+    for (const [name, view] of Object.entries(views)) {
+      if (!view || typeof view !== "object") {
+        next[name] = view;
+        continue;
+      }
+      const v = view as { html?: unknown; tall?: { html?: unknown }; more?: { html?: unknown } };
+      next[name] = {
+        ...v,
+        ...("html" in v ? { html: inHtml(v.html, `views.${name}.html`) } : {}),
+        ...(v.tall ? { tall: { ...v.tall, html: inHtml(v.tall.html, `views.${name}.tall.html`) } } : {}),
+        ...(v.more ? { more: { ...v.more, html: inHtml(v.more.html, `views.${name}.more.html`) } } : {}),
+      };
+    }
+    return { board: { ...(input as object), views: next }, files, errors };
+  }
+
   /** Copy the images the refs cite into files/, and point the refs at the copies. */
   function keepImages(board: ShapeBoard, folder: string, sourceDir: string | null | undefined): { board: ShapeBoard; errors: string[] } {
     const errors: string[] = [];
     if (!board.refs?.length) return { board, errors };
-    const files = join(folder, "files");
     const keep = (src: string, field: string): string => {
-      if (src.startsWith("files/")) {
-        if (!/^files\/[^/\\%?#.][^/\\%?#]*$/.test(src)) errors.push(`${field}: "${src.slice(0, 80)}" is not one file under files/`);
-        return src;
-      }
-      if (/^data:image\/(?:png|jpeg|gif|webp)[;,]/i.test(src)) return src;
-      // A board loads nothing from outside: an image is a file on this computer, copied in.
-      if (/^[a-z][a-z0-9+.-]+:|^\/\/|^\\\\/i.test(src)) {
-        errors.push(`${field}: "${src.slice(0, 80)}" is a URL; an image must be a file on this computer (it is copied into the board)`);
-        return src;
-      }
-      const path = isAbsolute(src) ? src : sourceDir ? resolve(sourceDir, src) : null;
-      if (!path) {
-        errors.push(`${field}: a relative image path needs the board file's folder`);
-        return src;
-      }
-      if (!IMAGE_EXT.has(extname(path).toLowerCase())) {
-        errors.push(`${field}: "${src}" is not a PNG, JPEG, GIF or WebP image`);
-        return src;
-      }
-      let size: number;
-      try {
-        const stat = statSync(path);
-        if (!stat.isFile()) throw new Error("not a file");
-        size = stat.size;
-      } catch {
-        errors.push(`${field}: "${src}" was not found`);
-        return src;
-      }
-      if (size > SHAPE_IMAGE_MAX_BYTES) {
-        errors.push(`${field}: "${src}" is ${size} bytes; at most ${SHAPE_IMAGE_MAX_BYTES}`);
-        return src;
-      }
-      const bytes = readFileSync(path);
-      const name = `${createHash("sha256").update(bytes).digest("hex").slice(0, 10)}-${basename(path).replace(/[^\w.-]+/g, "_")}`;
-      ensureDir(files);
-      const dest = join(files, name);
-      if (!existsSync(dest)) copyFileSync(path, dest);
-      return `files/${name}`;
+      const file = imageFile(src, field, sourceDir, errors);
+      if (!file) return src;
+      copyImage(file, folder);
+      return `files/${file.name}`;
     };
     const refs = board.refs.map((ref, i) => {
-      if (ref.kind !== "image") return ref;
+      if (ref.kind !== "image" && !ref.images) return ref;
       return {
         ...ref,
-        target: keep(ref.target, `refs[${i}].target`),
+        ...(ref.kind === "image" ? { target: keep(ref.target, `refs[${i}].target`) } : {}),
         ...(ref.images ? { images: ref.images.map((im, j) => ({ ...im, src: keep(im.src, `refs[${i}].images[${j}].src`) })) } : {}),
       };
     });
@@ -356,7 +437,9 @@ export function createShapeStore(options: { dataDir: string; now?: () => number
   }
 
   function update(input: ShapeUpdateInput): ShapeUpdateResult {
-    const checked = checkShapeBoard(input.board);
+    const drawn = drawnImages(input.board, input.sourceDir);
+    if (drawn.errors.length) return { ok: false, code: "invalid", errors: drawn.errors };
+    const checked = checkShapeBoard(drawn.board);
     if (!checked.ok) return { ok: false, code: "invalid", errors: checked.errors };
     const ids = (["thread", "through"] as const).filter((k) => input[k] != null && !MESSAGE_ID_RE.test(input[k]!));
     if (ids.length) return { ok: false, code: "invalid", errors: ids.map((k) => `${k}: must be an Inbox message id (msg_…)`) };
@@ -372,6 +455,7 @@ export function createShapeStore(options: { dataDir: string; now?: () => number
           rmSync(folder, { recursive: true, force: true });
           return { ok: false, code: "invalid", errors: kept.errors };
         }
+        for (const file of drawn.files) copyImage(file, folder);
         const version: ShapeVersion = {
           ...kept.board,
           n: 1,
@@ -429,6 +513,7 @@ export function createShapeStore(options: { dataDir: string; now?: () => number
       }
       const kept = keepImages(checked.value, folder, input.sourceDir);
       if (kept.errors.length) return { ok: false, code: "invalid", errors: kept.errors };
+      for (const file of drawn.files) copyImage(file, folder);
       const n = latest.n + 1;
       const version: ShapeVersion = {
         ...kept.board,
@@ -440,7 +525,9 @@ export function createShapeStore(options: { dataDir: string; now?: () => number
         parts: shapeParts(kept.board),
       };
       appendLine(join(folder, "versions.jsonl"), version);
-      const next: ShapeRecord = { ...record, title: kept.board.title, updated: at, latest: n, drawing: null };
+      // The board's checkout follows its latest write, within its project.
+      const project = input.project.root === record.project.root ? { ...input.project, name: record.project.name } : record.project;
+      const next: ShapeRecord = { ...record, project, title: kept.board.title, updated: at, latest: n, drawing: null };
       writeJsonAtomic(join(folder, "shape.json"), next);
       return { ok: true, id: record.id, v: n, created: false, record: next };
     });
@@ -591,8 +678,17 @@ export function createShapeStore(options: { dataDir: string; now?: () => number
       if (!record) return { ok: false, code: "not_found", message: `No shape ${id}.` };
       if (record.state === "finished") return { ok: false, code: "finished", message: `${id} is finished. Reopen it to change it.` };
       if (checked.value.v > record.latest) return { ok: false, code: "no_version", message: `${id} has no version ${checked.value.v}.` };
+      const noteId = shapeNoteId(now());
+      let picture: string | undefined;
+      if (checked.value.picture) {
+        // A box's picture: a file the shape keeps, named for its note.
+        const name = `note-${noteId}.png`;
+        ensureDir(join(folder, "files"));
+        writeFileSync(join(folder, "files", name), Buffer.from(checked.value.picture.slice(checked.value.picture.indexOf(",") + 1), "base64"), { mode: 0o600 });
+        picture = `files/${name}`;
+      }
       const note: ShapeNote = {
-        id: shapeNoteId(now()),
+        id: noteId,
         at: iso(),
         kind: checked.value.kind,
         v: checked.value.v,
@@ -603,6 +699,9 @@ export function createShapeStore(options: { dataDir: string; now?: () => number
         from: "you",
         re: null,
         delivered: null,
+        ...(checked.value.box ? { box: checked.value.box } : {}),
+        ...(checked.value.code ? { code: checked.value.code } : {}),
+        ...(picture ? { picture } : {}),
       };
       appendLine(join(folder, "chat.jsonl"), note);
       return { ok: true, note };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plannotator/pi-extension",
-  "version": "0.28.50",
+  "version": "0.28.51",
   "type": "module",
   "description": "Plannotator Pi extension - interactive plan review with annotations, annotate agent messages, and review code/PRs",
   "author": "backnotprop",