dsh-model-everything 0.5.1 → 0.6.0

package/lib/diagram-render-tool.js

@@ -11,7 +11,7 @@ import { writeSvg } from './render/write.js';
 export const DIAGRAM_TOOL_NAME = 'diagram_render';
 export const diagramRenderTool = defineTool({
     name: DIAGRAM_TOOL_NAME,
-    description: 'Draw a diagram from its source text and get back SVG. Accepts Mermaid (flowchart, stateDiagram) and PlantUML (component, package, state) for the subset this renderer draws, lays out boxes and arrows itself, and reports every line it refused with its line number instead of drawing half a diagram. Pass `out` to write the SVG next to a document. This tool draws; it does not parse a diagram back into a model, and it does not review one - uml_parse and uml_review do that.',
+    description: 'Draw a diagram from its source text and get back SVG. Structure is read from a picture, so reach for this whenever the answer is a layout, a flow, a set of boundaries or a change between two of them - not only when the request says draw. Pass `out` to write the SVG and show it to the reader beside the explanation it carries, and read the model-everything-diagram skill for what this notation subset covers and what it refuses. It accepts Mermaid (flowchart, stateDiagram) and PlantUML (component, package, state), lays out boxes and arrows itself, and reports every line it refused with its line number instead of drawing half a diagram. This tool draws; it does not parse a diagram back into a model, and it does not review one - uml_parse and uml_review do that.',
     parameters: {
         source: {
             type: 'string',
@@ -58,6 +58,18 @@ export const diagramRenderTool = defineTool({
             }
             return [{ type: 'text', text: lines.join('\n') }];
         },
+        // The card a UI shows. The host keeps this on the settled call as `block.meta`, which is the one place a
+        // view can find the drawing's own source: by then the arguments are gone. Measured against how
+        // dsh-deepread's card reads its payload - the same field.
+        presentationMeta(args, value) {
+            const result = value;
+            const asked = args;
+            return {
+                source: typeof asked.source === 'string' ? asked.source : '',
+                scheme: typeof asked.scheme === 'string' ? asked.scheme : 'default',
+                caption: typeof result.caption === 'string' ? result.caption : '',
+            };
+        },
     },
     timeoutMs: 10_000,
     isConcurrencySafe: () => true,

package/lib/diagram-review-tool.js

@@ -19,7 +19,7 @@ function limitsOf(args) {
 }
 export const diagramReviewTool = defineTool({
     name: DIAGRAM_REVIEW_TOOL_NAME,
-    description: 'Review the structure of a diagram from its source text: how wide each boundary is, how deep they nest, and how many nodes the drawing holds, against budgets you can set. Accepts the same Mermaid and PlantUML subset as diagram_render and reports what it measured, so an empty report cannot be mistaken for a clean one. Read `verdict`, never `ok`. This reviews structure; it does not draw (diagram_render does) and it does not check behaviour (model_verify does).',
+    description: 'Review the structure of a diagram from its source text: how wide each boundary is, how deep they nest, and how many nodes the drawing holds, against budgets you can set. Run it before a drawing goes in front of a reader: a picture that needs scrolling is no longer a summary. Accepts the same Mermaid and PlantUML subset as diagram_render and reports what it measured, so an empty report cannot be mistaken for a clean one. Read `verdict`, never `ok`. This reviews structure; it does not draw (diagram_render does) and it does not check behaviour (model_verify does).',
     parameters: {
         source: {
             type: 'string',

package/lib/diagram.js

@@ -10,6 +10,7 @@
  * boot, from the Plugins page, or by disabling this row, and none of those touches the tools or the skills.
  */
 import z from '@deepseek-ai/schemastery';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { diagramDiffTool } from './diagram-diff-tool.js';
 import { diagramRenderTool } from './diagram-render-tool.js';
 import { diagramReviewTool } from './diagram-review-tool.js';
@@ -39,5 +40,37 @@ export function apply(ctx, config) {
     ctx.tools.register(diagramRenderTool);
     ctx.tools.register(diagramReviewTool);
     ctx.tools.register(diagramDiffTool);
+    registerAnnotateCommand(ctx);
+}
+/**
+ * Offer an annotation as a session command, so a page can send one without a composer.
+ *
+ * Optional on purpose, and failure-tolerant on purpose: a host without the commands service keeps the
+ * composer path, and a registration that throws must not take the drawing tools down with it.
+ */
+export function registerAnnotateCommand(ctx) {
+    const commands = ctx.get?.('commands');
+    if (commands === undefined || typeof commands.register !== 'function')
+        return;
+    try {
+        commands.register({
+            name: 'annotate',
+            description: 'Send a diagram annotation to this session',
+            handler: (invocation) => {
+                const raw = typeof invocation.rawInput === 'string' ? invocation.rawInput.trim().replace(/^\/?annotate\s*/i, '') : '';
+                const agent = invocation.agent;
+                const followup = agent?.followup;
+                if (raw === '' || typeof followup !== 'function')
+                    return { kind: 'error', text: 'this host cannot take a follow-up note' };
+                // A follow-up takes a UserMessage, not a bag of fields: the runtime stamps the id and the time, and a
+                // hand-built object reaches the inbox without them. `createUserMessage` is the host's own constructor.
+                followup.call(agent, createUserMessage({ content: [{ type: 'text', text: raw }], source: { kind: 'user' } }));
+                return { kind: 'success', text: 'annotation sent' };
+            },
+        });
+    }
+    catch {
+        // A host whose command API differs keeps the composer path; the tools above are already registered.
+    }
 }
 export const inject = ['tools'];

package/lib/gate.js

@@ -10,13 +10,15 @@
  *
  * Why it is a separate row. The plugin's doctrine is that a capability is discoverable
  * through its own tool description or skill text. Injection departs from that, so it is
- * opt-in and mounted as its own component: install it, disable it, or never enable it,
- * without touching the tools or the skills. `enabled` is a live switch, so the Web Plugins
- * page flips it inside a running host.
+ * mounted as its own component: the bundle's patch enables it, and the row can be turned off
+ * or removed without touching the tools or the skills. `enabled` is a live switch, so the Web
+ * Plugins page flips it inside a running host.
  *
- * Why it is off by default. It costs tokens in every session that turns it on, to fix a
- * problem text-only routing was measured not to have once the session engages. A deployment
- * that wants it says so; the default pays nothing.
+ * Why the bundle turns it on. Measured: a session that never decides to load a skill is never
+ * routed, and the catalog line is cut at 500 characters, so a domain the request names can be
+ * invisible at the moment of choosing. The cost is a fixed message in every session, which is
+ * why the switch is live and documented: turn it off where the bundle's default is wrong. The
+ * component's own `enabled` script default is off, so a bare `app.add(gate)` injects nothing.
  *
  * What it does not do. It routes; it checks nothing. It cannot make a skill load, and it
  * does not restate the doctrine - the skill bodies carry that, and duplicating them here