@lingo.dev/cli 1.0.3 → 1.1.0

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin.js

@@ -1,5 +1,5 @@
-import { a as extractCommandInfo, b as ApiClientLive, d as subcommands, f as TelemetryService, g as cancel, i as collectOptions, l as helpConfig, m as trackCommand, n as renderRootHelp, o as unwrapCommand, p as TelemetryServiceLive, s as cliConfig, t as renderCommandHelp, u as run, w as AuthServiceLive, x as AuthContext, y as ConfigServiceLive } from "./renderer-D2iDOMA6.js";
-import { n as UpdateService, r as UpdateServiceLive } from "./update-RHUBOb93.js";
+import { a as extractCommandInfo, b as ApiClientLive, d as subcommands, f as TelemetryService, g as cancel, i as collectOptions, l as helpConfig, m as trackCommand, n as renderRootHelp, o as unwrapCommand, p as TelemetryServiceLive, s as cliConfig, t as renderCommandHelp, u as run, w as AuthServiceLive, x as AuthContext, y as ConfigServiceLive } from "./renderer.js";
+import { n as UpdateService, r as UpdateServiceLive } from "./update.js";
 import { AutoCorrect, CliConfig, ValidationError } from "@effect/cli";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
 import { Cause, Effect, Layer, pipe } from "effect";
@@ -68,7 +68,7 @@ process.on("SIGINT", () => process.exit(0));
 process.on("SIGTERM", () => process.exit(0));
 const args = process.argv;
 const userArgs = args.slice(2).filter((a) => a !== "--");
-if (userArgs[0] === "mcp") import("./server-DGIsMSAq.js").then((m) => m.startMcpServer()).catch((e) => {
+if (userArgs[0] === "mcp") import("./server.js").then((m) => m.startMcpServer()).catch((e) => {
 	process.stderr.write(`MCP server error: ${e}\n`);
 	process.exit(1);
 });

package/dist/flush-telemetry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,356 @@
+import { CliConfig, Command } from "@effect/cli";
+import { Context, Effect, Layer } from "effect";
+import "@supabase/supabase-js";
+import { z } from "zod";
+import * as effect_Cause0 from "effect/Cause";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Option0 from "effect/Option";
+import * as _effect_cli_ValidationError0 from "@effect/cli/ValidationError";
+import * as _effect_cli_CliApp0 from "@effect/cli/CliApp";
+import * as effect_Effect0 from "effect/Effect";
+
+//#region src/services/auth.d.ts
+type SessionCredentials = {
+  readonly type: "session";
+  readonly email: string;
+  readonly accessToken: string;
+  readonly refreshToken: string;
+  readonly expiresAt: number;
+};
+type ApiKeyCredentials = {
+  readonly type: "api-key";
+  readonly apiKey: string;
+};
+type AuthCredentials = SessionCredentials | ApiKeyCredentials;
+declare const AuthError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "AuthError";
+} & Readonly<A>;
+declare class AuthError extends AuthError_base<{
+  readonly message: string;
+}> {}
+declare const AuthContext_base: Context.TagClass<AuthContext, "AuthContext", {
+  readonly apiKeyFlag?: string;
+  readonly homeDir?: string;
+}>;
+declare class AuthContext extends AuthContext_base {}
+declare const AuthService_base: Context.TagClass<AuthService, "AuthService", {
+  readonly resolve: Effect.Effect<AuthCredentials, AuthError>;
+  readonly store: (creds: AuthCredentials) => Effect.Effect<void, AuthError>;
+  readonly clear: Effect.Effect<void, AuthError>;
+  readonly ensureFresh: Effect.Effect<AuthCredentials, AuthError>;
+}>;
+declare class AuthService extends AuthService_base {}
+declare const AuthServiceLive: Layer.Layer<AuthService, never, AuthContext>;
+//#endregion
+//#region src/services/api-client.d.ts
+declare const ApiError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "ApiError";
+} & Readonly<A>;
+declare class ApiError extends ApiError_base<{
+  readonly message: string;
+  readonly status?: number;
+}> {}
+type Membership = {
+  id: string;
+  userId: string;
+  organizationId: string;
+  organizationName: string;
+  role: string;
+};
+type Organization = {
+  id: string;
+  name: string;
+};
+type Engine = {
+  id: string;
+  ownerOrganizationId: string;
+  name: string;
+  description: string | null;
+};
+type LocalizeRequest = {
+  sourceLocale: string;
+  targetLocale: string;
+  data: Record<string, string>;
+  engineId?: string;
+  hints?: Record<string, string[]>;
+  triggerType?: "cli" | "ci";
+};
+type LocalizeResponse = {
+  sourceLocale: string;
+  targetLocale: string;
+  data: Record<string, string>;
+};
+declare const ApiClient_base: Context.TagClass<ApiClient, "ApiClient", {
+  readonly listMemberships: Effect.Effect<Membership[], ApiError | AuthError>;
+  readonly createOrganization: (name: string) => Effect.Effect<Organization, ApiError | AuthError>;
+  readonly listEngines: (orgId: string) => Effect.Effect<Engine[], ApiError | AuthError>;
+  readonly createEngine: (orgId: string, name: string) => Effect.Effect<Engine, ApiError | AuthError>;
+  readonly getMe: Effect.Effect<{
+    id: string;
+    email: string;
+    name: string;
+  }, ApiError | AuthError>;
+  readonly updateMe: (payload: {
+    selfAttribution?: string;
+    usecases?: string[];
+  }) => Effect.Effect<void, ApiError | AuthError>;
+  readonly localize: (params: LocalizeRequest) => Effect.Effect<LocalizeResponse, ApiError | AuthError>;
+}>;
+declare class ApiClient extends ApiClient_base {}
+//#endregion
+//#region src/services/config.d.ts
+type ProjectConfig = {
+  readonly orgId: string;
+  readonly engineId: string;
+};
+declare const ConfigError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "ConfigError";
+} & Readonly<A>;
+declare class ConfigError extends ConfigError_base<{
+  readonly message: string;
+}> {}
+declare const ConfigService_base: Context.TagClass<ConfigService, "ConfigService", {
+  readonly resolve: Effect.Effect<ProjectConfig | null>;
+  readonly store: (config: ProjectConfig) => Effect.Effect<void, ConfigError>;
+  readonly clear: Effect.Effect<void, ConfigError>;
+  readonly resolvedPath: Effect.Effect<string | null>;
+}>;
+declare class ConfigService extends ConfigService_base {}
+declare const ConfigServiceLive: Layer.Layer<ConfigService, never, never>;
+//#endregion
+//#region src/services/telemetry.d.ts
+declare const TelemetryService_base: Context.TagClass<TelemetryService, "TelemetryService", {
+  readonly capture: (event: string, properties?: Record<string, unknown>) => Effect.Effect<void>;
+  readonly identify: (traits?: Record<string, unknown>) => Effect.Effect<void>;
+  readonly shutdown: Effect.Effect<void>;
+}>;
+declare class TelemetryService extends TelemetryService_base {}
+//#endregion
+//#region src/services/supabase.d.ts
+declare const SupabaseError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "SupabaseError";
+} & Readonly<A>;
+declare class SupabaseError extends SupabaseError_base<{
+  readonly cause: unknown;
+  readonly message: string;
+}> {}
+//#endregion
+//#region src/help/renderer.d.ts
+type HelpConfig = {
+  name: string;
+  version: string;
+};
+declare function renderRootHelp(config: HelpConfig, subcommandDescriptors: readonly any[]): string;
+declare function renderCommandHelp(config: HelpConfig, descriptor: any): string;
+//#endregion
+//#region src/cli.d.ts
+declare const subcommands: readonly [Command.Command<"extract", never, effect_Cause0.UnknownException, {
+  readonly check: boolean;
+  readonly src: string;
+  readonly sourceLocale: string;
+  readonly out: string;
+  readonly types: string;
+}>, Command.Command<"localize", ApiClient | ConfigService, effect_Cause0.UnknownException, {
+  readonly sourceLocale: string;
+  readonly targetLocale: string[];
+  readonly out: string;
+  readonly dryRun: boolean;
+}>, Command.Command<"ship", ApiClient | ConfigService, effect_Cause0.UnknownException, {
+  readonly sourceLocale: string;
+  readonly targetLocale: string[];
+  readonly src: string;
+  readonly out: string;
+  readonly json: boolean;
+}>, Command.Command<"status", never, effect_Cause0.UnknownException, {
+  readonly json: boolean;
+  readonly sourceLocale: string;
+  readonly out: string;
+}>, Command.Command<"check", never, effect_Cause0.UnknownException, {
+  readonly json: boolean;
+  readonly src: string;
+  readonly sourceLocale: string;
+  readonly out: string;
+}>, Command.Command<"guide", never, effect_Cause0.UnknownException, {
+  readonly guide: string;
+}>, Command.Command<"install", never, effect_Cause0.UnknownException, {}>, Command.Command<"login", AuthService | TelemetryService, AuthError | effect_Cause0.UnknownException | PromptCancelledError | SupabaseError, {
+  readonly email: effect_Option0.Option<string>;
+  readonly code: effect_Option0.Option<string>;
+  readonly apiKey: effect_Option0.Option<string>;
+}>, Command.Command<"logout", AuthService | TelemetryService, AuthError, {}>, Command.Command<"whoami", AuthService | ApiClient | ConfigService, AuthError, {
+  readonly json: boolean;
+}>, Command.Command<"link", AuthService | ApiClient | ConfigService | TelemetryService, AuthError | effect_Cause0.UnknownException | ApiError | ConfigError | PromptCancelledError, {
+  readonly org: effect_Option0.Option<string>;
+  readonly engine: effect_Option0.Option<string>;
+}>, Command.Command<"unlink", ConfigService | TelemetryService, ConfigError, {}>, Command.Command<"update", TelemetryService | UpdateService, never, {}>, Command.Command<"score", never, never, {
+  readonly source: string;
+  readonly translation: string;
+  readonly reference: effect_Option0.Option<string>;
+  readonly sourceLocale: string;
+  readonly targetLocale: string;
+  readonly scenario: string;
+  readonly outputDir: string;
+  readonly config: effect_Option0.Option<string>;
+}>];
+declare const command: Command.Command<"lingo", AuthService | ApiClient | ConfigService | TelemetryService | UpdateService, AuthError | effect_Cause0.UnknownException | ApiError | ConfigError | PromptCancelledError | SupabaseError, {
+  readonly subcommand: effect_Option0.Option<{
+    readonly check: boolean;
+    readonly src: string;
+    readonly sourceLocale: string;
+    readonly out: string;
+    readonly types: string;
+  } | {
+    readonly sourceLocale: string;
+    readonly targetLocale: string[];
+    readonly out: string;
+    readonly dryRun: boolean;
+  } | {
+    readonly sourceLocale: string;
+    readonly targetLocale: string[];
+    readonly src: string;
+    readonly out: string;
+    readonly json: boolean;
+  } | {
+    readonly json: boolean;
+    readonly sourceLocale: string;
+    readonly out: string;
+  } | {
+    readonly json: boolean;
+    readonly src: string;
+    readonly sourceLocale: string;
+    readonly out: string;
+  } | {
+    readonly guide: string;
+  } | {} | {
+    readonly email: effect_Option0.Option<string>;
+    readonly code: effect_Option0.Option<string>;
+    readonly apiKey: effect_Option0.Option<string>;
+  } | {} | {
+    readonly json: boolean;
+  } | {
+    readonly org: effect_Option0.Option<string>;
+    readonly engine: effect_Option0.Option<string>;
+  } | {} | {} | {
+    readonly source: string;
+    readonly translation: string;
+    readonly reference: effect_Option0.Option<string>;
+    readonly sourceLocale: string;
+    readonly targetLocale: string;
+    readonly scenario: string;
+    readonly outputDir: string;
+    readonly config: effect_Option0.Option<string>;
+  }>;
+}>;
+declare const cliConfig: CliConfig.CliConfig;
+declare const helpConfig: HelpConfig;
+declare const run: (args: ReadonlyArray<string>) => effect_Effect0.Effect<void, AuthError | effect_Cause0.UnknownException | ApiError | ConfigError | PromptCancelledError | SupabaseError | _effect_cli_ValidationError0.ValidationError, AuthService | ApiClient | ConfigService | TelemetryService | UpdateService | _effect_cli_CliApp0.CliApp.Environment>;
+//#endregion
+//#region src/help/descriptor.d.ts
+type CommandInfo = {
+  name: string;
+  description: string;
+};
+type ArgInfo = {
+  name: string;
+  description: string;
+  required: boolean;
+  defaultValue?: string;
+};
+type OptionInfo = {
+  long: string;
+  short?: string;
+  type: string;
+  description: string;
+  required: boolean;
+  defaultValue?: string;
+  repeatable: boolean;
+  isBool: boolean;
+};
+declare function extractCommandInfo(desc: any): CommandInfo;
+declare function collectArgs(node: any): ArgInfo[];
+declare function collectOptions(node: any): OptionInfo[];
+//#endregion
+//#region src/services/prompt.d.ts
+declare const PromptCancelledError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "PromptCancelledError";
+} & Readonly<A>;
+declare class PromptCancelledError extends PromptCancelledError_base<{
+  readonly message: string;
+}> {}
+//#endregion
+//#region src/services/update.d.ts
+type InstallMethod = {
+  readonly type: "npm-global";
+} | {
+  readonly type: "pnpm-global";
+} | {
+  readonly type: "bun-global";
+} | {
+  readonly type: "yarn-global";
+} | {
+  readonly type: "local";
+  readonly pm: "npm" | "pnpm" | "bun" | "yarn";
+} | {
+  readonly type: "npx";
+} | {
+  readonly type: "unknown";
+};
+type UpdateInfo = {
+  readonly current: string;
+  readonly latest: string;
+  readonly isMajor: boolean;
+};
+declare const UpdateError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "UpdateError";
+} & Readonly<A>;
+declare class UpdateError extends UpdateError_base<{
+  readonly message: string;
+}> {}
+declare const UpdateService_base: Context.TagClass<UpdateService, "UpdateService", {
+  readonly check: Effect.Effect<UpdateInfo | null>;
+  readonly execute: (version?: string) => Effect.Effect<void, UpdateError>;
+  readonly installMethod: InstallMethod;
+}>;
+declare class UpdateService extends UpdateService_base {}
+declare const UpdateServiceLive: Layer.Layer<UpdateService, never, never>;
+//#endregion
+//#region src/version.d.ts
+declare const VERSION: string;
+//#endregion
+//#region ../scorer/dist/index.d.ts
+//#region src/types.d.ts
+type ScorerInput = {
+  readonly sourceLocale: string;
+  readonly targetLocale: string;
+  readonly sourceContent: string;
+  readonly targetContent: string;
+  readonly referenceContent: string | undefined;
+};
+type ScorerMeta = {
+  readonly name: string;
+  readonly description: string;
+  readonly version: string;
+};
+type LingoScorer<S extends z.ZodType = z.ZodType> = {
+  readonly meta: ScorerMeta;
+  readonly schema: S;
+  readonly prompt: (input: ScorerInput) => string;
+  readonly postprocess: (input: ScorerInput, output: z.infer<S>) => number;
+};
+type AnyLingoScorer = LingoScorer<any>;
+//#endregion
+//#region src/define-scorer.d.ts
+//#endregion
+//#region src/services/lingo-config.d.ts
+type ScoringModel = {
+  readonly provider: string;
+  readonly model: string;
+};
+type LingoConfig = {
+  readonly scoring: {
+    readonly plugins: readonly AnyLingoScorer[];
+    readonly models: readonly ScoringModel[];
+  };
+};
+declare function defineConfig(config: LingoConfig): LingoConfig;
+//#endregion
+export { type ApiKeyCredentials, type ArgInfo, AuthContext, type AuthCredentials, AuthError, AuthService, AuthServiceLive, type CommandInfo, ConfigError, ConfigService, ConfigServiceLive, type HelpConfig, type InstallMethod, type LingoConfig, type OptionInfo, type ProjectConfig, PromptCancelledError, type ScoringModel, type SessionCredentials, UpdateError, type UpdateInfo, UpdateService, UpdateServiceLive, VERSION, cliConfig, collectArgs, collectOptions, command, defineConfig, extractCommandInfo, helpConfig, renderCommandHelp, renderRootHelp, run, subcommands };

package/dist/index.js

@@ -1,3 +1,8 @@
-import { C as AuthService, S as AuthError, _ as ConfigError, a as extractCommandInfo, c as command, d as subcommands, h as PromptCancelledError, i as collectOptions, l as helpConfig, n as renderRootHelp, r as collectArgs, s as cliConfig, t as renderCommandHelp, u as run, v as ConfigService, w as AuthServiceLive, x as AuthContext, y as ConfigServiceLive } from "./renderer-D2iDOMA6.js";
-import { n as UpdateService, r as UpdateServiceLive, s as VERSION, t as UpdateError } from "./update-RHUBOb93.js";
-export { AuthContext, AuthError, AuthService, AuthServiceLive, ConfigError, ConfigService, ConfigServiceLive, PromptCancelledError, UpdateError, UpdateService, UpdateServiceLive, VERSION, cliConfig, collectArgs, collectOptions, command, extractCommandInfo, helpConfig, renderCommandHelp, renderRootHelp, run, subcommands };
+import { C as AuthService, S as AuthError, _ as ConfigError, a as extractCommandInfo, c as command, d as subcommands, h as PromptCancelledError, i as collectOptions, l as helpConfig, n as renderRootHelp, r as collectArgs, s as cliConfig, t as renderCommandHelp, u as run, v as ConfigService, w as AuthServiceLive, x as AuthContext, y as ConfigServiceLive } from "./renderer.js";
+import { n as UpdateService, r as UpdateServiceLive, s as VERSION, t as UpdateError } from "./update.js";
+//#region src/services/lingo-config.ts
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+export { AuthContext, AuthError, AuthService, AuthServiceLive, ConfigError, ConfigService, ConfigServiceLive, PromptCancelledError, UpdateError, UpdateService, UpdateServiceLive, VERSION, cliConfig, collectArgs, collectOptions, command, defineConfig, extractCommandInfo, helpConfig, renderCommandHelp, renderRootHelp, run, subcommands };

package/dist/{renderer-D2iDOMA6.js → renderer.js}

@@ -1,4 +1,4 @@
-import { C as discoverLocales, S as writeLocaleFile, T as tryReadFile, _ as runExtractionPipeline, b as mergeEntries, c as formatCheckResult, d as computeSourceStatus, f as formatStatusTable, g as generateTypes, h as toApiPayload, l as runChecks, m as planLocalization, n as UpdateService, p as applyTranslations, s as VERSION, t as UpdateError, u as computeLocaleStatus, v as toLocaleEntries, w as findSourceFiles, x as readLocaleFile, y as getActiveEntries } from "./update-RHUBOb93.js";
+import { C as discoverLocales, S as writeLocaleFile, T as tryReadFile, _ as runExtractionPipeline, b as mergeEntries, c as formatCheckResult, d as computeSourceStatus, f as formatStatusTable, g as generateTypes, h as toApiPayload, l as runChecks, m as planLocalization, n as UpdateService, p as applyTranslations, s as VERSION, t as UpdateError, u as computeLocaleStatus, v as toLocaleEntries, w as findSourceFiles, x as readLocaleFile, y as getActiveEntries } from "./update.js";
 import { Args, CliConfig, Command, Options } from "@effect/cli";
 import { Console, Context, Data, Effect, Layer, Option, pipe } from "effect";
 import pc from "picocolors";
@@ -14,6 +14,8 @@ import { spawn } from "node:child_process";
 import * as ci from "ci-info";
 import * as crypto from "node:crypto";
 import { fileURLToPath } from "node:url";
+import { Output, generateText } from "ai";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 //#region src/services/cli-options.ts
 /**
 * Shared CLI option definitions used across extract, localize, status, and ship commands.
@@ -1293,6 +1295,145 @@ const updateCommand = Command.make("update", {}, () => Effect.gen(function* () {
 	});
 })).pipe(Command.withDescription("Update the CLI to the latest version"));
 //#endregion
+//#region src/services/lingo-config-loader.ts
+const CONFIG_FILENAME = "lingo.config.ts";
+function findConfigFile(startDir) {
+	let dir = path.resolve(startDir);
+	const root = path.parse(dir).root;
+	while (true) {
+		const candidate = path.join(dir, CONFIG_FILENAME);
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir || dir === root) return null;
+		dir = parent;
+	}
+}
+function validate(value) {
+	if (!value || typeof value !== "object") throw new Error(`Invalid lingo config: expected an object, got ${typeof value}`);
+	const config = value;
+	if (!config.scoring || typeof config.scoring !== "object") throw new Error("Invalid lingo config: missing 'scoring' section");
+	const scoring = config.scoring;
+	if (!Array.isArray(scoring.plugins)) throw new Error("Invalid lingo config: 'scoring.plugins' must be an array");
+	for (const [i, plugin] of scoring.plugins.entries()) {
+		if (!plugin || typeof plugin !== "object") throw new Error(`Invalid lingo config: scoring.plugins[${i}] is not an object`);
+		const p = plugin;
+		if (!p.meta || typeof p.meta !== "object") throw new Error(`Invalid lingo config: scoring.plugins[${i}] is missing 'meta'`);
+		if (typeof p.prompt !== "function") throw new Error(`Invalid lingo config: scoring.plugins[${i}] is missing 'prompt' function`);
+		if (typeof p.postprocess !== "function") throw new Error(`Invalid lingo config: scoring.plugins[${i}] is missing 'postprocess' function`);
+		if (!p.schema) throw new Error(`Invalid lingo config: scoring.plugins[${i}] is missing 'schema'`);
+	}
+	if (!Array.isArray(scoring.models)) throw new Error("Invalid lingo config: 'scoring.models' must be an array");
+	for (const [i, model] of scoring.models.entries()) {
+		if (!model || typeof model !== "object") throw new Error(`Invalid lingo config: scoring.models[${i}] is not an object`);
+		const m = model;
+		if (typeof m.provider !== "string" || !m.provider) throw new Error(`Invalid lingo config: scoring.models[${i}] is missing 'provider'`);
+		if (typeof m.model !== "string" || !m.model) throw new Error(`Invalid lingo config: scoring.models[${i}] is missing 'model'`);
+	}
+	return value;
+}
+async function loadLingoConfig(configPath) {
+	const resolved = configPath ? path.resolve(configPath) : findConfigFile(process.cwd());
+	if (!resolved) throw new Error(`Could not find ${CONFIG_FILENAME}. Create one or pass --config.`);
+	if (!fs.existsSync(resolved)) throw new Error(`Config file not found: ${resolved}`);
+	const { createJiti } = await import("jiti");
+	const raw = await createJiti(resolved, { interopDefault: true }).import(resolved);
+	return validate(raw.default ?? raw);
+}
+//#endregion
+//#region src/services/scorer-runner.ts
+async function runScorer(scorer, input, model) {
+	const apiKey = process.env.OPENROUTER_API_KEY;
+	if (!apiKey) throw new Error("OPENROUTER_API_KEY environment variable is required for scoring.");
+	const openrouter = createOpenRouter({ apiKey });
+	const slug = `${model.provider}/${model.model}`;
+	const systemPrompt = scorer.prompt(input);
+	const result = await generateText({
+		model: openrouter(slug),
+		output: Output.object({ schema: scorer.schema }),
+		system: systemPrompt,
+		prompt: "Evaluate the translation."
+	});
+	const score = scorer.postprocess(input, result.output);
+	return {
+		scorer: scorer.meta.name,
+		providerId: model.provider,
+		modelId: model.model,
+		score,
+		details: result.output
+	};
+}
+//#endregion
+//#region src/commands/score.ts
+const source = Options.text("source").pipe(Options.withDescription("Path to source markdown file"));
+const translation = Options.text("translation").pipe(Options.withDescription("Path to translated markdown file"));
+const reference = pipe(Options.text("reference"), Options.withDescription("Path to human reference markdown file"), Options.optional);
+const sourceLocale = Options.text("source-locale").pipe(Options.withDescription("Source locale code (e.g. en)"));
+const targetLocale = Options.text("target-locale").pipe(Options.withDescription("Target locale code (e.g. de)"));
+const scenario = Options.text("scenario").pipe(Options.withDescription("Scenario name, used as output filename (e.g. mistral-raw-en-de)"));
+const outputDir = Options.text("output-dir").pipe(Options.withDescription("Directory for results JSON"), Options.withDefault("./scenarios"));
+const configPath = pipe(Options.text("config"), Options.withDescription("Path to lingo.config.ts"), Options.optional);
+const scoreCommand = Command.make("score", {
+	source,
+	translation,
+	reference,
+	sourceLocale,
+	targetLocale,
+	scenario,
+	outputDir,
+	config: configPath
+}, (opts) => Effect.gen(function* () {
+	const configFlag = Option.getOrUndefined(opts.config);
+	const { plugins, models } = (yield* Effect.promise(() => loadLingoConfig(configFlag))).scoring;
+	yield* Console.log(`Scoring with ${plugins.length} plugin(s) x ${models.length} model(s)`);
+	const sourceContent = yield* Effect.promise(() => fs$1.readFile(path.resolve(opts.source), "utf-8"));
+	const translationContent = yield* Effect.promise(() => fs$1.readFile(path.resolve(opts.translation), "utf-8"));
+	const referenceFlag = Option.getOrUndefined(opts.reference);
+	const referenceContent = referenceFlag ? yield* Effect.promise(() => fs$1.readFile(path.resolve(referenceFlag), "utf-8")) : void 0;
+	const input = {
+		sourceLocale: opts.sourceLocale,
+		targetLocale: opts.targetLocale,
+		sourceContent,
+		targetContent: translationContent,
+		referenceContent
+	};
+	const dir = path.resolve(opts.outputDir);
+	const outPath = path.join(dir, `${opts.scenario}.json`);
+	let existingResults = [];
+	const existingRaw = yield* Effect.promise(() => fs$1.readFile(outPath, "utf-8").catch(() => null));
+	if (existingRaw) try {
+		existingResults = JSON.parse(existingRaw).results ?? [];
+	} catch {}
+	const results = [...existingResults];
+	let skipped = 0;
+	for (const plugin of plugins) for (const model of models) {
+		const modelId = `${model.provider}/${model.model}`;
+		if (existingResults.some((r) => r.scorer === plugin.meta.name && r.providerId === model.provider && r.modelId === model.model)) {
+			skipped++;
+			continue;
+		}
+		yield* Console.log(`  ${plugin.meta.name} x ${modelId}...`);
+		const result = yield* Effect.promise(() => runScorer(plugin, input, model).catch((e) => {
+			process.stderr.write(`    ERROR: ${e.message}\n`);
+			throw e;
+		}));
+		yield* Console.log(`    score: ${result.score.toFixed(4)}`);
+		results.push(result);
+	}
+	if (skipped > 0) yield* Console.log(`  (skipped ${skipped} already-scored combo${skipped > 1 ? "s" : ""})`);
+	const payload = {
+		scenario: opts.scenario,
+		sourceLocale: opts.sourceLocale,
+		targetLocale: opts.targetLocale,
+		source: opts.source,
+		translation: opts.translation,
+		reference: referenceFlag ?? null,
+		results
+	};
+	yield* Effect.promise(() => fs$1.mkdir(dir, { recursive: true }));
+	yield* Effect.promise(() => fs$1.writeFile(outPath, JSON.stringify(payload, null, 2) + "\n"));
+	yield* Console.log(`\nResults written to ${outPath}`);
+})).pipe(Command.withDescription("Score a translation using configured scorer plugins"));
+//#endregion
 //#region src/cli.ts
 const subcommands = [
 	extractCommand,
@@ -1307,7 +1448,8 @@ const subcommands = [
 	whoamiCommand,
 	linkCommand,
 	unlinkCommand,
-	updateCommand
+	updateCommand,
+	scoreCommand
 ];
 const command = Command.make("lingo").pipe(Command.withDescription(TAGLINE), Command.withSubcommands([
 	extractCommand,
@@ -1322,7 +1464,8 @@ const command = Command.make("lingo").pipe(Command.withDescription(TAGLINE), Com
 	whoamiCommand,
 	linkCommand,
 	unlinkCommand,
-	updateCommand
+	updateCommand,
+	scoreCommand
 ]));
 const cliConfig = CliConfig.make({
 	showBuiltIns: false,
@@ -1515,9 +1658,10 @@ function renderCommandHelp(config, descriptor) {
 		for (let i = 0; i < opts.length; i++) {
 			const sig = signatures[i];
 			const pad = " ".repeat(maxLen - stripAnsi(sig).length);
-			const parts = [opts[i].description];
-			if (opts[i].defaultValue !== void 0) parts.push(pc.dim(`[default: ${opts[i].defaultValue}]`));
-			if (opts[i].repeatable) parts.push(pc.dim("(repeatable)"));
+			const opt = opts[i];
+			const parts = [opt.description];
+			if (opt.defaultValue !== void 0) parts.push(pc.dim(`[default: ${opt.defaultValue}]`));
+			if (opt.repeatable) parts.push(pc.dim("(repeatable)"));
 			lines.push(`  ${sig}${pad}  ${parts.filter(Boolean).join(" ")}`);
 		}
 	}

package/dist/{server-DGIsMSAq.js → server.js}

@@ -1,4 +1,4 @@
-import { C as discoverLocales, S as writeLocaleFile, T as tryReadFile, _ as runExtractionPipeline, a as detectInstallMethod, b as mergeEntries, d as computeSourceStatus, g as generateTypes, h as toApiPayload, i as compareVersions, l as runChecks, m as planLocalization, o as generateUpdateCommand, p as applyTranslations, s as VERSION, u as computeLocaleStatus, v as toLocaleEntries, w as findSourceFiles } from "./update-RHUBOb93.js";
+import { C as discoverLocales, S as writeLocaleFile, T as tryReadFile, _ as runExtractionPipeline, a as detectInstallMethod, b as mergeEntries, d as computeSourceStatus, g as generateTypes, h as toApiPayload, i as compareVersions, l as runChecks, m as planLocalization, o as generateUpdateCommand, p as applyTranslations, s as VERSION, u as computeLocaleStatus, v as toLocaleEntries, w as findSourceFiles } from "./update.js";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { computeKey, getActiveEntries, readLocaleFile } from "@lingo.dev/spec";

package/guides/api.md

@@ -1,9 +1,11 @@
 # API Reference – @lingo.dev/react
 
 ## Hooks
+
 - `useLingo()` → returns Lingo with translation + formatting helpers.
 
 ## Translation helpers (context required)
+
 ```tsx
 l.text(source, { context, values? })
 l.rich(source, { context, tags?, values? })
@@ -12,43 +14,52 @@ l.select(value, { ...forms, other }, { context })
 ```
 
 Examples:
+
 ```tsx
-l.text("Save", { context: "Form submit button" })
-l.text("Hello, {name}!", { context: "Dashboard welcome", values: { name } })
-l.rich("Read <link>docs</link>", { context: "Footer link", tags: { link: c => <a href="/docs">{c}</a> } })
-l.plural(items, { one: "# item", other: "# items" }, { context: "Cart count" })
-l.select(role, { admin: "Admin", user: "User", other: "Guest" }, { context: "Nav label" })
+l.text("Save", { context: "Form submit button" });
+l.text("Hello, {name}!", { context: "Dashboard welcome", values: { name } });
+l.rich("Read <link>docs</link>", { context: "Footer link", tags: { link: (c) => <a href="/docs">{c}</a> } });
+l.plural(items, { one: "# item", other: "# items" }, { context: "Cart count" });
+l.select(role, { admin: "Admin", user: "User", other: "Guest" }, { context: "Nav label" });
 ```
 
 Context rules:
-1) Always required on text/rich/plural/select.
-2) Describes where/how the string is used ("Checkout CTA", "Toast error").
-3) Same source + different context = different translation key.
+
+1. Always required on text/rich/plural/select.
+2. Describes where/how the string is used ("Checkout CTA", "Toast error").
+3. Same source + different context = different translation key.
 
 ## Formatting helpers (no context needed)
+
 ```tsx
-l.num(1234567)            // "1,234,567"
-l.currency(29.99, "USD") // "$29.99"
-l.percent(0.156)         // "16%"
-l.date(new Date())        // locale date
-l.time(new Date())        // locale time
-l.relative(-1, "day")    // "yesterday"
-l.list(["A","B","C"]) // "A, B, and C"
+l.num(1234567); // "1,234,567"
+l.currency(29.99, "USD"); // "$29.99"
+l.percent(0.156); // "16%"
+l.date(new Date()); // locale date
+l.time(new Date()); // locale time
+l.relative(-1, "day"); // "yesterday"
+l.list(["A", "B", "C"]); // "A, B, and C"
 ```
 
 ## Components / HOCs (Next.js Pages Router)
-- `withLingoApp(App)` → wraps _app.tsx; sets dir for RTL; warns if page missing withLingoProps.
+
+- `withLingoApp(App)` → wraps \_app.tsx; sets dir for RTL; warns if page missing withLingoProps.
 - `withLingoProps({ route, handler? })` → load route-specific messages in getStaticProps/SSR.
 - `withLingoPaths(handler)` → expands getStaticPaths across locales (fallback: "blocking").
 - `useLocaleSwitch()` → sets NEXT_LOCALE cookie + router.push with locale.
 - `LingoHead` → hreflang SEO tags.
 
 ## Files generated by CLI
+
 - `locales/<locale>.jsonc` – source/translated messages with @context + @src metadata.
 - `lingo.d.ts` – TypeScript augmentation with exact context unions and required values.
 
 ## Required patterns
+
 - Every page using translations must export withLingoProps({ route }).
 - Every translation call must include context.
 - Always run `npx @lingo.dev/cli check` before finishing.
+
+```
+
 ```

package/guides/index.md

@@ -3,6 +3,7 @@
 Use `npx @lingo.dev/cli guide <name>` to view a guide.
 
 Available guides:
+
 - `setup` – first-time setup for @lingo.dev/react (Next.js Pages Router focus, works for React too)
 - `api` – API reference for `l.text`, `l.rich`, `l.plural`, `l.select`, formatting helpers
 - `migrate` – migrate from next-intl, react-intl, i18next, lingui to @lingo.dev/react

package/guides/migrate.md

@@ -1,34 +1,41 @@
 # Migration Guide – to @lingo.dev/react
 
 ## Key differences
+
 - No manual keys. Use source text + required context: `l.text("Save", { context: "Form button" })`.
 - Automatic hash keys; per-route splitting via withLingoProps({ route }).
 - TypeScript enforces context and required values after `lingo extract`.
 
 ## API mapping
-| Pattern          | next-intl                  | react-intl                      | i18next                   | @lingo.dev/react                                    |
-|------------------|----------------------------|---------------------------------|---------------------------|------------------------------------------------------|
-| Plain text       | `t("key")`               | `formatMessage({ id })`         | `t("key")`              | `l.text("source", { context: "..." })`            |
-| With values      | `t("key", { name })`     | `formatMessage({ id }, { name })`| `t("key", { name })`   | `l.text("Hello, {name}", { context: "...", values: { name } })` |
-| Rich text        | `t.rich("key", { link })`| `<FormattedMessage components>`  | `<Trans components>`     | `l.rich("Click <link>here</link>", { context: "...", tags: { link } })` |
-| Plurals          | ICU in JSON               | `<FormattedPlural>`             | ICU in JSON              | `l.plural(count, { one: "# item", other: "# items" }, { context: "..." })` |
-| Provider         | `NextIntlProvider`        | `IntlProvider`                  | `I18nextProvider`        | `withLingoApp` (wraps LingoProvider)                 |
-| Hook             | `useTranslations()`       | `useIntl()`                     | `useTranslation()`       | `useLingo()`                                        |
+
+| Pattern     | next-intl                 | react-intl                        | i18next              | @lingo.dev/react                                                           |
+| ----------- | ------------------------- | --------------------------------- | -------------------- | -------------------------------------------------------------------------- |
+| Plain text  | `t("key")`                | `formatMessage({ id })`           | `t("key")`           | `l.text("source", { context: "..." })`                                     |
+| With values | `t("key", { name })`      | `formatMessage({ id }, { name })` | `t("key", { name })` | `l.text("Hello, {name}", { context: "...", values: { name } })`            |
+| Rich text   | `t.rich("key", { link })` | `<FormattedMessage components>`   | `<Trans components>` | `l.rich("Click <link>here</link>", { context: "...", tags: { link } })`    |
+| Plurals     | ICU in JSON               | `<FormattedPlural>`               | ICU in JSON          | `l.plural(count, { one: "# item", other: "# items" }, { context: "..." })` |
+| Provider    | `NextIntlProvider`        | `IntlProvider`                    | `I18nextProvider`    | `withLingoApp` (wraps LingoProvider)                                       |
+| Hook        | `useTranslations()`       | `useIntl()`                       | `useTranslation()`   | `useLingo()`                                                               |
 
 ## Steps
-1) Install @lingo.dev/react (and @lingo.dev/react-next for Next.js). Keep old lib temporarily.
-2) Wrap root with withLingoApp (and keep old provider during migration if needed).
-3) Per file:
+
+1. Install @lingo.dev/react (and @lingo.dev/react-next for Next.js). Keep old lib temporarily.
+2. Wrap root with withLingoApp (and keep old provider during migration if needed).
+3. Per file:
    - Replace old hook with `useLingo()`.
    - Replace calls using mapping above.
    - Add `withLingoProps({ route })` to every page using translations.
-4) Run `npx @lingo.dev/cli extract`.
-5) Run `npx @lingo.dev/cli localize --target-locale <locale>`.
-6) Run `npx @lingo.dev/cli check` (expect 0 issues).
-7) Remove old provider, message files, and dependencies once all pages migrated.
+4. Run `npx @lingo.dev/cli extract`.
+5. Run `npx @lingo.dev/cli localize --target-locale <locale>`.
+6. Run `npx @lingo.dev/cli check` (expect 0 issues).
+7. Remove old provider, message files, and dependencies once all pages migrated.
 
 ## Gotchas
+
 - Old JSON translation files can’t be reused directly (keys differ). Re-translate via `localize`.
 - Keep contexts specific (e.g., "Toolbar Save", "Form Save").
 - Dynamic routes still need withLingoPaths for locale expansion.
+
+```
+
 ```

package/guides/setup.md

@@ -3,14 +3,18 @@
 Philosophy: the agent writes i18n code; context is required on every call; route is required on every page loader. Finish with `npx @lingo.dev/cli check`.
 
 ## 1) Install packages
+
 Detect package manager from lockfile. Example (pnpm):
+
 ```bash
 pnpm add @lingo.dev/react @lingo.dev/react-next
 pnpm add -D @lingo.dev/cli
 ```
 
 ## 2) Configure Next.js i18n
+
 `next.config.ts`
+
 ```ts
 import type { NextConfig } from "next";
 
@@ -24,7 +28,8 @@ const nextConfig: NextConfig = {
 export default nextConfig;
 ```
 
-## 3) Wrap _app.tsx
+## 3) Wrap \_app.tsx
+
 ```tsx
 // pages/_app.tsx
 import type { AppProps } from "next/app";
@@ -39,24 +44,30 @@ export default withLingoApp(function App({ Component, pageProps }: AppProps) {
   );
 });
 ```
+
 - withLingoApp wires LingoProvider, sets dir for RTL, warns if a page lacks withLingoProps.
 - LingoHead adds hreflang tags.
 
 ## 4) Add withLingoProps to every page
+
 Route = file path without extension (relative to repo root).
+
 ```tsx
 import { withLingoProps } from "@lingo.dev/react-next/pages/server";
 export const getStaticProps = withLingoProps({ route: "src/pages/index" });
 ```
+
 Dynamic routes also add withLingoPaths:
+
 ```tsx
 import { withLingoPaths } from "@lingo.dev/react-next/pages/server";
 export const getStaticPaths = withLingoPaths(async () =>
-  getPosts().then((posts) => posts.map((p) => ({ params: { slug: p.slug } })))
+  getPosts().then((posts) => posts.map((p) => ({ params: { slug: p.slug } }))),
 );
 ```
 
 ## 5) Wrap strings with useLingo
+
 ```tsx
 import { useLingo } from "@lingo.dev/react";
 
@@ -65,9 +76,11 @@ const l = useLingo();
 <p>{l.text("The best tool for teams.", { context: "Hero subheading" })}</p>
 <button>{l.text("Get started", { context: "Hero CTA" })}</button>
 ```
+
 Context is REQUIRED on l.text/l.rich/l.plural/l.select.
 
 ### API cheatsheet
+
 - `l.text(source, { context, values? })`
 - `l.rich(source, { context, tags?, values? })`
 - `l.plural(count, forms, { context })`
@@ -75,6 +88,7 @@ Context is REQUIRED on l.text/l.rich/l.plural/l.select.
 - Formatting: `l.num`, `l.currency`, `l.percent`, `l.date`, `l.time`, `l.relative`, `l.list`
 
 ## 6) Locale switcher
+
 ```tsx
 import { useLocaleSwitch } from "@lingo.dev/react-next/pages/client";
 import { useRouter } from "next/router";
@@ -82,30 +96,42 @@ import { useRouter } from "next/router";
 const switchLocale = useLocaleSwitch();
 const { locale, locales } = useRouter();
 <select value={locale} onChange={(e) => switchLocale(e.target.value)}>
-  {locales?.map((loc) => <option key={loc}>{loc}</option>)}
-</select>
+  {locales?.map((loc) => (
+    <option key={loc}>{loc}</option>
+  ))}
+</select>;
 ```
 
 ## 7) Extract
+
 ```bash
 npx @lingo.dev/cli extract   # or pnpm lingo extract
 ```
+
 Generates `locales/en.jsonc` + `lingo.d.ts`. After this, TS enforces context + values.
 
 ## 8) Translate
+
 ```bash
 npx @lingo.dev/cli localize --target-locale es
 ```
+
 Writes `locales/es.jsonc`.
 
 ## 9) Verify
+
 ```bash
 npx @lingo.dev/cli check
 ```
+
 0 issues = done.
 
 ## Rules to remember
+
 - Context required on every translation call.
 - Route required on every withLingoProps.
 - Always finish with `npx @lingo.dev/cli check`.
+
+```
+
 ```

package/package.json

@@ -1,19 +1,26 @@
 {
   "name": "@lingo.dev/cli",
-  "version": "1.0.3",
-  "type": "module",
+  "version": "1.1.0",
   "bin": {
     "lingo": "./dist/bin.js"
   },
-  "main": "./dist/index.js",
-  "exports": {
-    ".": "./dist/index.js"
-  },
   "files": [
     "dist",
     "skills",
     "guides"
   ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "typescript": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.76",
     "@babel/parser": "^7.29.0",
@@ -23,23 +30,28 @@
     "@effect/platform": "^0.94.1",
     "@effect/platform-node": "^0.104.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "@openrouter/ai-sdk-provider": "^2.5.0",
     "@supabase/supabase-js": "^2.99.1",
+    "ai": "^6.0.152",
     "cfonts": "^3.3.1",
     "ci-info": "^4.4.0",
     "effect": "^3.19.0",
+    "jiti": "^2.6.1",
     "jsonc-parser": "^3.3.1",
     "log-update": "^7.2.0",
     "picocolors": "^1.1.1",
     "posthog-node": "^5.28.2",
     "semver": "^7.7.4",
     "zod": "^4.0.0",
-    "@lingo.dev/spec": "1.0.3"
+    "@lingo.dev/scorer": "0.0.1",
+    "@lingo.dev/spec": "1.1.0"
   },
   "devDependencies": {
     "@babel/types": "^7.29.0",
     "@types/babel__traverse": "^7.28.0",
     "@types/node": "^25.5.0",
     "@types/semver": "^7.7.1",
+    "@typescript/native-preview": "7.0.0-dev.20260330.1",
     "tsdown": "^0.12.5",
     "tsx": "^4.19.0",
     "typescript": "^5.8.2",
@@ -47,8 +59,8 @@
   },
   "scripts": {
     "build": "tsdown",
-    "typecheck": "tsc --noEmit",
+    "cli": "node --import tsx/esm src/bin.ts",
     "test": "vitest run",
-    "cli": "node --import tsx/esm src/bin.ts"
+    "typecheck": "tsgo"
   }
 }

package/skills/lingo/SKILL.md

@@ -8,4 +8,4 @@ user-invocable: true
 argument-hint: "[add <locale>, migrate from <library>, or blank]"
 ---
 
-Run `npx @lingo.dev/cli guide` to read the guides (setup, api, migrate).
+Run `npx @lingo.dev/cli guide` to read the guides (setup, api, migrate).