sad-mcp 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sad-mcp",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "MCP server for Software Analysis and Design course materials at BGU",
   "type": "module",
   "bin": {

package/skills/uml-use-case-diagram/SKILL.md

@@ -28,6 +28,9 @@ The shared files prepended to this prompt define the layout recipes, model shape
 5. **Every use case must have at least one association line to an actor.**
 6. **Actors must not overlap** — minimum 200px vertical distance between actor centers.
 7. **Default: zero «include» and zero «extend».** Most diagrams need none. More than two is almost always wrong. §4 defines a gate every such relationship must pass before you draw it.
+8. **UC labels describe actions WITH the information system, not physical real-world actions.** See §3 for the full rule and verb list.
+9. **Every system-time / cron actor association MUST carry a timing label** (e.g., "פעם ביום", "כל 5 דקות"). See §2 and §8 for rendering.
+10. **No "send-only" use cases.** If a UC's entire behavior is sending a message / notification / alert / email / SMS, it is not a UC — it is a step inside the UC that *decided* to send it. See §3.
 
 ---
 
@@ -56,18 +59,32 @@ The shared files prepended to this prompt define the layout recipes, model shape
 
 **System administrator** — include unless explicitly excluded. Responsible for managing the master data of every entity the system references. Each entity gets its own specific UC (not one catch-all).
 
+**System-time / cron actor (שחקן זמן).** Draw as a system-style actor (amber head, `«system»` label). Every association line from a time actor MUST carry a visible timing label at the midpoint (e.g., `פעם ביום`, `כל 5 דקות`, `בסוף חודש`). Without a timing label the trigger frequency is ambiguous and the diagram is incomplete. Rendering: the label is injected as a `<g class="timing-label">` (white `<rect>` + `<text>`) after `fixLayout` sets the endpoint coordinates — see §8.
+
 ---
 
 ## 3. Use Case Rules
 
 **Granularity**: one complete user goal per UC, achievable in one session.
 
+**Labels describe actions WITH the information system, not physical real-world actions.** A use case is the actor's interaction with the IS; the verb must imply data entry, query, or a system-state change.
+
+- ✅ Preferred verbs: `רישום`, `הזנה`, `עדכון`, `הצגה`, `הפקה` (of a report), `שליחה` (of a notification), `אישור`, `הקצאה`, `חיפוש`, `סגירה`, `פתיחה` (of a record).
+- ❌ Bare physical verbs that describe things happening outside the system: `הכנת משלוח` (physical preparing), `ספירת מלאי` (physical counting), `מסירת חבילה` (physical delivering), `תשלום במזומן` (physical paying).
+- **Fix rule:** when the requirement uses a physical verb, wrap it with a system verb. `הכנת משלוח` → `רישום הכנת משלוח` or `סימון משלוח כמוכן`. `ביצוע ספירת מלאי` → `הזנת תוצאות ספירת מלאי`. `קבלת משלוח` → `קליטת משלוח נכנס` (data entry on arrival).
+
 **When to combine vs. separate "ניהול X":**
 - Simple entity (just a form): single "ניהול X" is fine.
 - Complex entity with sub-items, lifecycle states, or different actors per operation: separate UCs (open / update / cancel / approve).
 
 **Implied UCs**: every entity the system references needs at least one UC that manages it.
 
+**No "send-only" use cases.** A UC must carry non-trivial behavior (decision, data entry, state change, non-trivial computation). If the only behavior is firing a message, it is not a UC — it is a system step inside the UC that *decided* to send.
+
+- ❌ Wrong UCs: `שליחת התראה`, `שליחת מייל אישור`, `שליחת SMS`, `הודעה למנהל`, `שליחת דוח`.
+- ✅ Fold into the decider: the alert send-step belongs inside `עדכון רמות מלאי` (which *detected* the low stock); the confirmation email belongs inside `אישור הזמנה` (which *decided* to confirm).
+- This rule applies even when the send is triggered by a condition — conditional sending is part of the conditional UC, not its own UC.
+
 ---
 
 ## 4. Include and Extend — Mandatory Justification Gate
@@ -225,17 +242,30 @@ function fixLayout(layout) {
   sortCol(cols.left,  'left');
   sortCol(cols.right, 'right');
 
-  // Step 3 — Initial Y assignment per column.
-  function place(ucs, colX) {
+  // Step 3 — Adaptive column X positions. Account for actual ellipse widths so
+  // adjacent columns never overlap horizontally. Widen the boundary if needed.
+  const COL_GAP = 30;
+  const maxRx = ucs => (ucs.length ? Math.max(...ucs.map(u => u.rx)) : 0);
+  const lRx = maxRx(cols.left), cRx = maxRx(cols.center), rRx = maxRx(cols.right);
+  const gaps =
+    (cRx ? 2 * COL_GAP : (lRx && rRx ? 2 * COL_GAP : 0));
+  const needed = 2 * UC_PAD + 2 * lRx + 2 * cRx + 2 * rRx + gaps;
+  if (b.width < needed) b.width = needed;
+
+  const leftX   = b.x + UC_PAD + lRx;
+  const rightX  = b.x + b.width - UC_PAD - rRx;
+  const centerX = (leftX + rightX) / 2;
+
+  function place(ucs, colX, colName) {
     ucs.forEach((uc, i) => {
       uc.cy = b.y + HEADER_H + UC_PAD + uc.ry + i * (uc.ry * 2 + UC_GAP);
       uc.cx = colX;
-      uc.col = ucSide[uc.id] || 'center';
+      uc.col = colName;
     });
   }
-  place(cols.left,   b.x + b.width * 0.28);
-  place(cols.right,  b.x + b.width * 0.72);
-  place(cols.center, b.x + b.width * 0.50);
+  place(cols.left,   leftX,   'left');
+  place(cols.right,  rightX,  'right');
+  place(cols.center, centerX, 'center');
 
   // Step 4 — Clamp and resolve overlaps. Idempotent fixed-point loop.
   const minX = b.x + UC_PAD;
@@ -314,15 +344,26 @@ function fixLayout(layout) {
     line.setAttribute('x2', x2); line.setAttribute('y2', y2);
   });
 
-  // Step 9 — Resize boundary rect and SVG viewBox.
+  // Step 9 — Resize boundary rect and SVG viewBox (BOTH width and height).
   const br = svg.querySelector('.system-boundary, rect[rx="12"]');
-  if (br) br.setAttribute('height', b.height);
+  if (br) { br.setAttribute('width', b.width); br.setAttribute('height', b.height); }
   const vb = svg.getAttribute('viewBox');
   if (vb) {
     const p = vb.split(/\s+/);
+    // Height: fit boundary + any bottom actors.
     p[3] = Math.max(parseFloat(p[3]), b.y + b.height + 120);
+    // Width: fit the rightmost actor + label margin. Without this, widening the
+    // boundary pushes right-column actors off the visible SVG.
+    const ACTOR_LABEL_MARGIN = 120;  // covers stick figure width + longest label
+    const maxActorX = layout.actors.length
+      ? Math.max(...layout.actors.map(a => a.x))
+      : b.x + b.width;
+    p[2] = Math.max(parseFloat(p[2]), maxActorX + ACTOR_LABEL_MARGIN);
     svg.setAttribute('viewBox', p.join(' '));
   }
+
+  // Step 10 — Decorate timed associations (see §8 renderTimingLabels).
+  if (typeof renderTimingLabels === 'function') renderTimingLabels(layout);
 }
 ```
 
@@ -420,7 +461,52 @@ document.addEventListener('click', e => {
 UC group: `<g id="uc-uc1" data-uc-id="uc1" onclick="showDesc('uc1','uc',event)" style="cursor:pointer">`
 Actor group: `<g id="actor-student" data-actor-id="student" onclick="showDesc('student','actor',event)" style="cursor:pointer">`
 
-**Association labels (timing/frequency):** when an actor connection has a timing annotation (e.g., "פעם ביום" for a cron actor), add a `<text>` with a white `<rect>` behind it at the midpoint of the line after `fixLayout` has set the endpoints.
+### Timing labels on cron/time-actor associations (required)
+
+When a connection carries a `timing` field (every connection from a system-time actor MUST have one — see §2), inject the label at the line midpoint **after** `fixLayout` has written the endpoints. The helper below is idempotent: it removes any existing `.timing-label` group before re-rendering, so calling it again after another `fixLayout` pass is safe.
+
+```javascript
+function renderTimingLabels(layout) {
+  const svg = document.getElementById(layout.svgId);
+  if (!svg) return;
+  svg.querySelectorAll('.timing-label').forEach(el => el.remove());
+  const NS = 'http://www.w3.org/2000/svg';
+  (layout.connections || []).forEach(conn => {
+    if (!conn.timing) return;
+    const line = svg.querySelector(
+      `[data-conn-from="${conn.from}"][data-conn-to="${conn.to}"]`);
+    if (!line) return;
+    const x1 = +line.getAttribute('x1'), y1 = +line.getAttribute('y1');
+    const x2 = +line.getAttribute('x2'), y2 = +line.getAttribute('y2');
+    const mx = (x1 + x2) / 2, my = (y1 + y2) / 2;
+    const w = 10 + conn.timing.length * 7, h = 16;
+    const g = document.createElementNS(NS, 'g');
+    g.setAttribute('class', 'timing-label');
+    const rect = document.createElementNS(NS, 'rect');
+    rect.setAttribute('x', mx - w / 2); rect.setAttribute('y', my - h / 2);
+    rect.setAttribute('width', w);      rect.setAttribute('height', h);
+    rect.setAttribute('fill', 'white'); rect.setAttribute('stroke', '#334155');
+    rect.setAttribute('stroke-width', '0.8'); rect.setAttribute('rx', '3');
+    const text = document.createElementNS(NS, 'text');
+    text.setAttribute('x', mx); text.setAttribute('y', my + 4);
+    text.setAttribute('font-size', '10'); text.setAttribute('text-anchor', 'middle');
+    text.setAttribute('fill', '#334155');
+    text.setAttribute('font-family', "'Noto Sans Hebrew', sans-serif");
+    text.setAttribute('direction', 'rtl');
+    text.textContent = conn.timing;
+    g.appendChild(rect); g.appendChild(text);
+    svg.appendChild(g);
+  });
+}
+```
+
+Call `renderTimingLabels(layout)` at the end of every `fixLayout` invocation, **and** on `DOMContentLoaded` (after the initial `fixLayout`). Add it inside `showDiagram(index)` too so the label tracks the active tab.
+
+The `connections` entry for a timed link looks like:
+
+```javascript
+{ from: 'cron', to: 'uc-daily-reconcile', type: 'association', timing: 'פעם ביום' }
+```
 
 ---
 
@@ -540,5 +626,9 @@ For a single-tab diagram, drop the tab bar, the split-rationale line, and the se
 - [ ] `fixLayout` runs on `DOMContentLoaded` and on the Fix Layout button; uses named constants (HEADER_H, UC_PAD, UC_GAP, ACTOR_PAD), not magic numbers.
 - [ ] UC and actor description popups wired to every `data-uc-id` / `data-actor-id` element.
 - [ ] System actors drawn as stick figures with `«system»` label (not rectangles).
+- [ ] Every UC label describes an action WITH the information system (data entry, query, state change) — no bare physical verbs (`הכנת X`, `ספירת X`, `מסירת X`, `תשלום במזומן`). Physical verbs are wrapped with a system verb (`רישום`, `הזנה`, `עדכון`, `סימון`, etc.).
+- [ ] Every system-time / cron actor association has a `timing` field (and the rendered diagram shows a visible label at the line midpoint) — no unlabeled cron connections.
+- [ ] No "send-only" UCs (no bare `שליחת X` / `הודעה ל-X`); message-sends are folded into the UC that decided to send.
+- [ ] `fixLayout` uses adaptive column X (widens boundary if needed so left/center/right ellipses never overlap horizontally) AND expands viewBox width so right-side actors are not clipped.
 - [ ] If split: each tab has a split-rationale line citing the actual trigger that fired (count > 8, or 2+ disjoint actor groups); `showDiagram` and per-tab `fixLayout` wired per §11.
 - [ ] `diagramModel` defined per `model-shape.md`; VP export button present and wired to `exportXMI()`.