lokalise-mcp/dist/domains/glossary/glossary.cli.js

The Lokalise MCP Server brings Lokalise's localization power to Claude and AI assistants—manage projects, keys, and translations by chat.

import { handleCliError } from "../../shared/utils/error.util.js";
import { Logger } from "../../shared/utils/logger.util.js";
import glossaryController from "./glossary.controller.js";
/**
 * Glossary CLI commands implementation.
 * Generated on 2025-07-10 for Glossary terms management for consistent translations.
 */
const logger = Logger.forContext("glossary.cli.ts");
/**
 * Register Glossary CLI commands
 * @param program The Commander program instance
 */
function register(program) {
    const methodLogger = logger.forMethod("register");
    methodLogger.debug("Registering Glossary CLI commands...");
    // List Glossary Terms Command
    program
        .command("list-glossary-terms")
        .description("Lists glossary terms in a Lokalise project with cursor pagination")
        .argument("<projectId>", "Project ID to list glossary terms for")
        .option("-l, --limit <number>", "Number of terms to return (1-5000, default: 100)", (value) => {
        const parsed = Number.parseInt(value, 10);
        if (Number.isNaN(parsed) || parsed < 1 || parsed > 5000) {
            throw new Error("Limit must be a number between 1 and 5000");
        }
        return parsed;
    })
        .option("-c, --cursor <cursor>", "Cursor for pagination (from previous response)")
        .action(async (projectId, options) => {
        const actionLogger = logger.forMethod("action:list-glossary-terms");
        try {
            actionLogger.debug("CLI list-glossary-terms called", {
                projectId,
                limit: options.limit,
                cursor: options.cursor,
            });
            // Build arguments
            const args = {
                projectId: projectId.trim(),
                limit: options.limit,
                cursor: options.cursor,
            };
            // Call controller
            const result = await glossaryController.listGlossaryTerms(args);
            console.log(result.content);
        }
        catch (error) {
            handleCliError(error);
        }
    });
    // Get Glossary Term Command
    program
        .command("get-glossary-term")
        .description("Gets details of a specific glossary term including translations")
        .argument("<projectId>", "Project ID containing the glossary term")
        .argument("<termId>", "Glossary term ID to get details for")
        .action(async (projectId, termId) => {
        const actionLogger = logger.forMethod("action:get-glossary-term");
        try {
            actionLogger.debug("CLI get-glossary-term called", {
                projectId,
                termId,
            });
            // Parse term ID as number
            const parsedTermId = Number.parseInt(termId, 10);
            if (Number.isNaN(parsedTermId)) {
                throw new Error("Term ID must be a number");
            }
            // Build arguments
            const args = {
                projectId: projectId.trim(),
                termId: parsedTermId,
            };
            // Call controller
            const result = await glossaryController.getGlossaryTerm(args);
            console.log(result.content);
        }
        catch (error) {
            handleCliError(error);
        }
    });
    // Create Glossary Terms Command
    program
        .command("create-glossary-term")
        .description("Creates a new glossary term to maintain translation consistency")
        .argument("<projectId>", "Project ID to add glossary term to")
        .requiredOption("-t, --term <term>", "The glossary term text")
        .requiredOption("-d, --description <description>", "Description of the term")
        .option("--case-sensitive", "Term matching is case-sensitive", false)
        .option("--not-translatable", "Term should not be translated", false)
        .option("--forbidden", "Term should be flagged as forbidden", false)
        .option("--tags <tags>", "Comma-separated tags", (value) => value.split(",").map((t) => t.trim()))
        .action(async (projectId, options) => {
        const actionLogger = logger.forMethod("action:create-glossary-term");
        try {
            actionLogger.debug("CLI create-glossary-term called", {
                projectId,
                options,
            });
            // Build arguments
            const args = {
                projectId: projectId.trim(),
                terms: [
                    {
                        term: options.term,
                        description: options.description,
                        caseSensitive: options.caseSensitive,
                        translatable: !options.notTranslatable,
                        forbidden: options.forbidden,
                        tags: options.tags,
                    },
                ],
            };
            // Call controller
            const result = await glossaryController.createGlossaryTerms(args);
            console.log(result.content);
        }
        catch (error) {
            handleCliError(error);
        }
    });
    methodLogger.debug("Glossary CLI commands registered successfully");
}
// Export the domain CLI implementation
const glossaryCli = {
    register,
    getMeta() {
        return {
            name: "glossary",
            description: "Glossary CLI commands",
            version: "1.0.0",
            cliCommandsCount: 3,
        };
    },
};
export default glossaryCli;