lingo-linter-tool 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+const no_string_concat_1 = require("./linter/rules/no-string-concat");
+const missing_keys_1 = require("./linter/rules/missing-keys");
+const healer_1 = require("./healer");
+const reporter_1 = require("./utils/reporter");
+const program = new commander_1.Command();
+const calculateHealth = (errors, warnings) => {
+    let score = 100 - errors * 5 - warnings * 2;
+    return Math.max(0, score);
+};
+program.name("lingo").description("Localization Linter + Self-Healing Tool");
+program
+    .command("lint [dir]")
+    .description("Analyze code in a specific directory")
+    .option("--fix", "Auto-heal missing keys")
+    .option("--locales <dir>", "Locales directory (relative to target)", "./locales")
+    .action(async (dir, options) => {
+    const targetRoot = dir ? path_1.default.resolve(dir) : process.cwd();
+    console.log(targetRoot);
+    const localesDir = path_1.default.resolve(targetRoot, options.locales);
+    console.log(chalk_1.default.blue(`🔍 Scanning: ${targetRoot}`));
+    console.log(chalk_1.default.gray(`   Locales:  ${localesDir}`));
+    const files = glob_1.glob.sync("**/*.{ts,tsx}", {
+        cwd: targetRoot,
+        absolute: true,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/*.d.ts"],
+    });
+    if (files.length === 0) {
+        console.log(chalk_1.default.red(`❌ No .ts/.tsx files found in ${targetRoot}`));
+        console.log(chalk_1.default.gray(`   Debug: Glob ran in ${targetRoot}`));
+        return;
+    }
+    const issues = [
+        ...no_string_concat_1.NoStringConcatRule.run(files),
+        ...missing_keys_1.MissingKeysRule.run(files, localesDir),
+    ];
+    let errorCount = 0;
+    let warningCount = 0;
+    issues.forEach((issue) => {
+        const color = issue.severity === "error" ? chalk_1.default.red : chalk_1.default.yellow;
+        const icon = issue.severity === "error" ? "❌" : "⚠️";
+        if (issue.severity === "error")
+            errorCount++;
+        else
+            warningCount++;
+        console.log(`${icon} ${color(issue.message)}`);
+        console.log(chalk_1.default.gray(`   at ${issue.file}:${issue.line}`));
+        if (issue.suggestion) {
+            console.log(chalk_1.default.green(`   💡 Suggestion: ${issue.suggestion}`));
+        }
+        console.log("");
+    });
+    const score = calculateHealth(errorCount, warningCount);
+    await (0, reporter_1.uploadHealthScore)(score, errorCount, warningCount);
+    const scoreColor = score > 80 ? chalk_1.default.green : score > 50 ? chalk_1.default.yellow : chalk_1.default.red;
+    console.log(chalk_1.default.bold("-----------------------------------"));
+    console.log(`Localization Health: ${scoreColor(score + " / 100")}`);
+    console.log(chalk_1.default.bold("-----------------------------------"));
+    if (options.fix && errorCount > 0) {
+        await (0, healer_1.healIssues)(issues, localesDir);
+    }
+    if (errorCount > 0 && !options.fix)
+        process.exit(1);
+});
+program.parse(process.argv);

package/dist/config.js

@@ -0,0 +1 @@
+"use strict";

package/dist/healer/index.d.ts

@@ -0,0 +1,2 @@
+import { LintIssue } from "../linter/types";
+export declare function healIssues(issues: LintIssue[], localesDir: string): Promise<void>;

package/dist/healer/index.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.healIssues = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const translator_1 = require("./translator");
+const chalk_1 = __importDefault(require("chalk"));
+function getSourceText(localesDir, key) {
+    try {
+        const enPath = path.join(localesDir, "en.json");
+        if (!fs.existsSync(enPath))
+            return null;
+        const raw = fs.readFileSync(enPath, "utf-8");
+        const json = JSON.parse(raw);
+        const keys = key.split(".");
+        let current = json;
+        for (const k of keys) {
+            if (current[k] === undefined)
+                return null;
+            current = current[k];
+        }
+        return typeof current === "string" ? current : null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+async function healIssues(issues, localesDir) {
+    console.log(chalk_1.default.blue("\n🩹 Initializing Lingo.dev Auto-Healer..."));
+    const missingKeyIssues = issues.filter((i) => i.ruleId === "missing-keys" && i.key);
+    if (missingKeyIssues.length === 0) {
+        console.log("✨ No missing keys to heal.");
+        return;
+    }
+    const updates = {};
+    for (const issue of missingKeyIssues) {
+        const targetFile = path.basename(issue.file);
+        const targetLang = targetFile.replace(".json", "");
+        const key = issue.key;
+        const sourceText = getSourceText(localesDir, key);
+        if (!sourceText) {
+            console.warn(chalk_1.default.yellow(`⚠️ Skipping "${key}": Key also missing in en.json (Source)`));
+            continue;
+        }
+        if (!updates[targetFile])
+            updates[targetFile] = {};
+        process.stdout.write(`   ✨ Translating "${key}" to ${targetLang}... `);
+        const translation = await translator_1.Translator.translate(sourceText, targetLang);
+        console.log(chalk_1.default.green("Done"));
+        updates[targetFile][key] = translation;
+    }
+    Object.keys(updates).forEach((file) => {
+        if (Object.keys(updates[file]).length === 0)
+            return;
+        const filePath = path.join(localesDir, file);
+        let currentContent = {};
+        try {
+            currentContent = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        }
+        catch (e) {
+        }
+        const newContent = { ...currentContent };
+        Object.entries(updates[file]).forEach(([key, val]) => {
+            const parts = key.split(".");
+            let current = newContent;
+            for (let i = 0; i < parts.length - 1; i++) {
+                const part = parts[i];
+                if (!current[part])
+                    current[part] = {};
+                current = current[part];
+            }
+            current[parts[parts.length - 1]] = val;
+        });
+        fs.writeFileSync(filePath, JSON.stringify(newContent, null, 2));
+        console.log(chalk_1.default.magenta(`💾 Written ${Object.keys(updates[file]).length} new keys to ${file}`));
+    });
+}
+exports.healIssues = healIssues;

package/dist/healer/translator.d.ts

@@ -0,0 +1,3 @@
+export declare class Translator {
+    static translate(text: string, targetLocale: string): Promise<string>;
+}

package/dist/healer/translator.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Translator = void 0;
+const axios_1 = __importDefault(require("axios"));
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+const API_KEY = process.env.LINGO_API_KEY;
+const API_URL = "https://api.lingo.dev/v1/translate";
+class Translator {
+    static async translate(text, targetLocale) {
+        if (!text)
+            return "";
+        if (!API_KEY) {
+            console.warn("⚠️ No LINGO_API_KEY found. Using mock mode.");
+            return `[${targetLocale.toUpperCase()}] ${text}`;
+        }
+        try {
+            const response = await axios_1.default.post(API_URL, {
+                source: "en",
+                target: targetLocale,
+                content: text,
+            }, {
+                headers: {
+                    Authorization: `Bearer ${API_KEY}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            return (response.data.translation ||
+                response.data.choices[0].message.content);
+        }
+        catch (error) {
+            console.error(`❌ API Error translating to ${targetLocale}:`, error);
+            return text;
+        }
+    }
+}
+exports.Translator = Translator;

package/dist/linter/engine.js

@@ -0,0 +1 @@
+"use strict";

package/dist/linter/rules/missing-keys.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from "../types";
+export declare const MissingKeysRule: Rule;

package/dist/linter/rules/missing-keys.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingKeysRule = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
+function flattenKeys(obj, prefix = "") {
+    let keys = [];
+    for (const key in obj) {
+        if (typeof obj[key] === "object" && obj[key] !== null) {
+            keys = keys.concat(flattenKeys(obj[key], prefix + key + "."));
+        }
+        else {
+            keys.push(prefix + key);
+        }
+    }
+    return keys;
+}
+exports.MissingKeysRule = {
+    id: "missing-keys",
+    run: (filePaths, localesDir = "./locales") => {
+        const issues = [];
+        const project = new ts_morph_1.Project();
+        const usedKeys = new Set();
+        filePaths.forEach((filePath) => {
+            const sourceFile = project.addSourceFileAtPath(filePath);
+            sourceFile
+                .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+                .forEach((call) => {
+                const expression = call.getExpression();
+                const functionName = ts_morph_1.Node.isPropertyAccessExpression(expression)
+                    ? expression.getName()
+                    : expression.getText();
+                if (functionName === "t") {
+                    const args = call.getArguments();
+                    if (args.length > 0) {
+                        const firstArg = args[0];
+                        if (ts_morph_1.Node.isStringLiteral(firstArg) ||
+                            ts_morph_1.Node.isNoSubstitutionTemplateLiteral(firstArg)) {
+                            usedKeys.add(firstArg.getLiteralText());
+                        }
+                    }
+                }
+            });
+        });
+        if (!fs.existsSync(localesDir))
+            return [];
+        const localeFiles = fs
+            .readdirSync(localesDir)
+            .filter((f) => f.endsWith(".json"));
+        localeFiles.forEach((file) => {
+            try {
+                const rawContent = fs.readFileSync(path.join(localesDir, file), "utf-8");
+                const jsonContent = JSON.parse(rawContent);
+                const existingKeys = new Set(flattenKeys(jsonContent));
+                usedKeys.forEach((key) => {
+                    if (!existingKeys.has(key)) {
+                        issues.push({
+                            file: path.join(localesDir, file),
+                            line: 1,
+                            ruleId: "missing-keys",
+                            severity: "error",
+                            message: `Key "${key}" is missing in ${file}`,
+                            key: key,
+                        });
+                    }
+                });
+            }
+            catch (e) {
+                console.error(`Error parsing ${file}:`, e);
+            }
+        });
+        return issues;
+    },
+};

package/dist/linter/rules/no-string-concat.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from "../types";
+export declare const NoStringConcatRule: Rule;

package/dist/linter/rules/no-string-concat.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoStringConcatRule = void 0;
+const ts_morph_1 = require("ts-morph");
+exports.NoStringConcatRule = {
+    id: "no-string-concat",
+    run: (filePaths) => {
+        const project = new ts_morph_1.Project();
+        const issues = [];
+        filePaths.forEach((filePath) => {
+            const sourceFile = project.addSourceFileAtPath(filePath);
+            sourceFile
+                .getDescendantsOfKind(ts_morph_1.SyntaxKind.BinaryExpression)
+                .forEach((expr) => {
+                if (expr.getOperatorToken().getText() !== "+")
+                    return;
+                const left = expr.getLeft();
+                const right = expr.getRight();
+                const hasString = left.getKind() === ts_morph_1.SyntaxKind.StringLiteral ||
+                    right.getKind() === ts_morph_1.SyntaxKind.StringLiteral;
+                const parentText = expr.getParent()?.getText() || "";
+                const isSafe = parentText.startsWith("console.") ||
+                    parentText.includes("logger.");
+                if (hasString && !isSafe) {
+                    issues.push({
+                        file: filePath,
+                        line: expr.getStartLineNumber(),
+                        ruleId: "no-string-concat",
+                        severity: "error",
+                        message: "Detected string concatenation. Use translation keys.",
+                        suggestion: `t("your_key", { variable: ... })`,
+                    });
+                }
+            });
+        });
+        return issues;
+    },
+};

package/dist/linter/types.d.ts

@@ -0,0 +1,13 @@
+export interface LintIssue {
+    file: string;
+    line: number;
+    ruleId: string;
+    message: string;
+    severity: "error" | "warning";
+    suggestion?: string;
+    key?: string;
+}
+export interface Rule {
+    id: string;
+    run: (files: string[], localesDir?: string) => LintIssue[];
+}

package/dist/linter/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/file-system.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/logger.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/reporter.d.ts

@@ -0,0 +1 @@
+export declare function uploadHealthScore(score: number, errors: number, warnings: number): Promise<void>;

package/dist/utils/reporter.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadHealthScore = void 0;
+const supabase_js_1 = require("@supabase/supabase-js");
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+async function uploadHealthScore(score, errors, warnings) {
+    if (!process.env.CI || !SUPABASE_URL || !SUPABASE_KEY) {
+        return;
+    }
+    console.log("📊 Uploading metrics to Supabase...");
+    const supabase = (0, supabase_js_1.createClient)(SUPABASE_URL, SUPABASE_KEY);
+    const { error } = await supabase.from("lingo_runs").insert({
+        project_name: process.env.GITHUB_REPOSITORY || "local-test",
+        branch: process.env.GITHUB_REF_NAME || "unknown",
+        commit_sha: process.env.GITHUB_SHA || "unknown",
+        health_score: score,
+        error_count: errors,
+        warning_count: warnings,
+    });
+    if (error)
+        console.error("❌ Failed to upload metrics:", error.message);
+    else
+        console.log("✅ Metrics uploaded successfully.");
+}
+exports.uploadHealthScore = uploadHealthScore;

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "lingo-linter-tool",
+    "version": "1.0.0",
+    "description": "Localization linter and self-healing tool",
+    "bin": {
+        "lingo": "./dist/cli.js"
+    },
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build",
+        "dev": "ts-node src/cli.ts lint",
+        "start": "node dist/cli.js lint"
+    },
+    "dependencies": {
+        "@supabase/supabase-js": "^2.91.0",
+        "axios": "^1.13.2",
+        "chalk": "^4.1.2",
+        "commander": "^10.0.0",
+        "dotenv": "^17.2.3",
+        "glob": "^8.1.0",
+        "ts-morph": "^17.0.0"
+    },
+    "devDependencies": {
+        "@types/glob": "^9.0.0",
+        "@types/node": "^18.0.0",
+        "ts-node": "^10.9.1",
+        "typescript": "^4.9.0"
+    }
+}