Skip to content

Turbocharge Claude Code, Cursor, Codex, Gemini & every coding agent: faster, cheaper, with contextual understanding specific to your codebase.

feat(claude): state module — stats/session storage + sync lock

Shrish Dwivedi075a25477454
diff --git a/src/claude/state.ts b/src/claude/state.ts
new file mode 100644
index 00000000..ab09cc9d
--- /dev/null
+++ b/src/claude/state.ts
@@ -0,0 +1,62 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface Stats {
+ nodeCount: number; edgeCount: number; languages: string[];
+ totalCount: number; readyCount: number;
+ staleCount: number; dirty: boolean; syncing: boolean;
+ syncedAt: string | null; lastFile: string | null;
+}
+export interface SessionState {
+ lastQuery: string | null;
+ perAgentQuery: Record<string, string>;
+ graftReads: number; sourceReads: number;
+}
+
+export const LOCK_STALE_MS = 300000;
+
+export function emptyStats(): Stats {
+ return { nodeCount: 0, edgeCount: 0, languages: [], totalCount: 0, readyCount: 0,
+ staleCount: 0, dirty: false, syncing: false, syncedAt: null, lastFile: null };
+}
+function emptySession(): SessionState {
+ return { lastQuery: null, perAgentQuery: {}, graftReads: 0, sourceReads: 0 };
+}
+
+export function cacheDir(projectDir: string): string { return join(projectDir, 'graft', '.cache'); }
+function statsPath(d: string): string { return join(cacheDir(d), 'stats.json'); }
+function sessionPath(d: string, id: string): string { return join(cacheDir(d), 'session', `${id}.json`); }
+function lockPath(d: string): string { return join(cacheDir(d), '.sync.lock'); }
+
+function readJson<T>(p: string): T | null {
+ try { return JSON.parse(readFileSync(p, 'utf8')) as T; } catch { return null; }
+}
+function writeJsonAtomic(p: string, value: unknown): void {
+ mkdirSync(join(p, '..'), { recursive: true });
+ const tmp = `${p}.${process.pid}.tmp`;
+ writeFileSync(tmp, JSON.stringify(value, null, 2));
+ renameSync(tmp, p);
+}
+
+export function readStats(d: string): Stats | null { return readJson<Stats>(statsPath(d)); }
+export function writeStats(d: string, s: Stats): void { writeJsonAtomic(statsPath(d), s); }
+export function patchStats(d: string, patch: Partial<Stats>): Stats {
+ const next: Stats = { ...(readStats(d) ?? emptyStats()), ...patch };
+ writeStats(d, next);
+ return next;
+}
+export function readSession(d: string, id: string): SessionState {
+ return readJson<SessionState>(sessionPath(d, id)) ?? emptySession();
+}
+export function writeSession(d: string, id: string, s: SessionState): void {
+ writeJsonAtomic(sessionPath(d, id), s);
+}
+
+export function acquireLock(d: string): boolean {
+ const p = lockPath(d);
+ if (existsSync(p) && Date.now() - statSync(p).mtimeMs < LOCK_STALE_MS) return false;
+ mkdirSync(cacheDir(d), { recursive: true });
+ writeFileSync(p, JSON.stringify({ pid: process.pid, at: new Date().toISOString() }));
+ return true;
+}
+export function releaseLock(d: string): void { try { rmSync(lockPath(d)); } catch { /* already gone */ } }
diff --git a/test/claude-state.test.ts b/test/claude-state.test.ts
new file mode 100644
index 00000000..474fb5b4
--- /dev/null
+++ b/test/claude-state.test.ts
@@ -0,0 +1,41 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+ emptyStats, readStats, writeStats, patchStats,
+ readSession, writeSession, acquireLock, releaseLock, cacheDir,
+} from '../src/claude/state.js';
+
+function fresh(): string { return mkdtempSync(join(tmpdir(), 'graft-state-')); }
+
+test('stats round-trip and patch merge', () => {
+ const d = fresh();
+ assert.equal(readStats(d), null);
+ writeStats(d, { ...emptyStats(), nodeCount: 319, edgeCount: 730 });
+ assert.equal(readStats(d)!.nodeCount, 319);
+ const patched = patchStats(d, { dirty: true, staleCount: 4 });
+ assert.equal(patched.dirty, true);
+ assert.equal(patched.staleCount, 4);
+ assert.equal(readStats(d)!.edgeCount, 730, 'patch preserves other fields');
+});
+
+test('session defaults and round-trip', () => {
+ const d = fresh();
+ const s = readSession(d, 'abc');
+ assert.deepEqual(s, { lastQuery: null, perAgentQuery: {}, graftReads: 0, sourceReads: 0 });
+ s.lastQuery = 'pkce'; s.graftReads = 2;
+ writeSession(d, 'abc', s);
+ assert.equal(readSession(d, 'abc').lastQuery, 'pkce');
+ assert.equal(readSession(d, 'xyz').graftReads, 0, 'other sessions isolated');
+});
+
+test('lock is exclusive then releasable', () => {
+ const d = fresh();
+ assert.equal(acquireLock(d), true);
+ assert.equal(acquireLock(d), false, 'second acquire blocked while held');
+ assert.ok(existsSync(join(cacheDir(d), '.sync.lock')));
+ releaseLock(d);
+ assert.equal(acquireLock(d), true, 'reacquire after release');
+});