@intentius/chant 0.124.24 → 0.124.25

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

@@ -371,6 +371,24 @@ describe("chant workspace agent: what a session reloads from (#2548)", () => {
     agent.expectValid(doc);
     expect(code(doc)).toBe("agent-unknown");
   });
+
+  test("a declaration that fails validation is declaration-invalid, with the problem, not declaration-missing (#3433)", async () => {
+    const broken = JSON.stringify({ name: "studio", schema: 1, members: [{ name: "app", dir: "app" }], agents: AGENTS });
+    for (const committed of [false, true]) {
+      const dir = repo({ "chant.workspace.json": broken, "app/server.mjs": "export {};\n" }, committed);
+      if (committed) git(dir, "branch", "-M", "main");
+      const doc = await agentSession({ cwd: dir, name: "app-agent" });
+      agent.expectValid(doc);
+      expect(code(doc), committed ? "committed on main" : "uncommitted").toBe("declaration-invalid");
+      expect("error" in doc ? doc.error.message : "").toMatch(/kind/);
+    }
+  });
+
+  test("no declaration at all is still declaration-missing", async () => {
+    const doc = await agentSession({ cwd: repo({ "app/server.mjs": "export {};\n" }), name: "app-agent" });
+    agent.expectValid(doc);
+    expect(code(doc)).toBe("declaration-missing");
+  });
 });
 
 describe("principal classes a plugin defines (#3080)", () => {

package/src/workspace/write-scope.ts

@@ -352,18 +352,28 @@ export interface ScopeSource {
   policy: TrustPolicy;
   /** The principal classes: the core four and those the declaration's pins supply, path pins read where the declaration was (#3080). */
   classes: ClassRegistry;
+  /** Why the working tree's declaration couldn't be read when `declaration` is null: declaration-missing, or declaration-invalid with the problem (#3433). */
+  failure?: WorkspaceReadError;
 }
 
-function readAt(cwd: string, at?: string): { declaration: Declaration; rootOnDisk: string; root: string; tree: WorkspaceTree } | null {
+type ReadAt = { declaration: Declaration; rootOnDisk: string; root: string; tree: WorkspaceTree };
+
+/** The declaration at `at` (the working tree without it), or the read error that says why there is none. */
+function readOrFailure(cwd: string, at?: string): ReadAt | WorkspaceReadError {
   try {
     const located = locateWorkspace(cwd, at);
     return { declaration: readDeclaration(located.tree), rootOnDisk: located.rootOnDisk, root: located.root, tree: located.tree };
   } catch (err) {
-    if (err instanceof WorkspaceReadError) return null;
+    if (err instanceof WorkspaceReadError) return err;
     throw err;
   }
 }
 
+function readAt(cwd: string, at?: string): ReadAt | null {
+  const read = readOrFailure(cwd, at);
+  return read instanceof WorkspaceReadError ? null : read;
+}
+
 /**
  * The scope for a write from `cwd`: the declaration and the trust policy at
  * the base revision (`origin/HEAD`, `main` or `master`), so a write can't
@@ -375,7 +385,7 @@ export function scopeSource(cwd: string, at?: string): ScopeSource {
   const top = gitRoot(cwd);
   const base = top ? resolveBase(top, at) : null;
   const policy = top && base ? policyAtBase(top, base) : emptyPolicy(null);
-  const withClasses = (read: NonNullable<ReturnType<typeof readAt>>) => {
+  const withClasses = (read: ReadAt) => {
     const { tree, ...rest } = read;
     return { ...rest, classes: loadClassRegistry(read.declaration.pins, read.rootOnDisk, { tree }).registry };
   };
@@ -383,8 +393,9 @@ export function scopeSource(cwd: string, at?: string): ScopeSource {
     const atBase = readAt(cwd, base.commit);
     if (atBase) return { ...withClasses(atBase), from: "base", policy };
   }
-  const here = readAt(cwd);
-  return here ? { ...withClasses(here), from: "working-tree", policy } : { declaration: null, from: null, rootOnDisk: null, root: null, policy, classes: coreClassRegistry() };
+  const here = readOrFailure(cwd);
+  if (here instanceof WorkspaceReadError) return { declaration: null, from: null, rootOnDisk: null, root: null, policy, classes: coreClassRegistry(), failure: here };
+  return { ...withClasses(here), from: "working-tree", policy };
 }
 
 const toPosix = (p: string) => (sep === "/" ? p : p.split(sep).join("/"));