create-yss-spec 3.0.0 → 3.0.1

package/template/.hermes/skills/archify/test/automatic-port-spread.test.mjs

@@ -1,376 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const skillRoot = path.resolve(__dirname, '..');
-
-function render(mode, doc) {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-port-spread-'));
-  const input = path.join(tmp, 'input.json');
-  const output = path.join(tmp, 'output.html');
-  fs.writeFileSync(input, JSON.stringify(doc));
-  try {
-    execFileSync('node', [
-      path.join(skillRoot, `renderers/${mode}/render-${mode}.mjs`),
-      input,
-      output,
-    ], { stdio: ['ignore', 'ignore', 'pipe'] });
-    return fs.readFileSync(output, 'utf8');
-  } finally {
-    fs.rmSync(tmp, { recursive: true, force: true });
-  }
-}
-
-function connectionPoints(html, id) {
-  const pattern = new RegExp(`data-edge-id="${id}"[^>]+data-composition-points="([^"]+)"`);
-  const match = html.match(pattern);
-  assert.ok(match, `missing rendered connection ${id}`);
-  return match[1].split(';').map((point) => point.split(',').map(Number));
-}
-
-function fanOutArchitecture(connections) {
-  return {
-    schema_version: 1,
-    diagram_type: 'architecture',
-    meta: { title: 'Automatic port spread' },
-    components: [
-      { id: 'hub', type: 'backend', label: 'Hub', pos: [100, 280], size: [120, 60] },
-      { id: 'upper', type: 'external', label: 'Upper', pos: [500, 100], size: [120, 60] },
-      { id: 'middle', type: 'database', label: 'Middle', pos: [500, 280], size: [120, 60] },
-      { id: 'lower', type: 'cloud', label: 'Lower', pos: [500, 460], size: [120, 60] },
-    ],
-    connections,
-  };
-}
-
-test('architecture: automatic fan-out uses distinct symmetric ports with corner clearance', () => {
-  const html = render('architecture', fanOutArchitecture([
-    { id: 'to-upper', from: 'hub', to: 'upper' },
-    { id: 'to-middle', from: 'hub', to: 'middle' },
-    { id: 'to-lower', from: 'hub', to: 'lower' },
-  ]));
-
-  assert.deepEqual(connectionPoints(html, 'to-upper')[0], [220, 296]);
-  assert.deepEqual(connectionPoints(html, 'to-middle')[0], [220, 310]);
-  assert.deepEqual(connectionPoints(html, 'to-lower')[0], [220, 324]);
-});
-
-test('architecture: automatic port assignment is stable when relationship input order changes', () => {
-  const connections = [
-    { id: 'to-upper', from: 'hub', to: 'upper' },
-    { id: 'to-middle', from: 'hub', to: 'middle' },
-    { id: 'to-lower', from: 'hub', to: 'lower' },
-  ];
-  const forward = render('architecture', fanOutArchitecture(connections));
-  const reversed = render('architecture', fanOutArchitecture([...connections].reverse()));
-
-  for (const connection of connections) {
-    assert.deepEqual(
-      connectionPoints(forward, connection.id),
-      connectionPoints(reversed, connection.id),
-      `${connection.id} moved after input reordering`,
-    );
-  }
-});
-
-test('architecture: a singly spread near-aligned vertical relationship keeps one direct axis', () => {
-  const html = render('architecture', {
-    schema_version: 1,
-    diagram_type: 'architecture',
-    meta: { title: 'Near-aligned fan-out' },
-    components: [
-      { id: 'api', type: 'backend', label: 'API', pos: [675, 300], size: [120, 60] },
-      { id: 'auth', type: 'security', label: 'Auth', pos: [570, 120], size: [100, 60] },
-      { id: 'cache', type: 'database', label: 'Cache', pos: [685, 120], size: [100, 60] },
-    ],
-    connections: [
-      { id: 'verify', from: 'api', to: 'auth', fromSide: 'top', toSide: 'bottom' },
-      { id: 'read', from: 'api', to: 'cache', fromSide: 'top', toSide: 'bottom' },
-    ],
-  });
-
-  assert.deepEqual(connectionPoints(html, 'read'), [[742, 300], [742, 180]]);
-  assert.notDeepEqual(connectionPoints(html, 'verify')[0], connectionPoints(html, 'read')[0]);
-});
-
-test('architecture: a singly spread near-aligned horizontal relationship keeps one direct axis', () => {
-  const html = render('architecture', {
-    schema_version: 1,
-    diagram_type: 'architecture',
-    meta: { title: 'Near-aligned horizontal fan-out' },
-    components: [
-      { id: 'hub', type: 'backend', label: 'Hub', pos: [100, 100], size: [120, 60] },
-      { id: 'direct', type: 'database', label: 'Direct', pos: [500, 107], size: [120, 60] },
-      { id: 'branch', type: 'cloud', label: 'Branch', pos: [500, 300], size: [120, 60] },
-    ],
-    connections: [
-      { id: 'hub-direct', from: 'hub', to: 'direct', fromSide: 'right', toSide: 'left' },
-      { id: 'hub-branch', from: 'hub', to: 'branch', fromSide: 'right', toSide: 'left' },
-    ],
-  });
-
-  assert.deepEqual(connectionPoints(html, 'hub-direct'), [[220, 123], [500, 123]]);
-  assert.notDeepEqual(connectionPoints(html, 'hub-branch')[0], connectionPoints(html, 'hub-direct')[0]);
-});
-
-test('architecture: a shared bottom port keeps its aligned child relationship straight', () => {
-  const doc = {
-    schema_version: 1,
-    diagram_type: 'architecture',
-    meta: { title: 'Vertical child relationship' },
-    components: [
-      { id: 'parent', type: 'backend', label: 'Parent Session', pos: [300, 100], size: [200, 60] },
-      { id: 'terminal', type: 'backend', label: 'Background terminal', pos: [300, 300], size: [200, 60] },
-      { id: 'workflow', type: 'backend', label: 'Workflow', pos: [560, 300], size: [180, 60] },
-    ],
-    connections: [
-      { id: 'parent-terminal', from: 'parent', to: 'terminal', fromSide: 'bottom', toSide: 'top' },
-      { id: 'parent-workflow', from: 'parent', to: 'workflow', fromSide: 'bottom', toSide: 'top' },
-    ],
-  };
-  const forward = render('architecture', doc);
-  const reversed = render('architecture', {
-    ...doc,
-    connections: [...doc.connections].reverse(),
-  });
-
-  assert.deepEqual(connectionPoints(forward, 'parent-terminal'), [[393, 160], [393, 300]]);
-  assert.notDeepEqual(
-    connectionPoints(forward, 'parent-workflow')[0],
-    connectionPoints(forward, 'parent-terminal')[0],
-  );
-  for (const connection of doc.connections) {
-    assert.deepEqual(
-      connectionPoints(forward, connection.id),
-      connectionPoints(reversed, connection.id),
-      `${connection.id} moved after input reordering`,
-    );
-  }
-});
-
-test('architecture: incoming and outgoing relationships keep distinct bottom ports while the direct child stays straight', () => {
-  const html = render('architecture', {
-    schema_version: 1,
-    diagram_type: 'architecture',
-    meta: { title: 'Shared incoming and outgoing side' },
-    components: [
-      { id: 'workflow', type: 'backend', label: 'Workflow', pos: [80, 320], size: [180, 60] },
-      { id: 'child', type: 'security', label: 'Child boundary', pos: [300, 100], size: [200, 60] },
-      { id: 'footer', type: 'frontend', label: 'Footer', pos: [300, 320], size: [200, 60] },
-    ],
-    connections: [
-      { id: 'workflow-child', from: 'workflow', to: 'child', fromSide: 'right', toSide: 'bottom' },
-      { id: 'child-footer', from: 'child', to: 'footer', fromSide: 'bottom', toSide: 'top' },
-    ],
-  });
-
-  assert.deepEqual(connectionPoints(html, 'child-footer'), [[407, 160], [407, 320]]);
-  assert.notDeepEqual(
-    connectionPoints(html, 'workflow-child').at(-1),
-    connectionPoints(html, 'child-footer')[0],
-  );
-});
-
-test('architecture: a near-aligned relationship keeps the outside bridge when both endpoints are spread', () => {
-  const html = render('architecture', {
-    schema_version: 1,
-    diagram_type: 'architecture',
-    meta: { title: 'Two-sided port competition' },
-    components: [
-      { id: 'source', type: 'backend', label: 'Source', pos: [300, 320], size: [160, 60] },
-      { id: 'source-peer', type: 'backend', label: 'Source peer', pos: [80, 320], size: [160, 60] },
-      { id: 'target', type: 'database', label: 'Target', pos: [300, 100], size: [160, 60] },
-      { id: 'target-peer', type: 'database', label: 'Target peer', pos: [560, 100], size: [160, 60] },
-    ],
-    connections: [
-      { id: 'source-target', from: 'source', to: 'target', fromSide: 'top', toSide: 'bottom' },
-      { id: 'source-peer-target', from: 'source-peer', to: 'target', fromSide: 'top', toSide: 'bottom' },
-      { id: 'source-target-peer', from: 'source', to: 'target-peer', fromSide: 'top', toSide: 'bottom' },
-    ],
-  });
-
-  const points = connectionPoints(html, 'source-target');
-  assert.ok(points.length > 2);
-  assert.notEqual(points[0][0], points.at(-1)[0]);
-});
-
-test('architecture: a singly spread near-aligned relationship keeps the bridge when its direct axis is blocked', () => {
-  const html = render('architecture', {
-    schema_version: 1,
-    diagram_type: 'architecture',
-    meta: { title: 'Blocked vertical axis' },
-    components: [
-      { id: 'parent', type: 'backend', label: 'Parent', pos: [300, 100], size: [200, 60] },
-      { id: 'terminal', type: 'backend', label: 'Terminal', pos: [300, 400], size: [200, 60] },
-      { id: 'workflow', type: 'backend', label: 'Workflow', pos: [560, 400], size: [180, 60] },
-      { id: 'obstacle', type: 'external', label: 'X', pos: [382, 245], size: [26, 60] },
-    ],
-    connections: [
-      { id: 'parent-terminal', from: 'parent', to: 'terminal', fromSide: 'bottom', toSide: 'top' },
-      { id: 'parent-workflow', from: 'parent', to: 'workflow', fromSide: 'bottom', toSide: 'top' },
-    ],
-  });
-
-  const points = connectionPoints(html, 'parent-terminal');
-  assert.ok(points.length > 2);
-  assert.notEqual(points[0][0], points.at(-1)[0]);
-});
-
-test('architecture: single and explicitly positioned relationships keep legacy anchors', () => {
-  const doc = fanOutArchitecture([
-    { id: 'single', from: 'hub', to: 'middle' },
-    { id: 'via', from: 'hub', to: 'upper', via: [[300, 310], [300, 130]] },
-    { id: 'fixed-route', from: 'hub', to: 'lower', route: 'orthogonal-h' },
-    { id: 'fixed-label', from: 'hub', to: 'upper', label: 'contract', labelAt: [360, 200] },
-  ]);
-  const html = render('architecture', doc);
-
-  assert.deepEqual(connectionPoints(html, 'single'), [[220, 310], [500, 310]]);
-  assert.deepEqual(connectionPoints(html, 'via'), [[220, 310], [300, 310], [300, 130], [500, 130]]);
-  assert.deepEqual(connectionPoints(html, 'fixed-route'), [[220, 310], [360, 310], [360, 490], [500, 490]]);
-  assert.deepEqual(connectionPoints(html, 'fixed-label'), [[220, 310], [360, 310], [360, 130], [500, 130]]);
-});
-
-test('architecture: an unspread near-aligned connection shares one horizontal axis', () => {
-  const html = render('architecture', {
-    schema_version: 1,
-    diagram_type: 'architecture',
-    meta: { title: 'Near-aligned single connection' },
-    components: [
-      { id: 'console', type: 'frontend', label: 'Console', pos: [260, 300], size: [170, 64] },
-      { id: 'controlplane', type: 'backend', label: 'Control plane', pos: [500, 300], size: [190, 72] },
-    ],
-    connections: [
-      { id: 'console-controlplane', from: 'console', to: 'controlplane', label: 'REST /api', variant: 'emphasis', labelDy: -36 },
-    ],
-  });
-
-  assert.deepEqual(connectionPoints(html, 'console-controlplane'), [[430, 332], [500, 332]]);
-});
-
-test('workflow: automatic cross-lane fan-out selects distinct perpendicular source sides', () => {
-  const html = render('workflow', {
-    schema_version: 1,
-    diagram_type: 'workflow',
-    meta: { title: 'Workflow port spread' },
-    lanes: [
-      { id: 'upper-lane', label: 'Upper' },
-      { id: 'hub-lane', label: 'Hub' },
-      { id: 'lower-lane', label: 'Lower' },
-    ],
-    nodes: [
-      { id: 'hub', lane: 'hub-lane', col: 0, type: 'backend', label: 'Hub' },
-      { id: 'upper', lane: 'upper-lane', col: 3, type: 'external', label: 'Upper' },
-      { id: 'middle', lane: 'hub-lane', col: 3, type: 'database', label: 'Middle' },
-      { id: 'lower', lane: 'lower-lane', col: 3, type: 'cloud', label: 'Lower' },
-    ],
-    edges: [
-      { id: 'to-upper', from: 'hub', to: 'upper' },
-      { id: 'to-middle', from: 'hub', to: 'middle' },
-      { id: 'to-lower', from: 'hub', to: 'lower' },
-    ],
-  });
-
-  assert.deepEqual(connectionPoints(html, 'to-upper')[0], [88, 217]);
-  assert.deepEqual(connectionPoints(html, 'to-middle')[0], [134, 243]);
-  assert.deepEqual(connectionPoints(html, 'to-lower')[0], [88, 269]);
-});
-
-test('dataflow: automatic fan-out spreads flows without changing their authored topology', () => {
-  const html = render('dataflow', {
-    schema_version: 1,
-    diagram_type: 'dataflow',
-    meta: { title: 'Data-flow port spread' },
-    stages: [{ label: 'Source' }, { label: 'Transform' }, { label: 'Sinks' }],
-    nodes: [
-      { id: 'hub', type: 'backend', label: 'Hub', stage: 0, row: 2 },
-      { id: 'upper', type: 'external', label: 'Upper', stage: 2, row: 0 },
-      { id: 'middle', type: 'database', label: 'Middle', stage: 2, row: 2 },
-      { id: 'lower', type: 'cloud', label: 'Lower', stage: 2, row: 4 },
-    ],
-    flows: [
-      { id: 'to-upper', from: 'hub', to: 'upper', label: 'upper feed' },
-      { id: 'to-middle', from: 'hub', to: 'middle', label: 'middle feed' },
-      { id: 'to-lower', from: 'hub', to: 'lower', label: 'lower feed' },
-    ],
-  });
-
-  assert.deepEqual(connectionPoints(html, 'to-upper')[0], [156, 372]);
-  assert.deepEqual(connectionPoints(html, 'to-middle')[0], [156, 385]);
-  assert.deepEqual(connectionPoints(html, 'to-lower')[0], [156, 398]);
-});
-
-test('lifecycle: automatic fan-out spreads transitions across lifecycle bands', () => {
-  const html = render('lifecycle', {
-    schema_version: 1,
-    diagram_type: 'lifecycle',
-    meta: { title: 'Lifecycle port spread' },
-    lanes: [
-      { id: 'main', label: 'Main' },
-      { id: 'event', label: 'Events' },
-      { id: 'terminal', label: 'Outcomes' },
-    ],
-    states: [
-      { id: 'hub', type: 'active', label: 'Hub', lane: 'event', col: 0 },
-      { id: 'upper', type: 'waiting', label: 'Upper', lane: 'main', col: 4 },
-      { id: 'middle', type: 'success', label: 'Middle', lane: 'event', col: 2 },
-      { id: 'lower', type: 'failure', label: 'Lower', lane: 'terminal', col: 2 },
-    ],
-    transitions: [
-      { id: 'to-upper', from: 'hub', to: 'upper' },
-      { id: 'to-middle', from: 'hub', to: 'middle' },
-      { id: 'to-lower', from: 'hub', to: 'lower' },
-    ],
-  });
-
-  assert.deepEqual(connectionPoints(html, 'to-upper')[0], [465, 294]);
-  assert.deepEqual(connectionPoints(html, 'to-middle')[0], [465, 307]);
-  assert.deepEqual(connectionPoints(html, 'to-lower')[0], [465, 320]);
-});
-
-test('lifecycle: same-band port spread remains orthogonal', () => {
-  const html = render('lifecycle', {
-    schema_version: 1,
-    diagram_type: 'lifecycle',
-    meta: { title: 'Orthogonal same-band spread' },
-    lanes: [{ id: 'main', label: 'Main' }],
-    states: [
-      { id: 'hub', type: 'active', label: 'Hub', lane: 'main', col: 0 },
-      { id: 'upper', type: 'waiting', label: 'Upper', lane: 'main', col: 2, yOffset: -50 },
-      { id: 'lower', type: 'success', label: 'Lower', lane: 'main', col: 4, yOffset: 50 },
-    ],
-    transitions: [
-      { id: 'to-upper', from: 'hub', to: 'upper' },
-      { id: 'to-lower', from: 'hub', to: 'lower' },
-    ],
-  });
-
-  assert.deepEqual(connectionPoints(html, 'to-upper'), [
-    [153, 150], [248, 150], [248, 107], [343, 107],
-  ]);
-  assert.deepEqual(connectionPoints(html, 'to-lower'), [
-    [153, 164], [402, 164], [402, 207], [651, 207],
-  ]);
-});
-
-test('skill and READMEs describe automatic port spread as bounded default behavior', () => {
-  const skill = fs.readFileSync(path.join(skillRoot, 'SKILL.md'), 'utf8');
-  assert.match(skill, /Automatic Port Spread is a default renderer behavior/);
-  assert.match(skill, /single relationship|single relationships/);
-  assert.match(skill, /explicit `via`.*`channelX`.*`channelY`.*`labelAt`/);
-  assert.match(skill, /facing automatic ports \(`left`\/`right` or `top`\/`bottom`\).*one shared axis/);
-
-  const authoringContract = fs.readFileSync(path.join(skillRoot, 'references/authoring-contract.md'), 'utf8');
-  assert.match(authoringContract, /unobstructed facing ports.*may share one horizontal or vertical axis/);
-
-  const repoRoot = path.resolve(skillRoot, '..');
-  for (const file of ['README.md', 'README_EN.md']) {
-    assert.match(fs.readFileSync(path.join(repoRoot, file), 'utf8'), /shared automatic endpoints spread deterministically/);
-  }
-  assert.match(fs.readFileSync(path.join(repoRoot, 'README_ZH.md'), 'utf8'), /共享的自动端点会确定性展开/);
-});

package/template/.hermes/skills/archify/test/base-input-compatibility.test.mjs

@@ -1,42 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const skillRoot = path.resolve(here, '..');
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-base-input-compatibility-'));
-
-function renderBaseFixture(type, name) {
-  const input = path.join(skillRoot, 'test', 'fixtures', 'v1-baseline', name);
-  const output = path.join(tmp, `${name}.html`);
-  return spawnSync(process.execPath, [
-    path.join(skillRoot, 'bin', 'archify.mjs'),
-    'render',
-    type,
-    input,
-    output,
-  ], {
-    cwd: skillRoot,
-    encoding: 'utf8',
-  });
-}
-
-test('base named-route fixtures remain valid without redundant authored endpoint sides', () => {
-  for (const [type, name] of [
-    ['dataflow', 'event-stream.dataflow.json'],
-    ['architecture', 'production-deployment.architecture.json'],
-  ]) {
-    const result = renderBaseFixture(type, name);
-    assert.equal(
-      result.status,
-      0,
-      `${type} base input must remain valid:\n${result.stdout || result.stderr}`,
-    );
-  }
-});
-
-process.on('exit', () => fs.rmSync(tmp, { recursive: true, force: true }));