update

tools/generowanie/akrylowe_podziekowanie_ojciec_chrzestny_wzor2.py

@@ -0,0 +1,168 @@
+"""
+Generator PSD — Akrylowe podziekowanie na chrzest dla Ojca Chrzestnego (Wzór 2).
+
+Dwa warianty szablonu (chlopiec / dziewczynka) wybierane parametrem --plec.
+Oba PSD maja identyczna strukture warstw w "Warstwa 1":
+imie, data, naglowek, tytul, podziekowanie oraz Smart Object "zdjecie".
+
+Podmiana zdjecia — jak w Wzorze 1: cover do oryginalnych boundsow,
+zielony placeholder gdy brak zdjecia.
+
+Wymaga: uruchomiony Adobe Photoshop, photoshop-python-api, Pillow.
+"""
+
+import argparse
+import os
+import photoshop.api as ps
+
+
+PROJEKT_DIR = os.path.join(
+    r"d:\pomysloweprezenty.pl\projekty\chrzest - podziękowania",
+    "Akrylowe podziękowanie na chrzest dla Ojca Chrzestnego - Wzór 2",
+)
+SZABLON_CHLOPIEC = os.path.join(
+    PROJEKT_DIR, "Akrylowe podziękowanie na chrzest dla Ojca Chrzestnego - Wzór 2 CMYK - chłopiec.psd"
+)
+SZABLON_DZIEWCZYNKA = os.path.join(
+    PROJEKT_DIR, "Akrylowe podziękowanie na chrzest dla Ojca Chrzestnego - Wzór 2 CMYK - dziewczynka.psd"
+)
+GOTOWE_DIR = os.path.join(PROJEKT_DIR, "_gotowe")
+
+ASSETS_DIR = os.path.join(os.path.dirname(__file__), "_assets")
+GREEN_PLACEHOLDER_PATH = os.path.join(ASSETS_DIR, "green_placeholder.png")
+
+
+def ensure_green_placeholder():
+    if os.path.exists(GREEN_PLACEHOLDER_PATH):
+        return GREEN_PLACEHOLDER_PATH
+    os.makedirs(ASSETS_DIR, exist_ok=True)
+    from PIL import Image
+    Image.new("RGB", (1000, 1000), (0, 255, 0)).save(GREEN_PLACEHOLDER_PATH)
+    return GREEN_PLACEHOLDER_PATH
+
+
+def set_text(layer, new_text):
+    b = [float(x) for x in layer.bounds]
+    cx, cy = (b[0] + b[2]) / 2, (b[1] + b[3]) / 2
+    layer.textItem.contents = new_text
+    b2 = [float(x) for x in layer.bounds]
+    cx2, cy2 = (b2[0] + b2[2]) / 2, (b2[1] + b2[3]) / 2
+    dx, dy = cx - cx2, cy - cy2
+    if dx or dy:
+        layer.translate(dx, dy)
+
+
+def set_layer_text(container, layer_name, new_text):
+    if new_text is None:
+        return
+    layer = container.artLayers[layer_name]
+    old = layer.textItem.contents
+    set_text(layer, new_text)
+    print(f'    {layer_name}: "{old}" -> "{new_text}"')
+
+
+def replace_smart_object_contents(app, file_path):
+    desc = ps.ActionDescriptor()
+    desc.putPath(app.charIDToTypeID("null"), file_path)
+    desc.putInteger(app.charIDToTypeID("PgNm"), 1)
+    app.executeAction(app.stringIDToTypeID("placedLayerReplaceContents"), desc)
+
+
+def replace_photo_cover(app, so_layer, photo_path):
+    target = [float(x) for x in so_layer.bounds]
+    target_w = target[2] - target[0]
+    target_h = target[3] - target[1]
+    target_cx = (target[0] + target[2]) / 2
+    target_cy = (target[1] + target[3]) / 2
+
+    app.activeDocument.activeLayer = so_layer
+    replace_smart_object_contents(app, photo_path)
+
+    new_b = [float(x) for x in so_layer.bounds]
+    new_w = new_b[2] - new_b[0]
+    new_h = new_b[3] - new_b[1]
+    if new_w <= 0 or new_h <= 0:
+        return
+
+    scale = max(target_w / new_w, target_h / new_h) * 100.0
+    so_layer.resize(scale, scale, ps.AnchorPosition.MiddleCenter)
+
+    cur = [float(x) for x in so_layer.bounds]
+    cur_cx = (cur[0] + cur[2]) / 2
+    cur_cy = (cur[1] + cur[3]) / 2
+    so_layer.translate(target_cx - cur_cx, target_cy - cur_cy)
+
+
+def generate(klient, imie, data, plec, zdjecie=None, naglowek=None, tytul=None, podziekowanie=None):
+    if plec == "m":
+        szablon_path = SZABLON_CHLOPIEC
+    elif plec == "k":
+        szablon_path = SZABLON_DZIEWCZYNKA
+    else:
+        raise ValueError(f"--plec musi byc 'm' lub 'k', otrzymano: {plec!r}")
+
+    os.makedirs(GOTOWE_DIR, exist_ok=True)
+    output_path = os.path.join(GOTOWE_DIR, f"{klient}.psd")
+
+    app = ps.Application()
+    doc = app.open(szablon_path)
+    print(f"Otwarto szablon: {doc.name}")
+
+    w1 = doc.layerSets["Warstwa 1"]
+
+    print("  Podmiana tekstow:")
+    set_layer_text(w1, "imie", imie)
+    set_layer_text(w1, "data", data)
+    set_layer_text(w1, "naglowek", naglowek)
+    set_layer_text(w1, "tytul", tytul)
+    set_layer_text(w1, "podziekowanie", podziekowanie)
+
+    so_layer = w1.artLayers["zdjecie"]
+    if zdjecie and os.path.isfile(zdjecie):
+        print(f"  Podmiana zdjecia: {zdjecie}")
+        replace_photo_cover(app, so_layer, zdjecie)
+    else:
+        if zdjecie:
+            print(f"  UWAGA: plik zdjecia nie istnieje ({zdjecie}) — wstawiam zielony placeholder")
+        else:
+            print("  Brak --zdjecie — wstawiam zielony placeholder")
+        replace_photo_cover(app, so_layer, ensure_green_placeholder())
+
+    psd_opts = ps.PhotoshopSaveOptions()
+    doc.saveAs(output_path, psd_opts, True)
+    print(f"Zapisano: {output_path}")
+
+    doc.close(ps.SaveOptions.DoNotSaveChanges)
+    print("Gotowe!")
+    return output_path
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generator PSD - Akrylowe podziekowanie chrzest, Ojciec Chrzestny Wzor 2 (chlopiec/dziewczynka)"
+    )
+    parser.add_argument("--klient", required=True, help="Nazwa pliku wyjsciowego")
+    parser.add_argument("--imie", required=True, help="Imie dziecka (np. Wojtus, Blanka)")
+    parser.add_argument("--data", required=True, help="Data uroczystosci (np. 19.04.2026)")
+    parser.add_argument("--plec", required=True, choices=["m", "k"],
+                        help="Plec dziecka: 'm' = chlopiec, 'k' = dziewczynka")
+    parser.add_argument("--zdjecie", default=None, help="Sciezka do zdjecia (opcjonalnie; brak = zielony placeholder)")
+    parser.add_argument("--naglowek", default=None, help="Naglowek (opcjonalnie, domyslnie 'OJCZE CHRZESTNY')")
+    parser.add_argument("--tytul", default=None, help="Tytul (opcjonalnie, domyslnie 'Dziękuję')")
+    parser.add_argument("--podziekowanie", default=None, help="Tresc podziekowania (opcjonalnie, domyslna z szablonu)")
+
+    args = parser.parse_args()
+    generate(
+        klient=args.klient,
+        imie=args.imie,
+        data=args.data,
+        plec=args.plec,
+        zdjecie=args.zdjecie,
+        naglowek=args.naglowek,
+        tytul=args.tytul,
+        podziekowanie=args.podziekowanie,
+    )
+
+
+if __name__ == "__main__":
+    main()

tools/generowanie/email_message_fetcher.py

@@ -0,0 +1,169 @@
+"""
+Pobieranie wiadomosci tekstowych od klientow z poczty IMAP.
+
+Bliznaczy modul do `email_photo_fetcher.py`, ale zamiast zalacznikow graficznych
+zwraca tresc tekstowa wiadomosci (body) od podanego nadawcy. Uzywany przez silnik
+`/wygeneruj-projekty` aby wykryc dodatkowe poprawki/uwagi ktore klient przysylal
+mailem juz po zlozeniu zamowienia.
+
+Skrzynka: EMAIL_01, folder: INBOX (na stale — zgodnie z wymaganiem).
+
+Wymagane zmienne srodowiskowe (.env w katalogu projektu):
+    EMAIL_01_HOST
+    EMAIL_01_USERNAME
+    EMAIL_01_PASSWORD
+    EMAIL_01_IMAP_PORT - opcjonalnie, domyslnie 993
+
+Uzycie programowe:
+    from email_message_fetcher import fetch_customer_messages
+    items = fetch_customer_messages("klient@example.com", days_back=60)
+    # items: list[dict] z kluczami: date, subject, body
+
+Uzycie z CLI:
+    python email_message_fetcher.py --email klient@example.com --days 60
+"""
+
+import argparse
+import email
+import imaplib
+import json
+import sys
+from datetime import datetime, timedelta
+from email.header import decode_header
+
+from email_photo_fetcher import _imap_config  # reuse env loader
+
+
+def _decode_header_value(raw):
+    if not raw:
+        return ""
+    parts = decode_header(raw)
+    out = []
+    for chunk, enc in parts:
+        if isinstance(chunk, bytes):
+            try:
+                out.append(chunk.decode(enc or "utf-8", errors="replace"))
+            except LookupError:
+                out.append(chunk.decode("utf-8", errors="replace"))
+        else:
+            out.append(chunk)
+    return "".join(out).strip()
+
+
+def _extract_text_body(msg):
+    """Zwraca text/plain z wiadomosci; gdy brak — fallback do text/html (bez tagow)."""
+    plain_parts = []
+    html_parts = []
+
+    for part in msg.walk():
+        if part.get_content_maintype() == "multipart":
+            continue
+        disposition = str(part.get("Content-Disposition") or "").lower()
+        if "attachment" in disposition:
+            continue
+
+        ctype = part.get_content_type()
+        payload = part.get_payload(decode=True)
+        if not payload:
+            continue
+        charset = part.get_content_charset() or "utf-8"
+        try:
+            text = payload.decode(charset, errors="replace")
+        except LookupError:
+            text = payload.decode("utf-8", errors="replace")
+
+        if ctype == "text/plain":
+            plain_parts.append(text)
+        elif ctype == "text/html":
+            html_parts.append(text)
+
+    if plain_parts:
+        return "\n".join(p.strip() for p in plain_parts).strip()
+
+    if html_parts:
+        import re
+        raw = "\n".join(html_parts)
+        raw = re.sub(r"(?is)<(script|style).*?>.*?</\1>", " ", raw)
+        raw = re.sub(r"(?s)<[^>]+>", " ", raw)
+        raw = re.sub(r"[ \t]+", " ", raw)
+        raw = re.sub(r"\s*\n\s*", "\n", raw)
+        return raw.strip()
+
+    return ""
+
+
+def fetch_customer_messages(customer_email, days_back=60):
+    """Szuka maili od `customer_email` w INBOX z ostatnich `days_back` dni.
+    Zwraca liste dict {date, subject, body}, od najnowszego do najstarszego."""
+    cfg = _imap_config()
+    if not cfg["host"] or not cfg["user"] or not cfg["password"]:
+        raise RuntimeError(
+            "Brak konfiguracji konta w .env — wymagane: EMAIL_01_HOST, EMAIL_01_USERNAME, EMAIL_01_PASSWORD"
+        )
+
+    imap = imaplib.IMAP4_SSL(cfg["host"], cfg["port"])
+    results = []
+
+    try:
+        imap.login(cfg["user"], cfg["password"])
+        imap.select("INBOX")
+
+        since = (datetime.now() - timedelta(days=days_back)).strftime("%d-%b-%Y")
+        criteria = f'(FROM "{customer_email}" SINCE "{since}")'
+        status, data = imap.search(None, criteria)
+        if status != "OK" or not data or not data[0]:
+            return results
+
+        ids = data[0].split()
+        for msg_id in reversed(ids):
+            status, msg_data = imap.fetch(msg_id, "(RFC822)")
+            if status != "OK" or not msg_data or not msg_data[0]:
+                continue
+            msg = email.message_from_bytes(msg_data[0][1])
+
+            subject = _decode_header_value(msg.get("Subject"))
+            date_hdr = msg.get("Date") or ""
+            body = _extract_text_body(msg)
+
+            if not body:
+                continue
+
+            results.append({"date": date_hdr, "subject": subject, "body": body})
+
+        return results
+    finally:
+        try:
+            imap.logout()
+        except Exception:
+            pass
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Pobierz wiadomosci klienta z INBOX")
+    parser.add_argument("--email", required=True, help="Adres email klienta (nadawca)")
+    parser.add_argument("--days", type=int, default=60, help="Ile dni wstecz szukac (domyslnie 60)")
+    parser.add_argument("--json", action="store_true", help="Wyjscie w formacie JSON")
+    args = parser.parse_args()
+
+    try:
+        items = fetch_customer_messages(args.email, days_back=args.days)
+    except Exception as exc:
+        print(f"BLAD: {exc}")
+        sys.exit(2)
+
+    if not items:
+        print("BRAK: nie znaleziono wiadomosci od tego klienta w INBOX")
+        sys.exit(1)
+
+    if args.json:
+        print(json.dumps(items, ensure_ascii=False, indent=2))
+    else:
+        for i, it in enumerate(items, 1):
+            print(f"=== [{i}] {it['date']} | {it['subject']} ===")
+            print(it["body"])
+            print()
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

tools/generowanie/magnes_chrzest_stopki_serce.py

@@ -0,0 +1,140 @@
+"""
+Generator PSD - Magnes podziekowanie na chrzest UV - Stopki serce.
+
+Makieta A3 z 15 kopiami magnesu linkowanymi do Smart Object "projekt".
+Edycja warstw wewnatrz SO "projekt" propaguje zmiany na wszystkie kopie.
+
+Struktura wewnatrz Smart Object "projekt" -> "Warstwa 2":
+- podziekowanie (text, domyslnie "Dziękuję za przybycie.")
+- data (DD.MM.RRRR)
+- tytul (2 linie: "Chrzest Świętego\r{imie}")
+
+Wymaga: uruchomiony Adobe Photoshop, photoshop-python-api.
+"""
+
+import argparse
+import os
+import photoshop.api as ps
+
+
+PROJEKT_DIR = os.path.join(
+    r"d:\pomysloweprezenty.pl\projekty\chrzest - magnesy",
+    "Magnes podziękowanie dla gości na chrzest UV - Stopki serce",
+)
+SZABLON_PATH = os.path.join(PROJEKT_DIR, "magnesy serduszka makieta A3 CMYK.psd")
+GOTOWE_DIR = os.path.join(PROJEKT_DIR, "_gotowe")
+
+SMART_OBJECT_NAME = "projekt"
+INNER_SET_NAME = "Warstwa 2"
+
+
+def set_text(layer, new_text):
+    """Zmienia tekst warstwy zachowujac srodek bounding boxa."""
+    b = [float(x) for x in layer.bounds]
+    cx, cy = (b[0] + b[2]) / 2, (b[1] + b[3]) / 2
+    layer.textItem.contents = new_text
+    b2 = [float(x) for x in layer.bounds]
+    cx2, cy2 = (b2[0] + b2[2]) / 2, (b2[1] + b2[3]) / 2
+    dx, dy = cx - cx2, cy - cy2
+    if dx or dy:
+        layer.translate(dx, dy)
+
+
+def set_layer_text(container, layer_name, new_text):
+    if new_text is None:
+        return
+    layer = container.artLayers[layer_name]
+    old = layer.textItem.contents
+    set_text(layer, new_text)
+    print(f'    {layer_name}: "{old[:30]}..." -> "{new_text[:40]}..."')
+
+
+def enter_smart_object(app, layer):
+    app.activeDocument.activeLayer = layer
+    desc = ps.ActionDescriptor()
+    ref = ps.ActionReference()
+    ref.putEnumerated(
+        app.stringIDToTypeID("layer"),
+        app.stringIDToTypeID("ordinal"),
+        app.stringIDToTypeID("targetEnum"),
+    )
+    desc.putReference(app.stringIDToTypeID("null"), ref)
+    app.executeAction(app.stringIDToTypeID("placedLayerEditContents"), desc)
+
+
+def hide_excess_copies(doc, liczba):
+    """Ukrywa nadmiarowe kopie magnesu (szablon ma 15 slotow)."""
+    slot_layers = []
+    for al in doc.artLayers:
+        if al.name == SMART_OBJECT_NAME or al.name.startswith("main kopia"):
+            slot_layers.append(al)
+    total = len(slot_layers)
+    if liczba >= total:
+        return
+    for layer in slot_layers[liczba:]:
+        layer.visible = False
+    print(f"  Ukryto {total - liczba}/{total} slotow (zamowienie: {liczba})")
+
+
+def generate(klient, imie, data, liczba, podziekowanie=None):
+    os.makedirs(GOTOWE_DIR, exist_ok=True)
+    output_path = os.path.join(GOTOWE_DIR, f"{klient}.psd")
+
+    app = ps.Application()
+    doc = app.open(SZABLON_PATH)
+    print(f"Otwarto szablon: {doc.name}")
+
+    try:
+        projekt_layer = None
+        for al in doc.artLayers:
+            if al.name == SMART_OBJECT_NAME:
+                projekt_layer = al
+                break
+        if projekt_layer is None:
+            raise RuntimeError(f'Nie znaleziono warstwy Smart Object "{SMART_OBJECT_NAME}"')
+
+        enter_smart_object(app, projekt_layer)
+        inner = app.activeDocument
+        print(f"  Wewnatrz SO: {inner.name}")
+
+        w2 = inner.layerSets[INNER_SET_NAME]
+        set_layer_text(w2, "tytul", f"Chrzest Świętego\r{imie}")
+        set_layer_text(w2, "data", data)
+        set_layer_text(w2, "podziekowanie", podziekowanie)
+
+        inner.close(ps.SaveOptions.SaveChanges)
+
+        hide_excess_copies(doc, liczba)
+
+        psd_opts = ps.PhotoshopSaveOptions()
+        doc.saveAs(output_path, psd_opts, True)
+        print(f"Zapisano: {output_path}")
+    finally:
+        app.activeDocument.close(ps.SaveOptions.DoNotSaveChanges)
+        print("Gotowe!")
+
+    return output_path
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generator PSD - Magnes chrzest, Stopki serce")
+    parser.add_argument("--klient", required=True, help="Nazwa pliku wyjsciowego")
+    parser.add_argument("--imie", required=True, help="Imie dziecka (dopelniacz, np. Rozalii, Szymona)")
+    parser.add_argument("--data", required=True, help='Data chrztu, format "DD.MM.RRRR" (np. 19.04.2026)')
+    parser.add_argument("--liczba", type=int, default=15,
+                        help="Liczba zamowionych magnesow (1-15, nadmiar slotow ukrywany; domyslnie 15)")
+    parser.add_argument("--podziekowanie", default=None,
+                        help='Tresc podziekowania (opcjonalnie, domyslnie "Dziękuję za przybycie.")')
+
+    args = parser.parse_args()
+    generate(
+        klient=args.klient,
+        imie=args.imie,
+        data=args.data,
+        liczba=args.liczba,
+        podziekowanie=args.podziekowanie,
+    )
+
+
+if __name__ == "__main__":
+    main()

tools/generowanie/pudelko_chrzest_dziewczynka_aniolek.py

@@ -58,18 +58,23 @@ def generate(klient, imie, data, od_kogo, zyczenia=None, naglowek=None, tytul=No
     print("  [KP] data:")
     set_layer_text(doc.layerSets["KP"], "data", data)
 
-    # GL — życzenia (Layer 2 → dane)
-    print("  [GL] życzenia:")
-    gl_dane = doc.layerSets["GL"].layerSets["dane"]
-    set_layer_text(gl_dane, "od_kogo", od_kogo)
-    set_layer_text(gl_dane, "naglowek", naglowek)
-    set_layer_text(gl_dane, "zyczenia", zyczenia)
+    # GL/GP — opcjonalne (niektóre warianty szablonu mają tylko DL/DP)
+    try:
+        gl_dane = doc.layerSets["GL"].layerSets["dane"]
+        print("  [GL] życzenia:")
+        set_layer_text(gl_dane, "od_kogo", od_kogo)
+        set_layer_text(gl_dane, "naglowek", naglowek)
+        set_layer_text(gl_dane, "zyczenia", zyczenia)
+    except Exception:
+        print("  [GL] pomijam (brak w szablonie)")
 
-    # GP — imię + tytuł (Layer 1 kopia → dane); brak daty na ściance
-    print("  [GP] imię/tytuł:")
-    gp_dane = doc.layerSets["GP"].layerSets["dane"]
-    set_layer_text(gp_dane, "imie", imie)
-    set_layer_text(gp_dane, "tytul", tytul)
+    try:
+        gp_dane = doc.layerSets["GP"].layerSets["dane"]
+        print("  [GP] imię/tytuł:")
+        set_layer_text(gp_dane, "imie", imie)
+        set_layer_text(gp_dane, "tytul", tytul)
+    except Exception:
+        print("  [GP] pomijam (brak w szablonie)")
 
     # DL — życzenia (warstwy bezpośrednio w secie)
     print("  [DL] życzenia:")

tools/generowanie/pudelko_komunia_kielich.py

@@ -0,0 +1,101 @@
+"""
+Generator PSD - Pudelko na pieniadze z zyczeniami na Komunie (Kielich).
+
+Makieta A3 z panelami:
+- DL: od_kogo, naglowek, zyczenia
+- DP: imie, data, tytul
+
+Format daty w szablonie: "DD.MM.RRRR" (standardowy).
+
+Wymaga: uruchomiony Adobe Photoshop, photoshop-python-api.
+"""
+
+import argparse
+import os
+import photoshop.api as ps
+
+
+PROJEKT_DIR = os.path.join(
+    r"d:\pomysloweprezenty.pl\projekty\komunia święta - pudełka na pieniądze",
+    "Pudełko na pieniądze z życzeniami na Komunie Świętą - Kielich",
+)
+SZABLON_PATH = os.path.join(PROJEKT_DIR, "pudełka na chrzest - makieta A3 CMYK.psd")
+GOTOWE_DIR = os.path.join(PROJEKT_DIR, "_gotowe")
+
+
+def set_text(layer, new_text):
+    """Zmienia tekst warstwy zachowujac srodek bounding boxa (centrowane warstwy)."""
+    b = [float(x) for x in layer.bounds]
+    cx, cy = (b[0] + b[2]) / 2, (b[1] + b[3]) / 2
+    layer.textItem.contents = new_text
+    b2 = [float(x) for x in layer.bounds]
+    cx2, cy2 = (b2[0] + b2[2]) / 2, (b2[1] + b2[3]) / 2
+    dx, dy = cx - cx2, cy - cy2
+    if dx or dy:
+        layer.translate(dx, dy)
+
+
+def set_layer_text(container, layer_name, new_text):
+    if new_text is None:
+        return
+    layer = container.artLayers[layer_name]
+    old = layer.textItem.contents
+    set_text(layer, new_text)
+    print(f'    {layer_name}: "{old[:30]}..." -> "{new_text[:40]}..."')
+
+
+def generate(klient, imie, data, od_kogo, zyczenia=None, naglowek=None, tytul=None):
+    os.makedirs(GOTOWE_DIR, exist_ok=True)
+    output_path = os.path.join(GOTOWE_DIR, f"{klient}.psd")
+
+    app = ps.Application()
+    doc = app.open(SZABLON_PATH)
+    print(f"Otwarto szablon: {doc.name}")
+
+    try:
+        dl = doc.layerSets["DL"]
+        print("  [DL] zyczenia:")
+        set_layer_text(dl, "od_kogo", od_kogo)
+        set_layer_text(dl, "naglowek", naglowek)
+        set_layer_text(dl, "zyczenia", zyczenia)
+
+        dp = doc.layerSets["DP"]
+        print("  [DP] imie/data/tytul:")
+        set_layer_text(dp, "imie", imie)
+        set_layer_text(dp, "data", data)
+        set_layer_text(dp, "tytul", tytul)
+
+        psd_opts = ps.PhotoshopSaveOptions()
+        doc.saveAs(output_path, psd_opts, True)
+        print(f"Zapisano: {output_path}")
+    finally:
+        app.activeDocument.close(ps.SaveOptions.DoNotSaveChanges)
+        print("Gotowe!")
+
+    return output_path
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generator PSD - Pudelko komunia, Kielich")
+    parser.add_argument("--klient", required=True, help="Nazwa pliku wyjsciowego")
+    parser.add_argument("--imie", required=True, help="Imie dziecka (odmienione, np. Jakuba)")
+    parser.add_argument("--data", required=True, help='Data komunii, format "DD.MM.RRRR" (np. 18.05.2026)')
+    parser.add_argument("--od-kogo", dest="od_kogo", required=True, help="Od kogo (np. Matka Chrzestna z rodziną)")
+    parser.add_argument("--zyczenia", default=None, help="Tresc zyczen (opcjonalnie, domyslnie z szablonu)")
+    parser.add_argument("--naglowek", default=None, help='Naglowek (opcjonalnie, domyslnie "Z najlepszymi życzeniami")')
+    parser.add_argument("--tytul", default=None, help='Tytul (opcjonalnie, domyslnie "Pamiątka I Komunii Świętej")')
+
+    args = parser.parse_args()
+    generate(
+        klient=args.klient,
+        imie=args.imie,
+        data=args.data,
+        od_kogo=args.od_kogo,
+        zyczenia=args.zyczenia,
+        naglowek=args.naglowek,
+        tytul=args.tytul,
+    )
+
+
+if __name__ == "__main__":
+    main()