storymaps 1.2.2 → 1.2.4

package/README.md

@@ -265,7 +265,7 @@ The CLI works with any storymaps.io instance:
 storymaps init --site storymaps.yourcompany.com
 ```
 
-See the [main project README](https://github.com/jackgleeson/userstorymaps#self-hosting) for setup instructions.
+See the [main project README](https://github.com/jackgleeson/storymaps.io#self-hosting) for setup instructions.
 
 ## Licence
 

package/lib/core/yaml.js

@@ -175,13 +175,15 @@ export function jsonToYamlObj(data) {
         if (stepTypes[i] === 'partial') return { partial: partialSlugMap[step.partialMapId] };
         const name = resolvedNames[i];
         const hasExtra = (step.color && step.color !== DEFAULT_STEP_COLOR)
-            || step.url || step.body || step.points != null;
+            || step.body || step.url || step.status || step.points != null || step.tags?.length;
         if (!hasExtra) return name;
         const obj = { name };
         if (step.color && step.color !== DEFAULT_STEP_COLOR) obj.color = step.color;
         if (step.body) obj.body = step.body;
         if (step.url) obj.url = step.url;
+        if (step.status) obj.status = step.status;
         if (step.points != null) obj.points = step.points;
+        if (step.tags?.length) obj.tags = [...step.tags];
         return obj;
     });
 
@@ -330,9 +332,11 @@ export function yamlObjToJson(obj) {
         stepNameToIndex[rawName] = jsonSteps.length;
         const s = { name: displayName, color };
         if (typeof step === 'object' && step !== null) {
-            if (step.url) s.url = step.url;
             if (step.body) s.body = step.body;
+            if (step.url) s.url = step.url;
+            if (step.status) s.status = step.status;
             if (step.points != null) s.points = step.points;
+            if (step.tags?.length) s.tags = [...step.tags];
         }
         jsonSteps.push(s);
     });

package/lib/util/summary.js

@@ -4,6 +4,114 @@
 import chalk from 'chalk';
 import jsyaml from 'js-yaml';
 
+// Fields compared on cards and steps that exist on both sides
+const FIELDS = ['body', 'color', 'url', 'status', 'points', 'tags'];
+
+const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+
+// Slice names can span lines (e.g. "V1:\nBasic House"); keep each summary entry on one line
+const oneLine = (s) => String(s ?? '').replace(/\s*\n\s*/g, ' ');
+
+const changedFields = (a, b) =>
+    FIELDS.filter(f => JSON.stringify(a?.[f] ?? null) !== JSON.stringify(b?.[f] ?? null));
+
+// True when the names both lists share appear in a different order
+const reordered = (oldNames, newNames) => {
+    const common = oldNames.filter(n => newNames.includes(n));
+    const commonNew = newNames.filter(n => oldNames.includes(n));
+    return common.join('\n') !== commonNew.join('\n');
+};
+
+// Compare located cards ({ card, group, at }) across the whole map. Cards are
+// paired by name in order, so a card that changes slice or step counts as moved
+// rather than removed and added. Returns per-group summary lines.
+function compareCards(oldItems, newItems) {
+    const stats = new Map();
+    const statsFor = (group) => {
+        if (!stats.has(group)) stats.set(group, { added: 0, removed: 0, moved: 0, updated: 0, fields: new Set() });
+        return stats.get(group);
+    };
+    // Report groups in their new order, then any that only exist on the old side
+    newItems.forEach(i => statsFor(i.group));
+    oldItems.forEach(i => statsFor(i.group));
+
+    const byName = (items) => {
+        const map = new Map();
+        for (const item of items) {
+            const name = item.card?.name ?? '';
+            if (!map.has(name)) map.set(name, []);
+            map.get(name).push(item);
+        }
+        return map;
+    };
+    const oldByName = byName(oldItems);
+    const newByName = byName(newItems);
+
+    for (const name of new Set([...oldByName.keys(), ...newByName.keys()])) {
+        const o = oldByName.get(name) || [];
+        const c = newByName.get(name) || [];
+        const paired = Math.min(o.length, c.length);
+        for (let i = 0; i < paired; i++) {
+            const s = statsFor(c[i].group);
+            if (o[i].group !== c[i].group || o[i].at !== c[i].at) s.moved++;
+            const fields = changedFields(o[i].card, c[i].card);
+            if (fields.length) {
+                s.updated++;
+                fields.forEach(f => s.fields.add(f));
+            }
+        }
+        c.slice(paired).forEach(item => statsFor(item.group).added++);
+        o.slice(paired).forEach(item => statsFor(item.group).removed++);
+    }
+
+    const lines = [];
+    for (const [group, s] of stats) {
+        // Equal numbers of unmatched adds and removes means the cards were renamed
+        if (s.added && s.added === s.removed) {
+            lines.push(chalk.yellow(`  ~ ${oneLine(group)}: ${plural(s.added, 'card')} renamed`));
+        } else {
+            if (s.added) lines.push(chalk.green(`  + ${oneLine(group)}: ${plural(s.added, 'card')}`));
+            if (s.removed) lines.push(chalk.red(`  - ${oneLine(group)}: ${plural(s.removed, 'card')}`));
+        }
+        if (s.moved) lines.push(chalk.yellow(`  ~ ${oneLine(group)}: ${plural(s.moved, 'card')} moved`));
+        if (s.updated) {
+            lines.push(chalk.yellow(`  ~ ${oneLine(group)}: ${plural(s.updated, 'card')} updated (${[...s.fields].join(', ')})`));
+        }
+    }
+    return lines;
+}
+
+function compareLegend(oldLegend, newLegend) {
+    const lines = [];
+    const key = e => `${e?.color ?? ''}\n${e?.label ?? ''}`;
+    const removed = [...oldLegend];
+    const added = [];
+    for (const entry of newLegend) {
+        const i = removed.findIndex(e => key(e) === key(entry));
+        if (i >= 0) removed.splice(i, 1);
+        else added.push(entry);
+    }
+    // Same color with a new label is a rename; same label with a new color is a recolor
+    for (const entry of [...added]) {
+        let i = removed.findIndex(e => e.color === entry.color);
+        if (i >= 0) {
+            lines.push(chalk.yellow(`  ~ legend: ${removed[i].label} → ${entry.label}`));
+        } else if ((i = removed.findIndex(e => e.label === entry.label)) >= 0) {
+            lines.push(chalk.yellow(`  ~ legend: ${entry.label} color changed`));
+        } else {
+            continue;
+        }
+        removed.splice(i, 1);
+        added.splice(added.indexOf(entry), 1);
+    }
+    for (const e of added) lines.push(chalk.green(`  + legend: ${e.label}`));
+    for (const e of removed) lines.push(chalk.red(`  - legend: ${e.label}`));
+    if (!lines.length && reordered(oldLegend.map(key), newLegend.map(key))) {
+        lines.push(chalk.yellow('  ~ legend reordered'));
+    }
+    return lines;
+}
+
 export function changeSummary(oldYaml, newYaml) {
     const old = jsyaml.load(oldYaml);
     const cur = jsyaml.load(newYaml);
@@ -15,13 +123,15 @@ export function changeSummary(oldYaml, newYaml) {
     }
 
     // Steps (skip spacers and partial refs)
-    const stepName = s => {
-        if (typeof s === 'string' && s !== 'spacer') return s;
-        if (typeof s === 'object' && s?.name) return s.name;
+    const toStep = s => {
+        if (typeof s === 'string' && s !== 'spacer') return { name: s };
+        if (typeof s === 'object' && s?.name) return s;
         return null;
     };
-    const oldSteps = (old.steps || []).map(stepName).filter(Boolean);
-    const newSteps = (cur.steps || []).map(stepName).filter(Boolean);
+    const oldStepObjs = (old.steps || []).map(toStep).filter(Boolean);
+    const newStepObjs = (cur.steps || []).map(toStep).filter(Boolean);
+    const oldSteps = oldStepObjs.map(s => s.name);
+    const newSteps = newStepObjs.map(s => s.name);
     const addedSteps = newSteps.filter(s => !oldSteps.includes(s));
     const removedSteps = oldSteps.filter(s => !newSteps.includes(s));
     if (addedSteps.length || removedSteps.length) {
@@ -31,55 +141,74 @@ export function changeSummary(oldYaml, newYaml) {
         for (const s of addedSteps) lines.push(chalk.green(`    + ${s}`));
         for (const s of removedSteps) lines.push(chalk.red(`    - ${s}`));
     }
+    if (reordered(oldSteps, newSteps)) lines.push(chalk.yellow('  ~ steps reordered'));
+    const stepFields = new Set();
+    let updatedSteps = 0;
+    for (const step of newStepObjs) {
+        const before = oldStepObjs.find(s => s.name === step.name);
+        if (!before) continue;
+        const fields = changedFields(before, step);
+        if (fields.length) {
+            updatedSteps++;
+            fields.forEach(f => stepFields.add(f));
+        }
+    }
+    if (updatedSteps) {
+        lines.push(chalk.yellow(`  ~ steps: ${plural(updatedSteps, 'step')} updated (${[...stepFields].join(', ')})`));
+    }
 
     // Slices
     const oldSlices = (old.slices || []).map(s => s.name);
     const newSlices = (cur.slices || []).map(s => s.name);
-    for (const s of newSlices.filter(s => !oldSlices.includes(s))) {
-        lines.push(chalk.green(`  + slice: ${s}`));
+    // A slice whose name changed in the same position is a rename, so its cards aren't reported as moved
+    const sliceRenames = new Map();
+    oldSlices.forEach((name, i) => {
+        const newName = newSlices[i];
+        if (newName !== undefined && !newSlices.includes(name) && !oldSlices.includes(newName)) {
+            sliceRenames.set(name, newName);
+        }
+    });
+    const currentName = name => sliceRenames.get(name) ?? name;
+    for (const [from, to] of sliceRenames) {
+        lines.push(chalk.yellow(`  ~ slice: ${oneLine(from)} → ${oneLine(to)}`));
     }
-    for (const s of oldSlices.filter(s => !newSlices.includes(s))) {
-        lines.push(chalk.red(`  - slice: ${s}`));
+    const renamedTo = new Set(sliceRenames.values());
+    for (const s of newSlices.filter(s => !oldSlices.includes(s) && !renamedTo.has(s))) {
+        lines.push(chalk.green(`  + slice: ${oneLine(s)}`));
+    }
+    for (const s of oldSlices.filter(s => !newSlices.includes(s) && !sliceRenames.has(s))) {
+        lines.push(chalk.red(`  - slice: ${oneLine(s)}`));
+    }
+    if (reordered(oldSlices.map(currentName), newSlices)) lines.push(chalk.yellow('  ~ slices reordered'));
+    for (const slice of cur.slices || []) {
+        const before = (old.slices || []).find(s => currentName(s.name) === slice.name);
+        if (!before) continue;
+        if (!!before.collapsed !== !!slice.collapsed || before.closedReason !== slice.closedReason) {
+            const state = !slice.collapsed ? 'reopened' : slice.closedReason === 'closed' ? 'closed' : 'completed';
+            lines.push(chalk.yellow(`  ~ slice: ${oneLine(slice.name)} ${state}`));
+        }
     }
 
-    // Detect card-level changes per slice (name-aware, handles renames)
-    const collectCardNames = (map) => {
-        const result = {};
-        for (const slice of (map.slices || [])) {
-            const names = [];
-            for (const cards of Object.values(slice.stories || {})) {
-                if (Array.isArray(cards)) names.push(...cards.map(c => c.name).filter(Boolean));
+    // Cards: users, activities and stories in every slice
+    const collectCards = (map, sliceName) => {
+        const items = [];
+        for (const group of ['users', 'activities']) {
+            for (const card of map[group] || []) items.push({ card, group, at: card.step });
+        }
+        for (const slice of map.slices || []) {
+            const group = sliceName(slice.name);
+            for (const [step, cards] of Object.entries(slice.stories || {})) {
+                if (Array.isArray(cards)) cards.forEach(card => items.push({ card, group, at: step }));
             }
-            result[slice.name] = names;
         }
-        return result;
+        return items;
     };
-    const oldCards = collectCardNames(old);
-    const newCards = collectCardNames(cur);
-    for (const sliceName of new Set([...Object.keys(oldCards), ...Object.keys(newCards)])) {
-        const oldNames = oldCards[sliceName] || [];
-        const newNames = newCards[sliceName] || [];
-        const oldCounts = new Map();
-        const newCounts = new Map();
-        for (const n of oldNames) oldCounts.set(n, (oldCounts.get(n) || 0) + 1);
-        for (const n of newNames) newCounts.set(n, (newCounts.get(n) || 0) + 1);
-        const allNames = new Set([...oldCounts.keys(), ...newCounts.keys()]);
-        let added = 0, removed = 0;
-        for (const n of allNames) {
-            const o = oldCounts.get(n) || 0;
-            const c = newCounts.get(n) || 0;
-            if (c > o) added += c - o;
-            if (o > c) removed += o - c;
-        }
-        if (added === 0 && removed === 0) continue;
-        const net = newNames.length - oldNames.length;
-        if (net === 0) {
-            const word = added === 1 ? 'card' : 'cards';
-            lines.push(chalk.yellow(`  ~ ${sliceName}: ${added} ${word} renamed`));
-        } else {
-            if (added) lines.push(chalk.green(`  + ${sliceName}: ${added} ${added === 1 ? 'card' : 'cards'}`));
-            if (removed) lines.push(chalk.red(`  - ${sliceName}: ${removed} ${removed === 1 ? 'card' : 'cards'}`));
-        }
+    lines.push(...compareCards(collectCards(old, currentName), collectCards(cur, name => name)));
+
+    lines.push(...compareLegend(old.legend || [], cur.legend || []));
+
+    if (JSON.stringify(old.partials ?? null) !== JSON.stringify(cur.partials ?? null)) {
+        lines.push(chalk.yellow('  ~ partials updated'));
     }
 
     // Notes
@@ -96,9 +225,12 @@ export function changeSummary(oldYaml, newYaml) {
 
 export function printChangeSummary(oldYaml, newYaml) {
     const lines = changeSummary(oldYaml, newYaml);
-    if (lines.length === 0) {
+    if (lines.length) {
+        lines.forEach(l => console.log(l));
+    } else if (oldYaml === newYaml) {
         console.log(chalk.dim('No changes.'));
     } else {
-        lines.forEach(l => console.log(l));
+        // Something differs that the summary doesn't describe (e.g. card order within a step)
+        console.log(chalk.yellow(`  ~ changes not shown in summary, run ${chalk.cyan('storymaps diff --full')} to see them`));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storymaps",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "CLI tool for storymaps.io - import, export, validate, and manage user story maps from the terminal",
   "type": "module",
   "bin": {