@elyracode/i18n-tools 0.5.2

package/README.md

@@ -0,0 +1,29 @@
+# @elyracode/i18n-tools
+
+Localization tools for Elyra -- find hardcoded strings, extract translations, detect missing keys.
+
+## Install
+
+```
+elyra install npm:@elyracode/i18n-tools
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `find_hardcoded_strings` | Scan Blade/Vue/React files for user-facing strings that need translation |
+| `find_missing_translations` | Compare locales in lang/ to find missing translation keys |
+
+## Commands
+
+- `/i18n` -- Run full i18n analysis
+
+## Usage
+
+```
+> Find hardcoded strings in my Blade views
+> Check for missing translations between en and nb
+> Scan the resources/ directory for untranslated text
+/i18n
+```

package/extensions/index.ts

@@ -0,0 +1,270 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+import type { ExtensionAPI } from "@elyracode/coding-agent";
+import { Type } from "typebox";
+
+export default function (elyra: ExtensionAPI): void {
+
+	// ── Tool: find_hardcoded_strings ──
+	elyra.registerTool({
+		name: "find_hardcoded_strings",
+		label: "Find Hardcoded Strings",
+		description:
+			"Scan Blade, Vue, React, or PHP files for hardcoded user-facing strings " +
+			"that should be translated. Finds strings in templates, labels, placeholders, " +
+			"error messages, and button text. Ignores code-only strings.",
+		parameters: Type.Object({
+			path: Type.Optional(
+				Type.String({ description: "Directory to scan (default: resources/)" }),
+			),
+			format: Type.Optional(
+				Type.Union([Type.Literal("blade"), Type.Literal("vue"), Type.Literal("react"), Type.Literal("auto")], {
+					description: "File format to scan (default: auto-detect)",
+				}),
+			),
+		}),
+		execute: async (_toolCallId, params) => {
+			try {
+				const cwd = process.cwd();
+				const scanPath = params.path ?? "resources";
+				const fullPath = join(cwd, scanPath);
+
+				if (!existsSync(fullPath)) {
+					return {
+						content: [{ type: "text", text: `Directory not found: ${scanPath}` }],
+						details: {},
+					};
+				}
+
+				const findings: Array<{ file: string; line: number; text: string; context: string }> = [];
+				const extensions = getExtensionsForFormat(params.format ?? "auto");
+
+				scanDirectory(fullPath, (filePath) => {
+					const ext = extname(filePath);
+					if (!extensions.includes(ext)) return;
+
+					const content = readFileSync(filePath, "utf-8");
+					const lines = content.split("\n");
+
+					for (let i = 0; i < lines.length; i++) {
+						const line = lines[i];
+						const hardcoded = findHardcodedInLine(line, ext);
+						for (const match of hardcoded) {
+							findings.push({
+								file: relative(cwd, filePath),
+								line: i + 1,
+								text: match,
+								context: line.trim().slice(0, 100),
+							});
+						}
+					}
+				});
+
+				if (findings.length === 0) {
+					return {
+						content: [{ type: "text", text: "No hardcoded strings found. Files may already be translated." }],
+						details: { count: 0 },
+					};
+				}
+
+				const lines = [
+					`# Hardcoded Strings (${findings.length})`,
+					"",
+					"These strings should be extracted to translation files:",
+					"",
+				];
+
+				const byFile = new Map<string, typeof findings>();
+				for (const f of findings) {
+					const list = byFile.get(f.file) ?? [];
+					list.push(f);
+					byFile.set(f.file, list);
+				}
+
+				for (const [file, items] of byFile) {
+					lines.push(`## ${file}`);
+					for (const item of items.slice(0, 20)) {
+						lines.push(`- Line ${item.line}: "${item.text}"`);
+					}
+					if (items.length > 20) {
+						lines.push(`- ... and ${items.length - 20} more`);
+					}
+					lines.push("");
+				}
+
+				lines.push("## Suggested Actions");
+				lines.push("1. Create translation keys in `lang/en/*.php` or `lang/en.json`");
+				lines.push("2. Replace strings with `__('key')` (Blade/PHP) or `$t('key')` (Vue)");
+				lines.push("3. Add translations for other locales");
+
+				return {
+					content: [{ type: "text", text: lines.join("\n") }],
+					details: { count: findings.length, files: byFile.size },
+				};
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `Scan failed: ${msg}` }],
+					details: {},
+				};
+			}
+		},
+	});
+
+	// ── Tool: find_missing_translations ──
+	elyra.registerTool({
+		name: "find_missing_translations",
+		label: "Find Missing Translations",
+		description:
+			"Compare translation files across locales to find missing keys. " +
+			"Scans lang/ directory for PHP and JSON translation files. " +
+			"Reports keys that exist in one locale but not another.",
+		parameters: Type.Object({
+			base_locale: Type.Optional(
+				Type.String({ description: "Base locale to compare against (default: 'en')" }),
+			),
+		}),
+		execute: async (_toolCallId, params) => {
+			try {
+				const cwd = process.cwd();
+				const baseLocale = params.base_locale ?? "en";
+				const langDir = join(cwd, "lang");
+
+				if (!existsSync(langDir)) {
+					return {
+						content: [{ type: "text", text: "No lang/ directory found. Laravel translation files should be at lang/." }],
+						details: {},
+					};
+				}
+
+				const locales = readdirSync(langDir).filter((f) => {
+					const full = join(langDir, f);
+					return statSync(full).isDirectory() || f.endsWith(".json");
+				});
+
+				if (locales.length <= 1) {
+					return {
+						content: [{ type: "text", text: `Only one locale found. Add more locales to lang/ for comparison.` }],
+						details: {},
+					};
+				}
+
+				// Collect keys per locale from JSON files
+				const localeKeys = new Map<string, Set<string>>();
+
+				for (const locale of locales) {
+					const jsonPath = join(langDir, locale.endsWith(".json") ? locale : `${locale}.json`);
+					if (existsSync(jsonPath)) {
+						const content = JSON.parse(readFileSync(jsonPath, "utf-8"));
+						const keys = new Set(Object.keys(content));
+						const localeName = locale.replace(".json", "");
+						localeKeys.set(localeName, keys);
+					}
+				}
+
+				const baseKeys = localeKeys.get(baseLocale);
+				if (!baseKeys) {
+					return {
+						content: [{ type: "text", text: `Base locale '${baseLocale}' not found as JSON file.` }],
+						details: {},
+					};
+				}
+
+				const lines = ["# Missing Translations", ""];
+				let totalMissing = 0;
+
+				for (const [locale, keys] of localeKeys) {
+					if (locale === baseLocale) continue;
+					const missing = [...baseKeys].filter((k) => !keys.has(k));
+					const extra = [...keys].filter((k) => !baseKeys.has(k));
+
+					if (missing.length > 0 || extra.length > 0) {
+						lines.push(`## ${locale}`);
+						if (missing.length > 0) {
+							lines.push(`Missing (in ${baseLocale} but not ${locale}): ${missing.length}`);
+							for (const k of missing.slice(0, 20)) {
+								lines.push(`- ${k}`);
+							}
+							totalMissing += missing.length;
+						}
+						if (extra.length > 0) {
+							lines.push(`Extra (in ${locale} but not ${baseLocale}): ${extra.length}`);
+						}
+						lines.push("");
+					}
+				}
+
+				if (totalMissing === 0) {
+					lines.push("All locales have matching keys.");
+				}
+
+				return {
+					content: [{ type: "text", text: lines.join("\n") }],
+					details: { totalMissing, locales: localeKeys.size },
+				};
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `Translation scan failed: ${msg}` }],
+					details: {},
+				};
+			}
+		},
+	});
+
+	// ── Commands ──
+	elyra.registerCommand("i18n", {
+		description: "Find hardcoded strings and missing translations",
+		handler: async (_args, _ctx) => {
+			elyra.sendUserMessage("Scan this project for i18n issues: find hardcoded strings that need translation and check for missing translation keys across locales.");
+		},
+	});
+}
+
+function getExtensionsForFormat(format: string): string[] {
+	switch (format) {
+		case "blade": return [".blade.php"];
+		case "vue": return [".vue"];
+		case "react": return [".tsx", ".jsx"];
+		default: return [".blade.php", ".vue", ".tsx", ".jsx", ".php"];
+	}
+}
+
+function scanDirectory(dir: string, callback: (path: string) => void): void {
+	try {
+		for (const entry of readdirSync(dir)) {
+			if (entry.startsWith(".") || entry === "node_modules" || entry === "vendor") continue;
+			const full = join(dir, entry);
+			const stat = statSync(full);
+			if (stat.isDirectory()) {
+				scanDirectory(full, callback);
+			} else if (stat.isFile()) {
+				callback(full);
+			}
+		}
+	} catch { /* permission errors */ }
+}
+
+function findHardcodedInLine(line: string, _ext: string): string[] {
+	const results: string[] = [];
+	const trimmed = line.trim();
+
+	// Skip comments, imports, variables, code-only lines
+	if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) return results;
+	if (trimmed.startsWith("use ") || trimmed.startsWith("import ")) return results;
+	if (trimmed.startsWith("$") || trimmed.startsWith("const ") || trimmed.startsWith("let ") || trimmed.startsWith("var ")) return results;
+
+	// Find strings in HTML-like contexts (labels, placeholders, button text, headings)
+	const htmlStringPattern = /(?:>|label="|placeholder="|title="|alt="|aria-label=")([A-Z][^"<>{}\n]{2,60})/g;
+	let match: RegExpExecArray | null = htmlStringPattern.exec(line);
+	while (match) {
+		const text = match[1].trim();
+		// Filter out likely code/CSS/paths
+		if (text && !text.includes("$") && !text.includes("{{") && !text.includes("__(") && !text.match(/^[a-z._/]+$/)) {
+			results.push(text);
+		}
+		match = htmlStringPattern.exec(line);
+	}
+
+	return results;
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@elyracode/i18n-tools",
+  "version": "0.5.2",
+  "description": "Elyra extension for localization -- find hardcoded strings, extract translations, detect missing keys",
+  "type": "module",
+  "keywords": ["elyra-package", "i18n", "localization", "translation", "laravel", "vue"],
+  "license": "MIT",
+  "author": "Knut W. Horne",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwhorne/elyra.git",
+    "directory": "packages/i18n-tools"
+  },
+  "elyra": { "extensions": ["./extensions/index.ts"] },
+  "peerDependencies": { "@elyracode/coding-agent": "*", "typebox": "*" },
+  "scripts": { "clean": "echo 'nothing to clean'", "build": "echo 'nothing to build'", "check": "echo 'nothing to check'" }
+}