@vsirotin/ts-stop 1.13.1 → 2.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vsirotin/ts-stop",
-  "version": "1.13.1",
+  "version": "2.4.2",
   "description": "State Oriented Programming library for TypeScript",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -13,20 +13,18 @@
     },
     "./sfsm": {
       "types": "./lib/sfsm/index.d.ts",
-      "browser": "./lib/esm/sfsm/index.browser.js",
       "import": "./lib/esm/sfsm/index.js",
       "require": "./lib/sfsm/index.js"
     }
   },
   "files": [
     "lib",
-    "scripts/reduce-fa.js",
-    "scripts/merge-fas.js",
-    "scripts/merge-fas-from-dir.js",
-    "scripts/update-fa.js",
-    "README.md",
-    "LICENSE",
-    "LICENSE-COMMERCIAL.md"
+    "scripts",
+    "ai/skills",
+    "tutorial",
+    "LICENSE-COMMERCIAL.md",
+    "LICENSE-PUBLIC.md",
+    "release-notes.md"
   ],
   "bin": {
     "reduce-fa": "./scripts/reduce-fa.js",
@@ -60,6 +58,7 @@
     "@types/jest": "^29.5.14",
     "@types/js-yaml": "^4.0.9",
     "@types/mocha": "^10.0.10",
+    "@types/node": "^26.1.1",
     "jest": "^29.5.0",
     "js-yaml": "^4.1.1",
     "ts-jest": "^29.1.0",
@@ -67,5 +66,9 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "elkjs": "^0.12.0",
+    "xml2js": "^0.6.2"
   }
 }

package/scripts/compare-compact-jsons.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/**
+ * Compare two compact SFSM JSON files
+ * Usage: node compare-compact-jsons.js <json-a> <json-b>
+ */
+
+const fs = require('fs');
+
+// ============ MAIN ============
+function main() {
+  const [jsonAPath, jsonBPath] = process.argv.slice(2);
+  
+  if (!jsonAPath || !jsonBPath) {
+    console.error('Usage: node compare-compact-jsons.js <json-a> <json-b>');
+    process.exit(1);
+  }
+
+  try {
+    const jsonA = JSON.parse(fs.readFileSync(jsonAPath, 'utf-8'));
+    const jsonB = JSON.parse(fs.readFileSync(jsonBPath, 'utf-8'));
+    
+    console.log('\n======== SFSM COMPACT JSON COMPARISON ========\n');
+    console.log(`File A: ${jsonAPath}`);
+    console.log(`File B: ${jsonBPath}\n`);
+    
+    compareJsons(jsonA, jsonB);
+    
+  } catch (err) {
+    console.error('Error:', err.message);
+    process.exit(1);
+  }
+}
+
+// ============ COMPARISON LOGIC ============
+
+function compareJsons(jsonA, jsonB) {
+  const fasA = Object.keys(jsonA);
+  const fasB = Object.keys(jsonB);
+  
+  console.log('--- FA NAMES ---');
+  console.log(`A: [${fasA.join(', ')}] (${fasA.length} FAs)`);
+  console.log(`B: [${fasB.join(', ')}] (${fasB.length} FAs)`);
+  
+  const missingInB = fasA.filter(fa => !fasB.includes(fa));
+  const missingInA = fasB.filter(fa => !fasA.includes(fa));
+  
+  if (missingInB.length > 0) {
+    console.log(`  ❌ Missing in B: ${missingInB.join(', ')}`);
+  }
+  if (missingInA.length > 0) {
+    console.log(`  ❌ Missing in A: ${missingInA.join(', ')}`);
+  }
+  
+  const commonFas = fasA.filter(fa => fasB.includes(fa));
+  if (commonFas.length === fasA.length && commonFas.length === fasB.length) {
+    console.log(`  ✓ All FAs match\n`);
+  } else {
+    console.log();
+  }
+  
+  // Compare transitions per FA
+  console.log('--- TRANSITIONS PER FA ---');
+  let totalTransitionsA = 0;
+  let totalTransitionsB = 0;
+  let totalDifferences = 0;
+  
+  for (const fa of commonFas) {
+    const transA = jsonA[fa] || [];
+    const transB = jsonB[fa] || [];
+    
+    totalTransitionsA += transA.length;
+    totalTransitionsB += transB.length;
+    
+    console.log(`\nFA: ${fa}`);
+    console.log(`  A: ${transA.length} transitions`);
+    console.log(`  B: ${transB.length} transitions`);
+    
+    // Normalize transitions for comparison
+    const transANorm = transA.map(tr => normalizeTransition(tr));
+    const transBNorm = transB.map(tr => normalizeTransition(tr));
+    
+    // Find missing and extra transitions
+    const missingInBTrans = [];
+    const missingInATrans = [];
+    
+    for (let i = 0; i < transANorm.length; i++) {
+      const trStr = transANorm[i];
+      const found = transBNorm.some(t => t === trStr);
+      if (!found) {
+        missingInBTrans.push(transA[i]);
+      }
+    }
+    
+    for (let i = 0; i < transBNorm.length; i++) {
+      const trStr = transBNorm[i];
+      const found = transANorm.some(t => t === trStr);
+      if (!found) {
+        missingInATrans.push(transB[i]);
+      }
+    }
+    
+    if (missingInBTrans.length === 0 && missingInATrans.length === 0) {
+      console.log(`  ✓ All transitions match`);
+    } else {
+      if (missingInBTrans.length > 0) {
+        console.log(`  ❌ Missing in B (${missingInBTrans.length}):`);
+        for (const tr of missingInBTrans) {
+          console.log(`     ${JSON.stringify(tr)}`);
+        }
+        totalDifferences += missingInBTrans.length;
+      }
+      if (missingInATrans.length > 0) {
+        console.log(`  ❌ Extra in B / Missing in A (${missingInATrans.length}):`);
+        for (const tr of missingInATrans) {
+          console.log(`     ${JSON.stringify(tr)}`);
+        }
+        totalDifferences += missingInATrans.length;
+      }
+    }
+  }
+  
+  // Summary
+  console.log('\n--- SUMMARY ---');
+  console.log(`Total FAs:        A=${fasA.length}, B=${fasB.length}`);
+  console.log(`Total transitions: A=${totalTransitionsA}, B=${totalTransitionsB}`);
+  console.log(`Total differences: ${totalDifferences}`);
+  
+  if (totalDifferences === 0 && fasA.length === fasB.length && totalTransitionsA === totalTransitionsB) {
+    console.log('\n✓ FILES ARE IDENTICAL');
+  } else {
+    console.log('\n❌ FILES DIFFER');
+  }
+  console.log();
+}
+
+function normalizeTransition(tr) {
+  // Transition format: [from, signal, to] or [from, signal, to, command]
+  if (tr.length === 3) {
+    return `${tr[0]}|${tr[1]}|${tr[2]}`;
+  } else if (tr.length === 4) {
+    return `${tr[0]}|${tr[1]}|${tr[2]}|${tr[3]}`;
+  }
+  return '';
+}
+
+main();

package/scripts/drawio-to-json.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+/**
+ * Convert draw.io UML state diagram back to compact SFSM JSON
+ * Usage: node drawio-to-json.js <input-drawio> <output-json>
+ */
+
+const fs = require('fs');
+const path = require('path');
+const xml2js = require('xml2js');
+
+// ============ MAIN ============
+async function main() {
+  const [inputDrawioPath, outputJsonPath] = process.argv.slice(2);
+  
+  if (!inputDrawioPath || !outputJsonPath) {
+    console.error('Usage: node drawio-to-json.js <input-drawio> <output-json>');
+    process.exit(1);
+  }
+
+  try {
+    const drawioContent = fs.readFileSync(inputDrawioPath, 'utf-8');
+    const json = await convertDrawioToJson(drawioContent);
+    
+    // Ensure output directory exists
+    const outputDir = path.dirname(outputJsonPath);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+    
+    fs.writeFileSync(outputJsonPath, JSON.stringify(json, null, 2));
+    console.log(`Generated: ${outputJsonPath}`);
+  } catch (err) {
+    console.error('Error:', err.message);
+    process.exit(1);
+  }
+}
+
+// ============ CONVERSION LOGIC ============
+
+async function convertDrawioToJson(drawioContent) {
+  const parser = new xml2js.Parser();
+  const result = await parser.parseStringPromise(drawioContent);
+  
+  const root = result.mxfile.diagram[0].mxGraphModel[0].root[0];
+  const mxCells = root.mxCell || [];
+  
+  // Parse cells
+  const cellsMap = new Map(); // id -> cell info
+  const transitionsByFa = new Map(); // faName -> [transitions]
+  const faNames = new Set();
+  
+  for (const cell of mxCells) {
+    const id = cell.$.id;
+    const style = cell.$.style || '';
+    const value = cell.$.value || '';
+    
+    // Extract SFSM metadata from style
+    const sfsmRole = extractStyleAttr(style, 'sfsmRole');
+    const sfsmFa = extractStyleAttr(style, 'sfsmFa');
+    const sfsmKey = extractStyleAttr(style, 'sfsmKey');
+    const sfsmSignal = extractStyleAttr(style, 'sfsmSignal');
+    const sfsmCommand = extractStyleAttr(style, 'sfsmCommand');
+    
+    if (sfsmFa) {
+      faNames.add(sfsmFa);
+      if (!transitionsByFa.has(sfsmFa)) {
+        transitionsByFa.set(sfsmFa, []);
+      }
+    }
+    
+    cellsMap.set(id, {
+      id,
+      value,
+      sfsmRole,
+      sfsmFa,
+      sfsmKey,
+      sfsmSignal,
+      sfsmCommand,
+      source: cell.$.source,
+      target: cell.$.target
+    });
+  }
+  
+  // Build transitions
+  for (const [faName] of transitionsByFa) {
+    const faTransitions = [];
+    
+    // Iterate through cells to find transition edges for this FA
+    for (const cell of mxCells) {
+      const cellId = cell.$.id;
+      const cellInfo = cellsMap.get(cellId);
+      
+      if (!cellInfo) continue;
+      if (cellInfo.sfsmRole !== 'transition' || cellInfo.sfsmFa !== faName) continue;
+      
+      const sourceId = cell.$.source;
+      const targetId = cell.$.target;
+      
+      if (!sourceId || !targetId) continue;
+      
+      const sourceCell = cellsMap.get(sourceId);
+      const targetCell = cellsMap.get(targetId);
+      
+      if (!sourceCell || !targetCell) continue;
+      
+      // Determine from state
+      let fromState;
+      if (sourceCell.sfsmRole === 'initial') {
+        fromState = 'I';
+      } else if (sourceCell.sfsmKey) {
+        fromState = sourceCell.sfsmKey;
+      } else {
+        continue;
+      }
+      
+      // Determine to state
+      const toState = targetCell.sfsmKey;
+      if (!toState) continue;
+      
+      const signal = cellInfo.sfsmSignal;
+      const command = cellInfo.sfsmCommand;
+      
+      // Build transition tuple
+      if (command && command.trim()) {
+        faTransitions.push([fromState, signal, toState, command]);
+      } else {
+        faTransitions.push([fromState, signal, toState]);
+      }
+    }
+    
+    transitionsByFa.set(faName, faTransitions);
+  }
+  
+  // Build compact JSON
+  const compactJson = {};
+  for (const faName of faNames) {
+    compactJson[faName] = transitionsByFa.get(faName) || [];
+  }
+  
+  return compactJson;
+}
+
+function extractStyleAttr(style, attrName) {
+  const regex = new RegExp(`${attrName}=([^;]+)`);
+  const match = style.match(regex);
+  return match ? match[1] : '';
+}
+
+main();

package/scripts/json-to-drawio-old.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+/**
+ * Convert SFSM compact-format FA JSON to draw.io UML state diagram using ELK.js for hierarchical layout
+ * Each FA is a separate container, sub-FAs are nested containers with light grey background
+ * Usage: node json-to-drawio.js <input-json> <output-drawio>
+ */
+
+const fs = require('fs');
+const path = require('path');
+const ELK = require('elkjs').default;
+
+const elk = new ELK();
+
+// ============ MAIN ============
+async function main() {
+  const [inputJsonPath, outputDrawioPath] = process.argv.slice(2);
+  
+  if (!inputJsonPath || !outputDrawioPath) {
+    console.error('Usage: node json-to-drawio.js <input-json> <output-drawio>');
+    process.exit(1);
+  }
+
+  try {
+    const faData = JSON.parse(fs.readFileSync(inputJsonPath, 'utf-8'));
+    const drawio = await generateDrawio(faData);
+    
+    // Ensure output directory exists
+    const outputDir = path.dirname(outputDrawioPath);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+    
+    fs.writeFileSync(outputDrawioPath, drawio);
+    console.log(`Generated: ${outputDrawioPath}`);
+  } catch (err) {
+    console.error('Error:', err.message);
+    process.exit(1);
+  }
+}
+
+// ============ CONVERSION LOGIC ============
+
+async function generateDrawio(faData) {
+  const rootFaName = getRootFaName(faData);
+  const allFaNames = Object.keys(faData);
+  
+  // Build hierarchical graph structure
+  const { cellsMap, edgeList } = await buildHierarchicalGraph(rootFaName, faData, allFaNames);
+  
+  // Convert to drawio
+  return buildDrawioXml(cellsMap, edgeList);
+}
+
+function getRootFaName(faData) {
+  const allFaNames = Object.keys(faData);
+  const referencedFas = new Set();
+  
+  for (const faKey of allFaNames) {
+    const transitions = faData[faKey];
+    for (const tr of transitions) {
+      const toState = tr[2];
+      if (allFaNames.includes(toState)) {
+        referencedFas.add(toState);
+      }
+    }
+  }
+  
+  for (const faName of allFaNames) {
+    if (!referencedFas.has(faName)) {
+      return faName;
+    }
+  }
+  
+  return allFaNames[0];
+}
+
+function buildGraphForELK(rootFaName, faData, allFaNames) {
+  const nodes = [];
+  const edges = [];
+  const nodeMap = new Map(); // nodeId -> { faKey, state, label, type }
+  const edgeMap = new Map(); // edgeId -> { from, signal, to, command, faKey }
+  const stateNodeMap = new Map(); // `${faKey}:${state}` -> nodeId
+  
+  let nodeCounter = 0;
+  let edgeCounter = 0;
+  
+  // Process all FAs (both root and sub-FAs)
+  for (const faName of allFaNames) {
+    processFA(faName, faData, allFaNames, nodes, edges, nodeMap, edgeMap, stateNodeMap, nodeCounter, edgeCounter);
+  }
+  
+  return { nodes, edges: edges, nodeMap, edgeMap };
+}
+
+function processFA(faKey, faData, allFaNames, nodes, edges, nodeMap, edgeMap, stateNodeMap, nodeCounter, edgeCounter) {
+  const transitions = faData[faKey];
+  const states = new Set();
+  const exitStates = new Set();
+  
+  // Collect states and exit states
+  for (const tr of transitions) {
+    const [from, signal, to, command] = tr;
+    states.add(from);
+    states.add(to);
+    if (to.startsWith('E_')) {
+      exitStates.add(to);
+    }
+  }
+  
+  // Create node for initial state
+  const initId = `init-${faKey}`;
+  nodeMap.set(initId, { faKey, state: 'I', label: '', type: 'initial' });
+  stateNodeMap.set(`${faKey}:I`, initId);
+  nodes.push({
+    id: initId,
+    width: 20,
+    height: 20,
+    properties: { sfsmRole: 'initial', sfsmFa: faKey }
+  });
+  
+  // Create nodes for other states
+  for (const state of states) {
+    if (state === 'I') continue;
+    
+    let type = 'state';
+    let label = state;
+    
+    if (exitStates.has(state)) {
+      type = 'exit';
+    } else if (allFaNames.includes(state)) {
+      type = 'subfa';
+    }
+    
+    const nodeId = `state-${faKey}-${state}`;
+    nodeMap.set(nodeId, { faKey, state, label, type });
+    stateNodeMap.set(`${faKey}:${state}`, nodeId);
+    
+    const width = type === 'exit' ? 70 : 140;
+    const height = type === 'exit' ? 70 : 50;
+    
+    nodes.push({
+      id: nodeId,
+      width: width,
+      height: height,
+      labels: [{ text: label }],
+      properties: { 
+        sfsmRole: type, 
+        sfsmFa: faKey,
+        sfsmKey: state
+      }
+    });
+  }
+  
+  // Create edges
+  for (const tr of transitions) {
+    const [from, signal, to, command] = tr;
+    const sourceId = stateNodeMap.get(`${faKey}:${from}`);
+    const targetId = stateNodeMap.get(`${faKey}:${to}`);
+    
+    if (!sourceId || !targetId) continue;
+    
+    const edgeLabel = command ? `${signal} / ${to}:${command}` : signal;
+    const edgeId = `tr-${faKey}-${edgeCounter++}`;
+    
+    edgeMap.set(edgeId, { from, signal, to, command, faKey });
+    
+    edges.push({
+      id: edgeId,
+      sources: [sourceId],
+      targets: [targetId],
+      labels: [{ text: edgeLabel }],
+      properties: {
+        sfsmRole: 'transition',
+        sfsmFa: faKey,
+        sfsmSignal: signal,
+        sfsmCommand: command || ''
+      }
+    });
+  }
+}
+
+function buildDrawioXmlFromLayout(layout, nodeMap, edgeMap, faData, allFaNames) {
+  const cellsMap = new Map();
+  const edges = [];
+  
+  // Convert ELK nodes to drawio cells
+  function convertNodes(elkNodes, parent = '1') {
+    if (!elkNodes) return;
+    
+    for (const elkNode of elkNodes) {
+      const nodeInfo = nodeMap.get(elkNode.id);
+      if (!nodeInfo) continue;
+      
+      const { faKey, state, label, type } = nodeInfo;
+      let style = '';
+      let width = 20;
+      let height = 20;
+      
+      switch (type) {
+        case 'initial':
+          style = `ellipse;whiteSpace=wrap;html=1;fillColor=#000000;strokeColor=#000000;sfsmRole=initial;sfsmFa=${faKey};`;
+          width = 20;
+          height = 20;
+          break;
+        case 'exit':
+          style = `ellipse;whiteSpace=wrap;html=1;strokeWidth=3;fillColor=#FFFFFF;sfsmRole=exit;sfsmFa=${faKey};sfsmKey=${state};`;
+          width = 70;
+          height = 70;
+          break;
+        case 'subfa':
+          style = `swimlane;whiteSpace=wrap;html=1;startSize=26;sfsmRole=subfa;sfsmFa=${faKey};sfsmKey=${state};`;
+          width = 200;
+          height = 200;
+          break;
+        default:
+          style = `rounded=1;whiteSpace=wrap;html=1;arcSize=20;sfsmRole=state;sfsmFa=${faKey};sfsmKey=${state};`;
+          width = 140;
+          height = 50;
+      }
+      
+      cellsMap.set(elkNode.id, {
+        id: elkNode.id,
+        value: label,
+        style: style,
+        x: Math.round(elkNode.x || 0),
+        y: Math.round(elkNode.y || 0),
+        width: width,
+        height: height,
+        parent: parent
+      });
+      
+      // Recursively process children
+      if (elkNode.children) {
+        convertNodes(elkNode.children, elkNode.id);
+      }
+    }
+  }
+  
+  convertNodes(layout.children);
+  
+  // Convert ELK edges to drawio edges
+  if (layout.edges) {
+    for (const elkEdge of layout.edges) {
+      const edgeInfo = edgeMap.get(elkEdge.id);
+      if (!edgeInfo) continue;
+      
+      const { from, signal, to, command, faKey } = edgeInfo;
+      const edgeLabel = command ? `${signal} / ${to}:${command}` : signal;
+      
+      let style = `edgeStyle=orthogonalEdgeStyle;rounded=0;html=1;sfsmRole=transition;sfsmFa=${faKey};sfsmSignal=${signal};sfsmCommand=${command || ''};`;
+      if (from === to) {
+        style += `exitX=0.25;exitY=0;exitDx=0;exitDy=0;entryX=0.75;entryY=0;entryDx=0;entryDy=0;`;
+      }
+      
+      edges.push({
+        id: elkEdge.id,
+        value: edgeLabel,
+        style: style,
+        source: elkEdge.sources[0],
+        target: elkEdge.targets[0],
+        parent: '1'
+      });
+    }
+  }
+  
+  return buildDrawioXml(cellsMap, edges);
+}
+
+function buildDrawioXml(cellsMap, edges) {
+  let xml = `<?xml version="1.0" encoding="UTF-8"?>
+<mxfile host="Electron">
+  <diagram id="sfsm-diagram" name="Page-1">
+    <mxGraphModel dx="800" dy="600" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
+      <root>
+        <mxCell id="0"/>
+        <mxCell id="1" parent="0"/>
+`;
+  
+  for (const [cellId, cell] of cellsMap) {
+    xml += `        <mxCell id="${cell.id}" value="${escapeXml(cell.value)}" style="${cell.style}" vertex="1" parent="${cell.parent}">
+          <mxGeometry x="${cell.x}" y="${cell.y}" width="${cell.width}" height="${cell.height}" as="geometry"/>
+        </mxCell>
+`;
+  }
+  
+  for (const edge of edges) {
+    xml += `        <mxCell id="${edge.id}" value="${escapeXml(edge.value)}" style="${edge.style}" edge="1" parent="${edge.parent}" source="${edge.source}" target="${edge.target}">
+          <mxGeometry relative="1" as="geometry"/>
+        </mxCell>
+`;
+  }
+  
+  xml += `      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>`;
+  
+  return xml;
+}
+
+function escapeXml(str) {
+  if (!str) return '';
+  return String(str)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+main();