@bytespell/amux 0.0.11 → 0.0.13

package/src/message-parser.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect } from 'vitest';
+import { parseMessageToContentBlocks } from './message-parser.js';
+
+describe('parseMessageToContentBlocks', () => {
+  const workingDir = '/home/user/project';
+
+  describe('plain text messages', () => {
+    it('returns single text block for plain text', () => {
+      const result = parseMessageToContentBlocks('hello world', workingDir);
+      expect(result).toEqual([{ type: 'text', text: 'hello world' }]);
+    });
+
+    it('returns single text block for empty message', () => {
+      const result = parseMessageToContentBlocks('', workingDir);
+      expect(result).toEqual([{ type: 'text', text: '' }]);
+    });
+
+    it('returns single text block for whitespace-only message', () => {
+      const result = parseMessageToContentBlocks('   ', workingDir);
+      expect(result).toEqual([{ type: 'text', text: '   ' }]);
+    });
+
+    it('preserves multi-line text', () => {
+      const result = parseMessageToContentBlocks('line one\nline two', workingDir);
+      expect(result).toEqual([{ type: 'text', text: 'line one\nline two' }]);
+    });
+  });
+
+  describe('single @mentions', () => {
+    it('parses single @mention as resource_link', () => {
+      const result = parseMessageToContentBlocks('@src/foo.ts', workingDir);
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/src/foo.ts',
+          name: 'src/foo.ts',
+        },
+      ]);
+    });
+
+    it('parses relative path with ./', () => {
+      const result = parseMessageToContentBlocks('@./local.ts', workingDir);
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/local.ts',
+          name: './local.ts',
+        },
+      ]);
+    });
+
+    it('parses relative path with ../', () => {
+      const result = parseMessageToContentBlocks('@../parent/file.ts', workingDir);
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/parent/file.ts',
+          name: '../parent/file.ts',
+        },
+      ]);
+    });
+
+    it('handles file with dashes in name', () => {
+      const result = parseMessageToContentBlocks('@src/my-file.ts', workingDir);
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/src/my-file.ts',
+          name: 'src/my-file.ts',
+        },
+      ]);
+    });
+
+    it('handles deeply nested paths', () => {
+      const result = parseMessageToContentBlocks('@src/a/b/c/d.ts', workingDir);
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/src/a/b/c/d.ts',
+          name: 'src/a/b/c/d.ts',
+        },
+      ]);
+    });
+  });
+
+  describe('mixed text and @mentions', () => {
+    it('parses text before and after mention', () => {
+      const result = parseMessageToContentBlocks('check @src/foo.ts for bugs', workingDir);
+      expect(result).toEqual([
+        { type: 'text', text: 'check ' },
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/src/foo.ts',
+          name: 'src/foo.ts',
+        },
+        { type: 'text', text: ' for bugs' },
+      ]);
+    });
+
+    it('parses text only before mention', () => {
+      const result = parseMessageToContentBlocks('look at @src/foo.ts', workingDir);
+      expect(result).toEqual([
+        { type: 'text', text: 'look at ' },
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/src/foo.ts',
+          name: 'src/foo.ts',
+        },
+      ]);
+    });
+
+    it('parses text only after mention', () => {
+      const result = parseMessageToContentBlocks('@src/foo.ts has a bug', workingDir);
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/src/foo.ts',
+          name: 'src/foo.ts',
+        },
+        { type: 'text', text: ' has a bug' },
+      ]);
+    });
+  });
+
+  describe('multiple @mentions', () => {
+    it('parses multiple mentions with text between', () => {
+      const result = parseMessageToContentBlocks('@src/a.ts and @src/b.ts', workingDir);
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/src/a.ts',
+          name: 'src/a.ts',
+        },
+        { type: 'text', text: ' and ' },
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/src/b.ts',
+          name: 'src/b.ts',
+        },
+      ]);
+    });
+
+    it('parses consecutive mentions without text between', () => {
+      const result = parseMessageToContentBlocks('@a.ts @b.ts', workingDir);
+      // The space between becomes whitespace-only and gets skipped
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/a.ts',
+          name: 'a.ts',
+        },
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/project/b.ts',
+          name: 'b.ts',
+        },
+      ]);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles email-like patterns (should not match)', () => {
+      // Email addresses should be matched by regex, which may not be desired
+      // This test documents current behavior
+      const result = parseMessageToContentBlocks('email user@example.com', workingDir);
+      // The regex matches @example.com as a mention
+      expect(result[0]).toEqual({ type: 'text', text: 'email user' });
+      expect(result[1]).toHaveProperty('type', 'resource_link');
+    });
+
+    it('handles @ at end of string without path', () => {
+      const result = parseMessageToContentBlocks('just an @', workingDir);
+      expect(result).toEqual([{ type: 'text', text: 'just an @' }]);
+    });
+
+    it('handles multiple @ signs', () => {
+      const result = parseMessageToContentBlocks('@@foo.ts', workingDir);
+      // First @ doesn't match (followed by @), second @ matches
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({ type: 'text', text: '@' });
+    });
+  });
+
+  describe('working directory resolution', () => {
+    it('uses provided working directory for absolute path resolution', () => {
+      const result = parseMessageToContentBlocks('@file.ts', '/custom/dir');
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///custom/dir/file.ts',
+          name: 'file.ts',
+        },
+      ]);
+    });
+
+    it('resolves relative paths correctly from working directory', () => {
+      const result = parseMessageToContentBlocks('@../sibling/file.ts', '/home/user/project');
+      expect(result).toEqual([
+        {
+          type: 'resource_link',
+          uri: 'file:///home/user/sibling/file.ts',
+          name: '../sibling/file.ts',
+        },
+      ]);
+    });
+  });
+});

package/src/message-parser.ts

@@ -0,0 +1,54 @@
+import path from 'path';
+import type * as acp from '@agentclientprotocol/sdk';
+
+/**
+ * Parse message text with @mentions into ContentBlock array.
+ * @mentions become resource_link blocks, other text becomes text blocks.
+ *
+ * Examples:
+ * - "hello world" → [{ type: 'text', text: 'hello world' }]
+ * - "@src/foo.ts" → [{ type: 'resource_link', uri: 'file://...', name: 'src/foo.ts' }]
+ * - "check @src/foo.ts for bugs" → text + resource_link + text
+ */
+export function parseMessageToContentBlocks(
+  message: string,
+  workingDir: string
+): acp.ContentBlock[] {
+  const blocks: acp.ContentBlock[] = [];
+  // Match @path/to/file.ts, @./local.ts, @../parent/file.ts
+  // Allows leading ./ or ../ followed by path characters
+  const mentionRegex = /@(\.{0,2}[\w\/\.\-]+)/g;
+
+  let lastIndex = 0;
+  for (const match of message.matchAll(mentionRegex)) {
+    // Add text before mention
+    if (match.index! > lastIndex) {
+      const text = message.slice(lastIndex, match.index);
+      if (text.trim()) {
+        blocks.push({ type: 'text', text });
+      }
+    }
+
+    // Add resource_link for mention
+    const relativePath = match[1]!;
+    const absolutePath = path.resolve(workingDir, relativePath);
+    blocks.push({
+      type: 'resource_link',
+      uri: `file://${absolutePath}`,
+      name: relativePath,
+    });
+
+    lastIndex = match.index! + match[0].length;
+  }
+
+  // Add remaining text
+  if (lastIndex < message.length) {
+    const text = message.slice(lastIndex);
+    if (text.trim()) {
+      blocks.push({ type: 'text', text });
+    }
+  }
+
+  // If no mentions found, return single text block
+  return blocks.length > 0 ? blocks : [{ type: 'text', text: message }];
+}

package/src/session-updates.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect } from 'vitest';
+import {
+  isToolCallUpdate,
+  isToolCallUpdateMessage,
+  normalizeSessionUpdate,
+} from './session-updates.js';
+import type * as acp from '@agentclientprotocol/sdk';
+
+describe('isToolCallUpdate', () => {
+  it('returns true for tool_call updates', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Test',
+      status: 'pending',
+    } as acp.SessionUpdate;
+    expect(isToolCallUpdate(update)).toBe(true);
+  });
+
+  it('returns false for other update types', () => {
+    const update = {
+      sessionUpdate: 'agent_message_chunk',
+      content: { type: 'text', text: 'hello' },
+    } as acp.SessionUpdate;
+    expect(isToolCallUpdate(update)).toBe(false);
+  });
+});
+
+describe('isToolCallUpdateMessage', () => {
+  it('returns true for tool_call_update updates', () => {
+    const update = {
+      sessionUpdate: 'tool_call_update',
+      id: 'test',
+    } as acp.SessionUpdate;
+    expect(isToolCallUpdateMessage(update)).toBe(true);
+  });
+
+  it('returns false for other update types', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Test',
+      status: 'pending',
+    } as acp.SessionUpdate;
+    expect(isToolCallUpdateMessage(update)).toBe(false);
+  });
+});
+
+describe('normalizeSessionUpdate', () => {
+  it('passes through non-tool updates unchanged', () => {
+    const update: acp.SessionUpdate = {
+      sessionUpdate: 'agent_message_chunk',
+      content: { type: 'text', text: 'hello' },
+    };
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('passes through turn_start unchanged', () => {
+    const update: acp.SessionUpdate = {
+      sessionUpdate: 'turn_start',
+    };
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('passes through turn_end unchanged', () => {
+    const update: acp.SessionUpdate = {
+      sessionUpdate: 'turn_end',
+    };
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('passes through tool_call without content unchanged', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Test Tool',
+      status: 'pending',
+    } as acp.SessionUpdate;
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('passes through tool_call with non-diff content unchanged', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Test Tool',
+      status: 'pending',
+      content: [{ type: 'text', text: 'some output' }],
+    } as acp.SessionUpdate;
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('normalizes tool_call with diff content', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Edit File',
+      status: 'completed',
+      content: [
+        {
+          type: 'diff',
+          oldText: 'old content',
+          newText: 'new content',
+          path: '/path/to/file.ts',
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+
+    // Should have same structure but with normalized diff
+    expect(result.sessionUpdate).toBe('tool_call');
+    expect((result as { content?: acp.ToolCallContent[] }).content).toHaveLength(1);
+
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0];
+    expect(diffContent.type).toBe('diff');
+
+    // The newText should now contain unified diff format
+    const normalizedDiff = diffContent as { newText: string; oldText: string; path: string };
+    expect(normalizedDiff.newText).toContain('Index: /path/to/file.ts');
+    expect(normalizedDiff.newText).toContain('---');
+    expect(normalizedDiff.newText).toContain('+++');
+    expect(normalizedDiff.newText).toContain('-old content');
+    expect(normalizedDiff.newText).toContain('+new content');
+    expect(normalizedDiff.oldText).toBe('');
+    expect(normalizedDiff.path).toBe('/path/to/file.ts');
+  });
+
+  it('normalizes tool_call_update with diff content', () => {
+    const update = {
+      sessionUpdate: 'tool_call_update',
+      id: 'test',
+      content: [
+        {
+          type: 'diff',
+          oldText: 'line1\nline2',
+          newText: 'line1\nmodified',
+          path: 'test.ts',
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0] as {
+      newText: string;
+    };
+
+    expect(diffContent.newText).toContain('-line1');
+    expect(diffContent.newText).toContain('-line2');
+    expect(diffContent.newText).toContain('+line1');
+    expect(diffContent.newText).toContain('+modified');
+  });
+
+  it('handles empty oldText (new file creation)', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Write File',
+      status: 'completed',
+      content: [
+        {
+          type: 'diff',
+          oldText: '',
+          newText: 'new file content',
+          path: 'new-file.ts',
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0] as {
+      newText: string;
+    };
+
+    expect(diffContent.newText).toContain('@@ -0,0 +1,1 @@');
+    expect(diffContent.newText).toContain('+new file content');
+    // No removed lines in the diff body (lines starting with - followed by content, not headers)
+    const lines = diffContent.newText.split('\n');
+    const removedLines = lines.filter(l => l.startsWith('-') && !l.startsWith('---'));
+    expect(removedLines).toHaveLength(0);
+  });
+
+  it('handles multi-line diffs', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Edit File',
+      status: 'completed',
+      content: [
+        {
+          type: 'diff',
+          oldText: 'line1\nline2\nline3',
+          newText: 'line1\nmodified\nline3\nline4',
+          path: 'file.ts',
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0] as {
+      newText: string;
+    };
+
+    // Should have correct line counts in header
+    expect(diffContent.newText).toContain('@@ -1,3 +1,4 @@');
+  });
+
+  it('uses "file" as default path when path is missing', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Edit',
+      status: 'completed',
+      content: [
+        {
+          type: 'diff',
+          oldText: 'old',
+          newText: 'new',
+          // path intentionally omitted
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0] as {
+      newText: string;
+      path: string;
+    };
+
+    expect(diffContent.newText).toContain('Index: file');
+    expect(diffContent.path).toBe('file');
+  });
+
+  it('preserves mixed content types in tool_call', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Complex Tool',
+      status: 'completed',
+      content: [
+        { type: 'text', text: 'Before diff' },
+        {
+          type: 'diff',
+          oldText: 'old',
+          newText: 'new',
+          path: 'file.ts',
+        },
+        { type: 'text', text: 'After diff' },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const content = (result as { content: acp.ToolCallContent[] }).content;
+
+    expect(content).toHaveLength(3);
+    expect(content[0]).toEqual({ type: 'text', text: 'Before diff' });
+    expect(content[1]?.type).toBe('diff');
+    expect(content[2]).toEqual({ type: 'text', text: 'After diff' });
+  });
+});

package/src/session-updates.ts

@@ -0,0 +1,87 @@
+import type * as acp from '@agentclientprotocol/sdk';
+
+/**
+ * Type guard for tool_call session updates
+ */
+export function isToolCallUpdate(
+  update: acp.SessionUpdate
+): update is acp.ToolCall & { sessionUpdate: 'tool_call' } {
+  return update.sessionUpdate === 'tool_call';
+}
+
+/**
+ * Type guard for tool_call_update session updates
+ */
+export function isToolCallUpdateMessage(
+  update: acp.SessionUpdate
+): update is acp.ToolCallUpdate & { sessionUpdate: 'tool_call_update' } {
+  return update.sessionUpdate === 'tool_call_update';
+}
+
+/**
+ * Type guard for diff content items
+ */
+export function isDiffContent(
+  item: acp.ToolCallContent
+): item is acp.Diff & { type: 'diff' } {
+  return item.type === 'diff';
+}
+
+/**
+ * Normalize ACP session updates.
+ * Claude sends Edit/Write diffs as {newText, oldText, path} instead of unified diff.
+ * We convert these to standard unified diff format so the UI doesn't need agent-specific logic.
+ */
+export function normalizeSessionUpdate(
+  update: acp.SessionUpdate
+): acp.SessionUpdate {
+  // Only process tool_call and tool_call_update events with content arrays
+  if (!isToolCallUpdate(update) && !isToolCallUpdateMessage(update)) {
+    return update;
+  }
+
+  const content = update.content;
+  if (!content || !Array.isArray(content)) {
+    return update;
+  }
+
+  // Check for diff items that need normalization
+  const normalizedContent = content.map((item): acp.ToolCallContent => {
+    if (!isDiffContent(item)) return item;
+
+    const diffItem = item;
+    const newText = diffItem.newText;
+    const oldText = diffItem.oldText;
+    const filePath = diffItem.path ?? 'file';
+
+    // Generate unified diff
+    const oldLines = oldText ? oldText.split('\n') : [];
+    const newLines = newText.split('\n');
+
+    let unifiedDiff = `Index: ${filePath}\n`;
+    unifiedDiff += '===================================================================\n';
+    unifiedDiff += `--- ${filePath}\n`;
+    unifiedDiff += `+++ ${filePath}\n`;
+    unifiedDiff += `@@ -${oldLines.length > 0 ? 1 : 0},${oldLines.length} +1,${newLines.length} @@\n`;
+
+    for (const line of oldLines) {
+      unifiedDiff += `-${line}\n`;
+    }
+    for (const line of newLines) {
+      unifiedDiff += `+${line}\n`;
+    }
+
+    // Return normalized diff item
+    return {
+      type: 'diff',
+      newText: unifiedDiff,
+      oldText: '',
+      path: filePath,
+    };
+  });
+
+  return {
+    ...update,
+    content: normalizedContent,
+  };
+}