ai-localize-config 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import { LocalizationConfig } from '@ai-localize/shared';
+
+declare const LocalizationConfigSchema: z.ZodObject<{
+    framework: z.ZodDefault<z.ZodEnum<["react", "react-cra", "react-vite", "react-nextjs", "angular", "angular-ngx", "angular-i18n", "vue", "vue-i18n", "jquery", "vanilla-js", "jsp", "unknown"]>>;
+    defaultLanguage: z.ZodDefault<z.ZodString>;
+    targetLanguages: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sourceDir: z.ZodDefault<z.ZodString>;
+    localesDir: z.ZodDefault<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+    namespaces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignorePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    incrementalCache: z.ZodDefault<z.ZodBoolean>;
+    cacheDir: z.ZodDefault<z.ZodString>;
+    aws: z.ZodOptional<z.ZodObject<{
+        region: z.ZodDefault<z.ZodString>;
+        bucket: z.ZodString;
+        distributionId: z.ZodString;
+        cdnBaseUrl: z.ZodOptional<z.ZodString>;
+        legacyCdnPattern: z.ZodOptional<z.ZodString>;
+        assetsPrefix: z.ZodDefault<z.ZodString>;
+        profile: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        region: string;
+        bucket: string;
+        distributionId: string;
+        assetsPrefix: string;
+        cdnBaseUrl?: string | undefined;
+        legacyCdnPattern?: string | undefined;
+        profile?: string | undefined;
+    }, {
+        bucket: string;
+        distributionId: string;
+        region?: string | undefined;
+        cdnBaseUrl?: string | undefined;
+        legacyCdnPattern?: string | undefined;
+        assetsPrefix?: string | undefined;
+        profile?: string | undefined;
+    }>>;
+    plugins: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    framework: "react" | "react-cra" | "react-vite" | "react-nextjs" | "angular" | "angular-ngx" | "angular-i18n" | "vue" | "vue-i18n" | "jquery" | "vanilla-js" | "jsp" | "unknown";
+    defaultLanguage: string;
+    targetLanguages: string[];
+    sourceDir: string;
+    localesDir: string;
+    ignorePatterns: string[];
+    incrementalCache: boolean;
+    cacheDir: string;
+    plugins: string[];
+    keyPrefix?: string | undefined;
+    namespaces?: string[] | undefined;
+    aws?: {
+        region: string;
+        bucket: string;
+        distributionId: string;
+        assetsPrefix: string;
+        cdnBaseUrl?: string | undefined;
+        legacyCdnPattern?: string | undefined;
+        profile?: string | undefined;
+    } | undefined;
+}, {
+    framework?: "react" | "react-cra" | "react-vite" | "react-nextjs" | "angular" | "angular-ngx" | "angular-i18n" | "vue" | "vue-i18n" | "jquery" | "vanilla-js" | "jsp" | "unknown" | undefined;
+    defaultLanguage?: string | undefined;
+    targetLanguages?: string[] | undefined;
+    sourceDir?: string | undefined;
+    localesDir?: string | undefined;
+    keyPrefix?: string | undefined;
+    namespaces?: string[] | undefined;
+    ignorePatterns?: string[] | undefined;
+    incrementalCache?: boolean | undefined;
+    cacheDir?: string | undefined;
+    aws?: {
+        bucket: string;
+        distributionId: string;
+        region?: string | undefined;
+        cdnBaseUrl?: string | undefined;
+        legacyCdnPattern?: string | undefined;
+        assetsPrefix?: string | undefined;
+        profile?: string | undefined;
+    } | undefined;
+    plugins?: string[] | undefined;
+}>;
+type LocalizationConfigInput = z.input<typeof LocalizationConfigSchema>;
+type LocalizationConfigOutput = z.output<typeof LocalizationConfigSchema>;
+
+interface ConfigLoadResult {
+    config: LocalizationConfig;
+    filePath: string | null;
+}
+/**
+ * Loads and validates the ai-localize configuration.
+ * Searches for config in standard locations using cosmiconfig.
+ */
+declare function loadConfig(cwd?: string, overrides?: Partial<LocalizationConfig>): Promise<ConfigLoadResult>;
+/**
+ * Writes a default config file to the project root.
+ */
+declare function writeDefaultConfig(cwd?: string, framework?: string): string;
+/** Validate an existing config file */
+declare function validateConfig(configPath: string): {
+    valid: boolean;
+    errors: string[];
+};
+
+export { type ConfigLoadResult, type LocalizationConfigInput, type LocalizationConfigOutput, LocalizationConfigSchema, loadConfig, validateConfig, writeDefaultConfig };

package/dist/index.d.ts

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import { LocalizationConfig } from '@ai-localize/shared';
+
+declare const LocalizationConfigSchema: z.ZodObject<{
+    framework: z.ZodDefault<z.ZodEnum<["react", "react-cra", "react-vite", "react-nextjs", "angular", "angular-ngx", "angular-i18n", "vue", "vue-i18n", "jquery", "vanilla-js", "jsp", "unknown"]>>;
+    defaultLanguage: z.ZodDefault<z.ZodString>;
+    targetLanguages: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sourceDir: z.ZodDefault<z.ZodString>;
+    localesDir: z.ZodDefault<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+    namespaces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignorePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    incrementalCache: z.ZodDefault<z.ZodBoolean>;
+    cacheDir: z.ZodDefault<z.ZodString>;
+    aws: z.ZodOptional<z.ZodObject<{
+        region: z.ZodDefault<z.ZodString>;
+        bucket: z.ZodString;
+        distributionId: z.ZodString;
+        cdnBaseUrl: z.ZodOptional<z.ZodString>;
+        legacyCdnPattern: z.ZodOptional<z.ZodString>;
+        assetsPrefix: z.ZodDefault<z.ZodString>;
+        profile: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        region: string;
+        bucket: string;
+        distributionId: string;
+        assetsPrefix: string;
+        cdnBaseUrl?: string | undefined;
+        legacyCdnPattern?: string | undefined;
+        profile?: string | undefined;
+    }, {
+        bucket: string;
+        distributionId: string;
+        region?: string | undefined;
+        cdnBaseUrl?: string | undefined;
+        legacyCdnPattern?: string | undefined;
+        assetsPrefix?: string | undefined;
+        profile?: string | undefined;
+    }>>;
+    plugins: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    framework: "react" | "react-cra" | "react-vite" | "react-nextjs" | "angular" | "angular-ngx" | "angular-i18n" | "vue" | "vue-i18n" | "jquery" | "vanilla-js" | "jsp" | "unknown";
+    defaultLanguage: string;
+    targetLanguages: string[];
+    sourceDir: string;
+    localesDir: string;
+    ignorePatterns: string[];
+    incrementalCache: boolean;
+    cacheDir: string;
+    plugins: string[];
+    keyPrefix?: string | undefined;
+    namespaces?: string[] | undefined;
+    aws?: {
+        region: string;
+        bucket: string;
+        distributionId: string;
+        assetsPrefix: string;
+        cdnBaseUrl?: string | undefined;
+        legacyCdnPattern?: string | undefined;
+        profile?: string | undefined;
+    } | undefined;
+}, {
+    framework?: "react" | "react-cra" | "react-vite" | "react-nextjs" | "angular" | "angular-ngx" | "angular-i18n" | "vue" | "vue-i18n" | "jquery" | "vanilla-js" | "jsp" | "unknown" | undefined;
+    defaultLanguage?: string | undefined;
+    targetLanguages?: string[] | undefined;
+    sourceDir?: string | undefined;
+    localesDir?: string | undefined;
+    keyPrefix?: string | undefined;
+    namespaces?: string[] | undefined;
+    ignorePatterns?: string[] | undefined;
+    incrementalCache?: boolean | undefined;
+    cacheDir?: string | undefined;
+    aws?: {
+        bucket: string;
+        distributionId: string;
+        region?: string | undefined;
+        cdnBaseUrl?: string | undefined;
+        legacyCdnPattern?: string | undefined;
+        assetsPrefix?: string | undefined;
+        profile?: string | undefined;
+    } | undefined;
+    plugins?: string[] | undefined;
+}>;
+type LocalizationConfigInput = z.input<typeof LocalizationConfigSchema>;
+type LocalizationConfigOutput = z.output<typeof LocalizationConfigSchema>;
+
+interface ConfigLoadResult {
+    config: LocalizationConfig;
+    filePath: string | null;
+}
+/**
+ * Loads and validates the ai-localize configuration.
+ * Searches for config in standard locations using cosmiconfig.
+ */
+declare function loadConfig(cwd?: string, overrides?: Partial<LocalizationConfig>): Promise<ConfigLoadResult>;
+/**
+ * Writes a default config file to the project root.
+ */
+declare function writeDefaultConfig(cwd?: string, framework?: string): string;
+/** Validate an existing config file */
+declare function validateConfig(configPath: string): {
+    valid: boolean;
+    errors: string[];
+};
+
+export { type ConfigLoadResult, type LocalizationConfigInput, type LocalizationConfigOutput, LocalizationConfigSchema, loadConfig, validateConfig, writeDefaultConfig };

package/dist/index.js

@@ -0,0 +1,186 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LocalizationConfigSchema: () => LocalizationConfigSchema,
+  loadConfig: () => loadConfig,
+  validateConfig: () => validateConfig,
+  writeDefaultConfig: () => writeDefaultConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schema.ts
+var import_zod = require("zod");
+var AwsConfigSchema = import_zod.z.object({
+  region: import_zod.z.string().default("us-east-1"),
+  bucket: import_zod.z.string().min(1, "S3 bucket name is required"),
+  distributionId: import_zod.z.string().min(1, "CloudFront distribution ID is required"),
+  cdnBaseUrl: import_zod.z.string().url().optional(),
+  legacyCdnPattern: import_zod.z.string().optional(),
+  assetsPrefix: import_zod.z.string().default("assets"),
+  profile: import_zod.z.string().optional()
+});
+var FrameworkSchema = import_zod.z.enum([
+  "react",
+  "react-cra",
+  "react-vite",
+  "react-nextjs",
+  "angular",
+  "angular-ngx",
+  "angular-i18n",
+  "vue",
+  "vue-i18n",
+  "jquery",
+  "vanilla-js",
+  "jsp",
+  "unknown"
+]);
+var LocalizationConfigSchema = import_zod.z.object({
+  framework: FrameworkSchema.default("unknown"),
+  defaultLanguage: import_zod.z.string().default("en"),
+  targetLanguages: import_zod.z.array(import_zod.z.string()).default([]),
+  sourceDir: import_zod.z.string().default("src"),
+  localesDir: import_zod.z.string().default("locales"),
+  keyPrefix: import_zod.z.string().optional(),
+  namespaces: import_zod.z.array(import_zod.z.string()).optional(),
+  ignorePatterns: import_zod.z.array(import_zod.z.string()).default(["node_modules", "dist", ".git", "coverage"]),
+  incrementalCache: import_zod.z.boolean().default(true),
+  cacheDir: import_zod.z.string().default(".ai-localize-cache"),
+  aws: AwsConfigSchema.optional(),
+  plugins: import_zod.z.array(import_zod.z.string()).default([])
+});
+
+// src/loader.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_cosmiconfig = require("cosmiconfig");
+var dotenv = __toESM(require("dotenv"));
+var import_shared = require("@ai-localize/shared");
+async function loadConfig(cwd = process.cwd(), overrides = {}) {
+  dotenv.config({ path: path.join(cwd, ".env") });
+  dotenv.config({ path: path.join(cwd, ".env.local") });
+  const explorer = (0, import_cosmiconfig.cosmiconfig)("ai-localize", {
+    searchPlaces: [
+      import_shared.CONFIG_FILE_NAME,
+      "ai-localize.config.js",
+      "ai-localize.config.ts",
+      ".ai-localizerc",
+      ".ai-localizerc.json",
+      ".ai-localizerc.js",
+      "package.json"
+    ],
+    packageProp: "aiLocalize"
+  });
+  let rawConfig = {};
+  let filePath = null;
+  try {
+    const result = await explorer.search(cwd);
+    if (result) {
+      rawConfig = result.config;
+      filePath = result.filepath;
+    }
+  } catch (err) {
+  }
+  const awsFromEnv = extractAwsFromEnv();
+  if (awsFromEnv && !rawConfig.aws) {
+    rawConfig.aws = awsFromEnv;
+  }
+  const merged = { ...rawConfig, ...overrides };
+  const validated = LocalizationConfigSchema.parse(merged);
+  return {
+    config: validated,
+    filePath
+  };
+}
+function extractAwsFromEnv() {
+  const bucket = process.env.AI_LOCALIZE_S3_BUCKET || process.env.AWS_S3_BUCKET;
+  const distributionId = process.env.AI_LOCALIZE_CF_DISTRIBUTION_ID || process.env.AWS_CF_DISTRIBUTION_ID;
+  if (!bucket || !distributionId) return null;
+  return {
+    bucket,
+    distributionId,
+    region: process.env.AWS_REGION || process.env.AI_LOCALIZE_AWS_REGION || "us-east-1",
+    cdnBaseUrl: process.env.AI_LOCALIZE_CDN_BASE_URL || "",
+    legacyCdnPattern: process.env.AI_LOCALIZE_LEGACY_CDN_PATTERN || "",
+    profile: process.env.AWS_PROFILE || ""
+  };
+}
+function writeDefaultConfig(cwd = process.cwd(), framework = "unknown") {
+  const configPath = path.join(cwd, import_shared.CONFIG_FILE_NAME);
+  const defaultConfig = {
+    framework,
+    defaultLanguage: "en",
+    targetLanguages: ["fr", "de"],
+    sourceDir: "src",
+    localesDir: "locales",
+    ignorePatterns: ["node_modules", "dist", ".git", "coverage"],
+    incrementalCache: true,
+    cacheDir: ".ai-localize-cache",
+    aws: {
+      region: "us-east-1",
+      bucket: "",
+      distributionId: "",
+      cdnBaseUrl: "",
+      legacyCdnPattern: "",
+      assetsPrefix: "assets"
+    },
+    plugins: []
+  };
+  fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
+  return configPath;
+}
+function validateConfig(configPath) {
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    LocalizationConfigSchema.parse(parsed);
+    return { valid: true, errors: [] };
+  } catch (err) {
+    if (err && typeof err === "object" && "errors" in err) {
+      const zodError = err;
+      return {
+        valid: false,
+        errors: zodError.errors.map((e) => `${e.path.join(".")}: ${e.message}`)
+      };
+    }
+    return {
+      valid: false,
+      errors: [err instanceof Error ? err.message : String(err)]
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalizationConfigSchema,
+  loadConfig,
+  validateConfig,
+  writeDefaultConfig
+});

package/dist/index.mjs

@@ -0,0 +1,146 @@
+// src/schema.ts
+import { z } from "zod";
+var AwsConfigSchema = z.object({
+  region: z.string().default("us-east-1"),
+  bucket: z.string().min(1, "S3 bucket name is required"),
+  distributionId: z.string().min(1, "CloudFront distribution ID is required"),
+  cdnBaseUrl: z.string().url().optional(),
+  legacyCdnPattern: z.string().optional(),
+  assetsPrefix: z.string().default("assets"),
+  profile: z.string().optional()
+});
+var FrameworkSchema = z.enum([
+  "react",
+  "react-cra",
+  "react-vite",
+  "react-nextjs",
+  "angular",
+  "angular-ngx",
+  "angular-i18n",
+  "vue",
+  "vue-i18n",
+  "jquery",
+  "vanilla-js",
+  "jsp",
+  "unknown"
+]);
+var LocalizationConfigSchema = z.object({
+  framework: FrameworkSchema.default("unknown"),
+  defaultLanguage: z.string().default("en"),
+  targetLanguages: z.array(z.string()).default([]),
+  sourceDir: z.string().default("src"),
+  localesDir: z.string().default("locales"),
+  keyPrefix: z.string().optional(),
+  namespaces: z.array(z.string()).optional(),
+  ignorePatterns: z.array(z.string()).default(["node_modules", "dist", ".git", "coverage"]),
+  incrementalCache: z.boolean().default(true),
+  cacheDir: z.string().default(".ai-localize-cache"),
+  aws: AwsConfigSchema.optional(),
+  plugins: z.array(z.string()).default([])
+});
+
+// src/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import { cosmiconfig } from "cosmiconfig";
+import * as dotenv from "dotenv";
+import { CONFIG_FILE_NAME } from "@ai-localize/shared";
+async function loadConfig(cwd = process.cwd(), overrides = {}) {
+  dotenv.config({ path: path.join(cwd, ".env") });
+  dotenv.config({ path: path.join(cwd, ".env.local") });
+  const explorer = cosmiconfig("ai-localize", {
+    searchPlaces: [
+      CONFIG_FILE_NAME,
+      "ai-localize.config.js",
+      "ai-localize.config.ts",
+      ".ai-localizerc",
+      ".ai-localizerc.json",
+      ".ai-localizerc.js",
+      "package.json"
+    ],
+    packageProp: "aiLocalize"
+  });
+  let rawConfig = {};
+  let filePath = null;
+  try {
+    const result = await explorer.search(cwd);
+    if (result) {
+      rawConfig = result.config;
+      filePath = result.filepath;
+    }
+  } catch (err) {
+  }
+  const awsFromEnv = extractAwsFromEnv();
+  if (awsFromEnv && !rawConfig.aws) {
+    rawConfig.aws = awsFromEnv;
+  }
+  const merged = { ...rawConfig, ...overrides };
+  const validated = LocalizationConfigSchema.parse(merged);
+  return {
+    config: validated,
+    filePath
+  };
+}
+function extractAwsFromEnv() {
+  const bucket = process.env.AI_LOCALIZE_S3_BUCKET || process.env.AWS_S3_BUCKET;
+  const distributionId = process.env.AI_LOCALIZE_CF_DISTRIBUTION_ID || process.env.AWS_CF_DISTRIBUTION_ID;
+  if (!bucket || !distributionId) return null;
+  return {
+    bucket,
+    distributionId,
+    region: process.env.AWS_REGION || process.env.AI_LOCALIZE_AWS_REGION || "us-east-1",
+    cdnBaseUrl: process.env.AI_LOCALIZE_CDN_BASE_URL || "",
+    legacyCdnPattern: process.env.AI_LOCALIZE_LEGACY_CDN_PATTERN || "",
+    profile: process.env.AWS_PROFILE || ""
+  };
+}
+function writeDefaultConfig(cwd = process.cwd(), framework = "unknown") {
+  const configPath = path.join(cwd, CONFIG_FILE_NAME);
+  const defaultConfig = {
+    framework,
+    defaultLanguage: "en",
+    targetLanguages: ["fr", "de"],
+    sourceDir: "src",
+    localesDir: "locales",
+    ignorePatterns: ["node_modules", "dist", ".git", "coverage"],
+    incrementalCache: true,
+    cacheDir: ".ai-localize-cache",
+    aws: {
+      region: "us-east-1",
+      bucket: "",
+      distributionId: "",
+      cdnBaseUrl: "",
+      legacyCdnPattern: "",
+      assetsPrefix: "assets"
+    },
+    plugins: []
+  };
+  fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
+  return configPath;
+}
+function validateConfig(configPath) {
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    LocalizationConfigSchema.parse(parsed);
+    return { valid: true, errors: [] };
+  } catch (err) {
+    if (err && typeof err === "object" && "errors" in err) {
+      const zodError = err;
+      return {
+        valid: false,
+        errors: zodError.errors.map((e) => `${e.path.join(".")}: ${e.message}`)
+      };
+    }
+    return {
+      valid: false,
+      errors: [err instanceof Error ? err.message : String(err)]
+    };
+  }
+}
+export {
+  LocalizationConfigSchema,
+  loadConfig,
+  validateConfig,
+  writeDefaultConfig
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "ai-localize-config",
+  "version": "1.0.0",
+  "description": "Configuration loader and schema validator for ai-localize-core",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "zod": "^3.22.4",
+    "cosmiconfig": "^9.0.0",
+    "dotenv": "^16.4.1",
+    "ai-localize-shared": "1.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.1"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint src --ext .ts"
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './schema.js';
+export * from './loader.js';

package/src/loader.ts

@@ -0,0 +1,138 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { cosmiconfig } from 'cosmiconfig';
+import * as dotenv from 'dotenv';
+
+import type { LocalizationConfig } from '@ai-localize/shared';
+import { CONFIG_FILE_NAME } from '@ai-localize/shared';
+import { LocalizationConfigSchema } from './schema.js';
+
+export interface ConfigLoadResult {
+  config: LocalizationConfig;
+  filePath: string | null;
+}
+
+/**
+ * Loads and validates the ai-localize configuration.
+ * Searches for config in standard locations using cosmiconfig.
+ */
+export async function loadConfig(
+  cwd = process.cwd(),
+  overrides: Partial<LocalizationConfig> = {}
+): Promise<ConfigLoadResult> {
+  // Load .env files for AWS credentials etc.
+  dotenv.config({ path: path.join(cwd, '.env') });
+  dotenv.config({ path: path.join(cwd, '.env.local') });
+
+  const explorer = cosmiconfig('ai-localize', {
+    searchPlaces: [
+      CONFIG_FILE_NAME,
+      'ai-localize.config.js',
+      'ai-localize.config.ts',
+'.ai-localizerc',
+      '.ai-localizerc.json',
+      '.ai-localizerc.js',
+      'package.json',
+    ],
+    packageProp: 'aiLocalize',
+  });
+
+  let rawConfig: Record<string, unknown> = {};
+  let filePath: string | null = null;
+
+  try {
+    const result = await explorer.search(cwd);
+  if (result) {
+      rawConfig = result.config as Record<string, unknown>;
+      filePath = result.filepath;
+    }
+  } catch (err) {
+    // Config not found - use defaults
+  }
+
+  // Merge env vars for AWS
+  const awsFromEnv = extractAwsFromEnv();
+  if (awsFromEnv && !rawConfig.aws) {
+    rawConfig.aws = awsFromEnv;
+  }
+
+  const merged = { ...rawConfig, ...overrides };
+  const validated = LocalizationConfigSchema.parse(merged);
+
+  return {
+    config: validated as LocalizationConfig,
+    filePath,
+  };
+}
+
+/** Extract AWS configuration from environment variables */
+function extractAwsFromEnv(): Record<string, string> | null {
+  const bucket = process.env.AI_LOCALIZE_S3_BUCKET || process.env.AWS_S3_BUCKET;
+  const distributionId =
+  process.env.AI_LOCALIZE_CF_DISTRIBUTION_ID || process.env.AWS_CF_DISTRIBUTION_ID;
+
+  if (!bucket || !distributionId) return null;
+
+  return {
+ bucket,
+    distributionId,
+    region: process.env.AWS_REGION || process.env.AI_LOCALIZE_AWS_REGION || 'us-east-1',
+ cdnBaseUrl: process.env.AI_LOCALIZE_CDN_BASE_URL || '',
+    legacyCdnPattern: process.env.AI_LOCALIZE_LEGACY_CDN_PATTERN || '',
+    profile: process.env.AWS_PROFILE || '',
+  };
+}
+
+/**
+ * Writes a default config file to the project root.
+ */
+export function writeDefaultConfig(cwd = process.cwd(), framework = 'unknown'): string {
+  const configPath = path.join(cwd, CONFIG_FILE_NAME);
+  const defaultConfig = {
+    framework,
+    defaultLanguage: 'en',
+    targetLanguages: ['fr', 'de'],
+    sourceDir: 'src',
+    localesDir: 'locales',
+    ignorePatterns: ['node_modules', 'dist', '.git', 'coverage'],
+    incrementalCache: true,
+    cacheDir: '.ai-localize-cache',
+    aws: {
+      region: 'us-east-1',
+      bucket: '',
+      distributionId: '',
+      cdnBaseUrl: '',
+      legacyCdnPattern: '',
+      assetsPrefix: 'assets',
+    },
+ plugins: [],
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + '\n', 'utf-8');
+  return configPath;
+}
+
+/** Validate an existing config file */
+export function validateConfig(configPath: string): {
+  valid: boolean;
+  errors: string[];
+} {
+  try {
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    LocalizationConfigSchema.parse(parsed);
+    return { valid: true, errors: [] };
+  } catch (err: unknown) {
+    if (err && typeof err === 'object' && 'errors' in err) {
+      const zodError = err as { errors: Array<{ path: unknown[]; message: string }> };
+      return {
+        valid: false,
+        errors: zodError.errors.map((e) => `${e.path.join('.')}: ${e.message}`),
+      };
+}
+    return {
+      valid: false,
+      errors: [err instanceof Error ? err.message : String(err)],
+    };
+  }
+}

package/src/schema.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+
+const AwsConfigSchema = z.object({
+  region: z.string().default('us-east-1'),
+  bucket: z.string().min(1, 'S3 bucket name is required'),
+  distributionId: z.string().min(1, 'CloudFront distribution ID is required'),
+  cdnBaseUrl: z.string().url().optional(),
+  legacyCdnPattern: z.string().optional(),
+  assetsPrefix: z.string().default('assets'),
+  profile: z.string().optional(),
+});
+
+const FrameworkSchema = z.enum([
+  'react',
+'react-cra',
+  'react-vite',
+  'react-nextjs',
+  'angular',
+  'angular-ngx',
+  'angular-i18n',
+  'vue',
+  'vue-i18n',
+  'jquery',
+  'vanilla-js',
+  'jsp',
+  'unknown',
+]);
+
+export const LocalizationConfigSchema = z.object({
+  framework: FrameworkSchema.default('unknown'),
+  defaultLanguage: z.string().default('en'),
+  targetLanguages: z.array(z.string()).default([]),
+  sourceDir: z.string().default('src'),
+  localesDir: z.string().default('locales'),
+  keyPrefix: z.string().optional(),
+  namespaces: z.array(z.string()).optional(),
+  ignorePatterns: z
+    .array(z.string())
+    .default(['node_modules', 'dist', '.git', 'coverage']),
+  incrementalCache: z.boolean().default(true),
+  cacheDir: z.string().default('.ai-localize-cache'),
+  aws: AwsConfigSchema.optional(),
+  plugins: z.array(z.string()).default([]),
+});
+
+export type LocalizationConfigInput = z.input<typeof LocalizationConfigSchema>;
+export type LocalizationConfigOutput = z.output<typeof LocalizationConfigSchema>;

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+"outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}