@1agh/maude 0.30.0 → 0.32.0

package/apps/studio/test/acp-transcript.test.ts

@@ -0,0 +1,112 @@
+// acp/transcript — repo-level chat list + raw-transcript → clean-messages.
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { deleteChat, listChats, readChatMessages } from '../acp/transcript.ts';
+
+let root: string;
+afterEach(() => {
+  if (root) rmSync(root, { recursive: true, force: true });
+});
+
+function seed(chatId: string, lines: object[]): string {
+  root = mkdtempSync(join(tmpdir(), 'acp-tx-'));
+  const dir = join(root, '_chat');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${chatId}.jsonl`), lines.map((l) => JSON.stringify(l)).join('\n'));
+  return root;
+}
+
+describe('readChatMessages — raw → clean turns', () => {
+  test('aggregates agent updates into one assistant message; drops noise', () => {
+    const designRoot = seed('c1', [
+      { ts: 1, role: 'user', text: 'make the button red' },
+      {
+        ts: 2,
+        role: 'agent',
+        update: { sessionUpdate: 'available_commands_update', availableCommands: [] },
+      },
+      {
+        ts: 3,
+        role: 'agent',
+        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Sure, ' } },
+      },
+      {
+        ts: 4,
+        role: 'agent',
+        update: {
+          sessionUpdate: 'tool_call',
+          toolCallId: 't1',
+          title: 'Edit Button.tsx',
+          kind: 'edit',
+          status: 'pending',
+        },
+      },
+      {
+        ts: 5,
+        role: 'agent',
+        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'done.' } },
+      },
+      {
+        ts: 6,
+        role: 'agent',
+        update: { sessionUpdate: 'tool_call_update', toolCallId: 't1', status: 'completed' },
+      },
+      { ts: 7, role: 'agent', update: { sessionUpdate: 'usage_update', used: 10 } },
+      { ts: 8, role: 'stop', stopReason: 'end_turn' },
+    ]);
+
+    const msgs = readChatMessages(designRoot, 'c1');
+    expect(msgs.length).toBe(2);
+    expect(msgs[0]).toEqual({
+      role: 'user',
+      parts: [{ type: 'text', text: 'make the button red' }],
+    });
+    expect(msgs[1].role).toBe('assistant');
+    // text parts merged across the tool call boundary order-preserving
+    const texts = msgs[1].parts.filter((p) => p.type === 'text').map((p) => p.text);
+    expect(texts.join('')).toBe('Sure, done.');
+    const tool = msgs[1].parts.find((p) => p.type === 'tool');
+    expect(tool?.toolName).toBe('Edit Button.tsx');
+    expect(tool?.done).toBe(true);
+    // noise (available_commands_update / usage_update) is not rendered
+    expect(JSON.stringify(msgs)).not.toContain('availableCommands');
+    expect(JSON.stringify(msgs)).not.toContain('usage');
+  });
+
+  test('missing chat → empty', () => {
+    const designRoot = seed('c1', [{ ts: 1, role: 'user', text: 'hi' }]);
+    expect(readChatMessages(designRoot, 'nope')).toEqual([]);
+  });
+});
+
+describe('listChats', () => {
+  test('lists chats with a title derived from the first user line', () => {
+    const designRoot = seed('chat-7', [
+      { ts: 1, role: 'user', text: 'redesign the pricing page please' },
+      { ts: 2, role: 'stop', stopReason: 'end_turn' },
+    ]);
+    const chats = listChats(designRoot);
+    expect(chats.length).toBe(1);
+    expect(chats[0].id).toBe('chat-7');
+    expect(chats[0].title).toBe('redesign the pricing page please');
+  });
+
+  test('no _chat dir → empty', () => {
+    root = mkdtempSync(join(tmpdir(), 'acp-tx-'));
+    expect(listChats(root)).toEqual([]);
+  });
+});
+
+describe('deleteChat', () => {
+  test('removes the transcript; missing → false', () => {
+    const designRoot = seed('gone', [{ ts: 1, role: 'user', text: 'bye' }]);
+    expect(listChats(designRoot).length).toBe(1);
+    expect(deleteChat(designRoot, 'gone')).toBe(true);
+    expect(listChats(designRoot).length).toBe(0);
+    expect(deleteChat(designRoot, 'gone')).toBe(false);
+  });
+});

package/apps/studio/test/canvas-create-api.test.ts

@@ -122,6 +122,71 @@ describe('/_api/canvas — POST round-trip', () => {
     }
   });
 
+  test('create + delete emit canvas-list-update over the inspector WS (Phase 30)', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    let socket: WebSocket | null = null;
+    try {
+      const messages: Array<{ type: string; payload?: { action?: string; slug?: string } }> = [];
+      const sock = new WebSocket(`ws://localhost:${port}/_ws`);
+      socket = sock;
+      await new Promise<void>((res, rej) => {
+        sock.addEventListener('open', () => res());
+        sock.addEventListener('error', () => rej(new Error('ws error')));
+        setTimeout(() => rej(new Error('ws open timeout')), 2000);
+      });
+      sock.addEventListener('message', (ev) => {
+        try {
+          messages.push(JSON.parse(String(ev.data)));
+        } catch {
+          /* ignore non-JSON */
+        }
+      });
+
+      const waitFor = async (pred: (m: (typeof messages)[number]) => boolean) => {
+        const deadline = Date.now() + 2000;
+        while (Date.now() < deadline) {
+          const hit = messages.find(pred);
+          if (hit) return hit;
+          await Bun.sleep(25);
+        }
+        return undefined;
+      };
+
+      const created = await fetch(`http://localhost:${port}/_api/canvas`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'Live Add', kind: 'brief-board' }),
+      });
+      expect(created.status).toBe(201);
+      const cj = (await created.json()) as { rel: string };
+
+      const added = await waitFor(
+        (m) => m.type === 'canvas-list-update' && m.payload?.action === 'added'
+      );
+      expect(added?.payload?.slug).toBe('ui-live_add');
+
+      const del = await fetch(
+        `http://localhost:${port}/_api/canvas?file=${encodeURIComponent(cj.rel)}`,
+        { method: 'DELETE' }
+      );
+      expect(del.status).toBe(200);
+
+      const removed = await waitFor(
+        (m) => m.type === 'canvas-list-update' && m.payload?.action === 'removed'
+      );
+      expect(removed?.payload?.slug).toBe('ui-live_add');
+    } finally {
+      try {
+        socket?.close();
+      } catch {
+        /* ignore */
+      }
+      await killProc(proc);
+    }
+  }, 10_000);
+
   test('defaults kind to brief-board when omitted', async () => {
     const { root } = makeSandbox();
     const port = nextPort();
@@ -284,6 +349,10 @@ describe('/_api/canvas — DELETE (soft-delete)', () => {
         join(designRoot, `${created.slug}.annotations.svg`),
         '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"></svg>'
       );
+      // Seed the per-machine camera view file (DDR-115) to prove it's swept too.
+      mkdirSync(join(designRoot, '_canvas-state'), { recursive: true });
+      const viewAbs = join(designRoot, '_canvas-state', `${created.slug}.view.json`);
+      writeFileSync(viewAbs, JSON.stringify({ viewport: { x: 1, y: 2, zoom: 1 } }));
       const tsx = join(designRoot, 'ui', 'Trash Me.tsx');
       expect(existsSync(tsx)).toBe(true);
 
@@ -293,14 +362,17 @@ describe('/_api/canvas — DELETE (soft-delete)', () => {
       expect(j.ok).toBe(true);
       expect(j.trashed.some((t) => t.endsWith('Trash Me.tsx'))).toBe(true);
       expect(j.trashed.some((t) => t.endsWith('.annotations.svg'))).toBe(true);
+      expect(j.trashed.some((t) => t.endsWith('.view.json'))).toBe(true);
 
       // Gone from the group; present (recoverable) under _trash/ with a manifest.
       expect(existsSync(tsx)).toBe(false);
       expect(existsSync(join(designRoot, `${created.slug}.annotations.svg`))).toBe(false);
+      expect(existsSync(viewAbs)).toBe(false);
       const trashDirs = readdirSync(join(designRoot, '_trash'));
       expect(trashDirs.length).toBe(1);
       const td = join(designRoot, '_trash', trashDirs[0] as string);
       expect(existsSync(join(td, 'Trash Me.tsx'))).toBe(true);
+      expect(existsSync(join(td, `_canvas-state__${created.slug}.view.json`))).toBe(true);
       expect(existsSync(join(td, '_trash-manifest.json'))).toBe(true);
     } finally {
       await killProc(proc);

package/apps/studio/test/canvas-list-watch.test.ts

@@ -0,0 +1,322 @@
+// canvas-list-watch — external-canvas list watcher. Emits `canvas-list-update`
+// when a canvas file appears/disappears on disk from OUTSIDE the dev-server
+// (the ACP agent's `/design:new`, agent Write, git checkout), so the browser
+// file tree refreshes without a reload.
+// RCA: .ai/logs/rca/issue-acp-new-canvas-not-in-filetree.md
+
+import { describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  CANVAS_LIST_DEBOUNCE_MS,
+  createCanvasListWatch,
+  isCanvasCandidate,
+} from '../canvas-list-watch.ts';
+import { type Context, createBus } from '../context.ts';
+import { createFsWatch } from '../fs-watch.ts';
+
+const GROUPS = [
+  { label: 'System', path: 'system' },
+  { label: 'UI', path: 'ui' },
+];
+
+function sandbox(): { root: string; designRoot: string } {
+  const root = mkdtempSync(join(tmpdir(), 'clw-test-'));
+  const designRoot = join(root, '.design');
+  mkdirSync(join(designRoot, 'ui'), { recursive: true });
+  return { root, designRoot };
+}
+
+function mkCtx(designRoot: string): Context {
+  return {
+    cfg: { canvasGroups: GROUPS } as Context['cfg'],
+    projectLabel: '',
+    paths: { designRoot, designRel: '.design' } as Context['paths'],
+    bus: createBus(),
+  };
+}
+
+const TSX = 'export default function C(){return null}';
+
+interface Update {
+  action?: string;
+  rel?: string;
+  slug?: string;
+}
+
+function collect(ctx: Context): Update[] {
+  const got: Update[] = [];
+  ctx.bus.on('canvas-list-update', (p) => got.push(p as Update));
+  return got;
+}
+
+describe('canvas-list-watch / isCanvasCandidate (pure gate)', () => {
+  const groups = ['system', 'ui'];
+  test('accepts openable canvases under a configured group', () => {
+    expect(isCanvasCandidate('ui/Pricing.tsx', groups)).toBe(true);
+    expect(isCanvasCandidate('ui/project/Pricing.tsx', groups)).toBe(true);
+    expect(isCanvasCandidate('ui/Smoke.html', groups)).toBe(true);
+    // DS preview specimens DO show in the tree, so they must trigger a refresh.
+    expect(isCanvasCandidate('system/project/preview/colors.tsx', groups)).toBe(true);
+  });
+
+  test('rejects non-canvas extensions (sidecars, tokens, docs)', () => {
+    expect(isCanvasCandidate('ui/Pricing.meta.json', groups)).toBe(false);
+    expect(isCanvasCandidate('ui/Pricing.css', groups)).toBe(false);
+    expect(isCanvasCandidate('system/project/README.md', groups)).toBe(false);
+  });
+
+  test('rejects runtime-state (`_`-prefixed segment) + SKIP_DIRS', () => {
+    expect(isCanvasCandidate('_history/ui-x/00-screen.tsx', groups)).toBe(false);
+    expect(isCanvasCandidate('ui/_draft.tsx', groups)).toBe(false);
+    expect(isCanvasCandidate('_active.json', groups)).toBe(false);
+    expect(isCanvasCandidate('node_modules/pkg/index.tsx', groups)).toBe(false);
+  });
+
+  test('rejects canvases outside any configured group', () => {
+    expect(isCanvasCandidate('docs/Thing.tsx', groups)).toBe(false);
+    expect(isCanvasCandidate('Thing.tsx', groups)).toBe(false);
+  });
+
+  test('non-string / empty input is rejected, not thrown', () => {
+    expect(isCanvasCandidate('', groups)).toBe(false);
+    expect(isCanvasCandidate(undefined as unknown as string, groups)).toBe(false);
+  });
+});
+
+describe('canvas-list-watch / diff + emit', () => {
+  test('seeding existing canvases emits nothing', async () => {
+    const { root, designRoot } = sandbox();
+    writeFileSync(join(designRoot, 'ui', 'Existing.tsx'), TSX);
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
+    await w.ready;
+    try {
+      expect(got).toHaveLength(0);
+      expect(w.known.has('.design/ui/Existing.tsx')).toBe(true);
+    } finally {
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('a canvas written straight to disk emits action:added (the bug)', async () => {
+    const { root, designRoot } = sandbox();
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
+    await w.ready;
+    try {
+      // Simulate `/design:new` writing the canvas (and its sidecar) directly —
+      // NO API call, so api.ts never emits.
+      writeFileSync(join(designRoot, 'ui', 'Pricing.tsx'), TSX);
+      writeFileSync(join(designRoot, 'ui', 'Pricing.meta.json'), '{}');
+      await w.refresh();
+      expect(got).toHaveLength(1);
+      expect(got[0]?.action).toBe('added');
+      expect(got[0]?.slug).toBe('ui-pricing');
+    } finally {
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('deleting a canvas on disk emits action:removed', async () => {
+    const { root, designRoot } = sandbox();
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
+    await w.ready;
+    try {
+      const abs = join(designRoot, 'ui', 'Gone.tsx');
+      writeFileSync(abs, TSX);
+      await w.refresh();
+      got.length = 0; // drop the 'added'
+      rmSync(abs);
+      await w.refresh();
+      expect(got).toHaveLength(1);
+      expect(got[0]?.action).toBe('removed');
+      expect(got[0]?.slug).toBe('ui-gone');
+    } finally {
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('editing an existing canvas body emits nothing (no tree thrash)', async () => {
+    const { root, designRoot } = sandbox();
+    const abs = join(designRoot, 'ui', 'Edited.tsx');
+    writeFileSync(abs, TSX);
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
+    await w.ready;
+    try {
+      writeFileSync(abs, `${TSX}\n// edited`);
+      writeFileSync(join(designRoot, 'ui', 'Edited.meta.json'), '{"x":1}');
+      await w.refresh();
+      expect(got).toHaveLength(0);
+    } finally {
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('runtime-state + sidecar writes never emit', async () => {
+    const { root, designRoot } = sandbox();
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
+    await w.ready;
+    try {
+      writeFileSync(join(designRoot, '_active.json'), '{}');
+      mkdirSync(join(designRoot, '_canvas-state'), { recursive: true });
+      writeFileSync(join(designRoot, '_canvas-state', 'ui-x.view.json'), '{}');
+      writeFileSync(join(designRoot, 'config.json'), '{}');
+      await w.refresh();
+      expect(got).toHaveLength(0);
+    } finally {
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('canvas-list-watch / live fs:any path', () => {
+  test('a candidate fs:any event schedules a debounced refresh that emits', async () => {
+    const { root, designRoot } = sandbox();
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 20 });
+    await w.ready;
+    try {
+      writeFileSync(join(designRoot, 'ui', 'Live.tsx'), TSX);
+      // The fs-watch would emit this; assert the subscriber wires through.
+      ctx.bus.emit('fs:any', 'ui/Live.tsx');
+      await new Promise((r) => setTimeout(r, 20 + 80));
+      await w.refresh(); // flush the chain
+      const added = got.find((m) => m.action === 'added' && m.slug === 'ui-live');
+      expect(added).toBeTruthy();
+      // Exactly one 'added' — the timer + the explicit flush must not double-emit.
+      expect(got.filter((m) => m.action === 'added' && m.slug === 'ui-live')).toHaveLength(1);
+    } finally {
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('a non-candidate fs:any event does not schedule a refresh', async () => {
+    const { root, designRoot } = sandbox();
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 20 });
+    await w.ready;
+    try {
+      // Create a canvas but only announce a NON-candidate path. The gate must
+      // skip the recompute, so the new canvas stays unseen until a real event.
+      writeFileSync(join(designRoot, 'ui', 'Sneaky.tsx'), TSX);
+      ctx.bus.emit('fs:any', 'ui/Sneaky.meta.json');
+      ctx.bus.emit('fs:any', '_active.json');
+      await new Promise((r) => setTimeout(r, 20 + 80));
+      expect(got).toHaveLength(0);
+    } finally {
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('stop() unsubscribes — later events are ignored', async () => {
+    const { root, designRoot } = sandbox();
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
+    await w.ready;
+    w.stop();
+    try {
+      writeFileSync(join(designRoot, 'ui', 'After.tsx'), TSX);
+      ctx.bus.emit('fs:any', 'ui/After.tsx');
+      await new Promise((r) => setTimeout(r, CANVAS_LIST_DEBOUNCE_MS + 40));
+      expect(got).toHaveLength(0);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('canvas-list-watch / serialization + multi-remove', () => {
+  test('overlapping refresh() calls serialize — a create between them emits exactly once', async () => {
+    const { root, designRoot } = sandbox();
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
+    await w.ready;
+    try {
+      writeFileSync(join(designRoot, 'ui', 'Pair.tsx'), TSX);
+      // Fire two refreshes WITHOUT awaiting the first. The promise-chain must
+      // serialize them: the first diffs the create against the pre-create set
+      // and updates `known`; the second sees no change. Without the chain both
+      // would snapshot concurrently against the stale `known` and emit twice.
+      const a = w.refresh();
+      const b = w.refresh();
+      await Promise.all([a, b]);
+      expect(got.filter((m) => m.action === 'added' && m.slug === 'ui-pair')).toHaveLength(1);
+    } finally {
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test('removing a whole group subdir emits one removed per canvas (git-checkout shape)', async () => {
+    const { root, designRoot } = sandbox();
+    mkdirSync(join(designRoot, 'ui', 'project'), { recursive: true });
+    writeFileSync(join(designRoot, 'ui', 'project', 'A.tsx'), TSX);
+    writeFileSync(join(designRoot, 'ui', 'project', 'B.tsx'), TSX);
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 10 });
+    await w.ready;
+    try {
+      rmSync(join(designRoot, 'ui', 'project'), { recursive: true, force: true });
+      await w.refresh();
+      const removed = got.filter((m) => m.action === 'removed').map((m) => m.slug);
+      expect(removed.sort()).toEqual(['ui-project-a', 'ui-project-b']);
+    } finally {
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('canvas-list-watch / real fs-watch end-to-end', () => {
+  test('a raw disk write through createFsWatch emits added (the actual bug path)', async () => {
+    const { root, designRoot } = sandbox();
+    const ctx = mkCtx(designRoot);
+    const got = collect(ctx);
+    const fsWatch = createFsWatch(ctx);
+    const w = createCanvasListWatch(ctx, { debounceMs: 30 });
+    await w.ready;
+    fsWatch.start();
+    try {
+      // Let the OS watcher arm, then write straight to disk — NO manual bus
+      // emit. This exercises the genuine ACP-agent path: disk write →
+      // fs.watch → fs:any → gate → debounce → snapshot diff → canvas-list-update.
+      await new Promise((r) => setTimeout(r, 60));
+      writeFileSync(join(designRoot, 'ui', 'Real.tsx'), TSX);
+      const deadline = Date.now() + 3000;
+      while (
+        Date.now() < deadline &&
+        !got.some((m) => m.action === 'added' && m.slug === 'ui-real')
+      ) {
+        await new Promise((r) => setTimeout(r, 50));
+      }
+      expect(got.some((m) => m.action === 'added' && m.slug === 'ui-real')).toBe(true);
+    } finally {
+      fsWatch.stop();
+      w.stop();
+      rmSync(root, { recursive: true, force: true });
+    }
+  }, 10_000);
+});