Files
obelisk/tests/indexer.test.mjs
T
tommy0103andClaude Opus 4.8 e3e61cc7ab fix: coordinate sqlite index writers
Implement the full ADR-0006 plan: three-layer separation of transaction
correctness, retry policy, and cross-process writer coordination.

Layer 1 — scripts/tx.ts (transaction correctness):
- runWriteTransaction executes work exactly once; no internal retry.
- BEGIN IMMEDIATE takes the write lock up front (avoids SQLITE_BUSY_SNAPSHOT).
- Guarded rollback: checks inTransaction() via adapter before attempting
  ROLLBACK; never masks the primary exception.
- WriteTxDiagnostics attached to errors: phase, code, label,
  rollbackSucceeded, rollbackError, transactionActive.
- Binding adapters (betterSqliteTransactionAdapter, nodeSqliteTransactionAdapter)
  mapping better-sqlite3's `.inTransaction` and node:sqlite's `.isTransaction`.
- configureConnection centralizes WAL + synchronous + busy_timeout.

Layer 2 — scripts/write-coordinator.ts (retry policy):
- runRetryableWriteTransaction: bounded retry with total time budget.
- Only retries when the transaction confirmed ended (transactionActive=false)
  and the error is SQLITE_BUSY during work/commit phase.
- BEGIN-phase BUSY = abort entire build (isBeginBusyFailure); the caller
  returns `{ deferred: true, reason: 'writer_busy' }` instead of waiting.
- hasUnusableTransaction detects a still-active transaction after failure;
  aborts the build immediately, never retries.

Layer 3 — scripts/writer-lease.ts (cross-process coordination):
- acquireWriterLease: dedicated writer.lock.sqlite with busy_timeout=0 +
  BEGIN IMMEDIATE. Non-blocking attempt; bounded wait with retryDelayMs.
- writerLockPathFor derives lock path from the target DB path.
- Lease held for the entire build; released on completion or failure.
- Lock DB uses DELETE journal (not WAL); crash/close auto-releases.
- All consumers obey: skill acquires at build start (returns deferred if
  unavailable); app daemon (via worker) acquires for its build cycle.

Build semantics changes:
- affectedSessionIds updated only after successful commit.
- BuildIndexResult gains skipped/skippedFiles for observability.
- Skill finalize failure now fails the build (was silently warned).
- Checkpoint changed to PASSIVE (TRUNCATE reserved for maintenance/exit).
- Skill buildIndex returns { deferred, reason } on lease contention;
  indexer-service reschedules the build (deferredRetryMs) without publishing
  a heartbeat (so the build-deferred state is visible to cross-process
  arbitration).
- Service publishes heartbeat immediately on start() for correct arbitration.

Tests:
- tests/write-transaction.test.mjs: single-shot execution, diagnostics
  propagation, auto-rolled-back transaction detected, rollback failure
  captured as metadata, BEGIN IMMEDIATE semantics.
- tests/writer-lease.test.mjs: acquire/release, contention returns null,
  bounded wait with release during budget.
- tests/app-writer-lease.test.mjs: better-sqlite3 adapter integration.
- tests/app-rollback-guard.test.mjs: rewritten — transient BUSY recovered
  by coordinator, persistent BUSY skips file, begin-busy aborts build,
  live-transaction aborts build, phantom affectedSessionIds prevented.
- tests/daemon-arbitration.test.mjs: skill defers to fresh app heartbeat,
  builds when heartbeat is stale.
- tests/app-indexer-service.test.mjs: new cases for deferred-retry
  scheduling and immediate heartbeat on start.
- app/tests/electron-concurrency.mjs + child: dual-child IPC structure for
  real better-sqlite3 contention (holder acquires lock → build child starts
  → delayed release → result collected; persistent contention bounded).

ADR-0006 updated to reflect the implemented design.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-11 00:42:43 +08:00

87 lines
2.6 KiB
JavaScript

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
import { inferProjectPath, refreshSessionProjectPaths, shouldSkipBuild } from '../scripts/indexer.mjs';
const require = createRequire(import.meta.url);
const { DatabaseSync } = require('node:sqlite');
test('inferProjectPath preserves hyphens from observed cwd', () => {
assert.equal(
inferProjectPath('-Users-dev-Code-quiet-zero', ['/Users/dev/Code/quiet-zero']),
'/Users/dev/Code/quiet-zero',
);
assert.equal(
inferProjectPath('-Users-dev-Code-research-widget-svc', ['/Users/dev/Code/research/widget-svc']),
'/Users/dev/Code/research/widget-svc',
);
});
test('inferProjectPath falls back to legacy slug decoding without cwd evidence', () => {
assert.equal(
inferProjectPath('-Users-dev-Code-quiet-zero', []),
'/Users/dev/Code/quiet/zero',
);
});
test('refreshSessionProjectPaths repairs indexed sessions from message cwd', () => {
const db = new DatabaseSync(':memory:');
db.exec(`
CREATE TABLE sessions (
id TEXT PRIMARY KEY, project TEXT, project_path TEXT
);
CREATE TABLE messages (
uuid TEXT PRIMARY KEY, session_id TEXT, timestamp TEXT, cwd TEXT
);
`);
db.prepare('INSERT INTO sessions (id, project, project_path) VALUES (?, ?, ?)').run(
'sid-1',
'-Users-dev-Code-quiet-zero',
'/Users/dev/Code/quiet/zero',
);
db.prepare('INSERT INTO messages (uuid, session_id, timestamp, cwd) VALUES (?, ?, ?, ?)').run(
'msg-1',
'sid-1',
'2026-06-10T10:00:00Z',
'/Users/dev/Code/quiet-zero',
);
refreshSessionProjectPaths(db);
assert.equal(
db.prepare('SELECT project_path FROM sessions WHERE id=?').get('sid-1').project_path,
'/Users/dev/Code/quiet-zero',
);
db.close();
});
test('shouldSkipBuild treats a fresh heartbeat alone as daemon write ownership', () => {
const db = new DatabaseSync(':memory:');
db.exec(`
CREATE TABLE index_state (
jsonl_path TEXT PRIMARY KEY, mtime REAL, lines_processed INTEGER
);
`);
db.prepare('INSERT INTO index_state (jsonl_path, mtime, lines_processed) VALUES (?, ?, 0)').run(
'__app_heartbeat__',
100000,
);
assert.deepEqual(
shouldSkipBuild(db, { now: 110000 }),
{ skip: true, reason: 'daemon_active' },
);
db.prepare('DELETE FROM index_state').run();
db.prepare('INSERT INTO index_state (jsonl_path, mtime, lines_processed) VALUES (?, ?, 0)').run(
'__app_last_successful_build__',
100000,
);
assert.equal(shouldSkipBuild(db, { now: 110000 }).skip, false);
assert.equal(shouldSkipBuild(db, { now: 200000 }).skip, false);
db.close();
});