@cocreate/cli 1.58.0 → 1.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/cli",
-  "version": "1.58.0",
+  "version": "1.60.0",
   "description": "Polyrepo management bash CLI tool. Run all git commands and yarn commands on multiple repositories. Also includes a few custom macros for cloning, installing, etc.",
   "keywords": [
     "cli",
@@ -48,13 +48,13 @@
     "coc": "src/coc.js"
   },
   "dependencies": {
-    "@cocreate/acme": "^1.5.2",
-    "@cocreate/config": "^1.14.3",
-    "@cocreate/file": "^1.22.2",
-    "@google/generative-ai": "0.24.1"
+    "@cocreate/certificates": "^1.7.0",
+    "@cocreate/config": "^1.17.0",
+    "@cocreate/file": "^1.23.0",
+    "@google/genai": "2.15.0"
   },
   "allowScripts": {
-    "@cocreate/acme@1.3.2": true,
+    "@cocreate/certificates@1.3.2": true,
     "@cocreate/actions@1.21.4": true,
     "@cocreate/api@1.22.5": true,
     "@cocreate/config@1.13.4": true,

package/src/commands/acme.js

@@ -1,4 +1,4 @@
-const { requestCertificate } = require("@cocreate/acme");
+const { requestCertificate } = require("@cocreate/certificates");
 
 module.exports = async function nginx(repos, args) {
 	let failed = [];

package/src/commands/other/translate.js

@@ -1,147 +1,145 @@
+const { GoogleGenAI, Type } = require("@google/genai");
+const Config = require("@cocreate/config");
+
 /**
- * @fileoverview
- * This script is designed to generate SEO-friendly content for a given HTML source.
- * It uses the Gemini API to translate and generate content based on the provided HTML and languages.
- *
- * Prerequisites:
- * - Node.js installed on your system.
- * - The Google Generative AI library installed:
- * `npm install @google/generative-ai`
- * - A valid Gemini API key.
- *
- * Usage:
- * Import and call the `translateHtml` function with the HTML source, languages array, and options.
+ * Default Gemini model identifier used for language translation tasks.
+ * @type {string}
  */
+const DEFAULT_MODEL = "gemini-2.5-flash-lite";
 
 /**
- * Example for structured data translation:
- *
- * {
- *   "selector": "script[type='application/ld+json']",
- *   "innerHTML": {
- *     "en": {
- *       "@context": "http://schema.org",
- *       "@type": "WebPage",
- *       "name": "Basketball Betting Sportsbook | NBA, EuroLeague, NCAA & Global Leagues",
- *       "description": "Unlock premier basketball betting at Amapola Sportsbook. Get competitive odds for NBA, EuroLeague, NCAA, and global basketball. Enjoy live betting, swift payouts, and insightful picks for an unmatched wagering experience.",
- *       "url": "https://amapolacasino.com/sportsbook/basketball/",
- *       "image": "https://amapolacasino.com/assets/basketball-og.jpg",
- *       "author": {
- *         "@type": "Organization",
- *         "name": "AmapolaCasino"
- *       }
- *     },
- *     "es": { ... },
- *     "fr": { ... },
- *     "pt": { ... },
- *     "ht": { ... },
- *     "nl": { ... },
- *     "gn": { ... }
- *   }
- * }
+ * Translation mapping for a single element's attributes and inner content.
+ * @typedef {Object} ElementTranslations
+ * @property {string|null} [text] - Inner text content or script payload.
+ * @property {string|null} [placeholder] - Input placeholder text.
+ * @property {string|null} [title] - Element title attribute.
+ * @property {string|null} [alt] - Image alternate text.
+ * @property {string|null} ["aria-label"] - ARIA accessibility label.
+ * @property {Record<string, string>} [additionalProperties] - Dynamic attributes (e.g., `aria-description`).
  */
 
-const { GoogleGenerativeAI } = require("@google/generative-ai");
-const Config = require("@cocreate/config");
-const MODEL_NAME = "gemini-2.5-flash-lite";
+/**
+ * Key-value mapping of `i18n` keys to element translations for a specific language.
+ * @typedef {Record<string, ElementTranslations>} LanguageTranslations
+ */
 
-// Send HTML to Gemini AI and get translation JSON
-// Exported function to generate translation object for HTML source and languages
+/**
+ * Language-First dictionary structure mapping language codes (e.g., "en", "es") to their translations.
+ * @typedef {Record<string, LanguageTranslations>} LanguageFirstTranslationMap
+ */
+
+/**
+ * Configuration options for the HTML translation process.
+ * @typedef {Object} TranslateOptions
+ * @property {string} [apiKey] - Google GenAI API key. If omitted, attempts lookup via configuration service.
+ * @property {string} [model] - Gemini model name override (defaults to "gemini-2.5-flash-lite").
+ * @property {number} [temperature] - Model sampling temperature (defaults to 0.2).
+ */
+
+/**
+ * Resolves the Google GenAI API key from explicit options or global configuration.
+ *
+ * @async
+ * @param {TranslateOptions} options - Configuration options passed to the translator.
+ * @returns {Promise<string|undefined>} Resolved API key string or undefined if not found.
+ */
 async function getApiKey(options) {
-	if (options.apiKey) return options.apiKey;
-	const config = await Config.prompt({
-		GoogleGenerativeAIApiKey: {
-			prompt: "Enter your Google Generative AI API key: "
-		}
-	});
-	return config.GoogleGenerativeAIApiKey;
+  if (options?.apiKey) return options.apiKey;
+  if (typeof Config?.get === "function") {
+    return await Config.get("GEMINI_API_KEY") || process.env.GEMINI_API_KEY;
+  }
+  return process.env.GEMINI_API_KEY;
 }
 
+/**
+ * Analyzes HTML source code, extracts `i18n` elements and `<script type="application/ld+json">` data,
+ * and uses Google GenAI to synthesize a Language-First JSON translation dictionary.
+ * 
+ * @async
+ * @param {string} html - Raw HTML source code string containing elements with `i18n` attributes.
+ * @param {string[]} languages - Array of target language codes (e.g., `["en", "es", "fr"]`).
+ * @param {TranslateOptions} [options={}] - Optional configuration parameters for model and authentication.
+ * @returns {Promise<LanguageFirstTranslationMap|null>} Language-First translation map, or `null` if generation fails.
+ * @throws {Error} Throws an error if no API key is provided or resolved.
+ *
+ * @example
+ * const translations = await translateHtml(
+ *   '<h1 i18n="heading">Hello</h1><input i18n="search" placeholder="Search...">',
+ *   ["es", "fr"]
+ * );
+ */
 module.exports = async function translateHtml(html, languages, options = {}) {
-	const apiKey = await getApiKey(options);
-	if (!apiKey)
-		throw new Error(
-			"Google Generative AI API key is required in options.apiKey, process.env, or via prompt."
-		);
-	const genAI = new GoogleGenerativeAI(apiKey);
-	const model =
-		options.model || genAI.getGenerativeModel({ model: MODEL_NAME });
-	const translationObj = await generateTranslationObject(
-		html,
-		model,
-		languages
-	);
-	return translationObj;
-};
-
-// Update generateTranslationObject to accept only html, model, languages
-async function generateTranslationObject(html, model, languages) {
-	const langList = languages.map((l) => `"${l}"`).join(", ");
-	const prompt = `
-You are an expert web localization AI. Given the following HTML file, extract all translatable content (titles, meta tags, headers, buttons, video/image alt/title, labels, aria-label, all aria-* attributes, and placeholders) and generate a JSON object in the following format:
+  const apiKey = await getApiKey(options);
+  if (!apiKey) {
+    throw new Error("Google GenAI API key is required for translateHtml.");
+  }
 
-{
-  "translations": [
-    {
-      "selector": "<css selector>",
-      "innerHTML": {
-        ${languages
-			.map((l) => `\"${l}\"`)
-			.join(
-				", \
-        "
-			)}
-      }
-    },
-    {
-      "selector": "<css selector>",
-      "attributes": {
-        "alt": { ${langList} },
-        "label": { ${langList} },
-        "aria-label": { ${langList} },
-        "aria-*": { ${langList} },
-        "title": { ${langList} },
-        "placeholder": { ${langList} }
-      }
-    },
-    // Example for structured data translation:
-    {
-      "selector": "script[type='application/ld+json']",
-      "innerHTML": {
-        "en": { "@context": "http://schema.org", "@type": "WebPage", "name": "English name", "description": "English description" },
-        "es": { "@context": "http://schema.org", "@type": "WebPage", "name": "Spanish name", "description": "Spanish description" },
-        "fr": { "@context": "http://schema.org", "@type": "WebPage", "name": "French name", "description": "French description" }
-        // ...other languages
-      }
-    }
-    // ...more selectors as needed
-  ]
-}
+  const ai = new GoogleGenAI({ apiKey });
+  const modelName = options.model || DEFAULT_MODEL;
+  const langList = Array.isArray(languages) ? languages.join(", ") : String(languages);
 
-Do not add any extra keys or key names not shown in this structure. Only use the keys: name, directory, path, content-type, translations, selector, innerHTML, attributes, alt, label, aria-label, aria-*, title, placeholder, and the language codes (${languages.join(
-		", "
-	)}).
+  const prompt = `
+You are an expert web localization AI. 
+Analyze the provided HTML and find all elements containing an "i18n" attribute, as well as any <script type="application/ld+json"> tags.
 
-For every translatable item (innerHTML and attributes), provide a translation for each language: ${languages.join(
-		", "
-	)}. Do not leave any language blank. For Guarani (\"gn\"), always translate to Guarani and never leave it in English.
+Target Languages: ${langList}
 
-Only output the JSON object, do not include any explanation or extra text.
+Instructions:
+1. Extract translatable content for each "i18n" key (inner text, alt, title, placeholder, label, aria-label, and aria-* attributes).
+2. For script[type='application/ld+json'], use the key "ld+json" or the element's "i18n" attribute, and translate string fields (like name, description) while keeping schema keywords (@context, @type, url) intact.
+3. Organize the translations into a LANGUAGE-FIRST structure where top-level keys are the target language codes (${langList}).
+4. Inside each language code object, map each "i18n" key to its translated properties (e.g., "text", "placeholder", "alt", "title", "aria-label").
+5. Provide a full translation for EVERY target language requested. Never leave a requested language empty.
 
-HTML:
+HTML Source:
 ${html}
 `;
 
-	try {
-		const result = await model.generateContent(prompt);
-		let jsonText = result.response.candidates[0].content.parts[0].text;
-		// Extract the first JSON object from the response
-		const match = jsonText.match(/\{[\s\S]*\}/);
-		if (!match) throw new Error("No JSON object found in AI response");
-		jsonText = match[0];
-		return JSON.parse(jsonText).translations;
-	} catch (err) {
-		console.log(`AI error:`, err);
-		return null;
-	}
-}
+  /**
+   * JSON Schema enforcing structured Language-First output from Gemini.
+   * @type {import("@google/genai").Schema}
+   */
+  const responseSchema = {
+    type: Type.OBJECT,
+    properties: {
+      translations: {
+        type: Type.OBJECT,
+        description: "Map of language codes (e.g., 'en', 'es') to key-value translation objects",
+        additionalProperties: {
+          type: Type.OBJECT,
+          description: "Map of i18n keys to element translation properties",
+          additionalProperties: {
+            type: Type.OBJECT,
+            properties: {
+              text: { type: Type.STRING, nullable: true },
+              placeholder: { type: Type.STRING, nullable: true },
+              title: { type: Type.STRING, nullable: true },
+              alt: { type: Type.STRING, nullable: true },
+              "aria-label": { type: Type.STRING, nullable: true }
+            },
+            additionalProperties: true
+          }
+        }
+      }
+    },
+    required: ["translations"]
+  };
+
+  try {
+    const response = await ai.models.generateContent({
+      model: modelName,
+      contents: prompt,
+      config: {
+        responseMimeType: "application/json",
+        responseSchema: responseSchema,
+        temperature: options.temperature ?? 0.2
+      }
+    });
+
+    const parsed = JSON.parse(response.text);
+    return parsed.translations;
+  } catch (err) {
+    console.error("Gemini Translation Error:", err);
+    return null;
+  }
+};