kaeris 0.1.0__tar.gz

kaeris-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: kaeris
+Version: 0.1.0
+Summary: AI localization CLI — translate JSON/YAML/.strings/.po/ARB/Android XML into 42 languages
+Author: KAERIS
+License: MIT
+Project-URL: Homepage, https://kaeris.dev
+Project-URL: Documentation, https://kaeris.dev/developer.html
+Keywords: i18n,l10n,localization,translation,ai,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Localization
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# KAERIS i18n — CLI
+
+AI localization from your terminal. Translate your app's strings files into **42 languages** —
+locally or in CI/CD. Format-aware, placeholder-safe, and **incremental** (only new keys).
+
+- **Zero dependencies** — pure Python stdlib, installs in a second
+- **6 formats** — JSON, YAML, `.strings`, `.po`, ARB, Android XML
+- **Incremental** — `--only-new` translates just the keys you added, merges the rest
+- **CI-ready** — GitHub Action included; open a PR with fresh translations on every push
+
+## Install
+
+```bash
+pip install kaeris
+# or, without installing:
+pipx run kaeris --help
+```
+
+## Quick start
+
+```bash
+# Translate a whole file into Spanish, French and Japanese
+kaeris translate locales/en.json --langs es,fr,ja --out locales
+
+# Only translate keys that are missing from the existing target files
+kaeris translate locales/en.json --langs es,fr,ja --out locales --only-new
+
+# List all supported languages
+kaeris languages
+```
+
+Output files are written next to the source (or into `--out`), named by language:
+`es.json`, `fr.json`, `ja.json` (or `values-es/strings.xml` for Android, etc.).
+
+## Authentication & tiers
+
+| Tier | How | Limit |
+|------|-----|-------|
+| **Free** (anonymous) | no key | 10,000 chars/file |
+| **Pro / Team** | `--key kaerisp_…` or `KAERIS_API_KEY` | 200k / 500k chars/file |
+| **Lifetime (BYOK)** | `--key` **and** `--openrouter-key sk-or-…` | unlimited (you pay OpenRouter for tokens) |
+
+```bash
+export KAERIS_API_KEY=kaerisp_xxxxxxxx
+export KAERIS_OPENROUTER_KEY=sk-or-v1-xxxx   # Lifetime/BYOK only
+kaeris translate en.json --langs de,uk
+```
+
+Get a key at <https://kaeris.dev/pricing.html>. A free OpenRouter key: <https://openrouter.ai/keys>.
+
+## CI/CD (GitHub Actions)
+
+Translate new keys and open a PR automatically on every push — see
+[`translate.example.yml`](../.github/workflows/translate.example.yml):
+
+```yaml
+- uses: kaeris-dev/i18n_tool/.github/actions/kaeris-translate@main
+  with:
+    source: locales/en.json
+    languages: es,fr,de,ja
+    out: locales
+    only-new: "true"
+```
+
+## How incremental mode works
+
+`--only-new` (JSON) parses your source and each existing translation, finds the keys present
+in the source but missing from the target, translates **only those**, and merges them back —
+preserving your existing translations and any non-string values (numbers, booleans). No more
+re-translating (and re-paying for) the whole file every time you add one string.
+
+## Environment variables
+
+- `KAERIS_API_KEY` — API key
+- `KAERIS_OPENROUTER_KEY` — OpenRouter key (BYOK)
+- `KAERIS_API_URL` — override the API base URL
+- `NO_COLOR` — disable coloured output
+
+## License
+
+MIT

kaeris-0.1.0/README.md

@@ -0,0 +1,81 @@
+# KAERIS i18n — CLI
+
+AI localization from your terminal. Translate your app's strings files into **42 languages** —
+locally or in CI/CD. Format-aware, placeholder-safe, and **incremental** (only new keys).
+
+- **Zero dependencies** — pure Python stdlib, installs in a second
+- **6 formats** — JSON, YAML, `.strings`, `.po`, ARB, Android XML
+- **Incremental** — `--only-new` translates just the keys you added, merges the rest
+- **CI-ready** — GitHub Action included; open a PR with fresh translations on every push
+
+## Install
+
+```bash
+pip install kaeris
+# or, without installing:
+pipx run kaeris --help
+```
+
+## Quick start
+
+```bash
+# Translate a whole file into Spanish, French and Japanese
+kaeris translate locales/en.json --langs es,fr,ja --out locales
+
+# Only translate keys that are missing from the existing target files
+kaeris translate locales/en.json --langs es,fr,ja --out locales --only-new
+
+# List all supported languages
+kaeris languages
+```
+
+Output files are written next to the source (or into `--out`), named by language:
+`es.json`, `fr.json`, `ja.json` (or `values-es/strings.xml` for Android, etc.).
+
+## Authentication & tiers
+
+| Tier | How | Limit |
+|------|-----|-------|
+| **Free** (anonymous) | no key | 10,000 chars/file |
+| **Pro / Team** | `--key kaerisp_…` or `KAERIS_API_KEY` | 200k / 500k chars/file |
+| **Lifetime (BYOK)** | `--key` **and** `--openrouter-key sk-or-…` | unlimited (you pay OpenRouter for tokens) |
+
+```bash
+export KAERIS_API_KEY=kaerisp_xxxxxxxx
+export KAERIS_OPENROUTER_KEY=sk-or-v1-xxxx   # Lifetime/BYOK only
+kaeris translate en.json --langs de,uk
+```
+
+Get a key at <https://kaeris.dev/pricing.html>. A free OpenRouter key: <https://openrouter.ai/keys>.
+
+## CI/CD (GitHub Actions)
+
+Translate new keys and open a PR automatically on every push — see
+[`translate.example.yml`](../.github/workflows/translate.example.yml):
+
+```yaml
+- uses: kaeris-dev/i18n_tool/.github/actions/kaeris-translate@main
+  with:
+    source: locales/en.json
+    languages: es,fr,de,ja
+    out: locales
+    only-new: "true"
+```
+
+## How incremental mode works
+
+`--only-new` (JSON) parses your source and each existing translation, finds the keys present
+in the source but missing from the target, translates **only those**, and merges them back —
+preserving your existing translations and any non-string values (numbers, booleans). No more
+re-translating (and re-paying for) the whole file every time you add one string.
+
+## Environment variables
+
+- `KAERIS_API_KEY` — API key
+- `KAERIS_OPENROUTER_KEY` — OpenRouter key (BYOK)
+- `KAERIS_API_URL` — override the API base URL
+- `NO_COLOR` — disable coloured output
+
+## License
+
+MIT

kaeris-0.1.0/kaeris/__init__.py

@@ -0,0 +1,7 @@
+"""KAERIS i18n — command-line client for AI localization.
+
+Translate your app's strings files (JSON, YAML, .strings, .po, ARB, Android XML)
+into 42 languages from your terminal or CI/CD pipeline.
+"""
+
+__version__ = "0.1.0"

kaeris-0.1.0/kaeris/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

kaeris-0.1.0/kaeris/cli.py

@@ -0,0 +1,189 @@
+"""KAERIS i18n command-line interface."""
+
+import argparse
+import json
+import os
+import sys
+
+from . import __version__
+from .client import KaerisClient, KaerisError, DEFAULT_API
+from . import incremental as inc
+
+
+def _c(text, code):
+    if os.environ.get("NO_COLOR") or not sys.stderr.isatty():
+        return text
+    return f"\033[{code}m{text}\033[0m"
+
+
+def info(msg):  print(_c("→", "36"), msg, file=sys.stderr)
+def ok(msg):    print(_c("✓", "32"), msg, file=sys.stderr)
+def warn(msg):  print(_c("!", "33"), msg, file=sys.stderr)
+def err(msg):   print(_c("✗", "31"), msg, file=sys.stderr)
+
+
+def _client(args):
+    return KaerisClient(
+        api_url=args.api_url,
+        api_key=args.key or os.environ.get("KAERIS_API_KEY"),
+        openrouter_key=args.openrouter_key or os.environ.get("KAERIS_OPENROUTER_KEY"),
+    )
+
+
+def cmd_languages(args):
+    langs = _client(args).languages()
+    for code, name in sorted(langs.items(), key=lambda kv: kv[1]):
+        print(f"  {code:5} {name}")
+    return 0
+
+
+def _progress_printer():
+    last = [-1]
+    def show(status):
+        total = status.get("total") or 0
+        done = status.get("progress") or 0
+        if total and done != last[0]:
+            pct = int(done / total * 100)
+            lang = status.get("current_lang") or ""
+            print(_c("→", "36") + f" {pct:3}%  {lang}", file=sys.stderr)
+            last[0] = done
+    return show
+
+
+def cmd_translate(args):
+    path = args.file
+    if not os.path.isfile(path):
+        err(f"File not found: {path}")
+        return 1
+    langs = [l.strip() for l in args.langs.split(",") if l.strip()]
+    if not langs:
+        err("No target languages given (use --langs es,fr,de)")
+        return 1
+
+    out_dir = args.out or os.path.dirname(os.path.abspath(path))
+    os.makedirs(out_dir, exist_ok=True)
+    fname = os.path.basename(path)
+    is_json = fname.lower().endswith(".json")
+    client = _client(args)
+
+    # ── incremental (delta) mode — JSON only ──────────────────────────────────
+    if args.only_new:
+        if not is_json:
+            warn("--only-new supports JSON only; translating the whole file instead")
+        else:
+            return _translate_incremental(client, path, out_dir, langs, args)
+
+    with open(path, "rb") as f:
+        content = f.read()
+
+    info(f"Translating {fname} → {', '.join(langs)}")
+    job = client.submit(fname, content, langs)
+    client.poll(job, on_progress=None if args.quiet else _progress_printer())
+    members = client.download(job)
+    written = _write_members(members, out_dir)
+    ok(f"Wrote {len(written)} file(s) to {out_dir}")
+    for w in written:
+        print(w)
+    return 0
+
+
+def _translate_incremental(client, path, out_dir, langs, args):
+    source_obj = inc.load_json(path)
+    source_flat = inc.flatten(source_obj)
+    flat_style = inc.is_flat(source_obj)
+    any_work = False
+
+    for lang in langs:
+        target_path = os.path.join(out_dir, f"{lang}.json")
+        existing = inc.load_json(target_path) if os.path.isfile(target_path) else {}
+        existing_flat = inc.flatten(existing) if existing else {}
+        todo = inc.missing_keys(source_flat, existing_flat)
+        if not todo:
+            ok(f"{lang}: up to date ({len(existing_flat)} keys)")
+            continue
+        any_work = True
+        info(f"{lang}: {len(todo)} new key(s) to translate")
+        subset = inc.build_subset(source_obj, set(todo), flat_style)
+        content = json.dumps(subset, ensure_ascii=False).encode()
+        job = client.submit(os.path.basename(path), content, [lang])
+        client.poll(job, on_progress=None if args.quiet else _progress_printer())
+        members = client.download(job)
+        translated = _find_json_member(members, lang)
+        if translated is None:
+            err(f"{lang}: no output returned")
+            continue
+        merged = inc.merge_translation(existing, translated)
+        inc.dump_json(merged, target_path)
+        ok(f"{lang}: merged {len(todo)} key(s) → {target_path}")
+
+    if not any_work:
+        ok("Everything already up to date — nothing to translate")
+    return 0
+
+
+def _find_json_member(members, lang):
+    for name, data in members.items():
+        if name.endswith(".json"):
+            try:
+                return json.loads(data.decode("utf-8"))
+            except Exception:
+                continue
+    return None
+
+
+def _write_members(members, out_dir):
+    written = []
+    for name, data in members.items():
+        dest = os.path.join(out_dir, name)
+        os.makedirs(os.path.dirname(dest) or out_dir, exist_ok=True)
+        with open(dest, "wb") as f:
+            f.write(data)
+        written.append(dest)
+    return written
+
+
+def build_parser():
+    p = argparse.ArgumentParser(
+        prog="kaeris",
+        description="AI localization from your terminal — translate strings files into 42 languages.",
+    )
+    p.add_argument("--version", action="version", version=f"kaeris {__version__}")
+    p.add_argument("--api-url", default=os.environ.get("KAERIS_API_URL", DEFAULT_API),
+                   help="API base URL (default: https://kaeris.dev)")
+    p.add_argument("--key", "-k", help="API key (or env KAERIS_API_KEY)")
+    p.add_argument("--openrouter-key", help="OpenRouter key for Lifetime/BYOK (or env KAERIS_OPENROUTER_KEY)")
+
+    sub = p.add_subparsers(dest="command")
+
+    t = sub.add_parser("translate", help="Translate a strings file")
+    t.add_argument("file", help="Source file (.json/.yml/.strings/.po/.arb/.xml)")
+    t.add_argument("--langs", "-l", required=True, help="Comma-separated target languages, e.g. es,fr,de")
+    t.add_argument("--out", "-o", help="Output directory (default: alongside the source)")
+    t.add_argument("--only-new", action="store_true",
+                   help="Incremental: translate only keys missing from existing targets (JSON)")
+    t.add_argument("--quiet", "-q", action="store_true", help="Suppress progress output")
+    t.set_defaults(func=cmd_translate)
+
+    ls = sub.add_parser("languages", help="List supported target languages")
+    ls.set_defaults(func=cmd_languages)
+
+    return p
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    if not getattr(args, "command", None):
+        build_parser().print_help()
+        return 1
+    try:
+        return args.func(args)
+    except KaerisError as e:
+        err(str(e))
+        return 2
+    except KeyboardInterrupt:
+        err("Interrupted")
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

kaeris-0.1.0/kaeris/client.py

@@ -0,0 +1,125 @@
+"""Zero-dependency API client for the KAERIS i18n service (stdlib only)."""
+
+import io
+import json
+import os
+import time
+import uuid
+import zipfile
+import urllib.request
+import urllib.error
+
+DEFAULT_API = "https://kaeris.dev"
+
+
+class KaerisError(Exception):
+    """Any error talking to the KAERIS API."""
+
+
+class KaerisClient:
+    def __init__(self, api_url=DEFAULT_API, api_key=None, openrouter_key=None, timeout=180):
+        self.api_url = api_url.rstrip("/")
+        self.api_key = api_key
+        self.openrouter_key = openrouter_key
+        self.timeout = timeout
+
+    # ── low-level ────────────────────────────────────────────────────────────
+    def _headers(self, extra=None):
+        h = {"User-Agent": "kaeris-cli"}
+        if self.api_key:
+            h["X-API-Key"] = self.api_key
+        if self.openrouter_key:
+            h["X-OpenRouter-Key"] = self.openrouter_key
+        if extra:
+            h.update(extra)
+        return h
+
+    def _get(self, path):
+        req = urllib.request.Request(self.api_url + path, headers=self._headers())
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as r:
+                return r.read()
+        except urllib.error.HTTPError as e:
+            raise KaerisError(self._err_message(e))
+        except urllib.error.URLError as e:
+            raise KaerisError(f"Cannot reach {self.api_url}: {e.reason}")
+
+    @staticmethod
+    def _err_message(e):
+        try:
+            body = json.loads(e.read().decode())
+            detail = body.get("detail") or body.get("error") or str(body)
+        except Exception:
+            detail = e.reason
+        return f"HTTP {e.code}: {detail}"
+
+    # ── public API ───────────────────────────────────────────────────────────
+    def languages(self):
+        return json.loads(self._get("/api/languages").decode())
+
+    def config(self):
+        return json.loads(self._get("/api/config").decode())
+
+    def _multipart(self, filename, content, languages):
+        boundary = "----kaeris" + uuid.uuid4().hex
+        crlf = b"\r\n"
+        parts = []
+        parts.append(b"--" + boundary.encode())
+        parts.append(
+            b'Content-Disposition: form-data; name="file"; filename="'
+            + filename.encode() + b'"'
+        )
+        parts.append(b"Content-Type: application/octet-stream")
+        parts.append(b"")
+        parts.append(content if isinstance(content, bytes) else content.encode())
+        parts.append(b"--" + boundary.encode())
+        parts.append(b'Content-Disposition: form-data; name="languages"')
+        parts.append(b"")
+        parts.append(",".join(languages).encode())
+        parts.append(b"--" + boundary.encode() + b"--")
+        parts.append(b"")
+        body = crlf.join(parts)
+        return body, "multipart/form-data; boundary=" + boundary
+
+    def submit(self, filename, content, languages):
+        """POST a file for translation; returns job_id."""
+        body, ctype = self._multipart(filename, content, languages)
+        req = urllib.request.Request(
+            self.api_url + "/api/translate", data=body, method="POST",
+            headers=self._headers({"Content-Type": ctype}),
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as r:
+                data = json.loads(r.read().decode())
+        except urllib.error.HTTPError as e:
+            raise KaerisError(self._err_message(e))
+        except urllib.error.URLError as e:
+            raise KaerisError(f"Cannot reach {self.api_url}: {e.reason}")
+        job_id = data.get("job_id")
+        if not job_id:
+            raise KaerisError(f"No job_id in response: {data}")
+        return job_id
+
+    def poll(self, job_id, on_progress=None, interval=1.0, max_wait=1800):
+        """Poll a job until done/error. Returns the final status dict."""
+        deadline = time.time() + max_wait
+        while time.time() < deadline:
+            status = json.loads(self._get(f"/api/status/{job_id}").decode())
+            if on_progress:
+                on_progress(status)
+            state = status.get("status")
+            if state == "done":
+                return status
+            if state == "error":
+                raise KaerisError(status.get("error") or "Translation failed")
+            time.sleep(interval)
+        raise KaerisError("Timed out waiting for translation")
+
+    def download(self, job_id):
+        """Download the result ZIP; returns {member_name: bytes}."""
+        raw = self._get(f"/api/download/{job_id}")
+        out = {}
+        with zipfile.ZipFile(io.BytesIO(raw)) as zf:
+            for name in zf.namelist():
+                out[name] = zf.read(name)
+        return out

kaeris-0.1.0/kaeris/incremental.py

@@ -0,0 +1,89 @@
+"""Incremental (delta) translation helpers for JSON files.
+
+Only new/changed keys are sent to the API; existing translations are preserved.
+This mirrors the server's flatten/unflatten so round-trips stay faithful.
+"""
+
+import json
+
+
+def flatten(obj, prefix=""):
+    """Flatten nested dict to dotted keys; only string leaves are returned
+    (these are the translatable keys used for delta detection)."""
+    out = {}
+    for k, v in obj.items():
+        key = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict):
+            out.update(flatten(v, key))
+        elif isinstance(v, str):
+            out[key] = v
+    return out
+
+
+def flatten_all(obj, prefix=""):
+    """Flatten keeping every scalar leaf (strings, numbers, booleans, null) —
+    used for merging so non-string values survive round-trips."""
+    out = {}
+    for k, v in obj.items():
+        key = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict):
+            out.update(flatten_all(v, key))
+        else:
+            out[key] = v
+    return out
+
+
+def unflatten(flat):
+    result = {}
+    for key, value in flat.items():
+        parts = key.split(".")
+        d = result
+        for p in parts[:-1]:
+            if not isinstance(d.get(p), dict):
+                d[p] = {}
+            d = d[p]
+        d[parts[-1]] = value
+    return result
+
+
+def is_flat(obj):
+    """True if the object has no nested dict values (dotted-key style)."""
+    return not any(isinstance(v, dict) for v in obj.values())
+
+
+def missing_keys(source_flat, existing_flat):
+    """Keys present in source but not in an existing translation."""
+    return {k: v for k, v in source_flat.items() if k not in existing_flat}
+
+
+def build_subset(source_obj, keys, flat_style):
+    """Build a JSON document containing only `keys` (dotted), matching the source style."""
+    subset_flat = {k: v for k, v in flatten(source_obj).items() if k in keys}
+    if flat_style:
+        return subset_flat
+    return unflatten(subset_flat)
+
+
+def merge_translation(existing_obj, translated_obj):
+    """Merge freshly translated keys into an existing target document (new keys win).
+    Preserves all existing leaves, including non-string scalars."""
+    ex = flatten_all(existing_obj) if existing_obj else {}
+    tr = flatten_all(translated_obj)
+    ex.update(tr)
+    return ex if is_flat_dict(existing_obj, translated_obj) else unflatten(ex)
+
+
+def is_flat_dict(existing_obj, translated_obj):
+    ref = existing_obj if existing_obj else translated_obj
+    return is_flat(ref) if ref else True
+
+
+def load_json(path):
+    with open(path, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def dump_json(obj, path):
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(obj, f, ensure_ascii=False, indent=2)
+        f.write("\n")

kaeris-0.1.0/kaeris.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: kaeris
+Version: 0.1.0
+Summary: AI localization CLI — translate JSON/YAML/.strings/.po/ARB/Android XML into 42 languages
+Author: KAERIS
+License: MIT
+Project-URL: Homepage, https://kaeris.dev
+Project-URL: Documentation, https://kaeris.dev/developer.html
+Keywords: i18n,l10n,localization,translation,ai,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Localization
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# KAERIS i18n — CLI
+
+AI localization from your terminal. Translate your app's strings files into **42 languages** —
+locally or in CI/CD. Format-aware, placeholder-safe, and **incremental** (only new keys).
+
+- **Zero dependencies** — pure Python stdlib, installs in a second
+- **6 formats** — JSON, YAML, `.strings`, `.po`, ARB, Android XML
+- **Incremental** — `--only-new` translates just the keys you added, merges the rest
+- **CI-ready** — GitHub Action included; open a PR with fresh translations on every push
+
+## Install
+
+```bash
+pip install kaeris
+# or, without installing:
+pipx run kaeris --help
+```
+
+## Quick start
+
+```bash
+# Translate a whole file into Spanish, French and Japanese
+kaeris translate locales/en.json --langs es,fr,ja --out locales
+
+# Only translate keys that are missing from the existing target files
+kaeris translate locales/en.json --langs es,fr,ja --out locales --only-new
+
+# List all supported languages
+kaeris languages
+```
+
+Output files are written next to the source (or into `--out`), named by language:
+`es.json`, `fr.json`, `ja.json` (or `values-es/strings.xml` for Android, etc.).
+
+## Authentication & tiers
+
+| Tier | How | Limit |
+|------|-----|-------|
+| **Free** (anonymous) | no key | 10,000 chars/file |
+| **Pro / Team** | `--key kaerisp_…` or `KAERIS_API_KEY` | 200k / 500k chars/file |
+| **Lifetime (BYOK)** | `--key` **and** `--openrouter-key sk-or-…` | unlimited (you pay OpenRouter for tokens) |
+
+```bash
+export KAERIS_API_KEY=kaerisp_xxxxxxxx
+export KAERIS_OPENROUTER_KEY=sk-or-v1-xxxx   # Lifetime/BYOK only
+kaeris translate en.json --langs de,uk
+```
+
+Get a key at <https://kaeris.dev/pricing.html>. A free OpenRouter key: <https://openrouter.ai/keys>.
+
+## CI/CD (GitHub Actions)
+
+Translate new keys and open a PR automatically on every push — see
+[`translate.example.yml`](../.github/workflows/translate.example.yml):
+
+```yaml
+- uses: kaeris-dev/i18n_tool/.github/actions/kaeris-translate@main
+  with:
+    source: locales/en.json
+    languages: es,fr,de,ja
+    out: locales
+    only-new: "true"
+```
+
+## How incremental mode works
+
+`--only-new` (JSON) parses your source and each existing translation, finds the keys present
+in the source but missing from the target, translates **only those**, and merges them back —
+preserving your existing translations and any non-string values (numbers, booleans). No more
+re-translating (and re-paying for) the whole file every time you add one string.
+
+## Environment variables
+
+- `KAERIS_API_KEY` — API key
+- `KAERIS_OPENROUTER_KEY` — OpenRouter key (BYOK)
+- `KAERIS_API_URL` — override the API base URL
+- `NO_COLOR` — disable coloured output
+
+## License
+
+MIT

kaeris-0.1.0/kaeris.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+kaeris/__init__.py
+kaeris/__main__.py
+kaeris/cli.py
+kaeris/client.py
+kaeris/incremental.py
+kaeris.egg-info/PKG-INFO
+kaeris.egg-info/SOURCES.txt
+kaeris.egg-info/dependency_links.txt
+kaeris.egg-info/entry_points.txt
+kaeris.egg-info/top_level.txt
+tests/test_incremental.py

kaeris-0.1.0/kaeris.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kaeris-0.1.0/kaeris.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kaeris = kaeris.cli:main

kaeris-0.1.0/kaeris.egg-info/top_level.txt

@@ -0,0 +1 @@
+kaeris

kaeris-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kaeris"
+version = "0.1.0"
+description = "AI localization CLI — translate JSON/YAML/.strings/.po/ARB/Android XML into 42 languages"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "KAERIS" }]
+keywords = ["i18n", "l10n", "localization", "translation", "ai", "cli"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Software Development :: Localization",
+    "Environment :: Console",
+]
+# Zero runtime dependencies — stdlib only.
+dependencies = []
+
+[project.urls]
+Homepage = "https://kaeris.dev"
+Documentation = "https://kaeris.dev/developer.html"
+
+[project.scripts]
+kaeris = "kaeris.cli:main"
+
+[tool.setuptools]
+packages = ["kaeris"]

kaeris-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

kaeris-0.1.0/tests/test_incremental.py

@@ -0,0 +1,58 @@
+"""Offline tests for the incremental (delta) logic — no API calls."""
+
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from kaeris import incremental as inc
+
+
+def test_flatten_strings_only():
+    src = {"a": "x", "n": 5, "b": {"c": "y"}, "ok": True}
+    assert inc.flatten(src) == {"a": "x", "b.c": "y"}
+
+
+def test_flatten_all_keeps_scalars():
+    src = {"a": "x", "n": 5, "ok": True, "z": None}
+    assert inc.flatten_all(src) == {"a": "x", "n": 5, "ok": True, "z": None}
+
+
+def test_missing_keys():
+    source = {"a": "1", "b": "2", "c": "3"}
+    existing = {"a": "uno"}
+    assert set(inc.missing_keys(source, existing)) == {"b", "c"}
+
+
+def test_build_subset_nested():
+    src = {"btn": {"save": "Save", "cancel": "Cancel"}, "hi": "Hi"}
+    subset = inc.build_subset(src, {"btn.save"}, flat_style=False)
+    assert subset == {"btn": {"save": "Save"}}
+
+
+def test_build_subset_flat():
+    src = {"btn.save": "Save", "btn.cancel": "Cancel"}
+    subset = inc.build_subset(src, {"btn.cancel"}, flat_style=True)
+    assert subset == {"btn.cancel": "Cancel"}
+
+
+def test_merge_preserves_existing_and_numbers():
+    existing = {"greeting": "Hola", "count": 5, "btn": {"save": "Guardar"}}
+    translated = {"btn": {"cancel": "Cancelar"}, "farewell": "Adiós"}
+    merged = inc.merge_translation(existing, translated)
+    assert merged["greeting"] == "Hola"
+    assert merged["count"] == 5
+    assert merged["btn"]["save"] == "Guardar"
+    assert merged["btn"]["cancel"] == "Cancelar"
+    assert merged["farewell"] == "Adiós"
+
+
+def test_flat_style_detection():
+    assert inc.is_flat({"a.b": "x", "c": "y"}) is True
+    assert inc.is_flat({"a": {"b": "x"}}) is False
+
+
+if __name__ == "__main__":
+    fns = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
+    for fn in fns:
+        fn()
+        print(f"ok  {fn.__name__}")
+    print(f"\n{len(fns)} passed")