tabwright 1.0.0

package/src/diff-utils.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect } from 'vitest'
+import { createSmartDiff } from './diff-utils.js'
+
+describe('createSmartDiff', () => {
+  it('returns no-change with full content when content is identical', () => {
+    const result = createSmartDiff({
+      oldContent: 'hello\nworld',
+      newContent: 'hello\nworld',
+    })
+    expect(result.type).toBe('no-change')
+    expect(result.content).toBe('hello\nworld')
+  })
+
+  it('returns full content when diff would be longer', () => {
+    // Small content - diff overhead makes it longer than full content
+    const result = createSmartDiff({
+      oldContent: 'line1\nline2\nline3\nline4\nline5',
+      newContent: 'line1\nline2-modified\nline3\nline4\nline5',
+    })
+    expect(result.type).toBe('full')
+    expect(result.content).toBe('line1\nline2-modified\nline3\nline4\nline5')
+  })
+
+  it('returns diff for large content with small changes', () => {
+    // Generate large content where diff will be shorter
+    const lines = Array.from({ length: 100 }, (_, i) => `line ${i + 1}: some content here`)
+    const oldContent = lines.join('\n')
+    const newLines = [...lines]
+    newLines[50] = 'line 51: MODIFIED content here'
+    const newContent = newLines.join('\n')
+
+    const result = createSmartDiff({ oldContent, newContent })
+    expect(result.type).toBe('diff')
+    expect(result.content).toContain('-line 51: some content here')
+    expect(result.content).toContain('+line 51: MODIFIED content here')
+  })
+
+  it('returns full content when changes exceed 50% threshold', () => {
+    const result = createSmartDiff({
+      oldContent: 'a\nb\nc\nd',
+      newContent: 'x\ny\nz\nw',
+    })
+    expect(result.type).toBe('full')
+    expect(result.content).toBe('x\ny\nz\nw')
+  })
+
+  it('respects custom threshold with large content', () => {
+    // Generate content where diff is shorter than full
+    const lines = Array.from({ length: 50 }, (_, i) => `line ${i + 1}`)
+    const oldContent = lines.join('\n')
+    const newLines = [...lines]
+    // Change 25 lines = 50%
+    for (let i = 0; i < 25; i++) {
+      newLines[i * 2] = `CHANGED ${i}`
+    }
+    const newContent = newLines.join('\n')
+
+    // With 40% threshold, should return full (50% >= 40%)
+    const resultLow = createSmartDiff({
+      oldContent,
+      newContent,
+      threshold: 0.4,
+    })
+    expect(resultLow.type).toBe('full')
+
+    // With 60% threshold, should return diff (50% < 60%) - but only if diff is shorter
+    const resultHigh = createSmartDiff({
+      oldContent,
+      newContent,
+      threshold: 0.6,
+    })
+    // For this case, even with high threshold, the diff may be longer than full content
+    // so it could return 'full' - the key is threshold + length check both apply
+    expect(['diff', 'full']).toContain(resultHigh.type)
+  })
+
+  it('uses custom label in diff output', () => {
+    // Generate large content where diff will be shorter than full
+    const lines = Array.from({ length: 100 }, (_, i) => `line ${i + 1}: content`)
+    const oldContent = lines.join('\n')
+    const newLines = [...lines]
+    newLines[50] = 'line 51: MODIFIED'
+    const newContent = newLines.join('\n')
+
+    const result = createSmartDiff({
+      oldContent,
+      newContent,
+      label: 'snapshot',
+    })
+    expect(result.type).toBe('diff')
+    expect(result.content).toContain('--- snapshot')
+    expect(result.content).toContain('+++ snapshot')
+  })
+
+  it('handles empty old content (all additions)', () => {
+    const result = createSmartDiff({
+      oldContent: '',
+      newContent: 'new\ncontent\nhere',
+    })
+    // 100% new content should trigger full
+    expect(result.type).toBe('full')
+    expect(result.content).toContain('new\ncontent\nhere')
+  })
+
+  it('handles empty new content (all deletions)', () => {
+    const result = createSmartDiff({
+      oldContent: 'old\ncontent\nhere',
+      newContent: '',
+    })
+    expect(result.type).toBe('full')
+    expect(result.content).toBe('')
+  })
+
+  it('handles single line changes', () => {
+    const result = createSmartDiff({
+      oldContent: 'single line',
+      newContent: 'modified line',
+    })
+    // 100% change on single line
+    expect(result.type).toBe('full')
+  })
+
+  it('returns full content when most lines changed', () => {
+    // 4 lines changed out of 5 = 80%
+    const result = createSmartDiff({
+      oldContent: 'a\nb\nc\nd\ne',
+      newContent: 'a\nX\nY\nZ\nW',
+    })
+    expect(result.type).toBe('full')
+    expect(result.content).toBe('a\nX\nY\nZ\nW')
+  })
+
+  it('includes context lines in diff output', () => {
+    // Generate large content where diff is shorter than full
+    const lines = Array.from({ length: 100 }, (_, i) => `line ${i + 1}: some longer content`)
+    const oldContent = lines.join('\n')
+    const newLines = [...lines]
+    newLines[50] = 'line 51: MODIFIED content'
+    const newContent = newLines.join('\n')
+
+    const result = createSmartDiff({
+      oldContent,
+      newContent,
+    })
+    expect(result.type).toBe('diff')
+    // Should have context around the change
+    expect(result.content).toContain('line 50')
+    expect(result.content).toContain('-line 51: some longer content')
+    expect(result.content).toContain('+line 51: MODIFIED content')
+    expect(result.content).toContain('line 52')
+  })
+})

package/src/diff-utils.ts

@@ -0,0 +1,70 @@
+import { structuredPatch } from 'diff'
+
+export interface SmartDiffResult {
+  type: 'diff' | 'full' | 'no-change'
+  content: string
+}
+
+export interface CreateSmartDiffOptions {
+  oldContent: string
+  newContent: string
+  /** Threshold ratio (0-1) above which full content is returned instead of diff. Default 0.5 (50%) */
+  threshold?: number
+  /** Label for the diff output */
+  label?: string
+}
+
+/**
+ * Creates a smart diff that returns full content when changes exceed threshold.
+ *
+ * When more than `threshold` (default 50%) of lines have changed, showing a diff
+ * is not useful - we return the full new content instead.
+ */
+export function createSmartDiff(options: CreateSmartDiffOptions): SmartDiffResult {
+  const { oldContent, newContent, threshold = 0.5, label = 'content' } = options
+
+  const patch = structuredPatch(label, label, oldContent, newContent, 'previous', 'current', {
+    context: 3,
+  })
+
+  // Count added and removed lines
+  let addedLines = 0
+  let removedLines = 0
+  for (const hunk of patch.hunks) {
+    for (const line of hunk.lines) {
+      if (line.startsWith('+')) {
+        addedLines++
+      } else if (line.startsWith('-')) {
+        removedLines++
+      }
+    }
+  }
+
+  // No changes - return full content
+  if (addedLines === 0 && removedLines === 0) {
+    return { type: 'no-change', content: newContent }
+  }
+
+  // Calculate change ratio: use max(added, removed) since a replacement counts as both
+  // This ensures the ratio stays in 0-100% range
+  const oldLineCount = oldContent.split('\n').length
+  const newLineCount = newContent.split('\n').length
+  const maxLines = Math.max(oldLineCount, newLineCount, 1) // Avoid division by zero
+  const changedLines = Math.max(addedLines, removedLines)
+  const changeRatio = Math.min(changedLines / maxLines, 1) // Cap at 100%
+
+  // Build unified diff string from structured patch
+  const diffLines: string[] = [`--- ${label} (previous)`, `+++ ${label} (current)`]
+  for (const hunk of patch.hunks) {
+    diffLines.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`)
+    diffLines.push(...hunk.lines)
+  }
+  const diffString = diffLines.join('\n')
+
+  // Return full content if changes exceed threshold OR if diff is longer than full content
+  if (changeRatio >= threshold || diffString.length >= newContent.length) {
+    return { type: 'full', content: newContent }
+  }
+
+  return { type: 'diff', content: diffString }
+}

package/src/doctor.test.ts

@@ -0,0 +1,244 @@
+import { describe, expect, test } from 'vitest'
+import { buildDoctorReport, formatDoctorReport, type DoctorSession } from './doctor.js'
+import type { ExtensionStatus } from './relay-client.js'
+import { CURRENT_EXTENSION_FEATURES } from './protocol.js'
+import type { TabwrightAgentSkillState, TabwrightAgentSkillStatus } from './tabwright-agent-skill.js'
+
+const extension = (overrides: Partial<ExtensionStatus> = {}): ExtensionStatus => {
+  return {
+    extensionId: 'extension-1',
+    stableKey: 'install:Chrome:profile-1',
+    browser: 'Chrome',
+    profile: null,
+    activeTargets: 1,
+    playwriterVersion: '0.4.0',
+    protocolVersion: 1,
+    features: [...CURRENT_EXTENSION_FEATURES],
+    connectionHealth: 'ready',
+    missingFeatures: [],
+    ...overrides,
+  }
+}
+
+const session = (overrides: Partial<DoctorSession> = {}): DoctorSession => {
+  return {
+    id: '1',
+    browser: 'Chrome',
+    extensionId: 'install:Chrome:profile-1',
+    cwd: '/project',
+    ...overrides,
+  }
+}
+
+const skillStatus = (state: TabwrightAgentSkillState): TabwrightAgentSkillStatus => {
+  return {
+    target: 'codex',
+    state,
+    bundledPath: '/package/dist/agent-skills/tabwright/SKILL.md',
+    installedPath: '/home/.codex/skills/tabwright/SKILL.md',
+    bundledSha256: 'bundled',
+    ...(state === 'missing' ? {} : { installedSha256: state === 'current' ? 'bundled' : 'different' }),
+    installCommand: `tabwright skill install --target codex${state === 'outdated' ? ' --force' : ''}`,
+  }
+}
+
+describe('buildDoctorReport', () => {
+  test('recognizes readiness without reusing another task session', () => {
+    const report = buildDoctorReport({
+      version: '0.4.0',
+      cwd: '/project',
+      remote: false,
+      relayVersion: '0.4.0',
+      extensions: [extension()],
+      sessions: [session()],
+      capabilityCount: 2,
+    })
+
+    expect(report.ready).toBe(true)
+    expect(report.next.command).toBe('tabwright session new --browser install:Chrome:profile-1')
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: 'relay', status: 'pass' }),
+        expect.objectContaining({ id: 'extension', status: 'pass' }),
+        expect.objectContaining({ id: 'session', status: 'pass' }),
+      ]),
+    )
+  })
+
+  test('chooses session creation when Chrome has an enabled tab', () => {
+    const report = buildDoctorReport({
+      version: '0.4.0',
+      cwd: '/project',
+      remote: false,
+      relayVersion: '0.4.0',
+      extensions: [extension()],
+      sessions: [],
+      capabilityCount: 0,
+    })
+
+    expect(report.ready).toBe(false)
+    expect(report.next.command).toBe('tabwright session new --browser install:Chrome:profile-1')
+  })
+
+  test('asks for the bundled Tabwright skill before starting a browser session', () => {
+    const report = buildDoctorReport({
+      version: '0.4.0',
+      cwd: '/project',
+      remote: false,
+      relayVersion: '0.4.0',
+      extensions: [extension()],
+      sessions: [session()],
+      capabilityCount: 0,
+      skillStatus: skillStatus('missing'),
+    })
+
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'skill',
+          status: 'warn',
+          message: expect.stringContaining('not installed'),
+        }),
+      ]),
+    )
+    expect(report.next.command).toBe('tabwright skill install --target codex')
+  })
+
+  test('asks for the extension click before suggesting a headless fallback', () => {
+    const report = buildDoctorReport({
+      version: '0.4.0',
+      cwd: '/project',
+      remote: false,
+      relayVersion: '0.4.0',
+      extensions: [extension({ activeTargets: 0 })],
+      sessions: [session()],
+      capabilityCount: 0,
+    })
+
+    expect(report.next.command).toBeUndefined()
+    expect(report.ready).toBe(false)
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'session',
+          status: 'warn',
+          message: expect.stringContaining('none are currently usable'),
+        }),
+      ]),
+    )
+    expect(report.next.title).toContain('click the Tabwright extension icon')
+    expect(report.next.fallbackCommand).toBe('tabwright session new --browser headless')
+  })
+
+  test('keeps a connected direct or headless session usable without an extension', () => {
+    const report = buildDoctorReport({
+      version: '0.4.0',
+      cwd: '/project',
+      remote: false,
+      relayVersion: '0.4.0',
+      extensions: [],
+      sessions: [session({ extensionId: null, connected: true, browser: 'Chromium (headless)' })],
+      capabilityCount: 0,
+    })
+
+    expect(report.ready).toBe(true)
+    expect(report.next.command).toBe('tabwright session new --browser headless')
+  })
+
+  test('explains a newer extension and missing relay', () => {
+    const report = buildDoctorReport({
+      version: '0.4.0',
+      cwd: '/project',
+      remote: false,
+      relayVersion: null,
+      relayError: 'Failed to start relay. Check logs at ~/.tabwright/relay-server.log',
+      extensions: [extension({ playwriterVersion: '0.5.0' })],
+      sessions: [],
+      capabilityCount: 0,
+    })
+
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: 'relay', status: 'fail' }),
+        expect.objectContaining({ id: 'extension', status: 'info' }),
+      ]),
+    )
+    expect(formatDoctorReport(report)).toContain('[FAIL] Local relay is not reachable.')
+    expect(formatDoctorReport(report)).toContain('Failed to start relay')
+    expect(report.next.command).toBe('tabwright logfile')
+  })
+
+  test('keeps core browser control ready for legacy feature handshakes', () => {
+    const report = buildDoctorReport({
+      version: '0.4.0',
+      cwd: '/project',
+      remote: false,
+      relayVersion: '0.4.0',
+      extensions: [
+        extension({
+          protocolVersion: undefined,
+          features: undefined,
+          connectionHealth: 'legacy',
+        }),
+      ],
+      sessions: [session()],
+      capabilityCount: 0,
+    })
+
+    expect(report.ready).toBe(true)
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'extension',
+          status: 'warn',
+          detail: expect.stringContaining('legacy handshake'),
+        }),
+      ]),
+    )
+  })
+
+  test('reports a same-version relay that is missing saved-data features', () => {
+    const report = buildDoctorReport({
+      version: '0.4.0',
+      cwd: '/project',
+      remote: false,
+      relayVersion: '0.4.0',
+      relayFeatures: null,
+      extensions: [extension()],
+      sessions: [session()],
+      capabilityCount: 2,
+    })
+
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'relay',
+          status: 'warn',
+          message: expect.stringContaining('saved-data features are missing'),
+        }),
+      ]),
+    )
+    expect(report.next.command).toBe('tabwright session list')
+  })
+
+  test('keeps remote connection failures diagnostic and non-destructive', () => {
+    const report = buildDoctorReport({
+      version: '0.4.0',
+      cwd: '/project',
+      remote: true,
+      relayVersion: null,
+      extensions: [],
+      sessions: [],
+      capabilityCount: 0,
+    })
+
+    expect(report.ready).toBe(false)
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: 'relay', status: 'fail', message: 'Remote relay is not reachable.' }),
+      ]),
+    )
+    expect(report.next.command).toBeUndefined()
+    expect(report.next.title).toContain('host, token, and network path')
+  })
+})