@loomweaver/cli 0.8.3 → 0.9.0-preview.2

package/dist/main.mjs

@@ -433,6 +433,12 @@ export class ${w.className}AgentPanel {
   private runs = 0;
 
   constructor() {
+    this.refreshOffered();
+  }
+
+  // The list is read again whenever the panel gains focus, because the weaver's own translations
+  // and other plugins' commands may arrive after this component was built.
+  protected refreshOffered(): void {
     this.offered.set(${w.propertyName}Agent()?.list() ?? []);
   }
 
@@ -523,7 +529,7 @@ export class ${w.className}AgentPanel {
 `;
 }
 function panelTemplateFile(w) {
-  return `<div class="flex h-full flex-col gap-3">
+  return `<div class="flex h-full flex-col gap-3" (focusin)="refreshOffered()">
   <p
     class="shrink-0 rounded-md border border-border bg-surface-raised px-3 py-2 text-xs text-content-muted"
   >
@@ -639,10 +645,10 @@ export async function* askAgent(
       toolCallName: picked.name,
     });
     // Arguments arrive in pieces, exactly as they do from a real model. The adapter assembles them;
-    // nothing downstream ever sees a half-written call. A real agent fills them from the JSON Schema
-    // the workbench described in picked.parameters; a stand-in has nothing to fill them from, so it
-    // sends none and lets the command apply its own defaults.
-    for (const piece of chunks(JSON.stringify({}), 4)) {
+    // nothing downstream ever sees a half-written call. The values come from the JSON Schema the
+    // workbench described in picked.parameters: the first declared choice of the first argument that
+    // has choices, and nothing for the rest, so the command applies its own defaults there.
+    for (const piece of chunks(JSON.stringify(sampleArguments(picked)), 4)) {
       yield event(EventType.TOOL_CALL_ARGS, { toolCallId, delta: piece });
       await pause();
     }
@@ -667,6 +673,18 @@ async function* speak(
   yield event(EventType.TEXT_MESSAGE_END, { messageId });
 }
 
+function sampleArguments(tool: Tool): Record<string, unknown> {
+  const schema = tool.parameters as
+    | { properties?: Record<string, { enum?: readonly unknown[] }> }
+    | undefined;
+  for (const [name, property] of Object.entries(schema?.properties ?? {})) {
+    if (property.enum && property.enum.length > 0) {
+      return { [name]: property.enum[0] };
+    }
+  }
+  return {};
+}
+
 function chunks(text: string, size: number): readonly string[] {
   const pieces: string[] = [];
   for (let at = 0; at < text.length; at += size) {
@@ -686,7 +704,7 @@ function pause(): Promise<void> {
 }
 
 // ../devkit/src/recipes/angular-weaver/agent-files.ts
-var AG_UI_ADAPTER_VERSION = "0.8.3";
+var AG_UI_ADAPTER_VERSION = "0.9.0-preview.2";
 var AG_UI_PROTOCOL_VERSION = "0.0.x";
 function connectionFile(w) {
   return `import { signal } from '@angular/core';
@@ -752,7 +770,7 @@ function contextThat(confirms: boolean, ran: Asked[]): PluginContext {
     ],
     invokeCommand: (id: string, args?: CommandArguments) => {
       ran.push({ id, args });
-      return Promise.resolve({ outcome: 'answered', value: 'it ran' });
+      return Promise.resolve({ outcome: 'answered', value: { tone: args?.['tone'] ?? 'info' } });
     },
     ui: { confirm: () => Promise.resolve(confirms) },
   } as unknown as PluginContext;
@@ -781,17 +799,17 @@ describe('${w.propertyName}Connection', () => {
       ),
     ).toBeNull();
     await tools.receive(
-      event(EventType.TOOL_CALL_ARGS, { toolCallId: 'c1', delta: '{"who"' }),
+      event(EventType.TOOL_CALL_ARGS, { toolCallId: 'c1', delta: '{"tone"' }),
     );
     await tools.receive(
-      event(EventType.TOOL_CALL_ARGS, { toolCallId: 'c1', delta: ':"you"}' }),
+      event(EventType.TOOL_CALL_ARGS, { toolCallId: 'c1', delta: ':"success"}' }),
     );
     const answer = await tools.receive(
       event(EventType.TOOL_CALL_END, { toolCallId: 'c1' }),
     );
 
-    expect(ran).toEqual([{ id: '${w.id}.hello', args: { who: 'you' } }]);
-    expect(answer?.content).toBe('it ran');
+    expect(ran).toEqual([{ id: '${w.id}.hello', args: { tone: 'success' } }]);
+    expect(JSON.parse(answer?.content ?? '{}').tone).toBe('success');
     expect(answer?.error).toBeUndefined();
   });
 
@@ -996,7 +1014,9 @@ function i18nBundle(w) {
   }
   if (w.features.command) {
     bundle["action"] = `${w.name} action`;
-    bundle["actionDescription"] = `Shows a short ${w.name} message.`;
+    bundle["actionDescription"] = `Shows a short ${w.name} message in the tone the caller chooses.`;
+    bundle["actionTone"] = "How the message is shown: info, success or warning. Use info unless the caller asked for emphasis.";
+    bundle["actionAnswers"] = "The tone the message was shown in.";
   }
   if (w.features.about) bundle["about"] = `About ${w.name}`;
   if (w.features.agent) {
@@ -1018,6 +1038,38 @@ function i18nFile(w) {
   return JSON.stringify(i18nBundle(w), null, 2) + "\n";
 }
 
+// ../devkit/src/recipes/angular-weaver/weaver-command.ts
+function commandBlock(w) {
+  return [
+    "    ctx.registerCommand({",
+    `      id: '${w.id}.hello',`,
+    `      title: '${w.id}.action',`,
+    `      description: '${w.id}.actionDescription',`,
+    "      arguments: [",
+    `        { name: 'tone', kind: 'choice', choices: ['info', 'success', 'warning'], description: '${w.id}.actionTone' },`,
+    "      ],",
+    `      answers: '${w.id}.actionAnswers',`,
+    `      shortcut: '${w.features.shortcut}',`,
+    "      callable: true,",
+    "      run: (_context, args) => {",
+    "        const tone = toneOf(args?.['tone']);",
+    `        ctx.ui.toast({ message: '${w.id}.action', kind: tone });`,
+    "        return { tone };",
+    "      },",
+    "    });"
+  ].join("\n");
+}
+function toneHelper() {
+  return [
+    "type Tone = 'info' | 'success' | 'warning';",
+    "",
+    "// The workbench already refused anything outside the declared choices; this narrows the type.",
+    "function toneOf(value: unknown): Tone {",
+    "  return value === 'success' || value === 'warning' ? value : 'info';",
+    "}"
+  ].join("\n");
+}
+
 // ../devkit/src/recipes/angular-weaver/recipe.ts
 var DEFAULT_MENU_SLOT = "content/tab/context";
 var SURFACE_ICON = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" aria-hidden="true"><rect x="4" y="4" width="16" height="16" rx="3"/><path d="M8 9h8M8 13h8M8 17h5"/></svg>';
@@ -1196,18 +1248,6 @@ function railBlock(w) {
   lines.push("    });");
   return lines.join("\n");
 }
-function commandBlock(w) {
-  return [
-    "    ctx.registerCommand({",
-    `      id: '${w.id}.hello',`,
-    `      title: '${w.id}.action',`,
-    `      description: '${w.id}.actionDescription',`,
-    `      shortcut: '${w.features.shortcut}',`,
-    "      callable: true,",
-    `      run: () => ctx.ui.toast({ message: '${w.id}.action', kind: 'info' }),`,
-    "    });"
-  ].join("\n");
-}
 function barItemBlock(w) {
   return [
     "    ctx.registerBarItem({",
@@ -1319,9 +1359,10 @@ function pluginFile(w) {
   deactivate() {
     ${w.propertyName}Agent.set(null);
   },` : "";
+  if (w.features.command) consts.push(toneHelper());
   return `${imports.join("\n")}
 
-${consts.join("\n")}
+${consts.join("\n\n")}
 
 export const ${w.propertyName}Plugin: Plugin = {
   manifest: {
@@ -1760,9 +1801,9 @@ function readme2(d) {
     "project's `project.json`, keeping the targets, `implicitDependencies` and tags it already had.",
     "",
     "Two leftovers from `ng new` are no longer referenced and can go: `src/app/app.routes.ts` (the",
-    "shell owns content routing via `provideShellRouter()`) and `src/app/app.css`. The generated",
-    "`src/app/app.spec.ts` now fails \u2014 `App` pulls the whole shell into a bare `TestBed` \u2014 so delete",
-    "it and test your own components instead of the composition root.",
+    "shell owns content routing via `provideShellRouter()`) and `src/app/app.css`. The starter test",
+    "`src/app/app.spec.ts` was replaced by one that boots the shell with this composition root, so",
+    "`ng test` is green as generated; test your own components beside it.",
     "",
     "The project is generated **untagged**: Nx tags belong to your `depConstraints`, and inventing",
     "one would fail a lint policy you never opted this project into. If your workspace enforces",
@@ -2016,6 +2057,31 @@ describe('layout', () => {
 });
 `;
 }
+function appSpec() {
+  return `import { TestBed } from '@angular/core/testing';
+import { App } from './app';
+import { appConfig } from './app.config';
+
+/* The application's starter test, rewritten for a root component that renders the shell: it boots
+   with the composition root's own providers, so whatever you compose in is what the test boots
+   with, and it asserts only that the shell mounted. */
+describe('App', () => {
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [App],
+      providers: appConfig.providers,
+    }).compileComponents();
+  });
+
+  it('boots the shell', async () => {
+    const fixture = TestBed.createComponent(App);
+    await fixture.whenStable();
+    const compiled = fixture.nativeElement as HTMLElement;
+    expect(compiled.querySelector('lw-shell')).toBeTruthy();
+  });
+});
+`;
+}
 function indexHtml(d) {
   return `<!DOCTYPE html>
 <html lang="en">
@@ -2142,7 +2208,10 @@ var angularDistribution = {
     return {
       "src/main.ts": mainTs(),
       "src/app/app.config.ts": appConfigTs(d),
-      ...d.withTests && { "src/app/app.config.spec.ts": appConfigSpec() },
+      ...d.withTests && {
+        "src/app/app.config.spec.ts": appConfigSpec(),
+        "src/app/app.spec.ts": appSpec()
+      },
       "src/app/app.ts": appTs(),
       "src/app/app.html": appHtml(),
       "src/index.html": indexHtml(d),
@@ -2382,6 +2451,8 @@ function bootstrapFile(t) {
     --lw-on-info: #000;
 
     --lw-scrim: rgb(0 0 0 / 0.5);
+    --lw-scroll-thumb: rgb(0 0 0 / 0.3);
+    --lw-scroll-track: transparent;
 
     --lw-font-sans: var(--bs-body-font-family);
     --lw-font-mono: var(--bs-font-monospace);
@@ -3069,6 +3140,184 @@ function validateCatalog(catalog, known = KNOWN_CAPABILITIES) {
   return findings;
 }
 
+// ../devkit/src/lib/validate/commands.ts
+var RUNTIME_NOTE = "Grants, access and the window decide what is finally offered at runtime; this check judged the registrations alone.";
+function validateCommands(sources, ts) {
+  const findings = [];
+  for (const source of sources) {
+    const file = ts.createSourceFile(source.path, source.text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    for (const call of registerCommandCalls(ts, file)) {
+      findings.push(...judge(read(ts, file, call)));
+    }
+  }
+  findings.push({ level: "info", code: "commands.runtime", message: RUNTIME_NOTE });
+  return findings;
+}
+function registerCommandCalls(ts, file) {
+  const calls = [];
+  const visit = (node) => {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "registerCommand") {
+      calls.push(node);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(file);
+  return calls;
+}
+function read(ts, file, call) {
+  const line = file.getLineAndCharacterOfPosition(call.getStart(file)).line + 1;
+  const at2 = `${file.fileName}:${line}`;
+  const literal = call.arguments[0];
+  const empty = { at: at2, callable: false, described: false, answers: false, returnsValue: false, arguments: [] };
+  if (!literal || !ts.isObjectLiteralExpression(literal)) {
+    return { ...empty, unreadable: "its argument is not an object literal" };
+  }
+  const properties = /* @__PURE__ */ new Map();
+  for (const property of literal.properties) {
+    if (ts.isSpreadAssignment(property)) {
+      return { ...empty, unreadable: "it spreads another value into the registration" };
+    }
+    if (ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))) {
+      properties.set(property.name.text, property.initializer);
+    } else if (ts.isMethodDeclaration(property) && ts.isIdentifier(property.name)) {
+      properties.set(property.name.text, property);
+    }
+  }
+  const id = properties.get("id");
+  if (!id || !ts.isStringLiteral(id)) {
+    return { ...empty, unreadable: "its id is not a string literal" };
+  }
+  const callable = properties.get("callable");
+  return {
+    at: at2,
+    id: id.text,
+    callable: callable !== void 0 && callable.kind === ts.SyntaxKind.TrueKeyword,
+    described: properties.has("description"),
+    answers: properties.has("answers"),
+    returnsValue: returnsValue(ts, properties.get("run")),
+    arguments: readArguments(ts, properties.get("arguments"))
+  };
+}
+function readArguments(ts, value) {
+  if (!value || !ts.isArrayLiteralExpression(value)) {
+    return [];
+  }
+  return value.elements.map((element, index) => {
+    if (!ts.isObjectLiteralExpression(element)) {
+      return { name: `#${index + 1}`, described: false };
+    }
+    let name = `#${index + 1}`;
+    let described = false;
+    for (const property of element.properties) {
+      if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+        continue;
+      }
+      if (property.name.text === "name" && ts.isStringLiteral(property.initializer)) {
+        name = property.initializer.text;
+      }
+      if (property.name.text === "description") {
+        described = true;
+      }
+    }
+    return { name, described };
+  });
+}
+function returnsValue(ts, run2) {
+  if (!run2) {
+    return false;
+  }
+  if (ts.isArrowFunction(run2) && !ts.isBlock(run2.body)) {
+    return ts.isObjectLiteralExpression(run2.body) || ts.isArrayLiteralExpression(run2.body);
+  }
+  let found = false;
+  const visit = (node) => {
+    if (found || ts.isFunctionLike(node) && node !== run2) {
+      return;
+    }
+    if (ts.isReturnStatement(node) && node.expression && node.expression.kind !== ts.SyntaxKind.UndefinedKeyword) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(run2);
+  return found;
+}
+function judge(registration) {
+  const { at: at2, id } = registration;
+  if (registration.unreadable) {
+    return [
+      {
+        level: "info",
+        code: "command.unreadable",
+        path: at2,
+        message: `A registerCommand call at ${at2} could not be read: ${registration.unreadable}. What it offers an agent is unknown here.`
+      }
+    ];
+  }
+  if (!registration.callable) {
+    return [
+      {
+        level: "info",
+        code: "command.private",
+        path: at2,
+        message: `${id}: not offered to an agent, because it is not callable; an agent never sees it.`
+      }
+    ];
+  }
+  const findings = [];
+  if (!registration.described) {
+    findings.push({
+      level: "warning",
+      code: "command.description",
+      path: at2,
+      message: `${id}: offered to an agent without a description; the agent sees only the id and has to guess what it does.`
+    });
+  }
+  for (const argument of registration.arguments) {
+    if (!argument.described) {
+      findings.push({
+        level: "info",
+        code: "command.argument",
+        path: at2,
+        message: `${id}: argument "${argument.name}" has no description; an agent sees a bare name and guesses its value.`
+      });
+    }
+  }
+  if (registration.returnsValue && !registration.answers) {
+    findings.push({
+      level: "info",
+      code: "command.answers",
+      path: at2,
+      message: `${id}: run returns a value but declares no answers; an agent hears that the command ran, not what it answered.`
+    });
+  }
+  if (findings.length === 0) {
+    const count = registration.arguments.length;
+    findings.push({
+      level: "info",
+      code: "command.offered",
+      path: at2,
+      message: `${id}: offered to an agent, with ${count} described argument${count === 1 ? "" : "s"}${registration.answers ? " and a declared answer" : ""}.`
+    });
+  }
+  return findings;
+}
+
+// ../devkit/src/lib/validate/typescript.ts
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+function loadTypeScript(fromDir) {
+  for (const from of [resolve(fromDir, "package.json"), resolve(process.cwd(), "package.json")]) {
+    try {
+      return createRequire(from)("typescript");
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
 // src/lib/run.ts
 import { readdirSync, readFileSync as readFileSync3 } from "node:fs";
 import { join } from "node:path";
@@ -3162,17 +3411,17 @@ function boolFlag(args, name) {
 
 // src/lib/amend.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { dirname as dirname2, posix, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { dirname as dirname2, posix, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
 
 // src/lib/workspace.ts
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, relative, resolve, sep } from "node:path";
+import { dirname, relative, resolve as resolve2, sep } from "node:path";
 var WorkspaceError = class extends Error {
 };
 function findWorkspace(from) {
-  let dir = resolve(from);
+  let dir = resolve2(from);
   for (; ; ) {
-    if (existsSync(resolve(dir, "package.json"))) {
+    if (existsSync(resolve2(dir, "package.json"))) {
       return { root: dir, ...buildConfigIn(dir) };
     }
     const parent = dirname(dir);
@@ -3210,11 +3459,11 @@ function readJsonFile(file) {
   }
 }
 function buildConfigIn(dir) {
-  const angular = resolve(dir, "angular.json");
+  const angular = resolve2(dir, "angular.json");
   if (existsSync(angular)) {
     return { configFile: angular, kind: "angular" };
   }
-  const nx = resolve(dir, "nx.json");
+  const nx = resolve2(dir, "nx.json");
   if (existsSync(nx)) {
     return { configFile: nx, kind: "nx" };
   }
@@ -3239,7 +3488,7 @@ function contains(projectRoot, target) {
   return projectRoot === "" || target === projectRoot || target.startsWith(`${projectRoot}/`);
 }
 function relativeTo(root, target) {
-  return relative(root, resolve(target)).split(sep).join("/");
+  return relative(root, resolve2(target)).split(sep).join("/");
 }
 function withoutTrailingSlashes(path) {
   let end = path.length;
@@ -3331,7 +3580,7 @@ var Amender = class {
   }
   planPostcss(amendment) {
     const inTheWay = JS_POSTCSS_CONFIGS.find(
-      (name) => existsSync2(resolve2(this.workspace.root, name))
+      (name) => existsSync2(resolve3(this.workspace.root, name))
     );
     if (inTheWay) {
       this.remaining.push(
@@ -3339,7 +3588,7 @@ var Amender = class {
       );
       return;
     }
-    const file = resolve2(this.workspace.root, amendment.file);
+    const file = resolve3(this.workspace.root, amendment.file);
     const result = ensurePostcssPlugin(
       existsSync2(file) ? readJsonFile(file) : void 0,
       amendment
@@ -3357,7 +3606,7 @@ var Amender = class {
     });
   }
   planPackage(amendment) {
-    const file = resolve2(this.workspace.root, "package.json");
+    const file = resolve3(this.workspace.root, "package.json");
     if (!existsSync2(file)) {
       this.remaining.push(describeAmendment(amendment));
       return;
@@ -3375,7 +3624,7 @@ var Amender = class {
     if (this.manifestAdded.length === 0 || !this.manifest) {
       return;
     }
-    const file = resolve2(this.workspace.root, "package.json");
+    const file = resolve3(this.workspace.root, "package.json");
     this.planned.push({
       file,
       display: this.displayName(file),
@@ -3433,7 +3682,7 @@ var Amender = class {
     });
   }
   planComposePlugin(amendment, project) {
-    const root = resolve2(
+    const root = resolve3(
       this.workspace.root,
       project.root,
       "src/app/app.config.ts"
@@ -3524,7 +3773,7 @@ var Amender = class {
     const entry = styles.find(
       (style) => typeof style === "string" && style.endsWith(".css")
     );
-    return entry === void 0 ? void 0 : resolve2(this.workspace.root, entry);
+    return entry === void 0 ? void 0 : resolve3(this.workspace.root, entry);
   }
   nonAngularNote(amendment) {
     const where = this.workspace.kind === "nx" ? "the project's own project.json" : "your build configuration";
@@ -3544,7 +3793,7 @@ function relativeImport(fromDir, sourceRoot) {
 }
 
 // src/lib/scaffold.ts
-import { relative as relative3, resolve as resolve3 } from "node:path";
+import { relative as relative3, resolve as resolve4 } from "node:path";
 function findScaffold2(name) {
   const scaffold2 = findScaffold(name);
   if (!scaffold2) {
@@ -3596,7 +3845,7 @@ function valuesFor(scaffold2, args) {
   return values;
 }
 function directoryFromOut(out) {
-  const below = relative3(process.cwd(), resolve3(out ?? "."));
+  const below = relative3(process.cwd(), resolve4(out ?? "."));
   return below.startsWith("..") ? "" : below;
 }
 function scaffoldValues(scaffold2, args) {
@@ -3628,15 +3877,15 @@ import {
   rmSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { dirname as dirname3, isAbsolute, relative as relative4, resolve as resolve4 } from "node:path";
+import { dirname as dirname3, isAbsolute, relative as relative4, resolve as resolve5 } from "node:path";
 var WriteError = class extends Error {
 };
 function planWrite(files, root) {
-  const absoluteRoot = resolve4(root);
+  const absoluteRoot = resolve5(root);
   const planned = [];
   const conflicts = [];
   for (const path of Object.keys(files).toSorted((a, b) => a.localeCompare(b))) {
-    const absolute = resolve4(absoluteRoot, path);
+    const absolute = resolve5(absoluteRoot, path);
     const inside = relative4(absoluteRoot, absolute);
     if (inside.startsWith("..") || isAbsolute(inside)) {
       throw new WriteError(`Refusing to write outside the target directory: ${path}`);
@@ -3679,7 +3928,7 @@ function replaceSymlinkEntry(absolute) {
 }
 
 // src/lib/run.ts
-var VERSION = "0.8.3";
+var VERSION = "0.9.0-preview.2";
 function help() {
   const commands = SCAFFOLDS.map((s) => `  ${s.name.padEnd(16)}${s.summary}`);
   return [
@@ -3695,6 +3944,7 @@ function help() {
     "  validate-manifest --id <id> [--name <name>] [--capabilities <a,b>]",
     "  validate-i18n   --dir <dir>   check <lang>.json bundles for key parity",
     "  validate-catalog --file <path> check a plugin store catalog the host parses defensively",
+    "  validate-commands --dir <dir> say, per command, whether an agent is offered it and what it would guess at",
     "",
     "Options:",
     "  --out <dir>     where to write (default: the current directory)",
@@ -3724,11 +3974,14 @@ function reportFindings(io, findings, strict) {
     io.out("No findings.");
     return 0;
   }
-  for (const f of findings) io.err(`${f.level}: ${f.message}`);
-  if (findings.some((f) => f.level === "error")) {
+  for (const f of findings) {
+    (f.level === "info" ? io.out : io.err)(`${f.level}: ${f.message}`);
+  }
+  const gating = findings.filter((f) => f.level !== "info");
+  if (gating.some((f) => f.level === "error")) {
     return 1;
   }
-  return strict ? 1 : 0;
+  return strict && gating.length > 0 ? 1 : 0;
 }
 function validateManifestCommand(args, io) {
   rejectUnknownFlags(args, ["id", "name", "capabilities", "strict"]);
@@ -3769,6 +4022,42 @@ function validateI18nCommand(args, io) {
     boolFlag(args, "strict") === true
   );
 }
+function readSources(dir) {
+  const sources = [];
+  const walk = (folder) => {
+    for (const entry of readdirSync(folder, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name.startsWith(".")) {
+        continue;
+      }
+      const path = join(folder, entry.name);
+      if (entry.isDirectory()) {
+        walk(path);
+      } else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".spec.ts")) {
+        sources.push({ path, text: readFileSync3(path, "utf8") });
+      }
+    }
+  };
+  try {
+    walk(dir);
+  } catch (error) {
+    throw new ArgError(`Cannot read ${dir}: ${error.message}`);
+  }
+  if (sources.length === 0) {
+    throw new ArgError(`No TypeScript sources found under ${dir}.`);
+  }
+  return sources;
+}
+function validateCommandsCommand(args, io) {
+  rejectUnknownFlags(args, ["dir", "strict"]);
+  const dir = requiredFlag(args, "dir");
+  const ts = loadTypeScript(dir);
+  if (!ts) {
+    throw new ArgError(
+      `typescript is not installed where ${dir} can reach it; the check reads sources with the TypeScript compiler API, so run it inside the project.`
+    );
+  }
+  return reportFindings(io, validateCommands(readSources(dir), ts), boolFlag(args, "strict") === true);
+}
 function readCatalog(file) {
   let raw;
   try {
@@ -3889,6 +4178,9 @@ function run(argv, io) {
     if (args.command === "validate-catalog") {
       return validateCatalogCommand(args, io);
     }
+    if (args.command === "validate-commands") {
+      return validateCommandsCommand(args, io);
+    }
     return scaffold(args, io);
   } catch (error) {
     io.err(error.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomweaver/cli",
-  "version": "0.8.3",
+  "version": "0.9.0-preview.2",
   "description": "LoomWeaver: open-source plugin platform for Angular workbenches. The scaffolding CLI: generates weavers, distributions and integrations into any project, with no Nx workspace and no checkout required.",
   "keywords": [
     "loomweaver",