transduck 0.6.2 → 0.6.4

package/dist/cli.js

@@ -544,7 +544,7 @@ export async function runStats(opts) {
 }
 // CLI entry point
 const program = new Command();
-program.name('transduck').description('AI-native translation tool').version('0.6.2');
+program.name('transduck').description('AI-native translation tool').version('0.6.4');
 program.command('init')
     .description('Initialize a new transduck project')
     .action(async () => {

package/dist/handler.d.ts

@@ -1,3 +1,4 @@
+import { type TranslationHook } from './hooks.js';
 interface TranslationRequestString {
     text: string;
     context?: string;
@@ -20,6 +21,10 @@ export interface TranslationResponse {
 }
 /** @internal Reset the singleton store — for testing only. */
 export declare function _resetHandlerStore(): void;
-export declare function handleTranslationRequest(body: TranslationRequest, configPath?: string): Promise<TranslationResponse>;
-export declare function createTransDuckHandler(configPath?: string): (request: Request) => Promise<Response>;
+export declare function handleTranslationRequest(body: TranslationRequest, configPath?: string, opts?: {
+    onTranslate?: TranslationHook;
+}): Promise<TranslationResponse>;
+export declare function createTransDuckHandler(configPath?: string, opts?: {
+    onTranslate?: TranslationHook;
+}): (request: Request) => Promise<Response>;
 export {};

package/dist/handler.js

@@ -4,6 +4,7 @@ import { TranslationStore } from './storage.js';
 import { SharedStore } from './shared-store.js';
 import { translate as backendTranslate, translatePlural as backendTranslatePlural } from './backend.js';
 import { validateTranslation } from './validation.js';
+import { fireHooks } from './hooks.js';
 function hash(text) {
     return createHash('sha256').update(text).digest('hex');
 }
@@ -40,7 +41,7 @@ export function _resetHandlerStore() {
     _store = null;
     _sharedStore = null;
 }
-export async function handleTranslationRequest(body, configPath) {
+export async function handleTranslationRequest(body, configPath, opts) {
     const cfg = loadConfig(configPath);
     const store = await getStore(configPath);
     const shared = await getSharedStore(configPath);
@@ -87,6 +88,15 @@ export async function handleTranslationRequest(body, configPath) {
                 await store.insert(insertParams);
                 if (shared)
                     await shared.insert(insertParams);
+                if (opts?.onTranslate) {
+                    const event = {
+                        sourceText: item.text, translatedText: translated,
+                        sourceLang, lang: targetLang, context: item.context ?? null,
+                        projectContext: cfg.projectContext, source: 'translated',
+                        plural: false,
+                    };
+                    await fireHooks([], event, opts.onTranslate);
+                }
                 translations[key] = translated;
             }
             else {
@@ -142,6 +152,15 @@ export async function handleTranslationRequest(body, configPath) {
                 if (shared)
                     await shared.insertPlural(insertParams);
             }
+            if (opts?.onTranslate && 'other' in forms) {
+                const event = {
+                    sourceText: sourceKey, translatedText: forms.other ?? '',
+                    sourceLang, lang: targetLang, context: item.context ?? null,
+                    projectContext: cfg.projectContext, source: 'translated',
+                    plural: true, pluralForms: forms,
+                };
+                await fireHooks([], event, opts.onTranslate);
+            }
             plurals[responseKey] = forms;
         }
         catch {
@@ -150,11 +169,11 @@ export async function handleTranslationRequest(body, configPath) {
     }
     return { translations, plurals };
 }
-export function createTransDuckHandler(configPath) {
+export function createTransDuckHandler(configPath, opts) {
     return async function POST(request) {
         try {
             const body = await request.json();
-            const result = await handleTranslationRequest(body, configPath);
+            const result = await handleTranslationRequest(body, configPath, opts);
             return new Response(JSON.stringify(result), {
                 status: 200,
                 headers: { 'Content-Type': 'application/json' },

package/dist/hooks.d.ts

@@ -0,0 +1,22 @@
+/**
+ * TransDuck hooks — event types and dispatch helpers.
+ *
+ * Field names match TranslationResult for consistency.
+ */
+export interface TranslationEvent {
+    sourceText: string;
+    translatedText: string;
+    sourceLang: string;
+    lang: string;
+    context: string | null;
+    projectContext: string;
+    source: 'cache' | 'translated' | 'shared_cache';
+    plural: boolean;
+    pluralCategory?: string;
+    pluralForms?: Record<string, string>;
+}
+export type TranslationHook = (event: TranslationEvent) => void | Promise<void>;
+/**
+ * Invoke global hooks then per-call hook. Errors are logged, never raised.
+ */
+export declare function fireHooks(hooks: TranslationHook[], event: TranslationEvent, perCallHook?: TranslationHook): Promise<void>;

package/dist/hooks.js

@@ -0,0 +1,26 @@
+/**
+ * TransDuck hooks — event types and dispatch helpers.
+ *
+ * Field names match TranslationResult for consistency.
+ */
+/**
+ * Invoke global hooks then per-call hook. Errors are logged, never raised.
+ */
+export async function fireHooks(hooks, event, perCallHook) {
+    for (const hook of hooks) {
+        try {
+            await hook(event);
+        }
+        catch (err) {
+            console.warn('[transduck] Global translation hook error:', err);
+        }
+    }
+    if (perCallHook) {
+        try {
+            await perCallHook(event);
+        }
+        catch (err) {
+            console.warn('[transduck] Per-call translation hook error:', err);
+        }
+    }
+}

package/dist/index.d.ts

@@ -2,9 +2,12 @@ import { type TransduckConfig } from './config.js';
 import { TranslationStore } from './storage.js';
 import { SharedStore } from './shared-store.js';
 import { TranslationResult } from './result.js';
+import { type TranslationHook } from './hooks.js';
 export declare function initialize(config?: TransduckConfig): Promise<void>;
 export declare function setLanguage(lang: string): void;
 export declare function _resetState(): void;
+export declare function on(eventName: string, callback: TranslationHook): void;
+export declare function off(eventName: string, callback: TranslationHook): void;
 export declare function _getStore(): TranslationStore | null;
 export declare function _getSharedStore(): SharedStore | null;
 export declare function _setSharedStore(shared: SharedStore | null): void;
@@ -13,15 +16,18 @@ export interface AitOptions {
     vars?: Record<string, string | number>;
     sourceLang?: string;
     background?: boolean;
+    onTranslate?: TranslationHook;
 }
 export declare function ait(sourceText: string, contextOrOpts?: string | AitOptions, vars?: Record<string, string | number>): Promise<TranslationResult>;
 export { createTransDuckHandler } from './handler.js';
 export { TranslationResult } from './result.js';
 export { SharedStore } from './shared-store.js';
+export type { TranslationEvent, TranslationHook } from './hooks.js';
 export declare function detectLanguage(text: string): Promise<string>;
 export declare function aitPlural(one: string, other: string, count: number, opts?: {
     context?: string;
     vars?: Record<string, string | number>;
     sourceLang?: string;
     background?: boolean;
+    onTranslate?: TranslationHook;
 }): Promise<TranslationResult>;

package/dist/index.js

@@ -6,6 +6,7 @@ import { TranslationResult } from './result.js';
 import { translate as backendTranslate, translatePlural as backendTranslatePlural, detectLanguage as backendDetectLanguage } from './backend.js';
 import { validateTranslation, extractPlaceholders } from './validation.js';
 import { getPluralCategory, getPluralCategories, interpolateVars } from './plural.js';
+import { fireHooks } from './hooks.js';
 let state = {
     config: null,
     store: null,
@@ -13,6 +14,7 @@ let state = {
     targetLang: null,
     pendingTranslations: new Map(),
     backgroundKeys: new Set(),
+    hooks: new Map(),
 };
 function hash(text) {
     return createHash('sha256').update(text).digest('hex');
@@ -42,8 +44,40 @@ export function _resetState() {
     state = {
         config: null, store: null, sharedStore: null, targetLang: null,
         pendingTranslations: new Map(), backgroundKeys: new Set(),
+        hooks: new Map(),
     };
 }
+export function on(eventName, callback) {
+    const hooks = state.hooks.get(eventName) ?? [];
+    hooks.push(callback);
+    state.hooks.set(eventName, hooks);
+}
+export function off(eventName, callback) {
+    const hooks = state.hooks.get(eventName);
+    if (hooks) {
+        const idx = hooks.indexOf(callback);
+        if (idx !== -1)
+            hooks.splice(idx, 1);
+    }
+}
+async function _maybeFireHooks(opts) {
+    const globalHooks = state.hooks.get('translate');
+    if (!globalHooks?.length && !opts.onTranslate)
+        return;
+    const event = {
+        sourceText: opts.sourceText,
+        translatedText: opts.translatedText,
+        sourceLang: opts.sourceLang,
+        lang: opts.lang,
+        context: opts.context,
+        projectContext: state.config?.projectContext ?? '',
+        source: opts.source,
+        plural: opts.plural ?? false,
+        pluralCategory: opts.pluralCategory,
+        pluralForms: opts.pluralForms,
+    };
+    await fireHooks(globalHooks ?? [], event, opts.onTranslate);
+}
 export function _getStore() {
     return state.store;
 }
@@ -65,6 +99,7 @@ export async function ait(sourceText, contextOrOpts, vars) {
     let resolvedVars;
     let sourceLang;
     let background = false;
+    let onTranslate;
     if (typeof contextOrOpts === 'string') {
         context = contextOrOpts;
         resolvedVars = vars;
@@ -74,6 +109,7 @@ export async function ait(sourceText, contextOrOpts, vars) {
         resolvedVars = contextOrOpts.vars;
         sourceLang = contextOrOpts.sourceLang;
         background = contextOrOpts.background ?? false;
+        onTranslate = contextOrOpts.onTranslate;
     }
     else {
         resolvedVars = vars;
@@ -93,7 +129,11 @@ export async function ait(sourceText, contextOrOpts, vars) {
     // Tier 1: local SQLite lookup
     const cached = await state.store.lookup(lookupParams);
     if (cached !== null) {
-        return new TranslationResult(interpolateVars(cached, resolvedVars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang });
+        await _maybeFireHooks({
+            sourceText, translatedText: cached, sourceLang: effectiveSourceLang,
+            lang: targetLang, context: context ?? null, source: 'cache', onTranslate,
+        });
+        return new TranslationResult(interpolateVars(cached, resolvedVars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'cache' });
     }
     // Tier 2: shared Postgres lookup
     if (state.sharedStore) {
@@ -104,7 +144,11 @@ export async function ait(sourceText, contextOrOpts, vars) {
                 ...lookupParams, stringContext: context ?? '',
                 translatedText: sharedCached, model: cfg.backendModel, status: 'translated',
             });
-            return new TranslationResult(interpolateVars(sharedCached, resolvedVars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang });
+            await _maybeFireHooks({
+                sourceText, translatedText: sharedCached, sourceLang: effectiveSourceLang,
+                lang: targetLang, context: context ?? null, source: 'shared_cache', onTranslate,
+            });
+            return new TranslationResult(interpolateVars(sharedCached, resolvedVars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'shared_cache' });
         }
     }
     // Read-only mode: skip backend, return source text
@@ -117,6 +161,14 @@ export async function ait(sourceText, contextOrOpts, vars) {
         if (!state.backgroundKeys.has(bgKey)) {
             state.backgroundKeys.add(bgKey);
             _doTranslate(sourceText, effectiveSourceLang, targetLang, projectContextHash, stringContextHash, context ?? '', cfg)
+                .then(async (translated) => {
+                if (translated !== sourceText) {
+                    await _maybeFireHooks({
+                        sourceText, translatedText: translated, sourceLang: effectiveSourceLang,
+                        lang: targetLang, context: context ?? null, source: 'translated', onTranslate,
+                    });
+                }
+            })
                 .finally(() => state.backgroundKeys.delete(bgKey));
         }
         return new TranslationResult(interpolateVars(sourceText, resolvedVars), { pending: true, sourceLang: effectiveSourceLang, lang: targetLang });
@@ -131,7 +183,14 @@ export async function ait(sourceText, contextOrOpts, vars) {
     state.pendingTranslations.set(lockKey, translationPromise);
     const result = await translationPromise;
     state.pendingTranslations.delete(lockKey);
-    return new TranslationResult(interpolateVars(result, resolvedVars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang });
+    const isTranslated = result !== sourceText;
+    if (isTranslated) {
+        await _maybeFireHooks({
+            sourceText, translatedText: result, sourceLang: effectiveSourceLang,
+            lang: targetLang, context: context ?? null, source: 'translated', onTranslate,
+        });
+    }
+    return new TranslationResult(interpolateVars(result, resolvedVars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: isTranslated ? 'translated' : undefined });
 }
 async function _doTranslate(sourceText, sourceLang, targetLang, projectContextHash, stringContextHash, stringContext, cfg) {
     // Double-check local cache
@@ -184,6 +243,7 @@ export async function aitPlural(one, other, count, opts) {
     const context = opts?.context;
     const effectiveSourceLang = opts?.sourceLang?.toUpperCase() ?? cfg.sourceLang;
     const background = opts?.background ?? false;
+    const onTranslatePlural = opts?.onTranslate;
     // Build vars with count
     let vars;
     if (!opts?.vars) {
@@ -217,7 +277,12 @@ export async function aitPlural(one, other, count, opts) {
     // Tier 1: local cache lookup
     const cached = await state.store.lookupPlural(lookupParams);
     if (category in cached) {
-        return new TranslationResult(interpolateVars(cached[category], vars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang });
+        await _maybeFireHooks({
+            sourceText: sourceKey, translatedText: cached[category], sourceLang: effectiveSourceLang,
+            lang: targetLang, context: context ?? null, source: 'cache', onTranslate: onTranslatePlural,
+            plural: true, pluralCategory: category, pluralForms: cached,
+        });
+        return new TranslationResult(interpolateVars(cached[category], vars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'cache' });
     }
     // Tier 2: shared store lookup
     if (state.sharedStore) {
@@ -231,7 +296,12 @@ export async function aitPlural(one, other, count, opts) {
                     model: cfg.backendModel, status: 'translated',
                 });
             }
-            return new TranslationResult(interpolateVars(sharedCached[category], vars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang });
+            await _maybeFireHooks({
+                sourceText: sourceKey, translatedText: sharedCached[category], sourceLang: effectiveSourceLang,
+                lang: targetLang, context: context ?? null, source: 'shared_cache', onTranslate: onTranslatePlural,
+                plural: true, pluralCategory: category, pluralForms: sharedCached,
+            });
+            return new TranslationResult(interpolateVars(sharedCached[category], vars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'shared_cache' });
         }
     }
     // Read-only mode: skip backend, fall back to source forms
@@ -246,6 +316,15 @@ export async function aitPlural(one, other, count, opts) {
         if (!state.backgroundKeys.has(bgKey)) {
             state.backgroundKeys.add(bgKey);
             _doPluralTranslate(one, other, sourceKey, effectiveSourceLang, targetLang, projectContextHash, stringContextHash, context ?? '', cfg)
+                .then(async (forms) => {
+                if (forms !== null && category in forms) {
+                    await _maybeFireHooks({
+                        sourceText: sourceKey, translatedText: forms[category], sourceLang: effectiveSourceLang,
+                        lang: targetLang, context: context ?? null, source: 'translated', onTranslate: onTranslatePlural,
+                        plural: true, pluralCategory: category, pluralForms: forms,
+                    });
+                }
+            })
                 .finally(() => state.backgroundKeys.delete(bgKey));
         }
         const fallbackCategory = getPluralCategory(effectiveSourceLang, count);
@@ -255,7 +334,12 @@ export async function aitPlural(one, other, count, opts) {
     // Cache miss — call backend
     const translatedText = await _doPluralTranslate(one, other, sourceKey, effectiveSourceLang, targetLang, projectContextHash, stringContextHash, context ?? '', cfg);
     if (translatedText !== null && category in translatedText) {
-        return new TranslationResult(interpolateVars(translatedText[category], vars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang });
+        await _maybeFireHooks({
+            sourceText: sourceKey, translatedText: translatedText[category], sourceLang: effectiveSourceLang,
+            lang: targetLang, context: context ?? null, source: 'translated', onTranslate: onTranslatePlural,
+            plural: true, pluralCategory: category, pluralForms: translatedText,
+        });
+        return new TranslationResult(interpolateVars(translatedText[category], vars), { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'translated' });
     }
     // Fallback
     const fallbackCategory = getPluralCategory(effectiveSourceLang, count);

package/dist/result.d.ts

@@ -8,10 +8,12 @@ export declare class TranslationResult extends String {
     readonly pending: boolean;
     readonly sourceLang: string;
     readonly lang: string;
+    readonly source: string | null;
     constructor(text: string, opts: {
         pending: boolean;
         sourceLang: string;
         lang: string;
+        source?: string | null;
     });
     toString(): string;
     valueOf(): string;

package/dist/result.js

@@ -8,11 +8,13 @@ export class TranslationResult extends String {
     pending;
     sourceLang;
     lang;
+    source;
     constructor(text, opts) {
         super(text);
         this.pending = opts.pending;
         this.sourceLang = opts.sourceLang;
         this.lang = opts.lang;
+        this.source = opts.source ?? null;
     }
     toString() {
         return super.toString();

package/dist/scanner.js

@@ -12,6 +12,8 @@ const AIT_POSITIONAL_CTX = /ait\s*\(\s*(['"])(.*?)\1(?:\s*,\s*(['"])(.*?)\3)?/g;
 const AIT_PLURAL = /ait(?:_p|P)lural\s*\(\s*(['"])(.*?)\1\s*,\s*(['"])(.*?)\3/g;
 // {% ait "text" %} or {% ait "text" context="ctx" %}
 const DJANGO_TAG = /\{%\s*ait\s+(['"])(.*?)\1(?:\s+context=(['"])(.*?)\3)?\s*%\}/g;
+// {% ait_plural "one" "other" %} or {% ait_plural "one" "other" context="ctx" %}
+const DJANGO_PLURAL_TAG = /\{%\s*ait_plural\s+(['"])(.*?)\1\s+(['"])(.*?)\3(?:\s+context=(['"])(.*?)\5)?\s*%\}/g;
 // t("text") or t("text", "ctx") — only matched in files with transduck/react import
 const T_POSITIONAL = /(?<![a-zA-Z_.$])t\s*\(\s*(['"])(.*?)\1(?:\s*,\s*(['"])(.*?)\3)?/g;
 // tPlural("one", "other") — only matched in files with transduck/react import
@@ -81,6 +83,15 @@ export function extractStrings(content, filename) {
             const lineNum = content.slice(0, match.index).split('\n').length;
             results.push({ text, context, line: lineNum });
         }
+        const djangoPluralRegex = new RegExp(DJANGO_PLURAL_TAG.source, 'g');
+        while ((match = djangoPluralRegex.exec(content)) !== null) {
+            const one = match[2];
+            const other = match[4];
+            const context = match[6] || null;
+            const lineNum = content.slice(0, match.index).split('\n').length;
+            results.push({ plural: true, one, other, context, line: lineNum });
+            pluralSpans.push([match.index, match.index + match[0].length]);
+        }
     }
     // 3. Find ait() calls
     const pattern = isJs ? AIT_POSITIONAL_CTX : AIT_KEYWORD_CTX;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transduck",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "AI-native translation tool using source text as keys",
   "type": "module",
   "main": "./dist/index.js",

package/src/cli.ts

@@ -661,7 +661,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.6.2');
+program.name('transduck').description('AI-native translation tool').version('0.6.4');
 
 program.command('init')
   .description('Initialize a new transduck project')

package/src/handler.ts

@@ -4,6 +4,7 @@ import { TranslationStore } from './storage.js';
 import { SharedStore } from './shared-store.js';
 import { translate as backendTranslate, translatePlural as backendTranslatePlural } from './backend.js';
 import { validateTranslation } from './validation.js';
+import { type TranslationEvent, type TranslationHook, fireHooks } from './hooks.js';
 
 function hash(text: string): string {
   return createHash('sha256').update(text).digest('hex');
@@ -70,6 +71,7 @@ export function _resetHandlerStore(): void {
 export async function handleTranslationRequest(
   body: TranslationRequest,
   configPath?: string,
+  opts?: { onTranslate?: TranslationHook },
 ): Promise<TranslationResponse> {
   const cfg = loadConfig(configPath);
   const store = await getStore(configPath);
@@ -126,6 +128,15 @@ export async function handleTranslationRequest(
         };
         await store.insert(insertParams);
         if (shared) await shared.insert(insertParams);
+        if (opts?.onTranslate) {
+          const event: TranslationEvent = {
+            sourceText: item.text, translatedText: translated,
+            sourceLang, lang: targetLang, context: item.context ?? null,
+            projectContext: cfg.projectContext, source: 'translated',
+            plural: false,
+          };
+          await fireHooks([], event, opts.onTranslate);
+        }
         translations[key] = translated;
       } else {
         translations[key] = item.text;
@@ -186,6 +197,15 @@ export async function handleTranslationRequest(
         await store.insertPlural(insertParams);
         if (shared) await shared.insertPlural(insertParams);
       }
+      if (opts?.onTranslate && 'other' in forms) {
+        const event: TranslationEvent = {
+          sourceText: sourceKey, translatedText: forms.other ?? '',
+          sourceLang, lang: targetLang, context: item.context ?? null,
+          projectContext: cfg.projectContext, source: 'translated',
+          plural: true, pluralForms: forms,
+        };
+        await fireHooks([], event, opts.onTranslate);
+      }
       plurals[responseKey] = forms;
     } catch {
       plurals[responseKey] = { one: item.one, other: item.other };
@@ -195,11 +215,11 @@ export async function handleTranslationRequest(
   return { translations, plurals };
 }
 
-export function createTransDuckHandler(configPath?: string) {
+export function createTransDuckHandler(configPath?: string, opts?: { onTranslate?: TranslationHook }) {
   return async function POST(request: Request): Promise<Response> {
     try {
       const body = await request.json() as TranslationRequest;
-      const result = await handleTranslationRequest(body, configPath);
+      const result = await handleTranslationRequest(body, configPath, opts);
       return new Response(JSON.stringify(result), {
         status: 200,
         headers: { 'Content-Type': 'application/json' },

package/src/hooks.ts

@@ -0,0 +1,44 @@
+/**
+ * TransDuck hooks — event types and dispatch helpers.
+ *
+ * Field names match TranslationResult for consistency.
+ */
+
+export interface TranslationEvent {
+  sourceText: string;
+  translatedText: string;
+  sourceLang: string;
+  lang: string; // target language — matches TranslationResult.lang
+  context: string | null;
+  projectContext: string;
+  source: 'cache' | 'translated' | 'shared_cache';
+  plural: boolean;
+  pluralCategory?: string;
+  pluralForms?: Record<string, string>;
+}
+
+export type TranslationHook = (event: TranslationEvent) => void | Promise<void>;
+
+/**
+ * Invoke global hooks then per-call hook. Errors are logged, never raised.
+ */
+export async function fireHooks(
+  hooks: TranslationHook[],
+  event: TranslationEvent,
+  perCallHook?: TranslationHook,
+): Promise<void> {
+  for (const hook of hooks) {
+    try {
+      await hook(event);
+    } catch (err) {
+      console.warn('[transduck] Global translation hook error:', err);
+    }
+  }
+  if (perCallHook) {
+    try {
+      await perCallHook(event);
+    } catch (err) {
+      console.warn('[transduck] Per-call translation hook error:', err);
+    }
+  }
+}

package/src/index.ts

@@ -6,6 +6,7 @@ import { TranslationResult } from './result.js';
 import { translate as backendTranslate, translatePlural as backendTranslatePlural, detectLanguage as backendDetectLanguage } from './backend.js';
 import { validateTranslation, extractPlaceholders } from './validation.js';
 import { getPluralCategory, getPluralCategories, interpolateVars } from './plural.js';
+import { type TranslationEvent, type TranslationHook, fireHooks } from './hooks.js';
 
 interface State {
   config: TransduckConfig | null;
@@ -14,6 +15,7 @@ interface State {
   targetLang: string | null;
   pendingTranslations: Map<string, Promise<string>>;
   backgroundKeys: Set<string>;
+  hooks: Map<string, TranslationHook[]>;
 }
 
 let state: State = {
@@ -23,6 +25,7 @@ let state: State = {
   targetLang: null,
   pendingTranslations: new Map(),
   backgroundKeys: new Set(),
+  hooks: new Map(),
 };
 
 function hash(text: string): string {
@@ -56,9 +59,47 @@ export function _resetState(): void {
   state = {
     config: null, store: null, sharedStore: null, targetLang: null,
     pendingTranslations: new Map(), backgroundKeys: new Set(),
+    hooks: new Map(),
   };
 }
 
+export function on(eventName: string, callback: TranslationHook): void {
+  const hooks = state.hooks.get(eventName) ?? [];
+  hooks.push(callback);
+  state.hooks.set(eventName, hooks);
+}
+
+export function off(eventName: string, callback: TranslationHook): void {
+  const hooks = state.hooks.get(eventName);
+  if (hooks) {
+    const idx = hooks.indexOf(callback);
+    if (idx !== -1) hooks.splice(idx, 1);
+  }
+}
+
+async function _maybeFireHooks(opts: {
+  sourceText: string; translatedText: string; sourceLang: string; lang: string;
+  context: string | null; source: 'cache' | 'translated' | 'shared_cache';
+  onTranslate?: TranslationHook; plural?: boolean;
+  pluralCategory?: string; pluralForms?: Record<string, string>;
+}): Promise<void> {
+  const globalHooks = state.hooks.get('translate');
+  if (!globalHooks?.length && !opts.onTranslate) return;
+  const event: TranslationEvent = {
+    sourceText: opts.sourceText,
+    translatedText: opts.translatedText,
+    sourceLang: opts.sourceLang,
+    lang: opts.lang,
+    context: opts.context,
+    projectContext: state.config?.projectContext ?? '',
+    source: opts.source,
+    plural: opts.plural ?? false,
+    pluralCategory: opts.pluralCategory,
+    pluralForms: opts.pluralForms,
+  };
+  await fireHooks(globalHooks ?? [], event, opts.onTranslate);
+}
+
 export function _getStore(): TranslationStore | null {
   return state.store;
 }
@@ -76,6 +117,7 @@ export interface AitOptions {
   vars?: Record<string, string | number>;
   sourceLang?: string;
   background?: boolean;
+  onTranslate?: TranslationHook;
 }
 
 export async function ait(
@@ -96,6 +138,8 @@ export async function ait(
   let sourceLang: string | undefined;
   let background = false;
 
+  let onTranslate: TranslationHook | undefined;
+
   if (typeof contextOrOpts === 'string') {
     context = contextOrOpts;
     resolvedVars = vars;
@@ -104,6 +148,7 @@ export async function ait(
     resolvedVars = contextOrOpts.vars;
     sourceLang = contextOrOpts.sourceLang;
     background = contextOrOpts.background ?? false;
+    onTranslate = contextOrOpts.onTranslate;
   } else {
     resolvedVars = vars;
   }
@@ -129,9 +174,13 @@ export async function ait(
   // Tier 1: local SQLite lookup
   const cached = await state.store.lookup(lookupParams);
   if (cached !== null) {
+    await _maybeFireHooks({
+      sourceText, translatedText: cached, sourceLang: effectiveSourceLang,
+      lang: targetLang, context: context ?? null, source: 'cache', onTranslate,
+    });
     return new TranslationResult(
       interpolateVars(cached, resolvedVars),
-      { pending: false, sourceLang: effectiveSourceLang, lang: targetLang },
+      { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'cache' },
     );
   }
 
@@ -144,9 +193,13 @@ export async function ait(
         ...lookupParams, stringContext: context ?? '',
         translatedText: sharedCached, model: cfg.backendModel, status: 'translated',
       });
+      await _maybeFireHooks({
+        sourceText, translatedText: sharedCached, sourceLang: effectiveSourceLang,
+        lang: targetLang, context: context ?? null, source: 'shared_cache', onTranslate,
+      });
       return new TranslationResult(
         interpolateVars(sharedCached, resolvedVars),
-        { pending: false, sourceLang: effectiveSourceLang, lang: targetLang },
+        { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'shared_cache' },
       );
     }
   }
@@ -165,6 +218,14 @@ export async function ait(
     if (!state.backgroundKeys.has(bgKey)) {
       state.backgroundKeys.add(bgKey);
       _doTranslate(sourceText, effectiveSourceLang, targetLang, projectContextHash, stringContextHash, context ?? '', cfg)
+        .then(async (translated) => {
+          if (translated !== sourceText) {
+            await _maybeFireHooks({
+              sourceText, translatedText: translated, sourceLang: effectiveSourceLang,
+              lang: targetLang, context: context ?? null, source: 'translated', onTranslate,
+            });
+          }
+        })
         .finally(() => state.backgroundKeys.delete(bgKey));
     }
     return new TranslationResult(
@@ -189,9 +250,17 @@ export async function ait(
   state.pendingTranslations.set(lockKey, translationPromise);
   const result = await translationPromise;
   state.pendingTranslations.delete(lockKey);
+
+  const isTranslated = result !== sourceText;
+  if (isTranslated) {
+    await _maybeFireHooks({
+      sourceText, translatedText: result, sourceLang: effectiveSourceLang,
+      lang: targetLang, context: context ?? null, source: 'translated', onTranslate,
+    });
+  }
   return new TranslationResult(
     interpolateVars(result, resolvedVars),
-    { pending: false, sourceLang: effectiveSourceLang, lang: targetLang },
+    { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: isTranslated ? 'translated' : undefined },
   );
 }
 
@@ -241,6 +310,7 @@ async function _doTranslate(
 export { createTransDuckHandler } from './handler.js';
 export { TranslationResult } from './result.js';
 export { SharedStore } from './shared-store.js';
+export type { TranslationEvent, TranslationHook } from './hooks.js';
 export async function detectLanguage(text: string): Promise<string> {
   if (!state.config) {
     throw new Error('transduck not initialized. Call initialize() first.');
@@ -252,7 +322,7 @@ export async function aitPlural(
   one: string,
   other: string,
   count: number,
-  opts?: { context?: string; vars?: Record<string, string | number>; sourceLang?: string; background?: boolean },
+  opts?: { context?: string; vars?: Record<string, string | number>; sourceLang?: string; background?: boolean; onTranslate?: TranslationHook },
 ): Promise<TranslationResult> {
   if (!state.config || !state.store) {
     throw new Error('transduck not initialized. Call initialize() first.');
@@ -265,6 +335,7 @@ export async function aitPlural(
   const context = opts?.context;
   const effectiveSourceLang = opts?.sourceLang?.toUpperCase() ?? cfg.sourceLang;
   const background = opts?.background ?? false;
+  const onTranslatePlural = opts?.onTranslate;
 
   // Build vars with count
   let vars: Record<string, string | number>;
@@ -305,9 +376,14 @@ export async function aitPlural(
   // Tier 1: local cache lookup
   const cached = await state.store.lookupPlural(lookupParams);
   if (category in cached) {
+    await _maybeFireHooks({
+      sourceText: sourceKey, translatedText: cached[category], sourceLang: effectiveSourceLang,
+      lang: targetLang, context: context ?? null, source: 'cache', onTranslate: onTranslatePlural,
+      plural: true, pluralCategory: category, pluralForms: cached,
+    });
     return new TranslationResult(
       interpolateVars(cached[category], vars),
-      { pending: false, sourceLang: effectiveSourceLang, lang: targetLang },
+      { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'cache' },
     );
   }
 
@@ -323,9 +399,14 @@ export async function aitPlural(
           model: cfg.backendModel, status: 'translated',
         });
       }
+      await _maybeFireHooks({
+        sourceText: sourceKey, translatedText: sharedCached[category], sourceLang: effectiveSourceLang,
+        lang: targetLang, context: context ?? null, source: 'shared_cache', onTranslate: onTranslatePlural,
+        plural: true, pluralCategory: category, pluralForms: sharedCached,
+      });
       return new TranslationResult(
         interpolateVars(sharedCached[category], vars),
-        { pending: false, sourceLang: effectiveSourceLang, lang: targetLang },
+        { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'shared_cache' },
       );
     }
   }
@@ -346,6 +427,15 @@ export async function aitPlural(
     if (!state.backgroundKeys.has(bgKey)) {
       state.backgroundKeys.add(bgKey);
       _doPluralTranslate(one, other, sourceKey, effectiveSourceLang, targetLang, projectContextHash, stringContextHash, context ?? '', cfg)
+        .then(async (forms) => {
+          if (forms !== null && category in forms) {
+            await _maybeFireHooks({
+              sourceText: sourceKey, translatedText: forms[category], sourceLang: effectiveSourceLang,
+              lang: targetLang, context: context ?? null, source: 'translated', onTranslate: onTranslatePlural,
+              plural: true, pluralCategory: category, pluralForms: forms,
+            });
+          }
+        })
         .finally(() => state.backgroundKeys.delete(bgKey));
     }
     const fallbackCategory = getPluralCategory(effectiveSourceLang, count);
@@ -360,9 +450,14 @@ export async function aitPlural(
   const translatedText = await _doPluralTranslate(one, other, sourceKey, effectiveSourceLang, targetLang, projectContextHash, stringContextHash, context ?? '', cfg);
 
   if (translatedText !== null && category in translatedText) {
+    await _maybeFireHooks({
+      sourceText: sourceKey, translatedText: translatedText[category], sourceLang: effectiveSourceLang,
+      lang: targetLang, context: context ?? null, source: 'translated', onTranslate: onTranslatePlural,
+      plural: true, pluralCategory: category, pluralForms: translatedText,
+    });
     return new TranslationResult(
       interpolateVars(translatedText[category], vars),
-      { pending: false, sourceLang: effectiveSourceLang, lang: targetLang },
+      { pending: false, sourceLang: effectiveSourceLang, lang: targetLang, source: 'translated' },
     );
   }
 

package/src/result.ts

@@ -8,12 +8,14 @@ export class TranslationResult extends String {
   readonly pending: boolean;
   readonly sourceLang: string;
   readonly lang: string;
+  readonly source: string | null;
 
-  constructor(text: string, opts: { pending: boolean; sourceLang: string; lang: string }) {
+  constructor(text: string, opts: { pending: boolean; sourceLang: string; lang: string; source?: string | null }) {
     super(text);
     this.pending = opts.pending;
     this.sourceLang = opts.sourceLang;
     this.lang = opts.lang;
+    this.source = opts.source ?? null;
   }
 
   override toString(): string {

package/src/scanner.ts

@@ -31,6 +31,9 @@ const AIT_PLURAL = /ait(?:_p|P)lural\s*\(\s*(['"])(.*?)\1\s*,\s*(['"])(.*?)\3/g;
 // {% ait "text" %} or {% ait "text" context="ctx" %}
 const DJANGO_TAG = /\{%\s*ait\s+(['"])(.*?)\1(?:\s+context=(['"])(.*?)\3)?\s*%\}/g;
 
+// {% ait_plural "one" "other" %} or {% ait_plural "one" "other" context="ctx" %}
+const DJANGO_PLURAL_TAG = /\{%\s*ait_plural\s+(['"])(.*?)\1\s+(['"])(.*?)\3(?:\s+context=(['"])(.*?)\5)?\s*%\}/g;
+
 // t("text") or t("text", "ctx") — only matched in files with transduck/react import
 const T_POSITIONAL = /(?<![a-zA-Z_.$])t\s*\(\s*(['"])(.*?)\1(?:\s*,\s*(['"])(.*?)\3)?/g;
 
@@ -113,6 +116,16 @@ export function extractStrings(content: string, filename: string): ScanEntry[] {
       const lineNum = content.slice(0, match.index).split('\n').length;
       results.push({ text, context, line: lineNum });
     }
+
+    const djangoPluralRegex = new RegExp(DJANGO_PLURAL_TAG.source, 'g');
+    while ((match = djangoPluralRegex.exec(content)) !== null) {
+      const one = match[2];
+      const other = match[4];
+      const context = match[6] || null;
+      const lineNum = content.slice(0, match.index).split('\n').length;
+      results.push({ plural: true, one, other, context, line: lineNum });
+      pluralSpans.push([match.index, match.index + match[0].length]);
+    }
   }
 
   // 3. Find ait() calls

package/tests/hooks.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createHash } from 'crypto';
+import { join } from 'path';
+import { mkdtempSync } from 'fs';
+import { tmpdir } from 'os';
+import type { TransduckConfig } from '../src/config.js';
+import type { TranslationEvent, TranslationHook } from '../src/hooks.js';
+
+function hash(text: string): string {
+  return createHash('sha256').update(text).digest('hex');
+}
+
+function makeConfig(tmpDir: string, overrides?: Partial<TransduckConfig>): TransduckConfig {
+  return {
+    projectName: 'test',
+    projectContext: 'A test site',
+    sourceLang: 'EN',
+    targetLangs: ['DE', 'ES'],
+    storagePath: join(tmpDir, 'test.db'),
+    provider: 'openai',
+    apiKeyEnv: 'OPENAI_API_KEY',
+    tokenEnv: 'CLAUDE_CODE_OAUTH_TOKEN',
+    backendModel: 'gpt-4.1-mini',
+    backendTimeout: 10,
+    backendMaxRetries: 2,
+    sharedUrl: null,
+    readOnly: false,
+    ...overrides,
+  };
+}
+
+describe('hooks', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    const mod = await import('../src/index.js');
+    mod._resetState();
+    tmpDir = mkdtempSync(join(tmpdir(), 'transduck-hooks-test-'));
+    process.env.OPENAI_API_KEY = 'test-key';
+  });
+
+  async function setup() {
+    const mod = await import('../src/index.js');
+    const cfg = makeConfig(tmpDir);
+    await mod.initialize(cfg);
+    mod.setLanguage('DE');
+    return mod;
+  }
+
+  async function preInsert(sourceText = 'Hello', translatedText = 'Hallo', context = '') {
+    const mod = await import('../src/index.js');
+    const store = mod._getStore()!;
+    await store.insert({
+      sourceText,
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: hash('A test site'),
+      stringContextHash: hash(context),
+      stringContext: context,
+      translatedText,
+      model: 'gpt-4.1-mini',
+      status: 'translated',
+    });
+  }
+
+  // --- Global hook tests ---
+
+  it('global hook fires on cache hit', async () => {
+    const mod = await setup();
+    await preInsert();
+    const events: TranslationEvent[] = [];
+    mod.on('translate', (e: TranslationEvent) => { events.push(e); });
+    await mod.ait('Hello');
+    expect(events).toHaveLength(1);
+    expect(events[0].source).toBe('cache');
+    expect(events[0].translatedText).toBe('Hallo');
+    expect(events[0].sourceText).toBe('Hello');
+    expect(events[0].sourceLang).toBe('EN');
+    expect(events[0].lang).toBe('DE');
+    expect(events[0].projectContext).toBe('A test site');
+    expect(events[0].plural).toBe(false);
+  });
+
+  it('global hook fires on fresh translation', async () => {
+    const mod = await setup();
+    vi.spyOn(await import('../src/backend.js'), 'translate').mockResolvedValue('Hallo');
+    const events: TranslationEvent[] = [];
+    mod.on('translate', (e: TranslationEvent) => { events.push(e); });
+    await mod.ait('Hello');
+    expect(events).toHaveLength(1);
+    expect(events[0].source).toBe('translated');
+    expect(events[0].translatedText).toBe('Hallo');
+  });
+
+  it('global hook receives context and project_context', async () => {
+    const mod = await setup();
+    vi.spyOn(await import('../src/backend.js'), 'translate').mockResolvedValue('Buchen');
+    const events: TranslationEvent[] = [];
+    mod.on('translate', (e: TranslationEvent) => { events.push(e); });
+    await mod.ait('Book', { context: 'Button to book a trip' });
+    expect(events[0].context).toBe('Button to book a trip');
+    expect(events[0].projectContext).toBe('A test site');
+  });
+
+  it('off() removes a hook', async () => {
+    const mod = await setup();
+    await preInsert();
+    const events: TranslationEvent[] = [];
+    const hook: TranslationHook = (e) => { events.push(e); };
+    mod.on('translate', hook);
+    await mod.ait('Hello');
+    expect(events).toHaveLength(1);
+    mod.off('translate', hook);
+    await mod.ait('Hello');
+    expect(events).toHaveLength(1); // no new event
+  });
+
+  it('multiple global hooks fire in order', async () => {
+    const mod = await setup();
+    await preInsert();
+    const order: string[] = [];
+    mod.on('translate', () => { order.push('first'); });
+    mod.on('translate', () => { order.push('second'); });
+    await mod.ait('Hello');
+    expect(order).toEqual(['first', 'second']);
+  });
+
+  // --- Per-call hook tests ---
+
+  it('per-call hook fires on cache hit', async () => {
+    const mod = await setup();
+    await preInsert();
+    const events: TranslationEvent[] = [];
+    await mod.ait('Hello', { onTranslate: (e: TranslationEvent) => { events.push(e); } });
+    expect(events).toHaveLength(1);
+    expect(events[0].translatedText).toBe('Hallo');
+  });
+
+  it('per-call hook fires on fresh translation', async () => {
+    const mod = await setup();
+    vi.spyOn(await import('../src/backend.js'), 'translate').mockResolvedValue('Hallo');
+    const events: TranslationEvent[] = [];
+    await mod.ait('Hello', { onTranslate: (e: TranslationEvent) => { events.push(e); } });
+    expect(events).toHaveLength(1);
+    expect(events[0].source).toBe('translated');
+  });
+
+  // --- Global + per-call combination ---
+
+  it('global fires before per-call', async () => {
+    const mod = await setup();
+    await preInsert();
+    const order: string[] = [];
+    mod.on('translate', () => { order.push('global'); });
+    await mod.ait('Hello', { onTranslate: () => { order.push('per_call'); } });
+    expect(order).toEqual(['global', 'per_call']);
+  });
+
+  // --- Error isolation ---
+
+  it('hook error does not crash ait()', async () => {
+    const mod = await setup();
+    await preInsert();
+    mod.on('translate', () => { throw new Error('hook exploded'); });
+    const result = await mod.ait('Hello');
+    expect(result.toString()).toBe('Hallo');
+  });
+
+  it('per-call hook error does not crash ait()', async () => {
+    const mod = await setup();
+    await preInsert();
+    const result = await mod.ait('Hello', {
+      onTranslate: () => { throw new Error('boom'); },
+    });
+    expect(result.toString()).toBe('Hallo');
+  });
+
+  // --- Async hooks ---
+
+  it('async hooks are awaited', async () => {
+    const mod = await setup();
+    await preInsert();
+    let hookCompleted = false;
+    mod.on('translate', async () => {
+      await new Promise((r) => setTimeout(r, 50));
+      hookCompleted = true;
+    });
+    await mod.ait('Hello');
+    expect(hookCompleted).toBe(true);
+  });
+
+  // --- TranslationResult.source property ---
+
+  it('result has source="cache" on cache hit', async () => {
+    const mod = await setup();
+    await preInsert();
+    const result = await mod.ait('Hello');
+    expect(result.source).toBe('cache');
+  });
+
+  it('result has source="translated" on fresh translation', async () => {
+    const mod = await setup();
+    vi.spyOn(await import('../src/backend.js'), 'translate').mockResolvedValue('Hallo');
+    const result = await mod.ait('Hello');
+    expect(result.source).toBe('translated');
+  });
+
+  // --- Plural hook tests ---
+
+  it('plural hook fires on fresh translation', async () => {
+    const mod = await setup();
+    vi.spyOn(await import('../src/backend.js'), 'translatePlural').mockResolvedValue({
+      one: '{count} Nacht',
+      other: '{count} Nächte',
+    });
+    const events: TranslationEvent[] = [];
+    mod.on('translate', (e: TranslationEvent) => { events.push(e); });
+    await mod.aitPlural('{count} night', '{count} nights', 1);
+    expect(events).toHaveLength(1);
+    expect(events[0].plural).toBe(true);
+    expect(events[0].pluralCategory).toBe('one');
+    expect(events[0].pluralForms).toEqual({ one: '{count} Nacht', other: '{count} Nächte' });
+    expect(events[0].source).toBe('translated');
+  });
+
+  it('plural per-call hook fires', async () => {
+    const mod = await setup();
+    vi.spyOn(await import('../src/backend.js'), 'translatePlural').mockResolvedValue({
+      one: '{count} Nacht',
+      other: '{count} Nächte',
+    });
+    const events: TranslationEvent[] = [];
+    await mod.aitPlural('{count} night', '{count} nights', 7, {
+      onTranslate: (e: TranslationEvent) => { events.push(e); },
+    });
+    expect(events).toHaveLength(1);
+    expect(events[0].plural).toBe(true);
+    expect(events[0].pluralCategory).toBe('other');
+  });
+
+  it('plural hook fires on cache hit', async () => {
+    const mod = await setup();
+    const store = mod._getStore()!;
+    const sourceKey = '{count} night\x00{count} nights';
+    const lookupParams = {
+      sourceText: sourceKey,
+      sourceLang: 'EN',
+      targetLang: 'DE',
+      projectContextHash: hash('A test site'),
+      stringContextHash: hash(''),
+      stringContext: '',
+      model: 'gpt-4.1-mini',
+      status: 'translated',
+    };
+    await store.insertPlural({ ...lookupParams, pluralCategory: 'one', translatedText: '{count} Nacht' });
+    await store.insertPlural({ ...lookupParams, pluralCategory: 'other', translatedText: '{count} Nächte' });
+
+    const events: TranslationEvent[] = [];
+    mod.on('translate', (e: TranslationEvent) => { events.push(e); });
+    await mod.aitPlural('{count} night', '{count} nights', 1);
+    expect(events).toHaveLength(1);
+    expect(events[0].source).toBe('cache');
+    expect(events[0].pluralCategory).toBe('one');
+  });
+
+  // --- No hooks = no overhead ---
+
+  it('no hooks still works fine', async () => {
+    const mod = await setup();
+    vi.spyOn(await import('../src/backend.js'), 'translate').mockResolvedValue('Hallo');
+    const result = await mod.ait('Hello');
+    expect(result.toString()).toBe('Hallo');
+  });
+});

package/tests/scanner.test.ts

@@ -156,6 +156,37 @@ ait_plural("{count} item", "{count} items", count=n)
     expect(result[0].other).toBe('{count} long items description here');
   });
 
+  it('extracts Django plural template tag', () => {
+    const result = extractStrings('{% ait_plural "{count} night" "{count} nights" %}', 'test.html');
+    expect(result).toHaveLength(1);
+    expect(result[0].plural).toBe(true);
+    expect(result[0].one).toBe('{count} night');
+    expect(result[0].other).toBe('{count} nights');
+    expect(result[0].context).toBeNull();
+  });
+
+  it('extracts Django plural template tag with context', () => {
+    const result = extractStrings('{% ait_plural "{count} night" "{count} nights" context="Hotel stay duration" %}', 'test.html');
+    expect(result).toHaveLength(1);
+    expect(result[0].plural).toBe(true);
+    expect(result[0].one).toBe('{count} night');
+    expect(result[0].other).toBe('{count} nights');
+    expect(result[0].context).toBe('Hotel stay duration');
+  });
+
+  it('extracts Django plural tag with single quotes', () => {
+    const result = extractStrings("{% ait_plural '{count} item' '{count} items' %}", 'test.jinja2');
+    expect(result).toHaveLength(1);
+    expect(result[0].plural).toBe(true);
+    expect(result[0].one).toBe('{count} item');
+    expect(result[0].other).toBe('{count} items');
+  });
+
+  it('does not extract Django plural tag in .py files', () => {
+    const result = extractStrings('{% ait_plural "{count} night" "{count} nights" %}', 'test.py');
+    expect(result).toHaveLength(0);
+  });
+
   it('extracts multi-line single-quoted strings', () => {
     const code = `ait(\n    'This is a long '\n    'paragraph'\n)`;
     const result = extractStrings(code, 'test.py');