@1agh/maude 1.0.11 → 1.3.0

package/apps/studio/test/active-state.test.ts

@@ -1,186 +0,0 @@
-// Smoke: WS `active` + `tabs` + `select` messages reflect into _active.json.
-
-import { describe, expect, test } from 'bun:test';
-import { join } from 'node:path';
-
-import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
-
-async function openWs(port: number): Promise<WebSocket> {
-  const ws = new WebSocket(`ws://localhost:${port}/_ws`);
-  await new Promise<void>((resolve, reject) => {
-    const t = setTimeout(() => reject(new Error('ws open timeout')), 2000);
-    ws.addEventListener('open', () => {
-      clearTimeout(t);
-      resolve();
-    });
-    ws.addEventListener('error', (e) => {
-      clearTimeout(t);
-      reject(e);
-    });
-  });
-  return ws;
-}
-
-describe('_active.json round-trip', () => {
-  test('active + tabs + selected persist to disk', async () => {
-    const { root, designRoot } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const ws = await openWs(port);
-      ws.send(JSON.stringify({ type: 'active', file: '.design/ui/fixture.html' }));
-      ws.send(JSON.stringify({ type: 'tabs', tabs: ['.design/ui/fixture.html'] }));
-      ws.send(
-        JSON.stringify({
-          type: 'select',
-          selection: {
-            file: '.design/ui/fixture.html',
-            selector: 'h1',
-            tag: 'h1',
-            classes: '',
-            text: 'fixture',
-            dom_path: ['html', 'body', 'h1'],
-            bounds: { x: 0, y: 0, w: 100, h: 24 },
-            html: '<h1>fixture</h1>',
-          },
-        })
-      );
-
-      // Allow time for the queued microtask save to land.
-      await Bun.sleep(150);
-
-      const state = (await Bun.file(join(designRoot, '_active.json')).json()) as {
-        active: string;
-        open_tabs: string[];
-        selected: { selector: string; tag: string; v?: number };
-      };
-      expect(state.active).toBe('.design/ui/fixture.html');
-      expect(state.open_tabs).toContain('.design/ui/fixture.html');
-      expect(state.selected.selector).toBe('h1');
-      expect(state.selected.tag).toBe('h1');
-      expect(state.selected.v).toBe(1);
-      ws.close();
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('selection carrying data-cd-id stamps v=2 + canvas slug', async () => {
-    const { root, designRoot } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const ws = await openWs(port);
-      ws.send(JSON.stringify({ type: 'active', file: '.design/ui/fixture.tsx' }));
-      ws.send(
-        JSON.stringify({
-          type: 'select',
-          selection: {
-            file: '.design/ui/fixture.tsx',
-            selector: 'div.btn',
-            tag: 'button',
-            classes: 'btn btn--ghost',
-            text: 'OK',
-            dom_path: ['html', 'body', 'button'],
-            bounds: { x: 10, y: 20, w: 80, h: 32 },
-            html: '<button class="btn btn--ghost">OK</button>',
-            id: 'a1b2c3d4',
-          },
-        })
-      );
-      await Bun.sleep(150);
-
-      const state = (await Bun.file(join(designRoot, '_active.json')).json()) as {
-        selected: { id?: string; canvas?: string; v: number; selector: string };
-      };
-      expect(state.selected.v).toBe(2);
-      expect(state.selected.id).toBe('a1b2c3d4');
-      // Canvas slug = designRoot-relative path, ext-less, POSIX. The fixture
-      // file is `.design/ui/fixture.tsx`; designRel = `.design` → slug =
-      // `ui/fixture`.
-      expect(state.selected.canvas).toBe('ui/fixture');
-      // v=2 still carries the v1 selector as a fallback (legacy readers).
-      expect(state.selected.selector).toBe('div.btn');
-      ws.close();
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('selections map mirrors the active canvas selection on disk (context hardening)', async () => {
-    const { root, designRoot } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const ws = await openWs(port);
-      ws.send(JSON.stringify({ type: 'active', file: '.design/ui/fixture.html' }));
-      ws.send(
-        JSON.stringify({
-          type: 'select',
-          selection: {
-            file: '.design/ui/fixture.html',
-            selector: 'h1',
-            tag: 'h1',
-            classes: '',
-            text: 'fixture',
-            dom_path: ['html', 'body', 'h1'],
-            bounds: null,
-            html: '<h1>fixture</h1>',
-          },
-        })
-      );
-      await Bun.sleep(150);
-
-      const state = (await Bun.file(join(designRoot, '_active.json')).json()) as {
-        selected: { selector: string; canvas_mtime?: number };
-        selections: Record<string, { selector: string; html: string }>;
-      };
-      // Additive schema: `selected` unchanged for legacy readers, `selections`
-      // carries the per-canvas memory; active canvas's entry mirrors `selected`.
-      expect(state.selected.selector).toBe('h1');
-      expect(state.selections['ui/fixture']?.selector).toBe('h1');
-      expect(state.selections['ui/fixture']?.html).toBe('<h1>fixture</h1>');
-      // Drift-gate stamp present (fixture file exists on disk).
-      expect(state.selected.canvas_mtime).toBeGreaterThan(0);
-      ws.close();
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('selection without id stays v=1 (legacy HTML canvas / shell chrome click)', async () => {
-    const { root, designRoot } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const ws = await openWs(port);
-      ws.send(JSON.stringify({ type: 'active', file: '.design/ui/fixture.html' }));
-      ws.send(
-        JSON.stringify({
-          type: 'select',
-          selection: {
-            file: '.design/ui/fixture.html',
-            selector: 'h1',
-            tag: 'h1',
-            classes: '',
-            text: '',
-            dom_path: ['html', 'body', 'h1'],
-            bounds: { x: 0, y: 0, w: 0, h: 0 },
-            html: '<h1/>',
-          },
-        })
-      );
-      await Bun.sleep(150);
-
-      const state = (await Bun.file(join(designRoot, '_active.json')).json()) as {
-        selected: { v: number; id?: string; canvas?: string };
-      };
-      expect(state.selected.v).toBe(1);
-      expect(state.selected.id).toBeUndefined();
-      expect(state.selected.canvas).toBeUndefined();
-      ws.close();
-    } finally {
-      await killProc(proc);
-    }
-  });
-});

package/apps/studio/test/activity.test.ts

@@ -1,189 +0,0 @@
-// activity — Phase 13. fs:any → per-file active|idle tracker + region diff.
-
-import { describe, expect, test } from 'bun:test';
-
-import { type ActivityChange, createActivity, diffArtboardIds, isCanvasFile } from '../activity.ts';
-import { type Context, createBus } from '../context.ts';
-
-function mkCtx(): Context {
-  const bus = createBus();
-  return {
-    cfg: {} as Context['cfg'],
-    projectLabel: '',
-    // No designRoot → refineArtboards() short-circuits; transition tests stay
-    // fs-free. The diff is exercised directly via diffArtboardIds() below.
-    paths: {} as Context['paths'],
-    bus,
-  };
-}
-
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-describe('activity / isCanvasFile', () => {
-  test('accepts .tsx + .html canvases under ui/', () => {
-    expect(isCanvasFile('ui/Smoke TSX.tsx')).toBe(true);
-    expect(isCanvasFile('ui/legacy.html')).toBe(true);
-    expect(isCanvasFile('ui/components/Card.tsx')).toBe(true);
-  });
-
-  test('rejects non-canvas extensions', () => {
-    expect(isCanvasFile('ui/Smoke.css')).toBe(false);
-    expect(isCanvasFile('_locator.json')).toBe(false);
-    expect(isCanvasFile('ui/shot.png')).toBe(false);
-  });
-
-  test('rejects _-prefixed files + dirs (runtime artifacts, history, draw, smoke)', () => {
-    expect(isCanvasFile('_active.json')).toBe(false);
-    expect(isCanvasFile('_history/ui/Smoke TSX/0001.tsx')).toBe(false);
-    expect(isCanvasFile('_draw/logo.proof.tsx')).toBe(false);
-    expect(isCanvasFile('_history/snap.html')).toBe(false);
-  });
-
-  test('rejects SKIP_DIRS segments', () => {
-    expect(isCanvasFile('node_modules/react/index.tsx')).toBe(false);
-    expect(isCanvasFile('dist/runtime/x.tsx')).toBe(false);
-    expect(isCanvasFile('ui/build/out.tsx')).toBe(false);
-  });
-
-  test('rejects DS preview specimens (false-positive guard)', () => {
-    expect(isCanvasFile('system/aurora/preview/motion.html')).toBe(false);
-    expect(isCanvasFile('system/aurora/preview/motion.tsx')).toBe(false);
-    // but a real canvas elsewhere under system/ is fine
-    expect(isCanvasFile('system/aurora/showcase.tsx')).toBe(true);
-  });
-
-  test('normalizes back-slash + leading slash', () => {
-    expect(isCanvasFile('\\ui\\Smoke.tsx')).toBe(true);
-    expect(isCanvasFile('/ui/Smoke.tsx')).toBe(true);
-    expect(isCanvasFile('')).toBe(false);
-  });
-});
-
-describe('activity / transitions', () => {
-  test('idle → active on first canvas fs:any event', () => {
-    const ctx = mkCtx();
-    const seen: ActivityChange[] = [];
-    ctx.bus.on('activity:change', (c) => seen.push(c));
-    const act = createActivity(ctx, { idleMs: 40, diff: false });
-
-    ctx.bus.emit('fs:any', 'ui/Smoke.tsx');
-    expect(act.state['ui/Smoke.tsx']?.status).toBe('active');
-    expect(seen).toHaveLength(1);
-    expect(seen[0]).toMatchObject({ file: 'ui/Smoke.tsx', status: 'active', artboard_ids: null });
-    act.stop();
-  });
-
-  test('non-canvas fs:any events are ignored', () => {
-    const ctx = mkCtx();
-    const seen: ActivityChange[] = [];
-    ctx.bus.on('activity:change', (c) => seen.push(c));
-    const act = createActivity(ctx, { idleMs: 40, diff: false });
-
-    ctx.bus.emit('fs:any', 'ui/Smoke.css');
-    ctx.bus.emit('fs:any', '_active.json');
-    ctx.bus.emit('fs:any', 'system/x/preview/motion.tsx');
-    expect(seen).toHaveLength(0);
-    expect(act.state['ui/Smoke.css']).toBeUndefined();
-    act.stop();
-  });
-
-  test('active → active: rapid events keep the file active past one idle window', async () => {
-    const ctx = mkCtx();
-    const act = createActivity(ctx, { idleMs: 60, diff: false });
-
-    ctx.bus.emit('fs:any', 'ui/Smoke.tsx');
-    await sleep(40);
-    ctx.bus.emit('fs:any', 'ui/Smoke.tsx'); // refresh before the 60 ms idle fires
-    await sleep(40); // 80 ms since first event, but only 40 ms since the refresh
-    expect(act.state['ui/Smoke.tsx']?.status).toBe('active');
-    act.stop();
-  });
-
-  test('active → idle after idleMs of silence, and emits the idle change', async () => {
-    const ctx = mkCtx();
-    const seen: ActivityChange[] = [];
-    ctx.bus.on('activity:change', (c) => seen.push(c));
-    const act = createActivity(ctx, { idleMs: 40, diff: false });
-
-    ctx.bus.emit('fs:any', 'ui/Smoke.tsx');
-    await sleep(80);
-    expect(act.state['ui/Smoke.tsx']?.status).toBe('idle');
-    const last = seen[seen.length - 1];
-    expect(last).toMatchObject({ file: 'ui/Smoke.tsx', status: 'idle' });
-    act.stop();
-  });
-
-  test('mark() test seam marks active without the bus', () => {
-    const ctx = mkCtx();
-    const seen: ActivityChange[] = [];
-    ctx.bus.on('activity:change', (c) => seen.push(c));
-    const act = createActivity(ctx, { idleMs: 40, diff: false });
-
-    act.mark('ui/Manual.tsx');
-    expect(act.state['ui/Manual.tsx']?.status).toBe('active');
-    expect(seen[0]?.file).toBe('ui/Manual.tsx');
-    act.stop();
-  });
-
-  test('stop() halts the idle timer (no idle emit after stop)', async () => {
-    const ctx = mkCtx();
-    const seen: ActivityChange[] = [];
-    ctx.bus.on('activity:change', (c) => seen.push(c));
-    const act = createActivity(ctx, { idleMs: 40, diff: false });
-
-    ctx.bus.emit('fs:any', 'ui/Smoke.tsx');
-    act.stop();
-    await sleep(80);
-    expect(seen.filter((c) => c.status === 'idle')).toHaveLength(0);
-    // stop() also detaches the bus subscription.
-    ctx.bus.emit('fs:any', 'ui/Other.tsx');
-    expect(act.state['ui/Other.tsx']).toBeUndefined();
-  });
-});
-
-describe('activity / diffArtboardIds (Task 7)', () => {
-  const wrap = (primaryBody: string, secondaryBody: string) =>
-    `import { DesignCanvas, DCArtboard } from '@maude/canvas-lib';
-export default function C() {
-  return (
-    <DesignCanvas>
-      <DCArtboard id="primary" label="Primary" width={400} height={300}>${primaryBody}</DCArtboard>
-      <DCArtboard id="secondary" label="Secondary" width={400} height={300}>${secondaryBody}</DCArtboard>
-    </DesignCanvas>
-  );
-}`;
-
-  test('change confined to one artboard → that id only', () => {
-    const prev = wrap('<p>A</p>', '<p>B</p>');
-    const next = wrap('<p>A</p>', '<p>B changed</p>');
-    expect(diffArtboardIds(prev, next)).toEqual(['secondary']);
-  });
-
-  test('change in both artboards → both ids', () => {
-    const prev = wrap('<p>A</p>', '<p>B</p>');
-    const next = wrap('<p>A2</p>', '<p>B2</p>');
-    expect(diffArtboardIds(prev, next)?.sort()).toEqual(['primary', 'secondary']);
-  });
-
-  test('identical content → null (no region changed)', () => {
-    const src = wrap('<p>A</p>', '<p>B</p>');
-    expect(diffArtboardIds(src, src)).toBeNull();
-  });
-
-  test('change outside any artboard body → null (file-level fallback)', () => {
-    const prev = wrap('<p>A</p>', '<p>B</p>');
-    // Added an import line outside any DCArtboard → skeleton differs.
-    const next = `import x from 'y';\n${wrap('<p>A</p>', '<p>B</p>')}`;
-    expect(diffArtboardIds(prev, next)).toBeNull();
-  });
-
-  test('no DCArtboard markers → null (ambiguous)', () => {
-    expect(diffArtboardIds('<div>old</div>', '<div>new</div>')).toBeNull();
-  });
-
-  test('artboard added/removed → null (shell differs)', () => {
-    const prev = wrap('<p>A</p>', '<p>B</p>');
-    const next = `${wrap('<p>A</p>', '<p>B</p>')}\n// trailing <DCArtboard id="third" label="T" width={1} height={1}>x</DCArtboard>`;
-    expect(diffArtboardIds(prev, next)).toBeNull();
-  });
-});

package/apps/studio/test/ai-activity.test.ts

@@ -1,113 +0,0 @@
-// Unit: AI activity tracker (Phase 8 Task 4).
-
-import { describe, expect, test } from 'bun:test';
-
-import { createAiActivity, HEARTBEAT_GRACE_MS } from '../collab/ai-activity.ts';
-import { type Context, createBus } from '../context.ts';
-
-function makeCtx(): { ctx: Context; events: { file: string; entry: unknown }[] } {
-  const events: { file: string; entry: unknown }[] = [];
-  const bus = createBus();
-  bus.on('ai-activity', (p: { file: string; entry: unknown }) => events.push(p));
-  const ctx = {
-    cfg: {} as Context['cfg'],
-    projectLabel: 'test',
-    paths: {} as Context['paths'],
-    bus,
-  };
-  return { ctx, events };
-}
-
-describe('AiActivity', () => {
-  test('start adds an entry and emits bus event', () => {
-    const { ctx, events } = makeCtx();
-    const clock = 1000;
-    const ai = createAiActivity(ctx, () => clock);
-    const entry = ai.start('ui/Foo.tsx', 'Claude');
-    expect(entry.file).toBe('ui/Foo.tsx');
-    expect(entry.author).toBe('Claude');
-    expect(entry.startedAt).toBe(1000);
-    expect(entry.lastHeartbeat).toBe(1000);
-    expect(events).toHaveLength(1);
-    expect(events[0]?.entry).toBe(entry);
-    ai.stop();
-  });
-
-  test('start preserves startedAt across restart for the same file', () => {
-    const { ctx } = makeCtx();
-    let clock = 1000;
-    const ai = createAiActivity(ctx, () => clock);
-    ai.start('ui/Foo.tsx', 'Claude');
-    clock = 5000;
-    const restarted = ai.start('ui/Foo.tsx', 'Claude');
-    expect(restarted.startedAt).toBe(1000);
-    expect(restarted.lastHeartbeat).toBe(5000);
-    ai.stop();
-  });
-
-  test('heartbeat refreshes lastHeartbeat + emits', () => {
-    const { ctx, events } = makeCtx();
-    let clock = 1000;
-    const ai = createAiActivity(ctx, () => clock);
-    ai.start('ui/Foo.tsx', 'Claude');
-    clock = 2000;
-    const refreshed = ai.heartbeat('ui/Foo.tsx');
-    expect(refreshed?.lastHeartbeat).toBe(2000);
-    expect(refreshed?.startedAt).toBe(1000);
-    // Two bus events — one for start, one for heartbeat.
-    expect(events.length).toBe(2);
-    ai.stop();
-  });
-
-  test('heartbeat returns null when no entry exists', () => {
-    const { ctx } = makeCtx();
-    const ai = createAiActivity(ctx);
-    expect(ai.heartbeat('ui/Absent.tsx')).toBeNull();
-    ai.stop();
-  });
-
-  test('end clears the entry and emits a null', () => {
-    const { ctx, events } = makeCtx();
-    const clock = 1000;
-    const ai = createAiActivity(ctx, () => clock);
-    ai.start('ui/Foo.tsx', 'Claude');
-    const ok = ai.end('ui/Foo.tsx');
-    expect(ok).toBe(true);
-    expect(ai.get('ui/Foo.tsx')).toBeNull();
-    const last = events.at(-1);
-    expect(last?.entry).toBeNull();
-    ai.stop();
-  });
-
-  test('end on absent entry returns false (no emit)', () => {
-    const { ctx, events } = makeCtx();
-    const ai = createAiActivity(ctx);
-    expect(ai.end('ui/Absent.tsx')).toBe(false);
-    expect(events.length).toBe(0);
-    ai.stop();
-  });
-
-  test('list returns all live entries', () => {
-    const { ctx } = makeCtx();
-    const clock = 1000;
-    const ai = createAiActivity(ctx, () => clock);
-    ai.start('ui/Foo.tsx', 'Claude');
-    ai.start('ui/Bar.tsx', 'Claude');
-    expect(ai.list().length).toBe(2);
-    ai.end('ui/Foo.tsx');
-    expect(ai.list().length).toBe(1);
-    ai.stop();
-  });
-
-  test('grace period — entry stays inside HEARTBEAT_GRACE_MS', () => {
-    const { ctx } = makeCtx();
-    let clock = 1000;
-    const ai = createAiActivity(ctx, () => clock);
-    ai.start('ui/Foo.tsx', 'Claude');
-    // 29 s later — still within grace.
-    clock = 1000 + HEARTBEAT_GRACE_MS - 1000;
-    // We don't auto-tick the janitor in tests; just confirm entry still exists.
-    expect(ai.get('ui/Foo.tsx')).not.toBeNull();
-    ai.stop();
-  });
-});