md-redline 0.1.0

package/server/preferences.test.ts

@@ -0,0 +1,126 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { mkdtemp, rm, writeFile, readFile } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { readPreferences, writePreferences } from './preferences';
+
+let testDir: string;
+
+beforeAll(async () => {
+  testDir = await mkdtemp(join(tmpdir(), 'md-redline-prefs-'));
+});
+
+afterAll(async () => {
+  await rm(testDir, { recursive: true });
+});
+
+beforeEach(async () => {
+  // Clean up the prefs file between tests
+  try {
+    await rm(join(testDir, '.md-redline.json'));
+  } catch {
+    /* doesn't exist */
+  }
+  try {
+    await rm(join(testDir, '.md-redline.json.tmp'));
+  } catch {
+    /* doesn't exist */
+  }
+});
+
+describe('readPreferences', () => {
+  it('returns {} when dotfile does not exist', async () => {
+    const prefs = await readPreferences(testDir);
+    expect(prefs).toEqual({});
+  });
+
+  it('returns parsed content when dotfile exists', async () => {
+    await writeFile(
+      join(testDir, '.md-redline.json'),
+      JSON.stringify({ author: 'Alice', theme: 'dark' }),
+    );
+    const prefs = await readPreferences(testDir);
+    expect(prefs).toEqual({ author: 'Alice', theme: 'dark' });
+  });
+
+  it('returns {} on invalid JSON', async () => {
+    await writeFile(join(testDir, '.md-redline.json'), 'not json at all {{{');
+    const prefs = await readPreferences(testDir);
+    expect(prefs).toEqual({});
+  });
+
+  it('returns {} if file contains a JSON array', async () => {
+    await writeFile(join(testDir, '.md-redline.json'), '["not", "an", "object"]');
+    const prefs = await readPreferences(testDir);
+    expect(prefs).toEqual({});
+  });
+
+  it('returns {} if file contains a JSON null', async () => {
+    await writeFile(join(testDir, '.md-redline.json'), 'null');
+    const prefs = await readPreferences(testDir);
+    expect(prefs).toEqual({});
+  });
+});
+
+describe('writePreferences', () => {
+  it('creates file when it does not exist', async () => {
+    const result = await writePreferences(testDir, { author: 'Bob' });
+    expect(result).toEqual({ author: 'Bob' });
+
+    const raw = await readFile(join(testDir, '.md-redline.json'), 'utf-8');
+    const parsed = JSON.parse(raw);
+    expect(parsed.author).toBe('Bob');
+  });
+
+  it('merges with existing content', async () => {
+    await writePreferences(testDir, { author: 'Alice', theme: 'light' });
+    const result = await writePreferences(testDir, { theme: 'dark' });
+    expect(result).toEqual({ author: 'Alice', theme: 'dark' });
+  });
+
+  it('preserves keys not in the patch', async () => {
+    await writePreferences(testDir, {
+      author: 'Alice',
+      theme: 'dark',
+      recentFiles: [{ path: '/a.md', name: 'a.md', openedAt: '2026-01-01T00:00:00Z' }],
+    });
+    const result = await writePreferences(testDir, { author: 'Bob' });
+    expect(result.author).toBe('Bob');
+    expect(result.theme).toBe('dark');
+    expect(result.recentFiles).toHaveLength(1);
+  });
+
+  it('replaces top-level keys entirely (no deep merge)', async () => {
+    await writePreferences(testDir, {
+      settings: { commentMaxLength: 500, enableResolve: true },
+    });
+    const result = await writePreferences(testDir, {
+      settings: { commentMaxLength: 1000 },
+    });
+    // enableResolve should be gone — settings was replaced entirely
+    expect(result.settings).toEqual({ commentMaxLength: 1000 });
+  });
+
+  it('serializes concurrent writes correctly', async () => {
+    // Fire multiple writes concurrently
+    const promises = [
+      writePreferences(testDir, { author: 'A' }),
+      writePreferences(testDir, { theme: 'dark' }),
+      writePreferences(testDir, { author: 'B' }),
+    ];
+    await Promise.all(promises);
+
+    const final = await readPreferences(testDir);
+    // Both author and theme should be present (all writes completed)
+    expect(final.theme).toBe('dark');
+    // Author should be either A or B (last write wins), but must exist
+    expect(typeof final.author).toBe('string');
+  });
+
+  it('writes valid JSON with trailing newline', async () => {
+    await writePreferences(testDir, { author: 'Test' });
+    const raw = await readFile(join(testDir, '.md-redline.json'), 'utf-8');
+    expect(raw.endsWith('\n')).toBe(true);
+    expect(() => JSON.parse(raw)).not.toThrow();
+  });
+});

package/server/preferences.ts

@@ -0,0 +1,76 @@
+import { readFile, rename, open } from 'fs/promises';
+import { unlinkSync } from 'fs';
+import { join } from 'path';
+
+const PREFS_FILENAME = '.md-redline.json';
+
+export interface RecentFile {
+  path: string;
+  name: string;
+  openedAt: string;
+}
+
+export interface AppSettings {
+  templates?: { label: string; text: string }[];
+  commentMaxLength?: number;
+  showTemplatesByDefault?: boolean;
+  enableResolve?: boolean;
+  quickComment?: boolean;
+}
+
+export interface Preferences {
+  author?: string;
+  settings?: AppSettings;
+  theme?: string;
+  recentFiles?: RecentFile[];
+}
+
+function prefsPath(homeDir: string): string {
+  return join(homeDir, PREFS_FILENAME);
+}
+
+export async function readPreferences(homeDir: string): Promise<Preferences> {
+  try {
+    const raw = await readFile(prefsPath(homeDir), 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return {};
+    return parsed as Preferences;
+  } catch {
+    return {};
+  }
+}
+
+// Write lock to serialize concurrent writes
+let writeLock: Promise<void> = Promise.resolve();
+
+export async function writePreferences(
+  homeDir: string,
+  patch: Partial<Preferences>,
+): Promise<Preferences> {
+  const result = await new Promise<Preferences>((resolve, reject) => {
+    writeLock = writeLock.then(async () => {
+      try {
+        const existing = await readPreferences(homeDir);
+        const merged = { ...existing, ...patch };
+        const filePath = prefsPath(homeDir);
+        const tmpPath = filePath + '.tmp';
+        try {
+          unlinkSync(tmpPath);
+        } catch {
+          // No existing file — fine
+        }
+        const fd = await open(tmpPath, 'wx');
+        try {
+          await fd.writeFile(JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+        } finally {
+          await fd.close();
+        }
+        await rename(tmpPath, filePath);
+        resolve(merged);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+  return result;
+}