transduck 0.0.1

package/tests/plural.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest';
+import { getPluralCategory, getPluralCategories, interpolateVars } from '../src/plural.js';
+
+describe('getPluralCategory', () => {
+  it('returns "one" for count 1 in English', () => {
+    expect(getPluralCategory('EN', 1)).toBe('one');
+  });
+
+  it('returns "other" for count 0 in English', () => {
+    expect(getPluralCategory('EN', 0)).toBe('other');
+  });
+
+  it('returns "other" for count 5 in English', () => {
+    expect(getPluralCategory('EN', 5)).toBe('other');
+  });
+
+  it('returns "one" for count 1 in German', () => {
+    expect(getPluralCategory('DE', 1)).toBe('one');
+  });
+
+  it('returns "other" for count 2 in German', () => {
+    expect(getPluralCategory('DE', 2)).toBe('other');
+  });
+
+  it('returns "few" for count 3 in Russian', () => {
+    expect(getPluralCategory('RU', 3)).toBe('few');
+  });
+
+  it('returns "many" for count 5 in Russian', () => {
+    expect(getPluralCategory('RU', 5)).toBe('many');
+  });
+
+  it('returns "one" for count 1 in Russian', () => {
+    expect(getPluralCategory('RU', 1)).toBe('one');
+  });
+
+  it('returns "one" for count 21 in Russian', () => {
+    expect(getPluralCategory('RU', 21)).toBe('one');
+  });
+
+  it('returns "other" for count 5 in Japanese', () => {
+    expect(getPluralCategory('JA', 5)).toBe('other');
+  });
+
+  it('returns "other" for count 1 in Japanese', () => {
+    expect(getPluralCategory('JA', 1)).toBe('other');
+  });
+});
+
+describe('getPluralCategories', () => {
+  it('returns one and other for English', () => {
+    const cats = getPluralCategories('EN');
+    expect(cats).toContain('one');
+    expect(cats).toContain('other');
+    expect(cats.size).toBe(2);
+  });
+
+  it('returns one and other for German', () => {
+    const cats = getPluralCategories('DE');
+    expect(cats).toContain('one');
+    expect(cats).toContain('other');
+    expect(cats.size).toBe(2);
+  });
+
+  it('returns one, few, many, other for Russian', () => {
+    const cats = getPluralCategories('RU');
+    expect(cats).toContain('one');
+    expect(cats).toContain('few');
+    expect(cats).toContain('many');
+    expect(cats).toContain('other');
+  });
+
+  it('returns only other for Japanese', () => {
+    const cats = getPluralCategories('JA');
+    expect(cats).toEqual(new Set(['other']));
+  });
+});
+
+describe('interpolateVars', () => {
+  it('replaces placeholders with values', () => {
+    expect(interpolateVars('Hello {name}', { name: 'Tim' })).toBe('Hello Tim');
+  });
+
+  it('replaces multiple placeholders', () => {
+    expect(interpolateVars('{count} items in {name}\'s cart', { count: 3, name: 'Tim' }))
+      .toBe("3 items in Tim's cart");
+  });
+
+  it('handles numeric values', () => {
+    expect(interpolateVars('{count} messages', { count: 42 })).toBe('42 messages');
+  });
+
+  it('returns text unchanged when no vars', () => {
+    expect(interpolateVars('Hello {name}')).toBe('Hello {name}');
+  });
+
+  it('returns text unchanged when vars is null', () => {
+    expect(interpolateVars('Hello {name}', null)).toBe('Hello {name}');
+  });
+
+  it('ignores extra keys in vars', () => {
+    expect(interpolateVars('Hello {name}', { name: 'Tim', extra: 'ignored' }))
+      .toBe('Hello Tim');
+  });
+
+  it('replaces all occurrences of the same placeholder', () => {
+    expect(interpolateVars('{name} and {name}', { name: 'Tim' }))
+      .toBe('Tim and Tim');
+  });
+
+  it('handles empty vars object', () => {
+    expect(interpolateVars('Hello', {})).toBe('Hello');
+  });
+});

package/tests/storage.test.ts

@@ -0,0 +1,262 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createHash } from 'crypto';
+import { join } from 'path';
+import { mkdtempSync } from 'fs';
+import { tmpdir } from 'os';
+import { TranslationStore } from '../src/storage.js';
+
+function hash(text: string): string {
+  return createHash('sha256').update(text).digest('hex');
+}
+
+describe('TranslationStore', () => {
+  let store: TranslationStore;
+
+  beforeEach(async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'transduck-test-'));
+    store = new TranslationStore(join(tmpDir, 'test.duckdb'));
+    await store.initialize();
+  });
+
+  it('creates table on initialize', async () => {
+    const result = await store.query('SELECT count(*) as c FROM translations');
+    expect(result[0].c).toBe(0);
+  });
+
+  it('inserts and looks up translation', async () => {
+    await store.insert({
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      translatedText: 'Hallo', model: 'gpt-4.1-mini', status: 'translated',
+    });
+    const result = await store.lookup({
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+    });
+    expect(result).toBe('Hallo');
+  });
+
+  it('returns null on miss', async () => {
+    const result = await store.lookup({
+      sourceText: 'Missing', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+    });
+    expect(result).toBeNull();
+  });
+
+  it('skips failed translations in lookup', async () => {
+    await store.insert({
+      sourceText: 'Bad', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      translatedText: 'bad translation', model: 'gpt-4.1-mini', status: 'failed',
+    });
+    const result = await store.lookup({
+      sourceText: 'Bad', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+    });
+    expect(result).toBeNull();
+  });
+
+  it('handles duplicate insert without error', async () => {
+    const entry = {
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      translatedText: 'Hallo', model: 'gpt-4.1-mini', status: 'translated',
+    };
+    await store.insert(entry);
+    await store.insert(entry); // should not throw
+  });
+
+  it('returns stats', async () => {
+    await store.insert({
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      translatedText: 'Hallo', model: 'gpt-4.1-mini', status: 'translated',
+    });
+    await store.insert({
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'ES',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      translatedText: 'Hola', model: 'gpt-4.1-mini', status: 'translated',
+    });
+    const stats = await store.stats();
+    expect(stats.totalTranslations).toBe(2);
+    expect(stats.byLanguage['DE']).toBe(1);
+    expect(stats.byLanguage['ES']).toBe(1);
+    expect(stats.totalFailed).toBe(0);
+  });
+
+  // --- Plural methods ---
+
+  it('inserts and looks up plural translations', async () => {
+    const lookupParams = {
+      sourceText: '{count} message\x00{count} messages',
+      sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+    };
+
+    // Insert plural forms
+    await store.insertPlural({
+      ...lookupParams,
+      pluralCategory: 'one',
+      translatedText: '{count} Nachricht',
+      model: 'gpt-4.1-mini', status: 'translated',
+    });
+    await store.insertPlural({
+      ...lookupParams,
+      pluralCategory: 'other',
+      translatedText: '{count} Nachrichten',
+      model: 'gpt-4.1-mini', status: 'translated',
+    });
+
+    // Lookup should return all forms
+    const result = await store.lookupPlural(lookupParams);
+    expect(result).toEqual({
+      one: '{count} Nachricht',
+      other: '{count} Nachrichten',
+    });
+  });
+
+  it('lookupPlural returns empty object on miss', async () => {
+    const result = await store.lookupPlural({
+      sourceText: 'missing\x00missing',
+      sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+    });
+    expect(result).toEqual({});
+  });
+
+  it('lookupPlural skips failed plural entries', async () => {
+    const lookupParams = {
+      sourceText: '{count} item\x00{count} items',
+      sourceLang: 'EN', targetLang: 'RU',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+    };
+
+    await store.insertPlural({
+      ...lookupParams,
+      pluralCategory: 'one',
+      translatedText: '{count} элемент',
+      model: 'gpt-4.1-mini', status: 'translated',
+    });
+    await store.insertPlural({
+      ...lookupParams,
+      pluralCategory: 'few',
+      translatedText: 'bad translation',
+      model: 'gpt-4.1-mini', status: 'failed',
+    });
+
+    const result = await store.lookupPlural(lookupParams);
+    expect(result).toEqual({ one: '{count} элемент' });
+    expect(result['few']).toBeUndefined();
+  });
+
+  it('plural and regular entries do not interfere', async () => {
+    const baseParams = {
+      sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+    };
+
+    // Regular insert
+    await store.insert({
+      ...baseParams,
+      sourceText: 'Hello',
+      translatedText: 'Hallo',
+      model: 'gpt-4.1-mini', status: 'translated',
+    });
+
+    // Plural insert with same-ish source text
+    await store.insertPlural({
+      ...baseParams,
+      sourceText: 'Hello',
+      pluralCategory: 'one',
+      translatedText: 'Hallo singular',
+      model: 'gpt-4.1-mini', status: 'translated',
+    });
+
+    // Regular lookup should return regular entry
+    const regular = await store.lookup({ ...baseParams, sourceText: 'Hello' });
+    expect(regular).toBe('Hallo');
+
+    // Plural lookup should return plural entry
+    const plural = await store.lookupPlural({ ...baseParams, sourceText: 'Hello' });
+    expect(plural).toEqual({ one: 'Hallo singular' });
+  });
+
+  it('handles duplicate plural insert without error', async () => {
+    const entry = {
+      sourceText: '{count} msg\x00{count} msgs',
+      sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      pluralCategory: 'other',
+      translatedText: '{count} Nachrichten',
+      model: 'gpt-4.1-mini', status: 'translated',
+    };
+    await store.insertPlural(entry);
+    await store.insertPlural(entry); // should not throw
+  });
+
+  // --- Migration ---
+
+  it('migrates v1 schema to v2', async () => {
+    // Create a fresh store with v1 schema
+    const tmpDir = mkdtempSync(join(tmpdir(), 'transduck-migration-'));
+    const dbPath = join(tmpDir, 'migrate.duckdb');
+
+    // Manually create v1 schema (no plural_category column)
+    const { DuckDBInstance } = await import('@duckdb/node-api');
+    const instance = await DuckDBInstance.create(dbPath);
+    const conn = await instance.connect();
+    await conn.run(`
+      CREATE TABLE translations (
+        source_text          TEXT NOT NULL,
+        source_lang          TEXT NOT NULL,
+        target_lang          TEXT NOT NULL,
+        project_context_hash TEXT NOT NULL,
+        string_context_hash  TEXT NOT NULL,
+        translated_text      TEXT NOT NULL,
+        model                TEXT NOT NULL,
+        status               TEXT NOT NULL DEFAULT 'translated',
+        created_at           TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY(source_text, source_lang, target_lang, project_context_hash, string_context_hash)
+      )
+    `);
+    // Insert a v1 row
+    await conn.run(`
+      INSERT INTO translations (source_text, source_lang, target_lang, project_context_hash, string_context_hash, translated_text, model, status)
+      VALUES ('Hello', 'EN', 'DE', '${hash('ctx')}', '${hash('')}', 'Hallo', 'gpt-4.1-mini', 'translated')
+    `);
+
+    // Close the raw connection
+    // (DuckDB node-api handles cleanup via GC, just null out)
+
+    // Now open with TranslationStore — should migrate
+    const migratedStore = new TranslationStore(dbPath);
+    await migratedStore.initialize();
+
+    // Old data should still be accessible
+    const result = await migratedStore.lookup({
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+    });
+    expect(result).toBe('Hallo');
+
+    // Plural methods should work
+    await migratedStore.insertPlural({
+      sourceText: 'test\x00tests',
+      sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      pluralCategory: 'other',
+      translatedText: 'Tests',
+      model: 'gpt-4.1-mini', status: 'translated',
+    });
+
+    const pluralResult = await migratedStore.lookupPlural({
+      sourceText: 'test\x00tests',
+      sourceLang: 'EN', targetLang: 'DE',
+      projectContextHash: hash('ctx'), stringContextHash: hash(''),
+    });
+    expect(pluralResult).toEqual({ other: 'Tests' });
+
+    migratedStore.close();
+  });
+});

package/tests/validation.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { extractPlaceholders, validateTranslation } from '../src/validation.js';
+
+describe('extractPlaceholders', () => {
+  it('extracts curly placeholders', () => {
+    expect(extractPlaceholders('Hello {name}')).toEqual(new Set(['{name}']));
+  });
+
+  it('extracts double curly placeholders', () => {
+    expect(extractPlaceholders('You have {{ count }} items')).toEqual(new Set(['{{ count }}']));
+  });
+
+  it('extracts percent placeholders', () => {
+    expect(extractPlaceholders('Hello %s, you have %d items')).toEqual(new Set(['%s', '%d']));
+  });
+
+  it('extracts dollar placeholders', () => {
+    expect(extractPlaceholders('Hello ${name}')).toEqual(new Set(['${name}']));
+  });
+
+  it('extracts mixed placeholders', () => {
+    const result = extractPlaceholders('{greeting} %s ${name}');
+    expect(result).toEqual(new Set(['{greeting}', '%s', '${name}']));
+  });
+
+  it('returns empty set for no placeholders', () => {
+    expect(extractPlaceholders('Hello world')).toEqual(new Set());
+  });
+});
+
+describe('validateTranslation', () => {
+  it('passes valid translation', () => {
+    expect(validateTranslation('Hello {name}', 'Hallo {name}')).toBe(true);
+  });
+
+  it('fails empty translation', () => {
+    expect(validateTranslation('Hello', '')).toBe(false);
+  });
+
+  it('fails missing placeholder', () => {
+    expect(validateTranslation('Hello {name}', 'Hallo')).toBe(false);
+  });
+
+  it('passes when no placeholders', () => {
+    expect(validateTranslation('Hello', 'Hallo')).toBe(true);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"]
+}