@valbuild/cli 0.120.3 → 0.121.0

package/CHANGELOG.md

@@ -1,5 +1,99 @@
 # @valbuild/cli
 
+## 0.121.0
+
+### Minor Changes
+
+- [#605](https://github.com/valbuild/val/pull/605) [`6794d29`](https://github.com/valbuild/val/commit/6794d2980bc81284ab7f2cc667f01cc21c9e3a79) Thanks [@freekh](https://github.com/freekh)! - `s.settings()`: the project's settings, as content.
+
+  A settings module is one per project, at the root of the content tree:
+
+  ```typescript
+  // settings.val.ts
+  export default c.define("/settings.val.ts", s.settings(), {});
+  ```
+
+  Register it in `val.modules.ts` like any other module, and it shows up in the
+  Studio under the cog at the foot of the left rail. Everything in it is content:
+  it is edited as a draft, it appears in the publish diff, and it is the same for
+  everyone working on the project.
+
+  Every key is optional, at every level, so `{}` is a complete settings module —
+  and stays one as sections are added. What it holds today is the assistant:
+
+  ```typescript
+  export default c.define("/settings.val.ts", s.settings(), {
+    assistant: {
+      enabled: true,
+      context: "A CMS for developers, run by a team of four in Oslo.",
+      tone: "Plain and direct. British English, sentence case in headings.",
+    },
+  });
+  ```
+
+  `context` is background the assistant would otherwise guess at; `tone` is how it
+  should write when it writes content. Both are sent with every message it makes.
+
+  `enabled` decides whether editors have an assistant, and it has **three** states
+  rather than two:
+
+  - `true` — they do.
+  - `false` — they do not, and every trace of it goes: no button in the top bar,
+    no row in the quick actions, no panel, nothing sent.
+  - unset — nobody has decided. The assistant is still **shown**, and asks to be
+    turned on before it is used. Hiding an assistant nobody has decided about
+    means nobody discovers it; quietly enabling one means a project starts sending
+    its content to a model because it did not know to say no.
+
+  A project with no settings module at all has an assistant, as before: there is
+  nowhere to record a decision, and nowhere for the prompt to write the answer.
+
+  **Breaking: `ai.chat` is gone from `val.config.ts`.** Whether the assistant is
+  available is a decision about the project's content, made by the people who edit
+  it, so it moved to settings — turning the chat on used to take a developer, a
+  deploy and a code review of a boolean. Remove the whole block:
+
+  ```diff
+   const { s, c, val, config } = initVal({
+  -  ai: {
+  -    chat: {
+  -      experimental: { enable: true },
+  -      suggestions: ["Summarize", "Fix typos at this page"],
+  -      title: "Ask me anything",
+  -      description: "Val can answer questions about the content.",
+  -    },
+  -  },
+   });
+  ```
+
+  `experimental.enable` becomes `assistant.enabled` in the settings module.
+  `suggestions`, `title` and `description` are removed with nothing replacing
+  them: the assistant now opens with its own copy. A project that had the chat
+  enabled and wants it to stay on for everyone should write
+  `assistant: { enabled: true }` — otherwise editors are offered it and asked.
+
+  `ai.commitMessages` stays in `val.config.ts`, and is unaffected.
+
+  Two settings modules, or one in a subdirectory, is a module error: the dev
+  server refuses to serve sources, `npx val validate` reports it against the file,
+  and the Studio says so rather than picking one.
+
+### Patch Changes
+
+- Updated dependencies [[`2bcc6fd`](https://github.com/valbuild/val/commit/2bcc6fdff8d668123e07e3c5e81ac6fa1436e47b), [`2bcbee1`](https://github.com/valbuild/val/commit/2bcbee1be682c2bbd5b7bc7d152ddd4204162fd2), [`6794d29`](https://github.com/valbuild/val/commit/6794d2980bc81284ab7f2cc667f01cc21c9e3a79)]:
+  - @valbuild/shared@0.121.0
+  - @valbuild/server@0.121.0
+  - @valbuild/core@0.121.0
+  - @valbuild/language-server@0.121.0
+
+## 0.120.4
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @valbuild/server@0.120.4
+  - @valbuild/language-server@0.120.4
+
 ## 0.120.3
 
 ### Patch Changes

package/cli/dist/valbuild-cli-cli.cjs.dev.js

@@ -145,6 +145,28 @@ async function* runValidation({
       return;
     }
     const start = Date.now();
+    // How this module is DECLARED, before what is in it: a module error is not
+    // something content can fix (a misplaced settings module is otherwise
+    // perfectly valid content), and validating on top of it would report the
+    // consequences instead of the cause.
+    const moduleErrors = service.getModuleErrors().filter(moduleError => moduleError.path === moduleFilePath);
+    if (moduleErrors.length > 0) {
+      for (const moduleError of moduleErrors) {
+        errors += 1;
+        yield {
+          type: "fatal-error",
+          file: moduleFilePath,
+          message: moduleError.message
+        };
+      }
+      yield {
+        type: "file-error-count",
+        file: moduleFilePath,
+        errorCount: moduleErrors.length,
+        durationMs: Date.now() - start
+      };
+      return;
+    }
     const valModule = await service.get(moduleFilePath, "", {
       validate: true
     });

package/cli/dist/valbuild-cli-cli.cjs.prod.js

@@ -145,6 +145,28 @@ async function* runValidation({
       return;
     }
     const start = Date.now();
+    // How this module is DECLARED, before what is in it: a module error is not
+    // something content can fix (a misplaced settings module is otherwise
+    // perfectly valid content), and validating on top of it would report the
+    // consequences instead of the cause.
+    const moduleErrors = service.getModuleErrors().filter(moduleError => moduleError.path === moduleFilePath);
+    if (moduleErrors.length > 0) {
+      for (const moduleError of moduleErrors) {
+        errors += 1;
+        yield {
+          type: "fatal-error",
+          file: moduleFilePath,
+          message: moduleError.message
+        };
+      }
+      yield {
+        type: "file-error-count",
+        file: moduleFilePath,
+        errorCount: moduleErrors.length,
+        durationMs: Date.now() - start
+      };
+      return;
+    }
     const valModule = await service.get(moduleFilePath, "", {
       validate: true
     });

package/cli/dist/valbuild-cli-cli.esm.js

@@ -113,6 +113,28 @@ async function* runValidation({
       return;
     }
     const start = Date.now();
+    // How this module is DECLARED, before what is in it: a module error is not
+    // something content can fix (a misplaced settings module is otherwise
+    // perfectly valid content), and validating on top of it would report the
+    // consequences instead of the cause.
+    const moduleErrors = service.getModuleErrors().filter(moduleError => moduleError.path === moduleFilePath);
+    if (moduleErrors.length > 0) {
+      for (const moduleError of moduleErrors) {
+        errors += 1;
+        yield {
+          type: "fatal-error",
+          file: moduleFilePath,
+          message: moduleError.message
+        };
+      }
+      yield {
+        type: "file-error-count",
+        file: moduleFilePath,
+        errorCount: moduleErrors.length,
+        durationMs: Date.now() - start
+      };
+      return;
+    }
     const valModule = await service.get(moduleFilePath, "", {
       validate: true
     });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.120.3",
+  "version": "0.121.0",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -24,11 +24,11 @@
     "jszip": "^3.10.1",
     "meow": "^9.0.0",
     "picocolors": "^1.1.1",
-    "@valbuild/core": "0.120.0",
+    "@valbuild/core": "0.121.0",
     "@valbuild/eslint-plugin": "0.108.0",
-    "@valbuild/language-server": "0.120.3",
-    "@valbuild/server": "0.120.3",
-    "@valbuild/shared": "0.120.0"
+    "@valbuild/language-server": "0.121.0",
+    "@valbuild/server": "0.121.0",
+    "@valbuild/shared": "0.121.0"
   },
   "peerDependencies": {
     "prettier": "*",

package/src/runValidation.test.ts

@@ -878,4 +878,105 @@ describe("runValidation", () => {
       expect(events.at(-1)).not.toEqual({ type: "summary-success" });
     });
   });
+
+  describe("settings modules", () => {
+    /**
+     * Writes a settings module into the fixture and registers it.
+     *
+     * Written by the test rather than kept as a fixture file: "one settings
+     * module, at the root" is a rule about the whole project, so a permanent
+     * broken fixture would be a rule the fixture project is always breaking.
+     */
+    const addSettingsModule = (moduleFilePath: string) => {
+      const relative = moduleFilePath.slice(1);
+      const upToRoot = "../".repeat(relative.split("/").length - 1) || "./";
+      fs.mkdirSync(path.dirname(path.join(tmpDir, relative)), {
+        recursive: true,
+      });
+      fs.writeFileSync(
+        path.join(tmpDir, relative),
+        [
+          `import { s, c } from "${upToRoot}val.config";`,
+          `export default c.define("${moduleFilePath}", s.settings(), {});`,
+          "",
+        ].join("\n"),
+      );
+      const valModulesPath = path.join(tmpDir, "val.modules.ts");
+      const registration = `  { def: () => import("./${relative.replace(
+        /\.ts$/,
+        "",
+      )}") },\n]);`;
+      fs.writeFileSync(
+        valModulesPath,
+        fs
+          .readFileSync(valModulesPath, "utf8")
+          .replace(/\]\);\s*$/, registration),
+      );
+    };
+
+    const runOn = async (valFiles: string[]) => {
+      const events: ValidationEvent[] = [];
+      for await (const event of runValidation({
+        root: tmpDir,
+        fix: false,
+        valFiles,
+        project: undefined,
+        remote: mockRemote,
+        fs: createDefaultValFSHost(),
+      })) {
+        events.push(event);
+      }
+      return events;
+    };
+
+    test("a settings module at the root is valid", async () => {
+      addSettingsModule("/settings.val.ts");
+
+      expect((await runOn(["settings.val.ts"])).at(-1)).toEqual({
+        type: "summary-success",
+      });
+    });
+
+    test("rejects a settings module in a subdirectory", async () => {
+      addSettingsModule("/content/settings.val.ts");
+
+      const events = await runOn(["content/settings.val.ts"]);
+
+      expect(events).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            type: "fatal-error",
+            message: expect.stringContaining(
+              "Settings must be defined at the root of the content tree",
+            ),
+          }),
+        ]),
+      );
+      expect(events.at(-1)).not.toEqual({ type: "summary-success" });
+    });
+
+    test("rejects a second settings module, naming both", async () => {
+      addSettingsModule("/settings.val.ts");
+      addSettingsModule("/config.val.ts");
+
+      const events = await runOn(["settings.val.ts", "config.val.ts"]);
+
+      expect(events).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            type: "fatal-error",
+            file: "/settings.val.ts",
+            message: expect.stringContaining(
+              "A project can only define settings once",
+            ),
+          }),
+          expect.objectContaining({
+            type: "fatal-error",
+            file: "/config.val.ts",
+          }),
+        ]),
+      );
+      expect(events.at(-1)).not.toEqual({ type: "summary-success" });
+    });
+  });
 });

package/src/runValidation.ts

@@ -134,6 +134,30 @@ export async function* runValidation({
       return;
     }
     const start = Date.now();
+    // How this module is DECLARED, before what is in it: a module error is not
+    // something content can fix (a misplaced settings module is otherwise
+    // perfectly valid content), and validating on top of it would report the
+    // consequences instead of the cause.
+    const moduleErrors = service
+      .getModuleErrors()
+      .filter((moduleError) => moduleError.path === moduleFilePath);
+    if (moduleErrors.length > 0) {
+      for (const moduleError of moduleErrors) {
+        errors += 1;
+        yield {
+          type: "fatal-error",
+          file: moduleFilePath,
+          message: moduleError.message,
+        };
+      }
+      yield {
+        type: "file-error-count",
+        file: moduleFilePath,
+        errorCount: moduleErrors.length,
+        durationMs: Date.now() - start,
+      };
+      return;
+    }
     const valModule = await service.get(moduleFilePath, "" as ModulePath, {
       validate: true,
     });