gogcli-mcp-gmail 2.22.0 → 2.23.1

package/tests/tools/draft-diff-arithmetic.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerExtraGmailTools } from '../../src/tools/gmail-extra.js';
+import * as lib from '../../../gogcli-mcp/src/lib.js';
+import { createTestHarness, type TestHarness } from '@chrischall/mcp-utils/test';
+import { rawTextResult, errorResult } from '@chrischall/mcp-utils';
+
+vi.mock('../../../gogcli-mcp/src/lib.js', async (o) => ({ ...(await o<typeof lib>()), run: vi.fn(), runOrDiagnose: vi.fn(), diagnose: vi.fn() }));
+
+let harness: TestHarness;
+beforeEach(async () => {
+  vi.clearAllMocks();
+  vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
+  vi.mocked(lib.diagnose).mockResolvedValue(errorResult('diagnosed'));
+  harness = await createTestHarness(registerExtraGmailTools);
+});
+
+const b64 = (t: string) => Buffer.from(t, 'utf8').toString('base64url');
+const draft = (id: string, body: string) => JSON.stringify({
+  draft: {
+    id,
+    message: { id: `m${id}`, threadId: `t${id}`, payload: { mimeType: 'text/plain', headers: [{ name: 'Subject', value: 'S' }], body: { data: b64(body) } } },
+  },
+});
+
+/**
+ * #264: bodyLineCount counted RAW normalized lines while diffBodyLines compares
+ * Set members, so onlyInACount + sharedLineCount === bodyLineCount stopped
+ * holding the moment a body repeated a line. Dividers repeat constantly in real
+ * mail, so this is the ordinary case, not an edge one.
+ *
+ * Asserted through the TOOL, against the emitted payload, because
+ * describeDraftSide is module-private — and because the payload is what a
+ * caller actually does arithmetic on.
+ */
+const A = ['Intro paragraph.', '---', 'Middle paragraph.', '---', 'Closing paragraph.'].join('\n');
+const B = ['Intro paragraph.', '---', 'A different middle.', '---', 'Closing paragraph.'].join('\n');
+
+describe('gog_gmail_drafts_diff count arithmetic', () => {
+  it('onlyInACount + sharedLineCount === bodyLineCount when a body repeats a line', async () => {
+    vi.mocked(lib.run).mockImplementation(async (args: readonly string[]) =>
+      draft(String(args[3]), String(args[3]) === 'a1' ? A : B));
+
+    const res = await harness.callTool('gog_gmail_drafts_diff', { draftIdA: 'a1', draftIdB: 'b1' });
+    const raw = res.content.map((c: any) => c.text).join('\n');
+    const payload = JSON.parse(raw);
+
+    const sideA = payload.drafts.a;
+    const diff = payload.bodyDiff;
+
+    expect(sideA.bodyLineCount).toBeDefined();
+    expect(diff.onlyInACount).toBeDefined();
+    expect(diff.sharedLineCount).toBeDefined();
+    // The body has 5 raw lines but only 4 distinct ones — that gap is the bug.
+    expect(sideA.bodyLineCount).toBe(4);
+    expect(diff.onlyInACount + diff.sharedLineCount).toBe(sideA.bodyLineCount);
+  });
+});

package/tests/tools/draft-fork-signature.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { authoredBodyLines, measureBodyAgreement } from '../../src/tools/gmail-extra.js';
+
+/**
+ * HAZARD A — the lineage judgement must not fire on two unrelated drafts.
+ *
+ * `boilerplateLineFlags` stripped the RFC 3676 `-- ` block, the client's own
+ * `Sent from my iPhone`, and the NAME under a sign-off — but the run stopped at
+ * the first line that was not name-shaped, so a USER-CONFIGURED signature
+ * survived as authored prose:
+ *
+ *     Thanks,                    -> stripped
+ *     Chris Hall                 -> stripped
+ *     (704) 555-0142             -> run stopped; survived
+ *     chris.c.hall@gmail.com     -> survived
+ *     https://example.com/chris  -> survived
+ *
+ * Those lines are identical on every message the account composes. Measured
+ * before the fix: two unrelated drafts shared 3 authored lines / 61 chars and
+ * scored similarity 0.60 against a 0.60 threshold — meetsThreshold TRUE on a
+ * plumber note and a soccer note. In a mailbox whose drafts go to a parenting
+ * coordinator, a wrong pairing is the expensive direction.
+ */
+const SIGNATURE = ['Thanks,', 'Chris Hall', '(704) 555-0142', 'chris.c.hall@gmail.com', 'https://example.com/chris'];
+const withSig = (body: string[]) => ['Hi Sam,', '', ...body, '', ...SIGNATURE].join('\n');
+
+describe('a shared signature is never lineage evidence', () => {
+  it('does not pair two unrelated drafts that share one signature', () => {
+    const m = measureBodyAgreement(withSig(['The plumber comes Tuesday at 9am.']), withSig(['Soccer registration closes Friday.']));
+    expect(m.sharedAuthoredLines).toBe(0);
+    expect(m.meetsThreshold).toBe(false);
+  });
+
+  it('strips the whole signature block, not just the name', () => {
+    expect(authoredBodyLines(withSig(['The plumber comes Tuesday at 9am.']))).toEqual(['The plumber comes Tuesday at 9am.']);
+  });
+});
+
+describe('and it still stops at authored content', () => {
+  it('keeps a postscript under the signature', () => {
+    expect(authoredBodyLines([...SIGNATURE, '', 'P.S. The invoice is attached.'].join('\n')))
+      .toEqual(['P.S. The invoice is attached.']);
+  });
+
+  it('keeps prose under the sign-off', () => {
+    expect(authoredBodyLines(['Thanks,', 'Chris', '', 'Actually the plumber moved to Wednesday.'].join('\n')))
+      .toEqual(['Actually the plumber moved to Wednesday.']);
+  });
+
+  it('keeps contact-shaped lines that are NOT under a sign-off', () => {
+    // The rule is positional. A bare phone number in the body is content.
+    expect(authoredBodyLines(['(704) 555-0142', 'chris@example.com'].join('\n')))
+      .toEqual(['(704) 555-0142', 'chris@example.com']);
+  });
+
+  it('keeps a phone number inside a sentence', () => {
+    expect(authoredBodyLines(['Call me at (704) 555-0142 about the roof.', '', 'Thanks,', 'Chris'].join('\n')))
+      .toEqual(['Call me at (704) 555-0142 about the roof.']);
+  });
+
+  it('still pairs two drafts that genuinely share authored prose', () => {
+    const shared = ['The plumber comes Tuesday at 9am.', 'He will need access to the crawlspace.', 'I left a key under the mat for him.'];
+    const m = measureBodyAgreement(withSig(shared), withSig([...shared, 'One more thing: the gate code is 4417.']));
+    expect(m.sharedAuthoredLines).toBeGreaterThanOrEqual(3);
+    expect(m.meetsThreshold).toBe(true);
+  });
+});