gbrain/test/sync-up-to-date-stamping.test.ts

/**
 * v0.18.2.fork.1 — sync.ts up_to_date path advances last_sync_at.
 *
 * Pre-fix: when `lastCommit === headCommit` (no new commits since last sync),
 * performSync early-returned without touching the source row. Quiet sources
 * (read-mostly repos like claude-config / personal-knowledge / subagent-writes)
 * kept stale `last_sync_at` forever; drift monitor (gbrain-projects-drift.sh)
 * false-flagged them as "stale (Nmin ago, threshold 60min)" even though sync
 * cron was firing every 10 min and pulling correctly.
 *
 * Fix: advance last_sync_at on up_to_date path so drift's contract holds:
 * "is the sync cron alive?" (real behavior), not "did the remote add commits?"
 * (red-herring proxy).
 *
 * Surfaced 2026-05-07 PW 1 part 2 prod deploy on LXC 107 — first drift tick
 * post-deploy reported stock-dashboard "stale 6197min ago" 30 seconds after
 * a successful sync tick.
 */

import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs';
import { join } from 'path';
import { tmpdir } from 'os';
import { execFileSync } from 'child_process';
import { PGLiteEngine } from '../src/core/pglite-engine.ts';
import { performSync } from '../src/commands/sync.ts';

let engine: PGLiteEngine;
const cleanupDirs: string[] = [];

function git(cwd: string, ...args: string[]): string {
  return execFileSync('git', ['-C', cwd, ...args], { encoding: 'utf-8' }).trim();
}

function makeFixtureRepo(): string {
  const dir = mkdtempSync(join(tmpdir(), 'gbrain-syncstamp-'));
  cleanupDirs.push(dir);
  git(dir, 'init', '--quiet', '--initial-branch=main');
  git(dir, 'config', 'user.email', 'test@example.com');
  git(dir, 'config', 'user.name', 'test');
  writeFileSync(
    join(dir, 'note.md'),
    `---\ntitle: note\ntype: note\n---\nbody\n`,
  );
  git(dir, 'add', '.');
  git(dir, 'commit', '--quiet', '-m', 'init');
  return dir;
}

beforeAll(async () => {
  engine = new PGLiteEngine();
  await engine.connect({ type: 'pglite' } as never);
  await engine.initSchema();
});

afterAll(async () => {
  await engine.disconnect();
  for (const d of cleanupDirs) {
    try { rmSync(d, { recursive: true, force: true }); } catch { /* best-effort */ }
  }
});

describe('sync up_to_date path — advances last_sync_at', () => {
  test('quiet repo (no new commits) bumps last_sync_at on subsequent sync', async () => {
    const repo = makeFixtureRepo();
    const headCommit = git(repo, 'rev-parse', 'HEAD');
    const sourceId = 'syncstamp-quiet';

    // Provision a source row anchored at HEAD with a stale last_sync_at one
    // hour in the past. Mirrors the prod state for quiet sources where the
    // last actual write happened well before the next idle tick.
    await engine.executeRaw(
      `INSERT INTO sources (id, name, local_path, last_commit, last_sync_at, config)
       VALUES ($1, $1, $2, $3, now() - interval '1 hour', '{"federated": true}'::jsonb)
       ON CONFLICT (id) DO UPDATE SET
         local_path = EXCLUDED.local_path,
         last_commit = EXCLUDED.last_commit,
         last_sync_at = EXCLUDED.last_sync_at`,
      [sourceId, repo, headCommit],
    );

    const before = await engine.executeRaw<{ last_sync_at: Date | string }>(
      `SELECT last_sync_at FROM sources WHERE id = $1`,
      [sourceId],
    );
    const beforeMs = new Date(before[0].last_sync_at as string).getTime();

    // Trigger a sync where HEAD is unchanged from anchor → up_to_date branch.
    const result = await performSync(engine, {
      repoPath: repo,
      noPull: true,
      noEmbed: true,
      sourceId,
    });
    expect(result.status).toBe('up_to_date');

    const after = await engine.executeRaw<{ last_sync_at: Date | string }>(
      `SELECT last_sync_at FROM sources WHERE id = $1`,
      [sourceId],
    );
    const afterMs = new Date(after[0].last_sync_at as string).getTime();

    // last_sync_at must advance — was 1h stale, should now be within seconds of now.
    expect(afterMs).toBeGreaterThan(beforeMs);
    expect(Date.now() - afterMs).toBeLessThan(10_000); // < 10s old
  });

  test('up_to_date does NOT touch last_commit (commit anchor stable)', async () => {
    const repo = makeFixtureRepo();
    const headCommit = git(repo, 'rev-parse', 'HEAD');
    const sourceId = 'syncstamp-anchor';

    await engine.executeRaw(
      `INSERT INTO sources (id, name, local_path, last_commit, last_sync_at, config)
       VALUES ($1, $1, $2, $3, now() - interval '1 hour', '{"federated": true}'::jsonb)
       ON CONFLICT (id) DO UPDATE SET
         local_path = EXCLUDED.local_path,
         last_commit = EXCLUDED.last_commit,
         last_sync_at = EXCLUDED.last_sync_at`,
      [sourceId, repo, headCommit],
    );

    await performSync(engine, {
      repoPath: repo,
      noPull: true,
      noEmbed: true,
      sourceId,
    });

    const after = await engine.executeRaw<{ last_commit: string }>(
      `SELECT last_commit FROM sources WHERE id = $1`,
      [sourceId],
    );
    expect(after[0].last_commit).toBe(headCommit);
  });

  test('non-sourceId (legacy global config) path: no source UPDATE attempted', async () => {
    const repo = makeFixtureRepo();
    const headCommit = git(repo, 'rev-parse', 'HEAD');

    // Seed legacy global config.
    await engine.setConfig('sync.last_commit', headCommit);
    await engine.setConfig('sync.repo_path', repo);

    // No sourceId → legacy path. Should not throw, should still record sync.last_run.
    const result = await performSync(engine, {
      repoPath: repo,
      noPull: true,
      noEmbed: true,
    });
    expect(result.status).toBe('up_to_date');

    const lastRun = await engine.getConfig('sync.last_run');
    expect(lastRun).not.toBeNull();
    expect(Date.now() - new Date(lastRun!).getTime()).toBeLessThan(10_000);
  });
});