eventmodeler 0.6.8 → 0.6.10

package/dist/index.js

@@ -2576,6 +2576,33 @@ function getEntry(doc, scope, id) {
     return;
   return entry instanceof Y4.AbstractType ? entry.toJSON() : entry;
 }
+// ../packages/canvas-model/src/dimensions.ts
+var ELEMENT_DIMENSIONS = {
+  commandSticky: { width: 160, height: 100 },
+  eventSticky: { width: 160, height: 100 },
+  readModelSticky: { width: 160, height: 100 },
+  screen: { width: 180, height: 120 },
+  processor: { width: 120, height: 120 },
+  slice: { width: 300, height: 200 },
+  aggregate: { width: 300, height: 200 },
+  actor: { width: 300, height: 200 },
+  chapter: { width: 800, height: 1200 },
+  note: { width: 200, height: 150 },
+  externalEvent: { width: 160, height: 100 },
+  context: { width: 300, height: 200 },
+  swimLane: { width: 300, height: 200 }
+};
+var FIXED_SIZE_SCOPE_DIMENSIONS = {
+  commands: ELEMENT_DIMENSIONS.commandSticky,
+  events: ELEMENT_DIMENSIONS.eventSticky,
+  readModels: ELEMENT_DIMENSIONS.readModelSticky,
+  screens: ELEMENT_DIMENSIONS.screen,
+  processors: ELEMENT_DIMENSIONS.processor,
+  externalEvents: ELEMENT_DIMENSIONS.externalEvent
+};
+function canonicalSizeForScope(scope) {
+  return FIXED_SIZE_SCOPE_DIMENSIONS[scope];
+}
 // ../packages/canvas-model/src/actions.ts
 import * as Y5 from "yjs";
 // ../packages/canvas-model/src/containment.ts
@@ -2705,7 +2732,7 @@ var FieldTypeSchema = z.enum([
   "Custom"
 ]);
 var FieldBase = z.object({
-  id: z.string().uuid().optional(),
+  id: z.string().uuid().default(() => crypto.randomUUID()),
   name: z.string().min(1),
   fieldType: FieldTypeSchema,
   isList: z.boolean().optional(),
@@ -3704,6 +3731,22 @@ function knownTypeAliases() {
   return TYPES.map((t) => t.type);
 }
 
+// src/lib/enforce-size.ts
+function enforceCanonicalSize(meta, entry) {
+  const dims = canonicalSizeForScope(meta.scope);
+  if (!dims)
+    return;
+  const hadW = typeof entry.width === "number";
+  const hadH = typeof entry.height === "number";
+  const mismatched = hadW && entry.width !== dims.width || hadH && entry.height !== dims.height;
+  entry.width = dims.width;
+  entry.height = dims.height;
+  if (mismatched) {
+    return `${meta.type} is a fixed-size element; using canonical ${dims.width}x${dims.height}.`;
+  }
+  return;
+}
+
 // src/commands/create.ts
 var CREATE_HELP = `
 Place a new element described by a JSON shape. The JSON is validated against
@@ -3714,6 +3757,12 @@ type-specific fields (e.g. \`status\` on slices, \`fields\` on stickies).
 Notes use \`title\` instead of \`name\`. The CLI fills in the id and modelId
 automatically — agents do not need to supply them.
 
+Fixed-size elements (command, event, read-model, screen, processor,
+external-event) are not resizable in the editor: the CLI always writes their
+canonical dimensions, so width/height are optional and any supplied size is
+overridden (a note is printed when it differs). Containers (slice, chapter,
+context, …) are resizable — pass the size you want.
+
 Screens accept an optional \`design\` field — an Excalidraw scene as a JSON
 array of elements. The CLI converts the array to the Y.Doc representation that
 the canvas streams in realtime, so passing valid Excalidraw JSON is enough:
@@ -3745,6 +3794,11 @@ function registerCreateCommands(program) {
       console.error(`Invalid JSON: ${err.message}`);
       process.exit(2);
     }
+    if (parsed && typeof parsed === "object") {
+      const note = enforceCanonicalSize(meta, parsed);
+      if (note)
+        console.error(note);
+    }
     const validation = validateEntry(meta.scope, parsed);
     if (!validation.ok) {
       console.error(`Validation failed for ${meta.type}:`);
@@ -3822,10 +3876,13 @@ Pattern (read-modify-write):
     | jq '.fields += [{"name":"customerId","fieldType":"UUID","isList":false,"isGenerated":false}]')
   eventmodeler update event "OrderPlaced" "$NEW"
 
-Linked-copy entries cannot be updated. They share the original's name and
-fields by design — edit the original and all copies pick up the change. The
-CLI refuses both name-based updates (ambiguous with the original) and
---id <copy-uuid> updates (would diverge from the original).
+Linked-copy entries can be repositioned/resized but never re-identified. A
+copy shares its original's name and fields by design, so an update to a copy
+writes geometry (x, y, width, height) only — any name/field keys in the
+payload are ignored. To change a copy's name or fields, edit the original and
+all copies pick up the change. Address a copy by uuid:
+
+  eventmodeler --id <copy-uuid> update event '{"x":120,"y":340}'
 
 Flows have no addressable name and must be updated via uuid:
 
@@ -3840,6 +3897,33 @@ semantics); to preserve it, round-trip via \`show screen ... | jq\`.
 This is a *replace*, not a patch: keys present in the previous entry but
 absent in the new JSON are removed.
 `;
+var GEOMETRY_KEYS = ["x", "y", "width", "height"];
+function extractGeometry(parsed) {
+  if (!parsed || typeof parsed !== "object") {
+    return { ok: false, values: {}, issues: ["payload must be a JSON object"] };
+  }
+  const obj = parsed;
+  const values = {};
+  const issues = [];
+  for (const k of GEOMETRY_KEYS) {
+    const v = obj[k];
+    if (v === undefined)
+      continue;
+    if (typeof v !== "number" || !Number.isFinite(v)) {
+      issues.push(`${k} must be a finite number`);
+      continue;
+    }
+    if ((k === "width" || k === "height") && v <= 0) {
+      issues.push(`${k} must be positive`);
+      continue;
+    }
+    values[k] = v;
+  }
+  if (issues.length === 0 && Object.keys(values).length === 0) {
+    issues.push("no geometry fields (x, y, width, height) present to update");
+  }
+  return { ok: issues.length === 0, values, issues };
+}
 function registerUpdateCommands(program) {
   program.command("update <type> <args...>").description(`Replace an element's shape with JSON. Types: ${knownTypeAliases().join(", ")}`).option("--model <id>", "Model id (defaults to .eventmodeler.json in cwd)").addHelpText("after", UPDATE_HELP).action(async (type, args, opts) => {
     const meta = resolveType(type);
@@ -3874,12 +3958,10 @@ function registerUpdateCommands(program) {
       console.error(`Invalid JSON: ${err.message}`);
       process.exit(2);
     }
-    const validation = validateEntry(meta.scope, parsed);
-    if (!validation.ok) {
-      console.error(`Validation failed for ${meta.type}:`);
-      for (const issue of validation.issues)
-        console.error(`  - ${issue}`);
-      process.exit(2);
+    if (parsed && typeof parsed === "object") {
+      const note = enforceCanonicalSize(meta, parsed);
+      if (note)
+        console.error(note);
     }
     const modelId = resolveModelId(opts.model);
     await withDoc(modelId, (doc) => {
@@ -3887,19 +3969,39 @@ function registerUpdateCommands(program) {
         idOverride,
         includeLinkedCopies: Boolean(idOverride)
       });
+      const map = getScopeMap(doc, meta.scope);
       if (entry.isLinkedCopy) {
-        const originalId = meta.originalIdKey ? entry[meta.originalIdKey] : undefined;
-        console.error(`Cannot update ${meta.type} ${id} — it is a linked copy. ` + `Linked copies share their original's name and fields; edit the original instead` + (originalId ? ` (--id ${originalId}).` : "."));
+        const geom = extractGeometry(parsed);
+        if (!geom.ok) {
+          console.error(`Cannot update ${meta.type} ${id} (linked copy):`);
+          for (const issue of geom.issues)
+            console.error(`  - ${issue}`);
+          process.exit(2);
+        }
+        doc.transact(() => {
+          const e = map.get(id);
+          if (!e)
+            return;
+          for (const [k, v] of Object.entries(geom.values))
+            e.set(k, v);
+        });
+        console.log(`Updated ${meta.type} geometry (linked copy — name and fields stay tied to the original).`);
+        return;
+      }
+      const validation = validateEntry(meta.scope, parsed);
+      if (!validation.ok) {
+        console.error(`Validation failed for ${meta.type}:`);
+        for (const issue of validation.issues)
+          console.error(`  - ${issue}`);
         process.exit(2);
       }
-      const map = getScopeMap(doc, meta.scope);
       const finalEntry = { ...validation.data, [meta.idKey]: id, modelId };
       doc.transact(() => {
         map.delete(id);
         map.set(id, deepToY(finalEntry));
       });
+      console.log(`Updated ${meta.type}.`);
     });
-    console.log(`Updated ${meta.type}.`);
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eventmodeler",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "description": "CLI tool for event modeling - explore, design, and generate code from your event models",
   "type": "module",
   "repository": {