@loomweaver/mcp 0.8.3 → 0.9.0-preview.10

package/dist/main.mjs

@@ -2984,7 +2984,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -3011,7 +3011,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3642,7 +3642,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
       const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
@@ -3926,7 +3926,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -23056,12 +23056,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -28980,7 +28980,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error51) {
@@ -28997,7 +28997,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error51) => {
         reject(error51);
       };
@@ -29075,7 +29075,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error51) {
           reject(error51);
@@ -29336,12 +29336,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -30432,7 +30432,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -31175,6 +31175,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() ?? []);
   }
 
@@ -31265,7 +31271,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"
   >
@@ -31381,10 +31387,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();
     }
@@ -31409,6 +31415,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) {
@@ -31428,7 +31446,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.10";
 var AG_UI_PROTOCOL_VERSION = "0.0.x";
 function connectionFile(w) {
   return `import { signal } from '@angular/core';
@@ -31494,7 +31512,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;
@@ -31523,17 +31541,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();
   });
 
@@ -31567,6 +31585,7 @@ function agentSurfaceBlock(w) {
     `      title: '${w.id}.agent.title',`,
     `      icon: '${w.id}',`,
     "      docks: ['right-panel'],",
+    "      padded: true,",
     `      component: ${w.className}AgentPanel,`,
     "    });"
   ].join("\n");
@@ -31738,7 +31757,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) {
@@ -31760,6 +31781,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>';
@@ -31938,18 +31991,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({",
@@ -32061,9 +32102,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: {
@@ -32502,9 +32544,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",
@@ -32758,6 +32800,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">
@@ -32884,7 +32951,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),
@@ -33124,6 +33194,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);
@@ -33797,6 +33869,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 file2 = ts.createSourceFile(source.path, source.text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    for (const call of registerCommandCalls(ts, file2)) {
+      findings.push(...judge(read(ts, file2, call)));
+    }
+  }
+  findings.push({ level: "info", code: "commands.runtime", message: RUNTIME_NOTE });
+  return findings;
+}
+function registerCommandCalls(ts, file2) {
+  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(file2);
+  return calls;
+}
+function read(ts, file2, call) {
+  const line = file2.getLineAndCharacterOfPosition(call.getStart(file2)).line + 1;
+  const at2 = `${file2.fileName}:${line}`;
+  const literal2 = call.arguments[0];
+  const empty = { at: at2, callable: false, described: false, answers: false, returnsValue: false, arguments: [] };
+  if (!literal2 || !ts.isObjectLiteralExpression(literal2)) {
+    return { ...empty, unreadable: "its argument is not an object literal" };
+  }
+  const properties = /* @__PURE__ */ new Map();
+  for (const property of literal2.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, run) {
+  if (!run) {
+    return false;
+  }
+  if (ts.isArrowFunction(run) && !ts.isBlock(run.body)) {
+    return ts.isObjectLiteralExpression(run.body) || ts.isArrayLiteralExpression(run.body);
+  }
+  let found = false;
+  const visit = (node) => {
+    if (found || ts.isFunctionLike(node) && node !== run) {
+      return;
+    }
+    if (ts.isReturnStatement(node) && node.expression && node.expression.kind !== ts.SyntaxKind.UndefinedKeyword) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(run);
+  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/tools.ts
 function ok(data) {
   return {
@@ -33852,6 +34102,23 @@ function validateI18nTool(a) {
   const bundles = a["bundles"] ?? {};
   return ok({ findings: validateI18nParity(bundles) });
 }
+function validateCommandsTool(a) {
+  const files = a["files"] ?? {};
+  const ts = loadTypeScript(process.cwd());
+  if (!ts) {
+    return ok({
+      findings: [
+        {
+          level: "error",
+          code: "commands.typescript",
+          message: "typescript is not installed where this server runs; the check reads sources with the TypeScript compiler API, so start the server inside the project."
+        }
+      ]
+    });
+  }
+  const sources = Object.entries(files).map(([path, text]) => ({ path, text }));
+  return ok({ findings: validateCommands(sources, ts), note: RUNTIME_NOTE });
+}
 
 // src/lib/server.ts
 var FILE_MAP_NOTE = 'Returns a file map (relative path -> content); write the files into your project. May also return "remaining": steps the workspace needs that this route cannot perform, each saying what it costs to skip. Carry them out, or the generated output builds and does not work.';
@@ -33873,7 +34140,7 @@ function inputSchema(descriptor) {
 function createMcpServer() {
   const server = new McpServer({
     name: "loomweaver-devkit",
-    version: "0.8.3"
+    version: "0.9.0-preview.10"
   });
   server.registerTool(
     "list_generators",
@@ -33915,6 +34182,16 @@ function createMcpServer() {
     },
     async (args) => validateI18nTool(args)
   );
+  server.registerTool(
+    "validate_commands",
+    {
+      description: "Say, per command a plugin registers, whether an agent is offered it and what would leave the agent guessing. Input: files = { <path>: <TypeScript source> }. Only a callable command without a description is a warning; the rest is information.",
+      inputSchema: {
+        files: external_exports.record(external_exports.string(), external_exports.string())
+      }
+    },
+    async (args) => validateCommandsTool(args)
+  );
   server.registerTool(
     "validate_catalog",
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomweaver/mcp",
-  "version": "0.8.3",
+  "version": "0.9.0-preview.10",
   "description": "LoomWeaver: open-source plugin platform for Angular workbenches. The MCP server: scaffolding and validation as tools, so an AI assistant in any product repo can build weavers without a checkout.",
   "keywords": [
     "loomweaver",