@intentius/chant 0.102.0 → 0.104.1

package/src/workspace/write-scope.test.ts

@@ -28,7 +28,7 @@ import { parseDeclaration, WorkspaceReadError } from "./declaration";
 import { parseFrontMatter } from "./records";
 import { amendRecord, newRecord, renderRecord, reviewRecord } from "./records-write";
 import { emptyPolicy } from "./trust/policy";
-import { judgePath, judgeRecord, principalClass, resolveWriter, WriteScopeError } from "./write-scope";
+import { judgePath, judgeRecord, onlyKeysChanged, principalClass, resolveWriter, WriteScopeError } from "./write-scope";
 import { createWorkspaceTools } from "../cli/mcp/workspace-tools";
 
 const DECISIONS = join(REPO, "docs", "design", "decisions");
@@ -141,6 +141,21 @@ describe("the declaration's writeScope and agents (#2548)", () => {
   });
 });
 
+describe("a protected JSON file's except by JSON Pointer (#3308)", () => {
+  const decl = (listing: unknown, intent = "ws-001") => JSON.stringify({ name: "w", members: [{ name: "a", box: { intent, listing } }, { name: "b" }] });
+  test("a * token matches every key or index at its level, and only what the pointer names may change", () => {
+    expect(onlyKeysChanged(decl({ title: "A" }), decl({ title: "B" }), ["/members/*/box/listing"])).toBe(true);
+    expect(onlyKeysChanged(decl({ title: "A" }), decl(undefined), ["/members/*/box/listing"])).toBe(true);
+    expect(onlyKeysChanged(decl({ title: "A" }), decl({ title: "B" }, "ws-002"), ["/members/*/box/listing"])).toBe(false);
+    expect(onlyKeysChanged(decl({ title: "A" }), decl({ title: "B" }), ["/members/1/box/listing"])).toBe(false);
+    expect(onlyKeysChanged(decl({ title: "A" }), decl({ title: "B" }), ["/members/0/box/listing"])).toBe(true);
+    expect(onlyKeysChanged(decl({ title: "A" }), decl({ title: "B" }), ["name"])).toBe(false);
+  });
+  test("reads a .jsonc file's comments and trailing commas", () => {
+    expect(onlyKeysChanged('{ "a": 1, // x\n "b": 2, }', '{ "a": 1, "b": 3 }', ["b"])).toBe(true);
+  });
+});
+
 describe("judging a write", () => {
   const decl = parseDeclaration(declaration(), "chant.workspace.json");
   const policy = { ...emptyPolicy("x"), roles: { runner: ["CI@example.com"], agent: ["model@example.com"] } };

package/src/workspace/write-scope.ts

@@ -61,6 +61,7 @@ import {
   type ClassRegistry,
 } from "./principal-classes";
 import type { ReasonCode } from "./reason-codes";
+import { parseJsonText } from "./jsonc";
 import { memberHolding } from "./record-assets";
 import { gitRoot } from "./record-source";
 import { normalisePrincipal, parseFrontMatter } from "./records";
@@ -253,22 +254,43 @@ export function protectedEntry(entries: readonly ProtectedPath[], path: string):
   return null;
 }
 
+/** What an array item an `except` pointer covers is compared as, so the items after it keep their places. */
+const REMOVED = Symbol("except");
+
+/** Remove every value `pointer` matches from `value`, in place; a `*` token matches every key or index at its level. */
+function removeAtPointer(value: unknown, tokens: readonly string[]): void {
+  if (tokens.length === 0 || value === null || typeof value !== "object") return;
+  const [head, ...rest] = tokens;
+  const container = value as Record<string, unknown>;
+  const names = head === "*" ? Object.keys(container) : Object.prototype.hasOwnProperty.call(container, head) ? [head] : [];
+  for (const name of names) {
+    if (rest.length > 0) removeAtPointer(container[name], rest);
+    else if (Array.isArray(value)) (value as unknown[])[Number(name)] = REMOVED;
+    else delete container[name];
+  }
+}
+
 /**
- * Whether JSON text `before` and `after` differ only in the top-level keys
- * `except` names. False when either is missing or isn't a JSON object.
+ * Whether JSON text `before` and `after` differ only in what `except`
+ * allows: a top-level key, or, for an entry starting with `/`, the values a
+ * JSON Pointer matches, where a `*` token matches every key or array index
+ * at its level (`/members/*\/box/listing`, #3308). Comments and trailing
+ * commas are read, so a `.jsonc` declaration is judged too. False when either
+ * is missing or isn't a JSON object.
  */
 export function onlyKeysChanged(before: string | null, after: string | null, except: readonly string[]): boolean {
   if (before === null || after === null || except.length === 0) return false;
   const strip = (text: string): Record<string, unknown> | null => {
-    try {
-      const value = JSON.parse(text) as unknown;
-      if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
-      const copy = { ...(value as Record<string, unknown>) };
-      for (const key of except) delete copy[key];
-      return copy;
-    } catch {
-      return null;
+    const parsed = parseJsonText(text, { jsonc: true });
+    if (!parsed.ok) return null;
+    const value = parsed.value;
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+    const copy = structuredClone(value) as Record<string, unknown>;
+    for (const entry of except) {
+      if (entry.startsWith("/")) removeAtPointer(copy, entry.slice(1).split("/").map((t) => t.replace(/~1/g, "/").replace(/~0/g, "~")));
+      else delete copy[entry];
     }
+    return copy;
   };
   const a = strip(before);
   const b = strip(after);
@@ -303,7 +325,7 @@ export function judgePath(declaration: Declaration | null, writer: Writer, path:
   const guarded = protectedEntry(scope.protected, path);
   if (guarded === null) return OK;
   if (guarded.except.length > 0 && change && onlyKeysChanged(change.before(), change.after(), guarded.except)) return OK;
-  const allowance = guarded.except.length > 0 ? `, outside the top-level keys it allows (${guarded.except.join(", ")})` : "";
+  const allowance = guarded.except.length > 0 ? `, outside what its except allows (${guarded.except.join(", ")})` : "";
   return {
     ok: false,
     code: "write-scope-protected",

package/src/yaml.ts

@@ -2,13 +2,22 @@
  * YAML emitter and parser.
  *
  * The emitter writes the block-style YAML chant's serializers produce. The
- * parser is js-yaml with chant's schema (#3006): YAML 1.2 core types,
+ * parser is a vendored js-yaml loader with chant's schema (#3006): YAML 1.2 core types,
  * merge keys, `yes`/`no` booleans, and local tags such as `!reference` read
  * as strings. `splitYAMLDocuments` splits a multi-document stream. Input the
  * parser cannot read throws a `YAMLParseError` naming the line.
  */
 
-import yaml from "js-yaml";
+import {
+  FLOAT_TYPE,
+  INT_TYPE,
+  load,
+  MAP_TYPE,
+  NULL_TYPE,
+  SEQ_TYPE,
+  STR_TYPE,
+  YAMLException,
+} from "./vendor/js-yaml-load";
 
 // ---------------------------------------------------------------------------
 // Emitter
@@ -191,14 +200,12 @@ const DOCUMENT_MARKER = /^(?:---|\.\.\.)(?:[ \t]+#.*)?[ \t]*$/;
  * Booleans as YAML 1.2's core schema reads them, plus `yes` and `no`, which
  * this parser has always read as booleans and its callers expect.
  */
-const BOOL = new yaml.Type("tag:yaml.org,2002:bool", {
+const BOOL = {
+  tag: "tag:yaml.org,2002:bool",
   kind: "scalar",
   resolve: (data: string | null) => data !== null && /^(?:true|True|TRUE|false|False|FALSE|yes|no)$/.test(data),
   construct: (data: string) => /^(?:true|True|TRUE|yes)$/.test(data),
-  predicate: (value: unknown) => typeof value === "boolean",
-  represent: { lowercase: (value: object) => (value ? "true" : "false") },
-  defaultStyle: "lowercase",
-});
+};
 
 /** A tagged value written back as text, the way it appeared: `!reference [.base, script]`. */
 function flowText(value: unknown): string {
@@ -215,31 +222,34 @@ function flowText(value: unknown): string {
  * `!reference [.base, script]` is the string `"!reference [.base, script]"`.
  * A tag on a mapping has no such form and is an error.
  */
-const TAGGED_SCALAR = new yaml.Type("!", {
+const TAGGED_SCALAR = {
+  tag: "!",
   kind: "scalar",
   multi: true,
   construct: (data: string | null, tag?: string) => (data === null || data === "" ? tag : `${tag} ${data}`),
-});
-const TAGGED_SEQUENCE = new yaml.Type("!", {
+};
+const TAGGED_SEQUENCE = {
+  tag: "!",
   kind: "sequence",
   multi: true,
   construct: (data: unknown[] | null, tag?: string) => `${tag} ${flowText(data ?? [])}`,
-});
+};
 
-/** The merge key `<<`, as js-yaml's own merge type reads it (its typings omit `types`). */
-const MERGE = new yaml.Type("tag:yaml.org,2002:merge", {
+/** The merge key `<<`, as js-yaml's own merge type reads it. */
+const MERGE = {
+  tag: "tag:yaml.org,2002:merge",
   kind: "scalar",
   resolve: (data: string | null) => data === "<<" || data === null,
-});
+};
 
 /**
  * YAML 1.2's core schema (no timestamps, so a date stays a string) with merge
  * keys, `yes`/`no` booleans and local tags read as strings.
  */
-const SCHEMA = yaml.CORE_SCHEMA.extend({
-  implicit: [BOOL, MERGE],
-  explicit: [TAGGED_SCALAR, TAGGED_SEQUENCE],
-});
+const SCHEMA = {
+  implicit: [NULL_TYPE, BOOL, INT_TYPE, FLOAT_TYPE, MERGE],
+  explicit: [STR_TYPE, SEQ_TYPE, MAP_TYPE, TAGGED_SCALAR, TAGGED_SEQUENCE],
+};
 
 /**
  * Give every alias its own copy of the anchored value. js-yaml shares one
@@ -266,7 +276,7 @@ function unshareAliases(value: unknown, seen = new Set<object>()): unknown {
  * multiline key. Report the line where that key starts instead, the text
  * that is not a key.
  */
-function errorLine(lines: string[], err: yaml.YAMLException): number {
+function errorLine(lines: string[], err: YAMLException): number {
   let line = err.mark?.line ?? 0;
   if (/multiline key may not be an implicit key/.test(err.reason)) {
     const indent = lines[line]?.search(/\S/) ?? -1;
@@ -297,9 +307,9 @@ function loadDocument(content: string): unknown {
     .join("\n");
   let value: unknown;
   try {
-    value = yaml.load(text, { schema: SCHEMA, json: true });
+    value = load(text, SCHEMA);
   } catch (err) {
-    if (!(err instanceof yaml.YAMLException)) throw err;
+    if (!(err instanceof YAMLException)) throw err;
     const line = errorLine(text.split("\n"), err);
     const tag = err.reason.match(/^unknown tag !<(![^>]*)>/)?.[1];
     throw new YAMLParseError(line, tag ? `the tag ${JSON.stringify(tag)} on a mapping is not supported` : err.reason);