@lingo.dev/compiler 0.1.0

package/build/translators/parse-xml.cjs

@@ -0,0 +1,109 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let fast_xml_parser = require("fast-xml-parser");
+
+//#region src/translators/parse-xml.ts
+const TAG_OBJECT = "object";
+const TAG_ARRAY = "array";
+const TAG_VALUE = "value";
+/**
+* Converts a JavaScript value to a generic XML node structure
+*/
+function toGenericNode(value, key) {
+	if (Array.isArray(value)) {
+		const children = value.map((item) => toGenericNode(item));
+		return { [TAG_ARRAY]: {
+			...key ? { key } : {},
+			...groupChildren(children)
+		} };
+	}
+	if (value && typeof value === "object" && value.constructor === Object) {
+		const children = Object.entries(value).map(([k, v]) => toGenericNode(v, k));
+		return { [TAG_OBJECT]: {
+			...key ? { key } : {},
+			...groupChildren(children)
+		} };
+	}
+	return { [TAG_VALUE]: {
+		...key ? { key } : {},
+		"#text": value ?? ""
+	} };
+}
+/**
+* Groups nodes by tag name for proper XML array handling
+*/
+function groupChildren(nodes) {
+	const grouped = {};
+	for (const node of nodes) {
+		const tag = Object.keys(node)[0];
+		if (!grouped[tag]) grouped[tag] = [];
+		grouped[tag].push(node[tag]);
+	}
+	return grouped;
+}
+/**
+* Recursively converts a generic XML node back to a JavaScript value
+*/
+function fromGenericNode(tag, data) {
+	if (tag === TAG_VALUE) {
+		if (data && typeof data === "object" && "#text" in data) return data["#text"] ?? "";
+		if (data && typeof data === "object") return "";
+		return data ?? "";
+	}
+	if (tag === TAG_ARRAY) {
+		const result = [];
+		for (const childTag of [
+			TAG_VALUE,
+			TAG_OBJECT,
+			TAG_ARRAY
+		]) {
+			const childNodes = Array.isArray(data[childTag]) ? data[childTag] : data[childTag] ? [data[childTag]] : [];
+			for (const child of childNodes) result.push(fromGenericNode(childTag, child));
+		}
+		return result;
+	}
+	const obj = {};
+	for (const childTag of [
+		TAG_VALUE,
+		TAG_OBJECT,
+		TAG_ARRAY
+	]) {
+		const childNodes = Array.isArray(data[childTag]) ? data[childTag] : data[childTag] ? [data[childTag]] : [];
+		for (const child of childNodes) {
+			const key = child.key || "";
+			obj[key] = fromGenericNode(childTag, child);
+		}
+	}
+	return obj;
+}
+function obj2xml(obj) {
+	const rootNode = toGenericNode(obj)[TAG_OBJECT];
+	return new fast_xml_parser.XMLBuilder({
+		ignoreAttributes: false,
+		attributeNamePrefix: "",
+		format: true,
+		suppressEmptyNode: true
+	}).build({ [TAG_OBJECT]: rootNode });
+}
+function parseXmlFromResponseText(text) {
+	const xmlStart = text.indexOf("<");
+	const xmlEnd = text.lastIndexOf(">") + 1;
+	if (xmlStart !== -1 && xmlEnd > xmlStart) text = text.substring(xmlStart, xmlEnd);
+	const { "?xml": _, ...withoutDeclaration } = new fast_xml_parser.XMLParser({
+		ignoreAttributes: false,
+		attributeNamePrefix: "",
+		parseTagValue: true,
+		parseAttributeValue: false,
+		processEntities: true,
+		isArray: (name) => [
+			TAG_VALUE,
+			TAG_ARRAY,
+			TAG_OBJECT
+		].includes(name)
+	}).parse(text);
+	const rootTag = Object.keys(withoutDeclaration)[0];
+	return fromGenericNode(rootTag, Array.isArray(withoutDeclaration[rootTag]) ? withoutDeclaration[rootTag][0] : withoutDeclaration[rootTag]);
+}
+
+//#endregion
+exports.obj2xml = obj2xml;
+exports.parseXmlFromResponseText = parseXmlFromResponseText;

package/build/translators/parse-xml.mjs

@@ -0,0 +1,108 @@
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+
+//#region src/translators/parse-xml.ts
+const TAG_OBJECT = "object";
+const TAG_ARRAY = "array";
+const TAG_VALUE = "value";
+/**
+* Converts a JavaScript value to a generic XML node structure
+*/
+function toGenericNode(value, key) {
+	if (Array.isArray(value)) {
+		const children = value.map((item) => toGenericNode(item));
+		return { [TAG_ARRAY]: {
+			...key ? { key } : {},
+			...groupChildren(children)
+		} };
+	}
+	if (value && typeof value === "object" && value.constructor === Object) {
+		const children = Object.entries(value).map(([k, v]) => toGenericNode(v, k));
+		return { [TAG_OBJECT]: {
+			...key ? { key } : {},
+			...groupChildren(children)
+		} };
+	}
+	return { [TAG_VALUE]: {
+		...key ? { key } : {},
+		"#text": value ?? ""
+	} };
+}
+/**
+* Groups nodes by tag name for proper XML array handling
+*/
+function groupChildren(nodes) {
+	const grouped = {};
+	for (const node of nodes) {
+		const tag = Object.keys(node)[0];
+		if (!grouped[tag]) grouped[tag] = [];
+		grouped[tag].push(node[tag]);
+	}
+	return grouped;
+}
+/**
+* Recursively converts a generic XML node back to a JavaScript value
+*/
+function fromGenericNode(tag, data) {
+	if (tag === TAG_VALUE) {
+		if (data && typeof data === "object" && "#text" in data) return data["#text"] ?? "";
+		if (data && typeof data === "object") return "";
+		return data ?? "";
+	}
+	if (tag === TAG_ARRAY) {
+		const result = [];
+		for (const childTag of [
+			TAG_VALUE,
+			TAG_OBJECT,
+			TAG_ARRAY
+		]) {
+			const childNodes = Array.isArray(data[childTag]) ? data[childTag] : data[childTag] ? [data[childTag]] : [];
+			for (const child of childNodes) result.push(fromGenericNode(childTag, child));
+		}
+		return result;
+	}
+	const obj = {};
+	for (const childTag of [
+		TAG_VALUE,
+		TAG_OBJECT,
+		TAG_ARRAY
+	]) {
+		const childNodes = Array.isArray(data[childTag]) ? data[childTag] : data[childTag] ? [data[childTag]] : [];
+		for (const child of childNodes) {
+			const key = child.key || "";
+			obj[key] = fromGenericNode(childTag, child);
+		}
+	}
+	return obj;
+}
+function obj2xml(obj) {
+	const rootNode = toGenericNode(obj)[TAG_OBJECT];
+	return new XMLBuilder({
+		ignoreAttributes: false,
+		attributeNamePrefix: "",
+		format: true,
+		suppressEmptyNode: true
+	}).build({ [TAG_OBJECT]: rootNode });
+}
+function parseXmlFromResponseText(text) {
+	const xmlStart = text.indexOf("<");
+	const xmlEnd = text.lastIndexOf(">") + 1;
+	if (xmlStart !== -1 && xmlEnd > xmlStart) text = text.substring(xmlStart, xmlEnd);
+	const { "?xml": _, ...withoutDeclaration } = new XMLParser({
+		ignoreAttributes: false,
+		attributeNamePrefix: "",
+		parseTagValue: true,
+		parseAttributeValue: false,
+		processEntities: true,
+		isArray: (name) => [
+			TAG_VALUE,
+			TAG_ARRAY,
+			TAG_OBJECT
+		].includes(name)
+	}).parse(text);
+	const rootTag = Object.keys(withoutDeclaration)[0];
+	return fromGenericNode(rootTag, Array.isArray(withoutDeclaration[rootTag]) ? withoutDeclaration[rootTag][0] : withoutDeclaration[rootTag]);
+}
+
+//#endregion
+export { obj2xml, parseXmlFromResponseText };
+//# sourceMappingURL=parse-xml.mjs.map

package/build/translators/parse-xml.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-xml.mjs","names":["grouped: Record<string, any[]>","result: any[]","obj: Record<string, any>"],"sources":["../../src/translators/parse-xml.ts"],"sourcesContent":["import { XMLParser, XMLBuilder } from \"fast-xml-parser\";\n\n// Generic tag names used in XML output\nconst TAG_OBJECT = \"object\";\nconst TAG_ARRAY = \"array\";\nconst TAG_VALUE = \"value\";\n\n/**\n * Converts a JavaScript value to a generic XML node structure\n */\nfunction toGenericNode(value: any, key?: string): Record<string, any> {\n  if (Array.isArray(value)) {\n    const children = value.map((item) => toGenericNode(item));\n    return {\n      [TAG_ARRAY]: {\n        ...(key ? { key } : {}),\n        ...groupChildren(children),\n      },\n    };\n  }\n\n  if (value && typeof value === \"object\" && value.constructor === Object) {\n    const children = Object.entries(value).map(([k, v]) => toGenericNode(v, k));\n    return {\n      [TAG_OBJECT]: {\n        ...(key ? { key } : {}),\n        ...groupChildren(children),\n      },\n    };\n  }\n\n  return {\n    [TAG_VALUE]: {\n      ...(key ? { key } : {}),\n      \"#text\": value ?? \"\",\n    },\n  };\n}\n\n/**\n * Groups nodes by tag name for proper XML array handling\n */\nfunction groupChildren(nodes: Record<string, any>[]): Record<string, any> {\n  const grouped: Record<string, any[]> = {};\n\n  for (const node of nodes) {\n    const tag = Object.keys(node)[0];\n    if (!grouped[tag]) {\n      grouped[tag] = [];\n    }\n    grouped[tag].push(node[tag]);\n  }\n\n  return grouped;\n}\n\n/**\n * Recursively converts a generic XML node back to a JavaScript value\n */\nfunction fromGenericNode(tag: string, data: any): any {\n  if (tag === TAG_VALUE) {\n    if (data && typeof data === \"object\" && \"#text\" in data) {\n      return data[\"#text\"] ?? \"\";\n    }\n    // For self-closing tags like <value key=\"x\" />, data is { key: \"x\" }\n    // We should return empty string, not the attributes object\n    if (data && typeof data === \"object\") {\n      return \"\";\n    }\n    return data ?? \"\";\n  }\n\n  if (tag === TAG_ARRAY) {\n    const result: any[] = [];\n    for (const childTag of [TAG_VALUE, TAG_OBJECT, TAG_ARRAY]) {\n      const childNodes = Array.isArray(data[childTag])\n        ? data[childTag]\n        : data[childTag]\n          ? [data[childTag]]\n          : [];\n      for (const child of childNodes) {\n        result.push(fromGenericNode(childTag, child));\n      }\n    }\n    return result;\n  }\n\n  // TAG_OBJECT\n  const obj: Record<string, any> = {};\n  for (const childTag of [TAG_VALUE, TAG_OBJECT, TAG_ARRAY]) {\n    const childNodes = Array.isArray(data[childTag])\n      ? data[childTag]\n      : data[childTag]\n        ? [data[childTag]]\n        : [];\n    for (const child of childNodes) {\n      const key = child.key || \"\";\n      obj[key] = fromGenericNode(childTag, child);\n    }\n  }\n  return obj;\n}\n\nexport function obj2xml<T>(obj: T): string {\n  const rootNode = toGenericNode(obj)[TAG_OBJECT];\n  const builder = new XMLBuilder({\n    ignoreAttributes: false,\n    attributeNamePrefix: \"\",\n    format: true,\n    suppressEmptyNode: true,\n  });\n  return builder.build({ [TAG_OBJECT]: rootNode });\n}\n\nexport function parseXmlFromResponseText<T = any>(text: string): T {\n  const xmlStart = text.indexOf(\"<\");\n  const xmlEnd = text.lastIndexOf(\">\") + 1;\n\n  if (xmlStart !== -1 && xmlEnd > xmlStart) {\n    text = text.substring(xmlStart, xmlEnd);\n  }\n\n  const parser = new XMLParser({\n    ignoreAttributes: false,\n    attributeNamePrefix: \"\",\n    parseTagValue: true,\n    parseAttributeValue: false,\n    processEntities: true,\n    isArray: (name) => [TAG_VALUE, TAG_ARRAY, TAG_OBJECT].includes(name),\n  });\n  const parsed = parser.parse(text);\n\n  // Remove XML declaration\n  const { \"?xml\": _, ...withoutDeclaration } = parsed;\n\n  const rootTag = Object.keys(withoutDeclaration)[0];\n  const rootNode = Array.isArray(withoutDeclaration[rootTag])\n    ? withoutDeclaration[rootTag][0]\n    : withoutDeclaration[rootTag];\n\n  return fromGenericNode(rootTag, rootNode);\n}\n"],"mappings":"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"}

package/build/translators/pluralization/icu-validator.cjs

@@ -0,0 +1,36 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let _formatjs_icu_messageformat_parser = require("@formatjs/icu-messageformat-parser");
+
+//#region src/translators/pluralization/icu-validator.ts
+/**
+* ICU MessageFormat validator using FormatJS parser
+*
+* Uses the official ICU MessageFormat parser for validation instead of custom regex logic.
+* This ensures standards-compliant validation that matches runtime behavior.
+*/
+/**
+* Validate and log result
+*
+* @param icuText ICU format text
+* @param originalText Original source text (for logging)
+* @param logger
+* @returns True if valid, false otherwise
+*/
+function validateICU(icuText, originalText, logger) {
+	try {
+		(0, _formatjs_icu_messageformat_parser.parse)(icuText, {
+			ignoreTag: false,
+			requiresOtherClause: true
+		});
+		logger.debug(`✓ ICU format valid for: "${originalText}"`);
+		return true;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown parsing error";
+		logger.warn(`✗ ICU format invalid for: "${originalText}"`);
+		logger.warn(`  - ${errorMessage}`);
+		return false;
+	}
+}
+
+//#endregion
+exports.validateICU = validateICU;

package/build/translators/pluralization/icu-validator.mjs

@@ -0,0 +1,36 @@
+import { parse } from "@formatjs/icu-messageformat-parser";
+
+//#region src/translators/pluralization/icu-validator.ts
+/**
+* ICU MessageFormat validator using FormatJS parser
+*
+* Uses the official ICU MessageFormat parser for validation instead of custom regex logic.
+* This ensures standards-compliant validation that matches runtime behavior.
+*/
+/**
+* Validate and log result
+*
+* @param icuText ICU format text
+* @param originalText Original source text (for logging)
+* @param logger
+* @returns True if valid, false otherwise
+*/
+function validateICU(icuText, originalText, logger) {
+	try {
+		parse(icuText, {
+			ignoreTag: false,
+			requiresOtherClause: true
+		});
+		logger.debug(`✓ ICU format valid for: "${originalText}"`);
+		return true;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown parsing error";
+		logger.warn(`✗ ICU format invalid for: "${originalText}"`);
+		logger.warn(`  - ${errorMessage}`);
+		return false;
+	}
+}
+
+//#endregion
+export { validateICU };
+//# sourceMappingURL=icu-validator.mjs.map

package/build/translators/pluralization/icu-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"icu-validator.mjs","names":[],"sources":["../../../src/translators/pluralization/icu-validator.ts"],"sourcesContent":["/**\n * ICU MessageFormat validator using FormatJS parser\n *\n * Uses the official ICU MessageFormat parser for validation instead of custom regex logic.\n * This ensures standards-compliant validation that matches runtime behavior.\n */\nimport { parse } from \"@formatjs/icu-messageformat-parser\";\nimport type { Logger } from \"../../utils/logger\";\n\n/**\n * Validate and log result\n *\n * @param icuText ICU format text\n * @param originalText Original source text (for logging)\n * @param logger\n * @returns True if valid, false otherwise\n */\nexport function validateICU(\n  icuText: string,\n  originalText: string,\n  logger: Logger,\n): boolean {\n  try {\n    // I guess `new IntlMessageFormat(icuText, \"locale\")` could also be used, but it looks less obvious than using parser explicitly.\n    parse(icuText, {\n      ignoreTag: false, // Don't ignore HTML-like tags\n      requiresOtherClause: true, // Require 'other' clause in plural/select\n    });\n    // LLM initially generated more validations. But validation for \"other\" clause is already done by the parser, and we care only about the validity of the message,\n    // we do not require it to have the pluralization. We trust that LLM adds them where needed.\n    logger.debug(`✓ ICU format valid for: \"${originalText}\"`);\n    return true;\n  } catch (error) {\n    // Parser throws SyntaxError for invalid ICU syntax\n    const errorMessage =\n      error instanceof Error ? error.message : \"Unknown parsing error\";\n    logger.warn(`✗ ICU format invalid for: \"${originalText}\"`);\n    logger.warn(`  - ${errorMessage}`);\n    return false;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,SAAgB,YACd,SACA,cACA,QACS;AACT,KAAI;AAEF,QAAM,SAAS;GACb,WAAW;GACX,qBAAqB;GACtB,CAAC;AAGF,SAAO,MAAM,4BAA4B,aAAa,GAAG;AACzD,SAAO;UACA,OAAO;EAEd,MAAM,eACJ,iBAAiB,QAAQ,MAAM,UAAU;AAC3C,SAAO,KAAK,8BAA8B,aAAa,GAAG;AAC1D,SAAO,KAAK,OAAO,eAAe;AAClC,SAAO"}

package/build/translators/pluralization/pattern-detector.cjs

@@ -0,0 +1,25 @@
+
+//#region src/translators/pluralization/pattern-detector.ts
+const EXPRESSION_PATTERN = /\{(\w+)}/g;
+/**
+* Detect plural candidates from a list of entries
+*
+* @param entries Map of hash -> source text
+* @returns Array of plural candidates
+*/
+function detectPluralCandidates(entries, logger) {
+	const candidates = [];
+	for (const [hash, sourceText] of Object.entries(entries)) {
+		const match = sourceText.match(EXPRESSION_PATTERN);
+		if (!match) continue;
+		logger.debug(`Found ${match[1]} expression in: "${sourceText}. Text selected for pluralization."`);
+		candidates.push({
+			hash,
+			sourceText
+		});
+	}
+	return candidates;
+}
+
+//#endregion
+exports.detectPluralCandidates = detectPluralCandidates;

package/build/translators/pluralization/pattern-detector.mjs

@@ -0,0 +1,25 @@
+//#region src/translators/pluralization/pattern-detector.ts
+const EXPRESSION_PATTERN = /\{(\w+)}/g;
+/**
+* Detect plural candidates from a list of entries
+*
+* @param entries Map of hash -> source text
+* @returns Array of plural candidates
+*/
+function detectPluralCandidates(entries, logger) {
+	const candidates = [];
+	for (const [hash, sourceText] of Object.entries(entries)) {
+		const match = sourceText.match(EXPRESSION_PATTERN);
+		if (!match) continue;
+		logger.debug(`Found ${match[1]} expression in: "${sourceText}. Text selected for pluralization."`);
+		candidates.push({
+			hash,
+			sourceText
+		});
+	}
+	return candidates;
+}
+
+//#endregion
+export { detectPluralCandidates };
+//# sourceMappingURL=pattern-detector.mjs.map

package/build/translators/pluralization/pattern-detector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-detector.mjs","names":["candidates: PluralCandidate[]"],"sources":["../../../src/translators/pluralization/pattern-detector.ts"],"sourcesContent":["/**\n * Pattern-based detection for plural candidates\n *\n * Uses heuristics to identify messages that might benefit from pluralization\n */\n\nimport type { PluralCandidate } from \"./types\";\nimport type { Logger } from \"../../utils/logger\";\n\n// Anything that's not a variable name like is not expected.\nconst EXPRESSION_PATTERN = /\\{(\\w+)}/g;\n\n/**\n * Detect plural candidates from a list of entries\n *\n * @param entries Map of hash -> source text\n * @returns Array of plural candidates\n */\nexport function detectPluralCandidates(\n  entries: Record<string, string>,\n  logger: Logger,\n): PluralCandidate[] {\n  const candidates: PluralCandidate[] = [];\n\n  for (const [hash, sourceText] of Object.entries(entries)) {\n    const match = sourceText.match(EXPRESSION_PATTERN);\n    if (!match) {\n      continue;\n    }\n    logger.debug(\n      `Found ${match[1]} expression in: \"${sourceText}. Text selected for pluralization.\"`,\n    );\n    candidates.push({\n      hash,\n      sourceText,\n    });\n  }\n\n  return candidates;\n}\n"],"mappings":";AAUA,MAAM,qBAAqB;;;;;;;AAQ3B,SAAgB,uBACd,SACA,QACmB;CACnB,MAAMA,aAAgC,EAAE;AAExC,MAAK,MAAM,CAAC,MAAM,eAAe,OAAO,QAAQ,QAAQ,EAAE;EACxD,MAAM,QAAQ,WAAW,MAAM,mBAAmB;AAClD,MAAI,CAAC,MACH;AAEF,SAAO,MACL,SAAS,MAAM,GAAG,mBAAmB,WAAW,qCACjD;AACD,aAAW,KAAK;GACd;GACA;GACD,CAAC;;AAGJ,QAAO"}

package/build/translators/pluralization/prompt.cjs

@@ -0,0 +1,98 @@
+
+//#region src/translators/pluralization/prompt.ts
+function getSystemPrompt(args) {
+	return `
+# Identity
+
+You are an advanced AI localization engine. You do state-of-the-art localization for software products.
+Your task is to analyze text messages and determine if they should be pluralized.
+If pluralization is appropriate, convert the message to ICU MessageFormat with proper plural rules.
+
+## Setup
+
+Source language (locale code): ${args.sourceLocale}
+
+ICU MessageFormat syntax for plurals:
+{variable, plural,
+  =0 {zero form}
+  one {singular form}
+  other {plural form}
+}
+
+Use # to represent the count in the message (e.g., "# item" becomes "1 item", "5 items").
+
+## Guidelines
+
+1. Only pluralize if the message varies based on a count/quantity
+2. Detect the variable name from the message (e.g., {count}, {itemCount})
+3. Generate appropriate forms: =0 (optional zero case), one (singular), other (plural)
+4. Preserve the original message structure and style
+5. Keep variable names from the original text
+6. If pluralization is NOT appropriate, explain why
+7. YOU MUST ONLY PRODUCE VALID XML.
+
+## Input Format
+
+You will receive an XML document with candidates to analyze:
+
+<pluralizationBatch>
+  <version>0.1</version>
+  <sourceLocale>${args.sourceLocale}</sourceLocale>
+  <candidates>
+    <candidate>
+      <hash>abc123</hash>
+      <text>You have {count} items</text>
+    </candidate>
+  </candidates>
+</pluralizationBatch>
+
+## Output Format
+
+Respond with XML containing results for each candidate:
+
+<pluralizationResponse>
+  <version>0.1</version>
+  <results>
+    <result>
+      <hash>abc123</hash>
+      <shouldPluralize>true</shouldPluralize>
+      <icuText>You have {count, plural, =0 {no items} one {# item} other {# items}}</icuText>
+      <reasoning>Message varies based on count quantity</reasoning>
+    </result>
+  </results>
+</pluralizationResponse>
+
+## Examples
+
+Example 1 - Should pluralize:
+Input:
+<candidate>
+  <hash>h1</hash>
+  <text>You have {count} items</text>
+</candidate>
+
+Output:
+<result>
+  <hash>h1</hash>
+  <shouldPluralize>true</shouldPluralize>
+  <icuText>You have {count, plural, =0 {no items} one {# item} other {# items}}</icuText>
+  <reasoning>Message varies based on count quantity</reasoning>
+</result>
+
+Example 2 - Should NOT pluralize:
+Input:
+<candidate>
+  <hash>h2</hash>
+  <text>Hello {name}</text>
+</candidate>
+
+Output:
+<result>
+  <hash>h2</hash>
+  <shouldPluralize>false</shouldPluralize>
+  <reasoning>Message does not vary based on quantity, {name} is not a count variable</reasoning>
+</result>`;
+}
+
+//#endregion
+exports.getSystemPrompt = getSystemPrompt;

package/build/translators/pluralization/prompt.mjs

@@ -0,0 +1,98 @@
+//#region src/translators/pluralization/prompt.ts
+function getSystemPrompt(args) {
+	return `
+# Identity
+
+You are an advanced AI localization engine. You do state-of-the-art localization for software products.
+Your task is to analyze text messages and determine if they should be pluralized.
+If pluralization is appropriate, convert the message to ICU MessageFormat with proper plural rules.
+
+## Setup
+
+Source language (locale code): ${args.sourceLocale}
+
+ICU MessageFormat syntax for plurals:
+{variable, plural,
+  =0 {zero form}
+  one {singular form}
+  other {plural form}
+}
+
+Use # to represent the count in the message (e.g., "# item" becomes "1 item", "5 items").
+
+## Guidelines
+
+1. Only pluralize if the message varies based on a count/quantity
+2. Detect the variable name from the message (e.g., {count}, {itemCount})
+3. Generate appropriate forms: =0 (optional zero case), one (singular), other (plural)
+4. Preserve the original message structure and style
+5. Keep variable names from the original text
+6. If pluralization is NOT appropriate, explain why
+7. YOU MUST ONLY PRODUCE VALID XML.
+
+## Input Format
+
+You will receive an XML document with candidates to analyze:
+
+<pluralizationBatch>
+  <version>0.1</version>
+  <sourceLocale>${args.sourceLocale}</sourceLocale>
+  <candidates>
+    <candidate>
+      <hash>abc123</hash>
+      <text>You have {count} items</text>
+    </candidate>
+  </candidates>
+</pluralizationBatch>
+
+## Output Format
+
+Respond with XML containing results for each candidate:
+
+<pluralizationResponse>
+  <version>0.1</version>
+  <results>
+    <result>
+      <hash>abc123</hash>
+      <shouldPluralize>true</shouldPluralize>
+      <icuText>You have {count, plural, =0 {no items} one {# item} other {# items}}</icuText>
+      <reasoning>Message varies based on count quantity</reasoning>
+    </result>
+  </results>
+</pluralizationResponse>
+
+## Examples
+
+Example 1 - Should pluralize:
+Input:
+<candidate>
+  <hash>h1</hash>
+  <text>You have {count} items</text>
+</candidate>
+
+Output:
+<result>
+  <hash>h1</hash>
+  <shouldPluralize>true</shouldPluralize>
+  <icuText>You have {count, plural, =0 {no items} one {# item} other {# items}}</icuText>
+  <reasoning>Message varies based on count quantity</reasoning>
+</result>
+
+Example 2 - Should NOT pluralize:
+Input:
+<candidate>
+  <hash>h2</hash>
+  <text>Hello {name}</text>
+</candidate>
+
+Output:
+<result>
+  <hash>h2</hash>
+  <shouldPluralize>false</shouldPluralize>
+  <reasoning>Message does not vary based on quantity, {name} is not a count variable</reasoning>
+</result>`;
+}
+
+//#endregion
+export { getSystemPrompt };
+//# sourceMappingURL=prompt.mjs.map

package/build/translators/pluralization/prompt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.mjs","names":[],"sources":["../../../src/translators/pluralization/prompt.ts"],"sourcesContent":["interface PromptArguments {\n  sourceLocale: string;\n}\n\nexport function getSystemPrompt(args: PromptArguments): string {\n  return `\n# Identity\n\nYou are an advanced AI localization engine. You do state-of-the-art localization for software products.\nYour task is to analyze text messages and determine if they should be pluralized.\nIf pluralization is appropriate, convert the message to ICU MessageFormat with proper plural rules.\n\n## Setup\n\nSource language (locale code): ${args.sourceLocale}\n\nICU MessageFormat syntax for plurals:\n{variable, plural,\n  =0 {zero form}\n  one {singular form}\n  other {plural form}\n}\n\nUse # to represent the count in the message (e.g., \"# item\" becomes \"1 item\", \"5 items\").\n\n## Guidelines\n\n1. Only pluralize if the message varies based on a count/quantity\n2. Detect the variable name from the message (e.g., {count}, {itemCount})\n3. Generate appropriate forms: =0 (optional zero case), one (singular), other (plural)\n4. Preserve the original message structure and style\n5. Keep variable names from the original text\n6. If pluralization is NOT appropriate, explain why\n7. YOU MUST ONLY PRODUCE VALID XML.\n\n## Input Format\n\nYou will receive an XML document with candidates to analyze:\n\n<pluralizationBatch>\n  <version>0.1</version>\n  <sourceLocale>${args.sourceLocale}</sourceLocale>\n  <candidates>\n    <candidate>\n      <hash>abc123</hash>\n      <text>You have {count} items</text>\n    </candidate>\n  </candidates>\n</pluralizationBatch>\n\n## Output Format\n\nRespond with XML containing results for each candidate:\n\n<pluralizationResponse>\n  <version>0.1</version>\n  <results>\n    <result>\n      <hash>abc123</hash>\n      <shouldPluralize>true</shouldPluralize>\n      <icuText>You have {count, plural, =0 {no items} one {# item} other {# items}}</icuText>\n      <reasoning>Message varies based on count quantity</reasoning>\n    </result>\n  </results>\n</pluralizationResponse>\n\n## Examples\n\nExample 1 - Should pluralize:\nInput:\n<candidate>\n  <hash>h1</hash>\n  <text>You have {count} items</text>\n</candidate>\n\nOutput:\n<result>\n  <hash>h1</hash>\n  <shouldPluralize>true</shouldPluralize>\n  <icuText>You have {count, plural, =0 {no items} one {# item} other {# items}}</icuText>\n  <reasoning>Message varies based on count quantity</reasoning>\n</result>\n\nExample 2 - Should NOT pluralize:\nInput:\n<candidate>\n  <hash>h2</hash>\n  <text>Hello {name}</text>\n</candidate>\n\nOutput:\n<result>\n  <hash>h2</hash>\n  <shouldPluralize>false</shouldPluralize>\n  <reasoning>Message does not vary based on quantity, {name} is not a count variable</reasoning>\n</result>`;\n}\n"],"mappings":";AAIA,SAAgB,gBAAgB,MAA+B;AAC7D,QAAO;;;;;;;;;iCASwB,KAAK,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2BjC,KAAK,aAAa"}