transduck 0.2.5 → 0.4.0

package/dist/storage.js

@@ -1,178 +1,162 @@
-import { DuckDBInstance, DuckDBResultReader } from '@duckdb/node-api';
-const SCHEMA_V2 = `
-CREATE TABLE IF NOT EXISTS 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,
-    plural_category      TEXT NOT NULL DEFAULT '',
-    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, plural_category)
-);
-`;
-const MIGRATION_V1_TO_V2 = `
-CREATE TABLE translations_v2 (
-    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,
-    plural_category      TEXT NOT NULL DEFAULT '',
-    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, plural_category)
-);
-INSERT INTO translations_v2
-    SELECT source_text, source_lang, target_lang, project_context_hash,
-           string_context_hash, '' as plural_category, translated_text,
-           model, status, created_at
-    FROM translations;
-DROP TABLE translations;
-ALTER TABLE translations_v2 RENAME TO translations;
-`;
-const CHECK_PLURAL_COLUMN = `
-SELECT column_name FROM information_schema.columns
-WHERE table_name = 'translations' AND column_name = 'plural_category'
-`;
-const LOOKUP_SQL = `
-SELECT translated_text FROM translations
-WHERE source_text = $1 AND source_lang = $2 AND target_lang = $3
-  AND project_context_hash = $4 AND string_context_hash = $5
-  AND plural_category = '' AND status = 'translated'
-`;
-const INSERT_SQL = `
-INSERT INTO translations
-    (source_text, source_lang, target_lang, project_context_hash,
-     string_context_hash, plural_category, translated_text, model, status)
-VALUES ($1, $2, $3, $4, $5, '', $6, $7, $8)
-ON CONFLICT DO NOTHING
-`;
-const LOOKUP_PLURAL_SQL = `
-SELECT plural_category, translated_text FROM translations
-WHERE source_text = $1 AND source_lang = $2 AND target_lang = $3
-  AND project_context_hash = $4 AND string_context_hash = $5
-  AND plural_category != '' AND status = 'translated'
-`;
-const INSERT_PLURAL_SQL = `
-INSERT INTO translations
-    (source_text, source_lang, target_lang, project_context_hash,
-     string_context_hash, plural_category, translated_text, model, status)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-ON CONFLICT DO NOTHING
-`;
+import { open } from 'lmdb';
+import { createHash } from 'crypto';
+// 1 GB default map size — plenty for translation caches
+const DEFAULT_MAP_SIZE = 1024 * 1024 * 1024;
+function contentHash(sourceText, projectContextHash, stringContextHash) {
+    return createHash('sha256')
+        .update(sourceText + '\x00' + projectContextHash + '\x00' + stringContextHash)
+        .digest('hex');
+}
+function makeKey(sourceLang, targetLang, chash, pluralCategory) {
+    return `${sourceLang}|${targetLang}|${chash}|${pluralCategory}`;
+}
+function parseKey(key) {
+    const parts = key.split('|');
+    return {
+        sourceLang: parts[0],
+        targetLang: parts[1],
+        contentHash: parts[2],
+        pluralCategory: parts[3] ?? '',
+    };
+}
 export class TranslationStore {
     dbPath;
-    instance = null;
-    conn = null;
+    db = null;
     constructor(dbPath) {
         this.dbPath = dbPath;
     }
-    async getConn() {
-        if (!this.conn)
-            throw new Error('Store not initialized');
-        return this.conn;
-    }
-    convertRow(row) {
-        const converted = {};
-        for (const [key, value] of Object.entries(row)) {
-            if (typeof value === 'bigint') {
-                converted[key] = Number(value);
-            }
-            else {
-                converted[key] = value;
-            }
-        }
-        return converted;
-    }
-    async query(sql, params = []) {
-        const conn = await this.getConn();
-        let result;
-        if (params.length === 0) {
-            result = await conn.run(sql);
-        }
-        else {
-            const stmt = await conn.prepare(sql);
-            for (let i = 0; i < params.length; i++) {
-                stmt.bindVarchar(i + 1, params[i]);
-            }
-            result = await stmt.run();
-        }
-        const reader = new DuckDBResultReader(result);
-        await reader.readAll();
-        return [...reader.getRowObjects()].map(row => this.convertRow(row));
-    }
     async initialize() {
-        this.instance = await DuckDBInstance.create(this.dbPath);
-        this.conn = await this.instance.connect();
-        // Check if table exists
-        const tables = await this.query("SELECT table_name FROM information_schema.tables WHERE table_name = 'translations'");
-        if (tables.length === 0) {
-            // Fresh database — create v2 schema
-            await this.conn.run(SCHEMA_V2);
-            return;
-        }
-        // Table exists — check if it has plural_category (v2)
-        const hasPlural = await this.query(CHECK_PLURAL_COLUMN);
-        if (hasPlural.length === 0) {
-            // Migrate from v1 to v2
-            await this.conn.run(MIGRATION_V1_TO_V2);
-        }
+        this.db = open({
+            path: this.dbPath,
+            mapSize: DEFAULT_MAP_SIZE,
+            // Use msgpack (default) for efficient storage
+        });
+    }
+    getDb() {
+        if (!this.db)
+            throw new Error('Store not initialized');
+        return this.db;
     }
     async lookup(params) {
-        const rows = await this.query(LOOKUP_SQL, [
-            params.sourceText, params.sourceLang, params.targetLang,
-            params.projectContextHash, params.stringContextHash,
-        ]);
-        return rows.length > 0 ? rows[0].translated_text : null;
+        const db = this.getDb();
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const key = makeKey(params.sourceLang, params.targetLang, chash, '');
+        const entry = db.get(key);
+        if (entry && entry.status === 'translated') {
+            return entry.translated_text;
+        }
+        return null;
     }
     async insert(params) {
-        await this.query(INSERT_SQL, [
-            params.sourceText, params.sourceLang, params.targetLang,
-            params.projectContextHash, params.stringContextHash,
-            params.translatedText, params.model, params.status,
-        ]);
+        const db = this.getDb();
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const key = makeKey(params.sourceLang, params.targetLang, chash, '');
+        // ON CONFLICT DO NOTHING — only insert if key doesn't exist
+        if (db.get(key) !== undefined)
+            return;
+        await db.put(key, {
+            source_text: params.sourceText,
+            translated_text: params.translatedText,
+            model: params.model,
+            status: params.status,
+            created_at: new Date().toISOString(),
+            project_context_hash: params.projectContextHash,
+            string_context_hash: params.stringContextHash,
+        });
     }
     async lookupPlural(params) {
-        const rows = await this.query(LOOKUP_PLURAL_SQL, [
-            params.sourceText, params.sourceLang, params.targetLang,
-            params.projectContextHash, params.stringContextHash,
-        ]);
+        const db = this.getDb();
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const prefix = makeKey(params.sourceLang, params.targetLang, chash, '');
         const result = {};
-        for (const row of rows) {
-            result[row.plural_category] = row.translated_text;
+        for (const { key, value } of db.getRange({ start: prefix })) {
+            const keyStr = key;
+            if (!keyStr.startsWith(prefix))
+                break;
+            const parsed = parseKey(keyStr);
+            // Skip regular entries (empty plural_category)
+            if (!parsed.pluralCategory)
+                continue;
+            if (value.status === 'translated') {
+                result[parsed.pluralCategory] = value.translated_text;
+            }
         }
         return result;
     }
     async insertPlural(params) {
-        await this.query(INSERT_PLURAL_SQL, [
-            params.sourceText, params.sourceLang, params.targetLang,
-            params.projectContextHash, params.stringContextHash,
-            params.pluralCategory, params.translatedText, params.model, params.status,
-        ]);
+        const db = this.getDb();
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const key = makeKey(params.sourceLang, params.targetLang, chash, params.pluralCategory);
+        // ON CONFLICT DO NOTHING
+        if (db.get(key) !== undefined)
+            return;
+        await db.put(key, {
+            source_text: params.sourceText,
+            translated_text: params.translatedText,
+            model: params.model,
+            status: params.status,
+            created_at: new Date().toISOString(),
+            project_context_hash: params.projectContextHash,
+            string_context_hash: params.stringContextHash,
+        });
     }
     async stats() {
-        const totalRows = await this.query("SELECT count(*) as c FROM translations WHERE status = 'translated'");
-        const failedRows = await this.query("SELECT count(*) as c FROM translations WHERE status = 'failed'");
-        const langRows = await this.query("SELECT target_lang, count(*) as c FROM translations WHERE status = 'translated' GROUP BY target_lang");
+        const db = this.getDb();
+        let totalTranslations = 0;
+        let totalFailed = 0;
         const byLanguage = {};
-        for (const row of langRows) {
-            byLanguage[row.target_lang] = Number(row.c);
+        for (const { key, value } of db.getRange({})) {
+            const parsed = parseKey(key);
+            if (value.status === 'translated') {
+                totalTranslations++;
+                byLanguage[parsed.targetLang] = (byLanguage[parsed.targetLang] ?? 0) + 1;
+            }
+            else if (value.status === 'failed') {
+                totalFailed++;
+            }
+        }
+        return { totalTranslations, totalFailed, byLanguage };
+    }
+    /**
+     * Count entries matching optional filters.
+     */
+    count(targetLang, failedOnly) {
+        const db = this.getDb();
+        let n = 0;
+        for (const { key, value } of db.getRange({})) {
+            const parsed = parseKey(key);
+            if (targetLang && parsed.targetLang !== targetLang)
+                continue;
+            if (failedOnly && value.status !== 'failed')
+                continue;
+            n++;
         }
-        return {
-            totalTranslations: Number(totalRows[0].c),
-            totalFailed: Number(failedRows[0].c),
-            byLanguage,
-        };
+        return n;
+    }
+    /**
+     * Delete entries matching optional filters. Returns count deleted.
+     */
+    async clear(targetLang, failedOnly) {
+        const db = this.getDb();
+        const toDelete = [];
+        for (const { key, value } of db.getRange({})) {
+            const keyStr = key;
+            const parsed = parseKey(keyStr);
+            if (targetLang && parsed.targetLang !== targetLang)
+                continue;
+            if (failedOnly && value.status !== 'failed')
+                continue;
+            toDelete.push(keyStr);
+        }
+        for (const k of toDelete) {
+            await db.remove(k);
+        }
+        return toDelete.length;
     }
     close() {
-        // @duckdb/node-api handles cleanup via GC
-        this.conn = null;
-        this.instance = null;
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transduck",
-  "version": "0.2.5",
+  "version": "0.4.0",
   "description": "AI-native translation tool using source text as keys",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,16 +24,16 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@duckdb/node-api": "^1.5.0-r.1",
     "commander": "^12.0.0",
+    "lmdb": "^3.5.2",
     "openai": "^4.0.0",
     "yaml": "^2.0.0"
   },
   "devDependencies": {
+    "@testing-library/react": "^16.0.0",
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
-    "@testing-library/react": "^16.0.0",
     "jsdom": "^25.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
@@ -41,15 +41,23 @@
     "vitest": "^2.0.0"
   },
   "peerDependencies": {
-    "react": ">=18.0.0",
-    "react-dom": ">=18.0.0",
+    "@anthropic-ai/claude-agent-sdk": ">=0.1.0",
     "@anthropic-ai/sdk": ">=0.30.0",
-    "@anthropic-ai/claude-agent-sdk": ">=0.1.0"
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
   },
   "peerDependenciesMeta": {
-    "react": { "optional": true },
-    "react-dom": { "optional": true },
-    "@anthropic-ai/sdk": { "optional": true },
-    "@anthropic-ai/claude-agent-sdk": { "optional": true }
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    }
   }
 }

package/src/cli.ts

@@ -31,7 +31,7 @@ export async function runInit(opts: InitOptions): Promise<string> {
   const config: Record<string, any> = {
     project: { name: opts.name, context: opts.context },
     languages: { source: opts.sourceLang.toUpperCase(), targets: opts.targetLangs.map(l => l.toUpperCase()) },
-    storage: { path: './translations.duckdb' },
+    storage: { path: './translations.lmdb' },
   };
 
   if (providerChoice === 2) {
@@ -60,7 +60,7 @@ export async function runInit(opts: InitOptions): Promise<string> {
   const configPath = join(opts.dir, 'transduck.yaml');
   writeFileSync(configPath, yamlStringify(config));
 
-  const dbPath = join(opts.dir, 'translations.duckdb');
+  const dbPath = join(opts.dir, 'translations.lmdb');
   const store = new TranslationStore(dbPath);
   await store.initialize();
   store.close();
@@ -562,7 +562,7 @@ export async function runStats(opts: StatsOptions): Promise<string> {
 // CLI entry point
 const program = new Command();
 
-program.name('transduck').description('AI-native translation tool').version('0.2.5');
+program.name('transduck').description('AI-native translation tool').version('0.4.0');
 
 program.command('init')
   .description('Initialize a new transduck project')

package/src/react/index.ts

@@ -1,3 +1,4 @@
 'use client';
 
-export { TransDuckProvider, t, ait, tPlural, aitPlural, useTransDuck, _resetReactState } from './provider.js';
+export { TransDuckProvider, t, ait, tPlural, aitPlural, useTransDuck, _resetReactState, _getReactState } from './provider.js';
+export type { UseTransDuckReturn } from './provider.js';