Test Planify V1

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11.8-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the FastAPI app
+COPY ./app /app
+
+# Expose Hugging Face-required port
+EXPOSE 7860
+
+# Run the app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app/CurrencyMapping/__init__.py

@@ -0,0 +1,17 @@
+# Currency Mapping Package
+
+import os
+import sys
+
+# Add the current directory to sys.path to handle the space in folder name
+current_dir = os.path.dirname(__file__)
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+# Import the main function for easy access
+from currency_mapping import convert_currency_symbols_to_iso, canonical_currency_map
+
+__all__ = [
+    'convert_currency_symbols_to_iso',
+    'canonical_currency_map'
+]

app/CurrencyMapping/currency_mapping.py

@@ -0,0 +1,538 @@
+# Currency Mapping Module
+# Contains canonical_currency_map dictionary and convert_currency_symbols_to_iso() function
+
+# Canonical currency map for symbol resolution (matches TypeScript version)
+canonical_currency_map = {
+    # Standard currency symbols
+    "$": "USD",
+    "£": "GBP", 
+    "€": "EUR",
+    "¥": "JPY",
+    "₹": "INR",
+    "₽": "RUB",
+    "₩": "KRW",
+    "₪": "ILS",
+    "₺": "TRY",
+    "₴": "UAH",
+    "₼": "AZN",
+    "₸": "KZT",
+    "₾": "GEL",
+    "֏": "AMD",
+    "₲": "PYG",
+    "₡": "CRC",
+    "₣": "XPF",
+    "₦": "NGN",
+    "₵": "GHS",
+    "₨": "PKR",
+    "₱": "PHP",
+    "₫": "VND",
+    "₭": "LAK",
+    "៛": "KHR",
+    "৳": "BDT",
+    "؋": "AFN",
+    "﷼": "IRR",
+    
+    # Custom symbols
+    "‡": "CUSTOM_DAGGER",
+    "†": "CUSTOM_DAGGER_SINGLE",
+    
+    # Letter-based currencies
+    "R": "ZAR",  # South African Rand
+    "C$": "CAD",  # Canadian Dollar
+    "A$": "AUD",  # Australian Dollar
+    "R$": "BRL",  # Brazilian Real
+    "S/": "PEN",  # Peruvian Sol
+    "Bs": "BOB",  # Bolivian Boliviano
+    "Q": "GTQ",  # Guatemalan Quetzal
+    "L": "HNL",  # Honduran Lempira
+    "ƒ": "AWG",  # Aruban Florin
+    "Vt": "VUV",  # Vanuatu Vatu
+    "T$": "TOP",  # Tongan Pa'anga
+    "T": "WST",  # Samoan Tala
+    "лв": "BGN",  # Bulgarian Lev
+    "Kč": "CZK",  # Czech Koruna
+    "kr": "DKK",  # Danish Krone
+    "Ft": "HUF",  # Hungarian Forint
+    "zł": "PLN",  # Polish Zloty
+    "lei": "RON",  # Romanian Leu
+    "CHF": "CHF",  # Swiss Franc
+    "KM": "BAM",  # Bosnian Marka
+    "ден": "MKD",  # North Macedonian Denar
+    "дин": "RSD",  # Serbian Dinar
+    "so'm": "UZS",  # Uzbekistani Som
+    "NT$": "TWD",  # Taiwan Dollar
+    "HK$": "HKD",  # Hong Kong Dollar
+    "S$": "SGD",  # Singapore Dollar
+    "RM": "MYR",  # Malaysian Ringgit
+    "฿": "THB",  # Thai Baht
+    "Rp": "IDR",  # Indonesian Rupiah
+    "K": "MMK",  # Myanmar Kyat
+    "Rs": "LKR",  # Sri Lankan Rupee
+    "Nu": "BTN",  # Bhutanese Ngultrum
+    "MVR": "MVR",  # Maldivian Rufiyaa
+    
+    # Middle Eastern currencies
+    "ع.د": "IQD",  # Iraqi Dinar
+    "ل.ل": "LBP",  # Lebanese Pound
+    "د.ا": "JOD",  # Jordanian Dinar
+    "ر.س": "SAR",  # Saudi Riyal
+    "د.إ": "AED",  # UAE Dirham
+    "ر.ق": "QAR",  # Qatari Riyal
+    "د.ك": "KWD",  # Kuwaiti Dinar
+    "د.ب": "BHD",  # Bahraini Dinar
+    "ر.ع.": "OMR",  # Omani Rial
+    "ر.ي": "YER",  # Yemeni Rial
+    "ج.م": "EGP",  # Egyptian Pound
+    "ل.د": "LYD",  # Libyan Dinar
+    "د.ت": "TND",  # Tunisian Dinar
+    "د.ج": "DZD",  # Algerian Dinar
+    "د.م.": "MAD",  # Moroccan Dirham
+    "ج.س.": "SDG",  # Sudanese Pound
+    "SSP": "SSP",  # South Sudanese Pound
+    
+    # African currencies
+    "KSh": "KES",  # Kenyan Shilling
+    "USh": "UGX",  # Ugandan Shilling
+    "TSh": "TZS",  # Tanzanian Shilling
+    "FRw": "RWF",  # Rwandan Franc
+    "FBu": "BIF",  # Burundian Franc
+    "MT": "MZN",  # Mozambican Metical
+    "P": "BWP",  # Botswanan Pula
+    "N$": "NAD",  # Namibian Dollar
+    "Ar": "MGA",  # Malagasy Ariary
+    "CF": "KMF",  # Comorian Franc
+    "MK": "MWK",  # Malawian Kwacha
+    "ZK": "ZMW",  # Zambian Kwacha
+    "Kz": "AOA",  # Angolan Kwanza
+    "FC": "CDF",  # Congolese Franc
+    "FCFA": "XAF",  # Central African Franc
+    "Db": "STD",  # Sao Tomean Dobra
+    "D": "GMD",  # Gambian Dalasi
+    "FG": "GNF",  # Guinean Franc
+    "CFA": "XOF",  # West African Franc
+    "Le": "SLL",  # Sierra Leonean Leone
+    "L$": "LRD",  # Liberian Dollar
+    "Br": "ETB",  # Ethiopian Birr
+    "Nfk": "ERN",  # Eritrean Nakfa
+    "Fdj": "DJF",  # Djiboutian Franc
+    "S": "SOS",  # Somali Shilling
+    
+    # Caribbean & Central American currencies
+    "J$": "JMD",  # Jamaican Dollar
+    "BZ$": "BZD",  # Belize Dollar
+    "TT$": "TTD",  # Trinidad and Tobago Dollar
+    "Bds$": "BBD",  # Barbadian Dollar
+    "EC$": "XCD",  # East Caribbean Dollar
+    "GY$": "GYD",  # Guyanese Dollar
+    "SRD": "SRD",  # Surinamese Dollar
+    "RD$": "DOP",  # Dominican Peso
+    
+    # Pacific Island currencies
+    "FJ$": "FJD",  # Fijian Dollar
+    "PGK": "PGK",  # Papua New Guinean Kina
+    "SI$": "SBD",  # Solomon Islands Dollar
+    "WS$": "WST",  # Samoan Tala
+    "VT": "VUV",  # Vanuatu Vatu
+    
+    # European currencies
+    "ISK": "ISK",  # Icelandic Krona
+    "Lt": "LTL",  # Lithuanian Litas
+    "Ls": "LVL",  # Latvian Lats
+    "EEK": "EEK",  # Estonian Kroon
+    "NOK": "NOK",  # Norwegian Krone
+    "SEK": "SEK",  # Swedish Krona
+    "ALL": "ALL",  # Albanian Lek
+    
+    # South American currencies
+    "Gs": "PYG",  # Paraguayan Guarani
+    "Bs.S": "VES",  # Venezuelan Bolívar Soberano
+    "Bs": "VEF",  # Venezuelan Bolívar
+    "$U": "UYU",  # Uruguayan Peso
+    "$a": "ARS",  # Argentine Peso
+    "$b": "BOB",  # Bolivian Boliviano
+    "CLP": "CLP",  # Chilean Peso
+    "COP": "COP",  # Colombian Peso
+    "MXN": "MXN",  # Mexican Peso
+    
+    # Small Island Nations
+    "BMD": "BMD",  # Bermudian Dollar
+    "BSD": "BSD",  # Bahamian Dollar
+    "KYD": "KYD",  # Cayman Islands Dollar
+    "TVD": "TVD",  # Tuvaluan Dollar
+    "ZWL": "ZWL",  # Zimbabwean Dollar
+    
+    # Additional African currencies
+    "LSL": "LSL",  # Lesotho Loti
+    "SZL": "SZL",  # Swazi Lilangeni
+    "CVE": "CVE",  # Cape Verdean Escudo
+    "MRO": "MRO",  # Mauritanian Ouguiya
+    "MRU": "MRU",  # Mauritanian Ouguiya
+    "SCR": "SCR",  # Seychellois Rupee
+    "SHP": "SHP",  # Saint Helena Pound
+    
+    # Additional Asian currencies
+    "BND": "BND",  # Brunei Dollar
+    "MOP": "MOP",  # Macanese Pataca
+    "NPR": "NPR",  # Nepalese Rupee
+    
+    # Additional Pacific currencies
+    "NZD": "NZD",  # New Zealand Dollar
+    
+    # Alternative $ symbols for countries (context-dependent)
+    "$BMD": "BMD",  # Bermudian Dollar
+    "$BSD": "BSD",  # Bahamian Dollar
+    "$BZD": "BZD",  # Belize Dollar
+    "$KYD": "KYD",  # Cayman Islands Dollar
+    "$FJD": "FJD",  # Fijian Dollar
+    "$GYD": "GYD",  # Guyanese Dollar
+    "$JMD": "JMD",  # Jamaican Dollar
+    "$LRD": "LRD",  # Liberian Dollar
+    "$NAD": "NAD",  # Namibian Dollar
+    "$SBD": "SBD",  # Solomon Islands Dollar
+    "$SRD": "SRD",  # Surinamese Dollar
+    "$TTD": "TTD",  # Trinidad and Tobago Dollar
+    "$TVD": "TVD",  # Tuvaluan Dollar
+    "$VUV": "VUV",  # Vanuatu Vatu
+    "$WST": "WST",  # Samoan Tala
+    "$XCD": "XCD",  # East Caribbean Dollar
+    "$ZWL": "ZWL",  # Zimbabwean Dollar
+    "$BWP": "BWP",  # Botswanan Pula
+    "$LSL": "LSL",  # Lesotho Loti
+    "$SZL": "SZL",  # Swazi Lilangeni
+    "$ZAR": "ZAR",  # South African Rand
+    "$HKD": "HKD",  # Hong Kong Dollar
+    "$SGD": "SGD",  # Singapore Dollar
+    "$TWD": "TWD",  # Taiwan Dollar
+    "$CHF": "CHF",  # Swiss Franc
+    "$DKK": "DKK",  # Danish Krone
+    "$NOK": "NOK",  # Norwegian Krone
+    "$SEK": "SEK",  # Swedish Krona
+    "$ARS": "ARS",  # Argentine Peso
+    "$BOB": "BOB",  # Bolivian Boliviano
+    "$CLP": "CLP",  # Chilean Peso
+    "$COP": "COP",  # Colombian Peso
+    "$MXN": "MXN",  # Mexican Peso
+    "$PEN": "PEN",  # Peruvian Sol
+    "$UYU": "UYU",  # Uruguayan Peso
+    "$VES": "VES",  # Venezuelan Bolívar Soberano
+    
+    # Cryptocurrencies (for modern business plans)
+    "₿": "BTC",  # Bitcoin
+    "Ξ": "ETH",  # Ethereum
+    "Ł": "LTC",  # Litecoin
+    
+    # Special Drawing Rights
+    "XDR": "XDR",  # Special Drawing Rights
+    
+    # Precious Metals
+    "XAU": "XAU",  # Gold (troy ounce)
+    "XAG": "XAG",  # Silver (troy ounce)
+    "XPT": "XPT",  # Platinum (troy ounce)
+    "XPD": "XPD",  # Palladium (troy ounce)
+    
+    # Other
+    "XTS": "XTS",  # Testing Currency Code
+    "XXX": "XXX",  # No Currency
+    
+    # Missing currencies from canonical_currency_map.py
+    "ADP": "ADP",  # Andorran Peseta
+    "AFA": "AFA",  # Afghan Afghani (1927–2002)
+    "ALK": "ALK",  # Albanian Lek (1946–1965)
+    "ANG": "ANG",  # Netherlands Antillean Guilder
+    "AOK": "AOK",  # Angolan Kwanza (1977–1991)
+    "AON": "AON",  # Angolan New Kwanza (1990–2000)
+    "AOR": "AOR",  # Angolan Readjusted Kwanza (1995–1999)
+    "ARA": "ARA",  # Argentine Austral
+    "ARL": "ARL",  # Argentine Peso Ley (1970–1983)
+    "ARM": "ARM",  # Argentine Peso (1881–1970)
+    "ARP": "ARP",  # Argentine Peso (1983–1985)
+    "ATS": "ATS",  # Austrian Schilling
+    "AZM": "AZM",  # Azerbaijani Manat (1993–2006)
+    "BAD": "BAD",  # Bosnia-Herzegovina Dinar (1992–1994)
+    "BAN": "BAN",  # Bosnia-Herzegovina New Dinar (1994–1997)
+    "BEC": "BEC",  # Belgian Franc (convertible)
+    "BEF": "BEF",  # Belgian Franc
+    "BEL": "BEL",  # Belgian Franc (financial)
+    "BGL": "BGL",  # Bulgarian Hard Lev
+    "BGM": "BGM",  # Bulgarian Socialist Lev
+    "BGO": "BGO",  # Bulgarian Lev (1879–1952)
+    "BOL": "BOL",  # Bolivian Boliviano (1863–1963)
+    "BOP": "BOP",  # Bolivian Peso
+    "BOV": "BOV",  # Bolivian Mvdol
+    "BRB": "BRB",  # Brazilian New Cruzeiro (1967–1986)
+    "BRC": "BRC",  # Brazilian Cruzado (1986–1989)
+    "BRE": "BRE",  # Brazilian Cruzeiro (1990–1993)
+    "BRN": "BRN",  # Brazilian New Cruzado (1989–1990)
+    "BRR": "BRR",  # Brazilian Cruzeiro (1993–1994)
+    "BRZ": "BRZ",  # Brazilian Cruzeiro (1942–1967)
+    "BUK": "BUK",  # Burmese Kyat
+    "BYB": "BYB",  # Belarusian Ruble (1994–1999)
+    "BYN": "BYN",  # Belarusian Ruble
+    "BYR": "BYR",  # Belarusian Ruble (2000–2016)
+    "CA$": "CAD",  # Canadian Dollar
+    "CHE": "CHE",  # WIR Euro
+    "CHW": "CHW",  # WIR Franc
+    "CLE": "CLE",  # Chilean Escudo
+    "CLF": "CLF",  # Chilean Unit of Account (UF)
+    "CNH": "CNH",  # Chinese Yuan (offshore)
+    "CNX": "CNX",  # Chinese People's Bank Dollar
+    "CN¥": "CNY",  # Chinese Yuan
+    "COU": "COU",  # Colombian Real Value Unit
+    "CSD": "CSD",  # Serbian Dinar (2002–2006)
+    "CSK": "CSK",  # Czechoslovak Hard Koruna
+    "CUC": "CUC",  # Cuban Convertible Peso
+    "CUP": "CUP",  # Cuban Peso
+    "CYP": "CYP",  # Cypriot Pound
+    "DDM": "DDM",  # East German Mark
+    "DEM": "DEM",  # German Mark
+    "ECS": "ECS",  # Ecuadorian Sucre
+    "ECV": "ECV",  # Ecuadorian Unit of Constant Value
+    "ESA": "ESA",  # Spanish Peseta (A account)
+    "ESB": "ESB",  # Spanish Peseta (convertible account)
+    "ESP": "ESP",  # Spanish Peseta
+    "FIM": "FIM",  # Finnish Markka
+    "FKP": "FKP",  # Falkland Islands Pound
+    "FRF": "FRF",  # French Franc
+    "GEK": "GEK",  # Georgian Kupon Larit
+    "GHC": "GHC",  # Ghanaian Cedi (1979–2007)
+    "GIP": "GIP",  # Gibraltar Pound
+    "GNS": "GNS",  # Guinean Syli
+    "GQE": "GQE",  # Equatorial Guinean Ekwele
+    "GRD": "GRD",  # Greek Drachma
+    "GWE": "GWE",  # Portuguese Guinea Escudo
+    "GWP": "GWP",  # Guinea-Bissau Peso
+    "HRD": "HRD",  # Croatian Dinar
+    "HRK": "HRK",  # Croatian Kuna
+    "HTG": "HTG",  # Haitian Gourde
+    "IEP": "IEP",  # Irish Pound
+    "ILP": "ILP",  # Israeli Pound
+    "ILR": "ILR",  # Israeli Shekel (1980–1985)
+    "ISJ": "ISJ",  # Icelandic Króna (1918–1981)
+    "ITL": "ITL",  # Italian Lira
+    "KGS": "KGS",  # Kyrgystani Som
+    "KPW": "KPW",  # North Korean Won
+    "KRH": "KRH",  # South Korean Hwan (1953–1962)
+    "KRO": "KRO",  # South Korean Won (1945–1953)
+    "LTT": "LTT",  # Lithuanian Talonas
+    "LUC": "LUC",  # Luxembourgian Convertible Franc
+    "LUF": "LUF",  # Luxembourgian Franc
+    "LUL": "LUL",  # Luxembourg Financial Franc
+    "LVR": "LVR",  # Latvian Ruble
+    "MAF": "MAF",  # Moroccan Franc
+    "MCF": "MCF",  # Monegasque Franc
+    "MDC": "MDC",  # Moldovan Cupon
+    "MDL": "MDL",  # Moldovan Leu
+    "MGF": "MGF",  # Malagasy Franc
+    "MKN": "MKN",  # Macedonian Denar (1992–1993)
+    "MLF": "MLF",  # Malian Franc
+    "MNT": "MNT",  # Mongolian Tugrik
+    "MTL": "MTL",  # Maltese Lira
+    "MTP": "MTP",  # Maltese Pound
+    "MUR": "MUR",  # Mauritian Rupee
+    "MVP": "MVP",  # Maldivian Rupee (1947–1981)
+    "MX$": "MXN",  # Mexican Peso
+    "MXP": "MXP",  # Mexican Silver Peso (1861–1992)
+    "MXV": "MXV",  # Mexican Investment Unit
+    "MZE": "MZE",  # Mozambican Escudo
+    "MZM": "MZM",  # Mozambican Metical (1980–2006)
+    "NIC": "NIC",  # Nicaraguan Córdoba (1988–1991)
+    "NIO": "NIO",  # Nicaraguan Córdoba
+    "NLG": "NLG",  # Dutch Guilder
+    "NZ$": "NZD",  # New Zealand Dollar
+    "PAB": "PAB",  # Panamanian Balboa
+    "PEI": "PEI",  # Peruvian Inti
+    "PES": "PES",  # Peruvian Sol (1863–1965)
+    "PLZ": "PLZ",  # Polish Zloty (1950–1995)
+    "PTE": "PTE",  # Portuguese Escudo
+    "RHD": "RHD",  # Rhodesian Dollar
+    "ROL": "ROL",  # Romanian Leu (1952–2006)
+    "RUR": "RUR",  # Russian Ruble (1991–1998)
+    "SDD": "SDD",  # Sudanese Dinar (1992–2007)
+    "SDP": "SDP",  # Sudanese Pound (1957–1998)
+    "SIT": "SIT",  # Slovenian Tolar
+    "SKK": "SKK",  # Slovak Koruna
+    "SLE": "SLE",  # Sierra Leonean Leone
+    "SRG": "SRG",  # Surinamese Guilder
+    "STN": "STN",  # São Tomé & Príncipe Dobra
+    "SUR": "SUR",  # Soviet Rouble
+    "SVC": "SVC",  # Salvadoran Colón
+    "SYP": "SYP",  # Syrian Pound
+    "TJR": "TJR",  # Tajikistani Ruble
+    "TJS": "TJS",  # Tajikistani Somoni
+    "TMM": "TMM",  # Turkmenistani Manat (1993–2009)
+    "TMT": "TMT",  # Turkmenistani Manat
+    "TPE": "TPE",  # Timorese Escudo
+    "TRL": "TRL",  # Turkish Lira (1922–2005)
+    "UAK": "UAK",  # Ukrainian Karbovanets
+    "UGS": "UGS",  # Ugandan Shilling (1966–1987)
+    "USN": "USN",  # US Dollar (Next day)
+    "USS": "USS",  # US Dollar (Same day)
+    "UYI": "UYI",  # Uruguayan Peso (Indexed Units)
+    "UYP": "UYP",  # Uruguayan Peso (1975–1993)
+    "UYW": "UYW",  # Uruguayan Nominal Wage Index Unit
+    "VEB": "VEB",  # Venezuelan Bolívar (1871–2008)
+    "VED": "VED",  # Bolívar Soberano
+    "VNN": "VNN",  # Vietnamese Dong (1978–1985)
+    "XBA": "XBA",  # European Composite Unit
+    "XBB": "XBB",  # European Monetary Unit
+    "XBC": "XBC",  # European Unit of Account (XBC)
+    "XBD": "XBD",  # European Unit of Account (XBD)
+    "Cg.": "XCG",  # Caribbean guilder
+    "XEU": "XEU",  # European Currency Unit
+    "XFO": "XFO",  # French Gold Franc
+    "XFU": "XFU",  # French UIC-Franc
+    "F CFA": "XOF",  # West African CFA Franc
+    "XRE": "XRE",  # RINET Funds
+    "XSU": "XSU",  # Sucre
+    "XUA": "XUA",  # ADB Unit of Account
+    "¤": "XXX",  # Unknown Currency
+    "YDD": "YDD",  # Yemeni Dinar
+    "YUD": "YUD",  # Yugoslavian Hard Dinar (1966–1990)
+    "YUM": "YUM",  # Yugoslavian New Dinar (1994–2002)
+    "YUN": "YUN",  # Yugoslavian Convertible Dinar (1990–1992)
+    "YUR": "YUR",  # Yugoslavian Reformed Dinar (1992–1993)
+    "ZAL": "ZAL",  # South African Rand (financial)
+    "ZMK": "ZMK",  # Zambian Kwacha (1968–2012)
+    "ZRN": "ZRN",  # Zairean New Zaire (1993–1998)
+    "ZRZ": "ZRZ",  # Zairean Zaire (1971–1993)
+    "ZWD": "ZWD",  # Zimbabwean Dollar (1980–2008)
+    "ZWG": "ZWG",  # Zimbabwean Gold
+    "ZWR": "ZWR",  # Zimbabwean Dollar (2008)
+    "US$": "USD",  # US Dollar
+    "C$": "NIO",  # Nicaraguan Córdoba
+    "TT$": "TTD",  # Trinidad & Tobago Dollar
+    "BD$": "BBD",  # Barbadian Dollar
+    "B$": "BND",  # Brunei Dollar
+    "SI$": "SBD",  # Solomon Islands Dollar
+    "G$": "GYD",  # Guyanaese Dollar
+    "SR$": "SRD",  # Surinamese Dollar
+    "CLP$": "CLP",  # Chilean Peso
+    "Bs.": "VES",  # Venezuelan Bolívar
+    "Rf": "MVR",  # Maldivian Rufiyaa
+    "SSh": "SOS",  # Somali Shilling
+    "GH₵": "GHS",  # Ghanaian Cedi
+    "Br": "BYN",  # Belarusian Ruble
+    "CFA F": "XOF",  # West African CFA Franc
+    "CFAF": "XAF",  # Central African CFA Franc
+    "JP¥": "JPY",  # Japanese Yen
+    "元": "TWD",  # New Taiwan Dollar
+    "TL": "TRY",  # Turkish Lira
+    "лв.": "BGN",  # Bulgarian Lev
+    "₮": "MNT",  # Mongolian Tugrik
+    "﷼": "SAR",  # Saudi Riyal
+    ".د.ب": "BHD",  # Bahraini Dinar
+    "ل.س": "SYP",  # Syrian Pound
+    "﷼‎": "IRR",  # Iranian Rial
+    "ש״ח": "ILS",  # Israeli New Shekel
+    "Fr": "CHF",  # Swiss Franc
+    "CFP": "XPF",  # CFP Franc
+    "E": "SZL",  # Swazi Lilangeni
+    "Rf.": "MVR",  # Maldivian Rufiyaa
+    "QR": "QAR",  # Qatari Riyal
+    "SR": "SAR",  # Saudi Riyal
+    "BD": "BHD",  # Bahraini Dinar
+    "KD": "KWD",  # Kuwaiti Dinar
+    "₯": "GRD",  # Greek Drachma
+    "ЅМ": "TJS",  # Tajikistani Somoni
+    "Br (BYN)": "BYN",  # Belarusian Ruble
+    "B/.": "PAB",  # Panamanian Balboa
+    "Gs.": "PYG",  # Paraguayan Guarani
+    "Afl.": "AWG",  # Aruban Florin
+    "NAƒ": "ANG",  # Netherlands Antillean Guilder
+    "lei (MDL)": "MDL",  # Moldovan Leu
+    "KM (BAM)": "BAM",  # Bosnia-Herzegovina Convertible Mark
+    "ден (MKD)": "MKD",  # Macedonian Denar
+    "kn": "HRK",  # Croatian Kuna
+    "Z$": "ZWL",  # Zimbabwean Dollar (2009–2024)
+    "RTGS$": "ZWL",  # Zimbabwean Dollar (2009–2024)
+    "Skr": "SEK",  # Swedish Krona
+    "Nkr": "NOK",  # Norwegian Krone
+    "Dkr": "DKK",  # Danish Krone
+    "Íkr": "ISK",  # Icelandic Króna
+    "AU$": "AUD",  # Australian Dollar
+    "SG$": "SGD",  # Singapore Dollar
+    "BB$": "BBD",  # Barbadian Dollar
+    "BS$": "BSD",  # Bahamian Dollar
+    "KY$": "KYD",  # Cayman Islands Dollar
+    "BM$": "BMD",  # Bermudan Dollar
+    "JM$": "JMD",  # Jamaican Dollar
+}
+
+def convert_currency_symbols_to_iso(text: str) -> str:
+    """
+    Convert currency symbols to ISO codes for PDF compatibility
+    Matches the TypeScript canonicalCurrencyMap logic
+    """
+    import re  # Import at function level to avoid scope issues
+    processed_text = text
+    
+    # Track all conversions for detailed logging
+    conversions_made = []
+    total_conversions = 0
+    
+    # Process each currency symbol in the canonical map
+    for symbol, iso_code in canonical_currency_map.items():
+        if symbol in processed_text:
+            # Check if it's a single character
+            is_single_character = len(symbol) == 1
+            is_unicode_currency = is_single_character and ord(symbol) > 127  # Non-ASCII
+            is_latin_single_letter = is_single_character and symbol.isalpha() and ord(symbol) < 128
+            
+            # Handle multi-character symbols (like "Le", "KSh", etc.)
+            is_multi_char_symbol = len(symbol) > 1
+            
+            # Skip plain Latin single letters (to avoid converting words like "A", "R", etc.)
+            # but DO convert single-character Unicode currency symbols like €, £, ¥, ؋, etc.
+            if not is_unicode_currency and is_latin_single_letter:
+                # Only convert if it's followed by a number (currency context)
+                # Pattern: R500, R 500, R500,000 etc.
+                pattern = rf'\b{re.escape(symbol)}\s*(\d{{1,3}}(?:,?\d{{3}})*(?:\.\d{{2}})?)\b'
+                matches = re.findall(pattern, processed_text)
+                
+                if matches:
+                    old_text = processed_text
+                    processed_text = re.sub(pattern, rf'{iso_code} \1', processed_text)
+                    
+                    if old_text != processed_text:
+                        conversions_made.append(f"{symbol} → {iso_code} (context: {matches})")
+                        total_conversions += len(matches)
+                continue
+            
+            # For multi-character symbols like "Ar", "Le", etc., be very careful
+            # Only convert if they appear as standalone words or in currency contexts
+            if is_multi_char_symbol and len(symbol) == 2 and symbol.isalpha():
+                # Only convert if it's a standalone word or followed by a number
+                # Pattern: \bAr\b or \bAr\s*\d or \bLe\b or \bLe\s*\d
+                standalone_pattern = rf'\b{re.escape(symbol)}\b'
+                currency_pattern = rf'\b{re.escape(symbol)}\s*(\d{{1,3}}(?:,?\d{{3}})*(?:\.\d{{2}})?)'
+                
+                # Check for standalone occurrences first
+                standalone_matches = re.findall(standalone_pattern, processed_text)
+                currency_matches = re.findall(currency_pattern, processed_text)
+                
+                if standalone_matches or currency_matches:
+                    old_text = processed_text
+                    # Replace standalone occurrences
+                    processed_text = re.sub(standalone_pattern, iso_code, processed_text)
+                    # Replace currency context occurrences
+                    processed_text = re.sub(currency_pattern, rf'{iso_code} \1', processed_text)
+                    
+                    if old_text != processed_text:
+                        conversions_made.append(f"{symbol} → {iso_code} (standalone/currency context)")
+                        total_conversions += len(standalone_matches) + len(currency_matches)
+                continue
+            
+            # For all other symbols (Unicode currency symbols, multi-character symbols)
+            # Count occurrences before replacement
+            old_count = processed_text.count(symbol)
+            
+            # Replace all occurrences
+            old_text = processed_text
+            processed_text = processed_text.replace(symbol, iso_code)
+            
+            # Check if replacement actually happened
+            if old_text != processed_text:
+                conversions_made.append(f"{symbol} → {iso_code} ({old_count} instances)")
+                total_conversions += old_count
+    
+    return processed_text

app/DocumentGeneration/__init__.py

@@ -0,0 +1,56 @@
+# Document Generation Package
+
+import os
+import sys
+
+# Add the current directory to sys.path to handle the space in folder name
+current_dir = os.path.dirname(__file__)
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+# Import all the main functions for easy access
+from pdf_generator import create_pdf_document
+from word_generator import create_word_document
+from chart_generator import parse_embedded_chart_data, create_chart_from_data
+from table_of_content import generate_table_of_contents_after_content, add_table_of_contents_page
+from document_helpers import (
+    extract_business_name_from_content,
+    filter_empty_sections,
+    extract_subheadings,
+    remove_duplicate_headings
+)
+from grouped import (
+    parse_content_into_groups,
+    extract_key_phrases,
+    get_content_groups_info
+)
+from markdown_renderer import (
+    clean_text_for_pdf,
+    render_markdown_to_pdf,
+    render_markdown_to_pdf_grouped,
+    render_markdown_to_docx,
+    render_markdown_to_docx_grouped,
+    clean_text_for_docx
+)
+
+__all__ = [
+    'create_pdf_document',
+    'create_word_document',
+    'parse_embedded_chart_data',
+    'create_chart_from_data',
+    'generate_table_of_contents_after_content',
+    'add_table_of_contents_page',
+    'extract_business_name_from_content',
+    'filter_empty_sections',
+    'extract_subheadings',
+    'parse_content_into_groups',
+    'extract_key_phrases',
+    'get_content_groups_info',
+    'remove_duplicate_headings',
+    'clean_text_for_pdf',
+    'render_markdown_to_pdf',
+    'render_markdown_to_pdf_grouped',
+    'render_markdown_to_docx',
+    'render_markdown_to_docx_grouped',
+    'clean_text_for_docx'
+]

app/DocumentGeneration/chart_generator.py

@@ -0,0 +1,384 @@
+# Chart Generator Module
+# Contains parse_embedded_chart_data() and create_chart_from_data() functions
+
+import re
+import io
+import os
+import sys
+import base64
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from typing import List, Dict, Any, Optional
+
+# Add the parent directory to sys.path to import from models.py
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from models import ExportSection
+
+def parse_embedded_chart_data(sections: List[ExportSection]) -> List[Dict[str, Any]]:
+    """Parse chart data embedded in section content using CHARTDATA markers"""
+    charts = []
+    
+    for section in sections:
+        if section.content:
+            # Look for chart data markers - handle both formats
+            chart_matches = re.findall(r'<!--CHART_DATA_START-->(.*?)<!--CHART_DATA_END-->', section.content, re.DOTALL)
+            
+            # Also check for alternative markers as fallback
+            alt_chart_matches = re.findall(r'<!--CHARTDATASTART-->(.*?)<!--CHARTDATAEND-->', section.content, re.DOTALL)
+            chart_matches.extend(alt_chart_matches)
+            
+            # logging.info(f"Section '{section.title}': Found {len(chart_matches)} chart data markers")
+            
+            for chart_data in chart_matches:
+                try:
+                    # Parse the chart data array
+                    chart_array = eval(chart_data.strip())
+                    # logging.info(f"Parsed chart array with {len(chart_array)} items")
+                    # logging.info(f"Chart array type: {type(chart_array)}")
+                    
+                    # Each chart is an array with: [Section, ChartType, Title, Period, Data]
+                    for chart_item in chart_array:
+                        if len(chart_item) >= 5:
+                            section_name = chart_item[0]
+                            chart_type = chart_item[1]  # DC=Doughnut, BG=Bar Graph, etc.
+                            chart_title = chart_item[2]
+                            period = chart_item[3]
+                            data = chart_item[4]
+                            
+                            chart_info = {
+                                "section": section_name,
+                                "type": chart_type,
+                                "title": chart_title,
+                                "period": period,
+                                "data": data,
+                                "source_section": section.title
+                            }
+                            
+                            charts.append(chart_info)
+                            # logging.info(f"Added chart: {chart_type} - {chart_title} for section {section_name}")
+                        else:
+                            # logging.warning(f"Chart item has insufficient data: {len(chart_item)} items, expected 5")
+                            pass
+                
+                except Exception as e:
+                    # logging.error(f"Failed to parse chart data for section '{section.title}': {str(e)}")
+                    continue
+            
+            # Additional debugging: Check for any chart-related content
+            if not chart_matches:
+                # Look for any chart-related markers or text
+                chart_indicators = re.findall(r'<!--.*?CHART.*?-->', section.content, re.DOTALL)
+                if chart_indicators:
+                    # logging.info(f"Section '{section.title}': Found chart indicators: {chart_indicators}")
+                    pass
+                
+                # Check for general chart text
+                if 'CHART' in section.content.upper() or 'chart' in section.content.lower():
+                    # logging.info(f"Section '{section.title}': Contains chart-related text")
+                    pass
+    
+    # logging.info(f"Total charts parsed: {len(charts)}")
+    return charts
+
+def create_enhanced_chart_style(chart_type, data, title, business_idea):
+    """Create charts with enhanced professional styling"""
+    # Set modern style
+    plt.style.use('default')
+    
+    # Design palette from image
+    colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
+    
+    if chart_type == "DC":  # Doughnut Chart
+        fig, ax = plt.subplots(figsize=(14, 10))
+        
+        # Extract labels and values from data
+        labels = [item[0] for item in data]
+        values = [item[1] for item in data]
+        
+        # Create doughnut chart with enhanced styling
+        wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
+                                         autopct='%1.1f%%', startangle=90,
+                                         wedgeprops=dict(width=0.6, edgecolor='white', linewidth=2),
+                                         textprops={'fontsize': 18})
+        
+        # Enhanced title styling
+        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
+        
+        # Add legend with enhanced styling
+        legend = ax.legend(wedges, labels, title="Categories", 
+                          loc="center left", bbox_to_anchor=(1, 0, 0.5, 1),
+                          fontsize=16, title_fontsize=18)
+        legend.get_title().set_color('#FF6B6B')
+        
+        # Add business name watermark
+        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
+                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
+        
+        plt.tight_layout()
+        return fig
+        
+    elif chart_type == "BG":  # Bar Graph
+        fig, ax = plt.subplots(figsize=(16, 10))
+        
+        # Extract labels and values
+        labels = [item[0] for item in data]
+        values = [item[1] for item in data]
+        
+        # Create bar chart with enhanced styling
+        bars = ax.bar(labels, values, color=colors[:len(values)], 
+                     edgecolor='white', linewidth=1, alpha=0.8)
+        
+        # Add value labels on bars
+        for bar, value in zip(bars, values):
+            height = bar.get_height()
+            ax.text(bar.get_x() + bar.get_width()/2., height + max(values)*0.01,
+                   f'{value}', ha='center', va='bottom', fontweight='bold', fontsize=18)
+        
+        # Enhanced styling
+        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
+        ax.set_xlabel('Categories', fontsize=18, color='#6B7280')
+        ax.set_ylabel('Values', fontsize=18, color='#6B7280')
+        
+        # Rotate x-axis labels for better readability
+        plt.setp(ax.get_xticklabels(), rotation=45, ha='right', fontsize=16)
+        plt.setp(ax.get_yticklabels(), fontsize=16)
+        
+        # Add grid for better readability
+        ax.yaxis.grid(True, alpha=0.3)
+        ax.set_axisbelow(True)
+        
+        # Add business name watermark
+        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
+                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
+        
+        plt.tight_layout()
+        return fig
+        
+    elif chart_type == "LG":  # Line Graph
+        fig, ax = plt.subplots(figsize=(16, 10))
+        
+        # Extract data
+        x_values = [item[0] for item in data]
+        y_values = [item[1] for item in data]
+        
+        # Create line chart with enhanced styling
+        ax.plot(x_values, y_values, color='#FF6B6B', linewidth=3, marker='o', 
+               markersize=8, markerfacecolor='white', markeredgecolor='#FF6B6B')
+        
+        # Fill area under line
+        ax.fill_between(x_values, y_values, alpha=0.3, color='#4ECDC4')
+        
+        # Enhanced styling
+        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
+        ax.set_xlabel('Time Period', fontsize=18, color='#6B7280')
+        ax.set_ylabel('Values', fontsize=18, color='#6B7280')
+        
+        # Add grid
+        ax.grid(True, alpha=0.3)
+        ax.set_axisbelow(True)
+        
+        # Increase tick label font sizes
+        plt.setp(ax.get_xticklabels(), fontsize=16)
+        plt.setp(ax.get_yticklabels(), fontsize=16)
+        
+        # Add business name watermark
+        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
+                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
+        
+        plt.tight_layout()
+        return fig
+        
+    elif chart_type == "PG":  # Pie Graph
+        fig, ax = plt.subplots(figsize=(14, 10))
+        
+        # Extract labels and values
+        labels = [item[0] for item in data]
+        values = [item[1] for item in data]
+        
+        # Create pie chart with enhanced styling
+        wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
+                                         autopct='%1.1f%%', startangle=90,
+                                         wedgeprops=dict(edgecolor='white', linewidth=2),
+                                         textprops={'fontsize': 18})
+        
+        # Enhanced title styling
+        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
+        
+        # Add business name watermark
+        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
+                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
+        
+        plt.tight_layout()
+        return fig
+    
+    return None
+
+def create_chart_from_data(chart_info: Dict[str, Any], business_idea: str) -> bytes:
+    """Create a matplotlib chart from parsed chart data with enhanced styling"""
+    try:
+        chart_type = chart_info["type"]
+        chart_title = chart_info["title"]
+        data = chart_info["data"]
+        
+        # logging.info(f"Creating chart: {chart_type} - {chart_title} with {len(data)} data points")
+        
+        # Use enhanced styling function
+        fig = create_enhanced_chart_style(chart_type, data, chart_title, business_idea)
+        
+        if fig is None:
+            # Fallback to original method if enhanced styling fails
+            if chart_type == "DC":  # Doughnut Chart
+                fig, ax = plt.subplots(figsize=(14, 10))  # Larger size for better visibility
+                
+                # Extract labels and values from data
+                labels = [item[0] for item in data]
+                values = [item[1] for item in data]
+                
+                # High contrast color scheme
+                colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
+                
+                # Create doughnut chart
+                wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
+                                                 autopct='%1.1f%%', startangle=90,
+                                                 wedgeprops=dict(width=0.6, edgecolor='white', linewidth=2),
+                                                 textprops={'fontsize': 18})
+                
+                # Enhanced title
+                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
+                
+                # Add legend
+                ax.legend(wedges, labels, title="Categories", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1), fontsize=16)
+                
+                plt.tight_layout()
+            elif chart_type == "BG":  # Bar Graph
+                fig, ax = plt.subplots(figsize=(16, 10))
+                
+                # Extract labels and values
+                labels = [item[0] for item in data]
+                values = [item[1] for item in data]
+                
+                # High contrast color scheme
+                colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
+                
+                # Create bar chart
+                bars = ax.bar(labels, values, color=colors[:len(values)], 
+                             edgecolor='white', linewidth=1, alpha=0.8)
+                
+                # Add value labels on bars
+                for bar, value in zip(bars, values):
+                    height = bar.get_height()
+                    ax.text(bar.get_x() + bar.get_width()/2., height + max(values)*0.01,
+                           f'{value}', ha='center', va='bottom', fontweight='bold', fontsize=18)
+                
+                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
+                ax.set_xlabel('Categories', fontsize=18, color='#6B7280')
+                ax.set_ylabel('Values', fontsize=18, color='#6B7280')
+                
+                # Rotate x-axis labels
+                plt.setp(ax.get_xticklabels(), rotation=45, ha='right', fontsize=16)
+                plt.setp(ax.get_yticklabels(), fontsize=16)
+                
+                # Add grid
+                ax.yaxis.grid(True, alpha=0.3)
+                ax.set_axisbelow(True)
+                
+                plt.tight_layout()
+            elif chart_type == "LG":  # Line Graph
+                fig, ax = plt.subplots(figsize=(16, 10))
+                
+                # Extract data
+                x_values = [item[0] for item in data]
+                y_values = [item[1] for item in data]
+                
+                # Create line chart
+                ax.plot(x_values, y_values, color='#FF6B6B', linewidth=3, marker='o', 
+                       markersize=8, markerfacecolor='white', markeredgecolor='#FF6B6B')
+                
+                # Fill area under line
+                ax.fill_between(x_values, y_values, alpha=0.3, color='#4ECDC4')
+                
+                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
+                ax.set_xlabel('Time Period', fontsize=18, color='#6B7280')
+                ax.set_ylabel('Values', fontsize=18, color='#6B7280')
+                
+                # Add grid
+                ax.grid(True, alpha=0.3)
+                ax.set_axisbelow(True)
+                
+                # Increase tick label font sizes
+                plt.setp(ax.get_xticklabels(), fontsize=16)
+                plt.setp(ax.get_yticklabels(), fontsize=16)
+                
+                plt.tight_layout()
+            elif chart_type == "PG":  # Pie Graph
+                fig, ax = plt.subplots(figsize=(14, 10))
+                
+                # Extract labels and values
+                labels = [item[0] for item in data]
+                values = [item[1] for item in data]
+                
+                # High contrast color scheme
+                colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
+                
+                # Create pie chart
+                wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
+                                                 autopct='%1.1f%%', startangle=90,
+                                                 wedgeprops=dict(edgecolor='white', linewidth=2),
+                                                 textprops={'fontsize': 18})
+                
+                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
+                
+                plt.tight_layout()
+            else:
+                # logging.warning(f"Unknown chart type: {chart_type}")
+                return None
+        
+        # Save to bytes
+        buffer = io.BytesIO()
+        fig.savefig(buffer, format='png', dpi=300, bbox_inches='tight', 
+                   facecolor='white', edgecolor='none')
+        buffer.seek(0)
+        chart_bytes = buffer.getvalue()
+        buffer.close()
+        
+        # Close the figure to free memory
+        plt.close(fig)
+        
+        return chart_bytes
+        
+    except Exception as e:
+        # logging.error(f"Failed to create chart: {str(e)}")
+        return None
+
+def fix_base64_padding(base64_string: str) -> str:
+    """Fix common base64 padding issues"""
+    # Remove any whitespace or newlines
+    base64_string = base64_string.strip()
+    
+    # Add padding if needed
+    missing_padding = len(base64_string) % 4
+    if missing_padding:
+        base64_string += '=' * (4 - missing_padding)
+    
+    return base64_string
+
+def robust_base64_decode(base64_string: str) -> Optional[bytes]:
+    """Robustly decode base64 string with error handling and padding correction"""
+    try:
+        # First try direct decoding
+        return base64.b64decode(base64_string)
+    except Exception as e1:
+        try:
+            # Try with padding correction
+            fixed_string = fix_base64_padding(base64_string)
+            return base64.b64decode(fixed_string)
+        except Exception as e2:
+            try:
+                # Try with URL-safe base64
+                return base64.urlsafe_b64decode(fix_base64_padding(base64_string))
+            except Exception as e3:
+                try:
+                    # Try with standard base64 ignoring padding
+                    return base64.b64decode(base64_string + '==', validate=False)
+                except Exception as e4:
+                    return None

app/DocumentGeneration/document_helpers.py

@@ -0,0 +1,159 @@
+# Document Helper Functions
+# Contains helper functions like filter_empty_sections(), extract_business_name_from_content(), etc.
+
+import re
+import os
+import sys
+from typing import List, Dict, Any
+
+# Add the parent directory to sys.path to import from models.py
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from models import ExportSection
+
+def extract_business_name_from_content(sections: List[ExportSection]) -> str:
+    """Extract business name from markdown content"""
+    for section in sections:
+        if section.content:
+            lines = section.content.split('\n')
+            for i, line in enumerate(lines):
+                line = line.strip()
+                # Look for "Business Name:" pattern
+                if '**Business Name:**' in line or 'Business Name:' in line:
+                    # Extract the business name from the line
+                    if '**Business Name:**' in line:
+                        business_name = line.split('**Business Name:**')[1].strip()
+                    else:
+                        business_name = line.split('Business Name:')[1].strip()
+                    
+                    # Keep markdown formatting - don't strip ** symbols
+                    # business_name = re.sub(r'[*_`~]', '', business_name)
+                    business_name = business_name.strip()
+                    
+                    if business_name:
+                        return business_name
+                    
+                    # If not found on same line, check next line
+                    if i + 1 < len(lines):
+                        next_line = lines[i + 1].strip()
+                        business_name = next_line  # Keep ** symbols
+                        business_name = business_name.strip()
+                        if business_name:
+                            return business_name
+    
+    return None
+
+def extract_subheadings(content: str) -> List[str]:
+    """Extract subheadings from markdown content"""
+    subheadings = []
+    lines = content.split('\n')
+    
+    for line in lines:
+        line = line.strip()
+        # Look for various markdown header patterns
+        if (line.startswith('##') and not line.startswith('###')) or \
+           line.startswith('**') and line.endswith('**') and len(line) > 4:
+            # Remove markdown formatting and clean up
+            if line.startswith('##'):
+                subheading = re.sub(r'^##+\s*', '', line)
+            else:
+                # Handle bold text that might be headings - keep ** symbols
+                subheading = line  # Keep ** symbols instead of stripping them
+            
+            # subheading = re.sub(r'[*_`~]', '', subheading)  # Commented out to preserve ** symbols
+            if subheading.strip() and len(subheading.strip()) > 3:  # Avoid very short headings
+                subheadings.append(subheading.strip())
+    
+    return subheadings
+
+
+
+
+
+
+
+
+
+
+
+def filter_empty_sections(sections: List[ExportSection]) -> List[ExportSection]:
+    """Filter out sections with no content to prevent empty pages"""
+    filtered_sections = []
+    
+    for section in sections:
+        if section.content and section.content.strip():
+            # Clean the content to check if it's actually meaningful
+            cleaned_content = section.content # No clean_text_for_pdf import, so use raw content
+            if cleaned_content and len(cleaned_content.strip()) > 10:  # At least 10 characters
+                filtered_sections.append(section)
+                # logging.info(f"Section '{section.title}' passed filtering with {len(cleaned_content)} characters")
+            else:
+                # logging.info(f"Section '{section.title}' filtered out - content too short: {len(cleaned_content) if cleaned_content else 0} chars")
+                pass
+        else:
+            # logging.info(f"Section '{section.title}' filtered out - no content")
+            pass
+    
+    # logging.info(f"Filtered sections: {len(filtered_sections)} out of {len(sections)} total")
+    return filtered_sections
+
+
+def remove_duplicate_headings(content: str) -> str:
+    """Remove duplicate headings from content"""
+    if not content:
+        return content
+    
+    lines = content.split('\n')
+    cleaned_lines = []
+    seen_headings = set()
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            cleaned_lines.append('')
+            continue
+        
+        # Check if this is any type of heading
+        is_heading = False
+        heading_text = ""
+        
+        # Markdown headings (# ## ### etc.)
+        if line.startswith('#'):
+            heading_text = re.sub(r'^#+\s*', '', line).strip()
+            is_heading = True
+        
+        # Bold headings (**text**)
+        elif line.startswith('**') and line.endswith('**') and len(line) > 4:
+            heading_text = line[2:-2].strip()  # Remove ** symbols
+            is_heading = True
+        
+        # Check for numbered headings (e.g., "8.1 Management Team")
+        elif re.match(r'^\d+\.?\d*\s+', line):
+            heading_text = re.sub(r'^\d+\.?\d*\s+', '', line).strip()
+            is_heading = True
+        
+        if is_heading and heading_text:
+            # Normalize the heading text for comparison
+            normalized_text = heading_text.lower().strip()
+            
+            # Also check for variations with "and" vs "&"
+            variations = [
+                normalized_text,
+                normalized_text.replace(' & ', ' and '),
+                normalized_text.replace(' and ', ' & '),
+                normalized_text.replace('&', 'and'),
+                normalized_text.replace('and', '&')
+            ]
+            
+            # Check if any variation has been seen before
+            is_duplicate = any(var in seen_headings for var in variations)
+            
+            if not is_duplicate:
+                # Add all variations to seen set
+                for var in variations:
+                    seen_headings.add(var)
+                cleaned_lines.append(line)
+            # Skip duplicate headings
+        else:
+            cleaned_lines.append(line)
+    
+    return '\n'.join(cleaned_lines)

app/DocumentGeneration/grouped.py

@@ -0,0 +1,304 @@
+import re
+from typing import List, Dict, Any
+
+def calculate_group_height(pdf, group: Dict[str, Any]) -> int:
+    """Calculate the estimated height needed for a complete group"""
+    subheading_type = group['subheading_type']
+    content_lines = group['content'].split('\n') if group['content'] else []
+    
+    # Base height for subheading
+    if subheading_type == 'h1':
+        subheading_height = 25  # 20pt font + spacing
+    elif subheading_type == 'h2':
+        subheading_height = 20  # 16pt font + underline + spacing
+    elif subheading_type == 'h3':
+        subheading_height = 16  # 14pt font + spacing
+    elif subheading_type == 'h4':
+        subheading_height = 14  # 12pt font + spacing
+    elif subheading_type == 'bold':
+        subheading_height = 20  # 16pt font + spacing
+    elif subheading_type == 'numbered':
+        subheading_height = 20  # 16pt font + spacing
+    else:
+        subheading_height = 16
+    
+    # Calculate content height more accurately
+    content_height = 0
+    for line in content_lines:
+        if line.strip():
+            # More accurate line height calculation
+            words = line.split()
+            if len(words) > 0:
+                # Estimate characters per line (roughly 80-90 chars per line)
+                chars_per_line = 85
+                estimated_lines = max(1, len(line) // chars_per_line + 1)
+                line_height = estimated_lines * 8  # 8pt per line
+                content_height += line_height
+            else:
+                content_height += 8  # Empty line
+        else:
+            content_height += 3  # Empty line spacing
+    
+    # Add spacing between groups
+    group_spacing = 8
+    
+    total_height = subheading_height + content_height + group_spacing
+    
+    print(f"DEBUG: Group '{group.get('subheading_clean', 'Unknown')[:30]}...' height calculation:")
+    print(f"  Subheading height: {subheading_height}")
+    print(f"  Content height: {content_height}")
+    print(f"  Group spacing: {group_spacing}")
+    print(f"  Total height: {total_height}")
+    
+    return total_height
+
+def should_break_page_for_group(pdf, group: Dict[str, Any], current_y: int, page_height: int = 280) -> bool:
+    """Determine if we should break to a new page for this group"""
+    estimated_height = calculate_group_height(pdf, group)
+    
+    print(f"DEBUG: should_break_page_for_group called")
+    print(f"DEBUG:   Subheading: '{group.get('subheading_clean', 'Unknown')[:30]}...'")
+    print(f"DEBUG:   Current Y: {current_y}")
+    print(f"DEBUG:   Estimated height: {estimated_height}")
+    print(f"DEBUG:   Page height: {page_height}")
+    print(f"DEBUG:   Available space: {page_height - current_y}")
+    print(f"DEBUG:   Will fit? {current_y + estimated_height <= page_height}")
+    
+    # CRITICAL FIX: Only break if the group absolutely won't fit
+    # This prevents splitting subheadings from their content
+    
+    # If the group won't fit on current page, break
+    if current_y + estimated_height > page_height:
+        print(f"DEBUG:   -> BREAKING: Group won't fit ({current_y} + {estimated_height} > {page_height})")
+        return True
+    
+    # If we're very close to the end of the page (less than 50mm remaining) and group is significant, break
+    if current_y > page_height - 50 and estimated_height > 30:
+        print(f"DEBUG:   -> BREAKING: Very close to end of page ({current_y} > {page_height - 50}) and group significant ({estimated_height} > 30)")
+        return True
+    
+    print(f"DEBUG:   -> NO BREAK: Group will fit on current page")
+    return False
+
+def clean_markdown_from_line(line: str) -> str:
+    """Clean markdown formatting from a single line"""
+    if not line:
+        return ""
+    
+    cleaned = line
+    
+    # Remove bold, italic formatting
+    cleaned = re.sub(r'\*\*(.*?)\*\*', r'\1', cleaned)  # Remove bold
+    cleaned = re.sub(r'\*(.*?)\*', r'\1', cleaned)  # Remove italic
+    cleaned = re.sub(r'`(.*?)`', r'\1', cleaned)  # Remove code
+    cleaned = re.sub(r'~~(.*?)~~', r'\1', cleaned)  # Remove strikethrough
+    
+    # Remove emphasis markers
+    cleaned = re.sub(r'_{1,2}(.*?)_{1,2}', r'\1', cleaned)  # Remove underscores
+    cleaned = re.sub(r'\*{1,2}(.*?)\*{1,2}', r'\1', cleaned)  # Remove asterisks
+    
+    # Remove links (keep text)
+    cleaned = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', cleaned)  # Remove links, keep text
+    
+    # Remove any remaining HTML-like tags
+    cleaned = re.sub(r'<[^>]+>', '', cleaned)
+    
+    # CRITICAL FIX: Replace multiple spaces with single space to prevent double spaces
+    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
+    
+    return cleaned.strip()
+
+def parse_content_into_groups(content: str) -> List[Dict[str, Any]]:
+    """Parse markdown content into subheading-content groups"""
+    if not content:
+        return []
+    
+    print(f"DEBUG: parse_content_into_groups called with content length: {len(content)}")
+    
+    lines = content.split('\n')
+    groups = []
+    current_group = None
+    
+    for i, line in enumerate(lines):
+        line = line.strip()
+        if not line:
+            if current_group:
+                current_group['content_lines'].append('')  # Preserve empty lines
+            continue
+        
+        # Check if this is a heading (H1, H2, H3, H4, or numbered)
+        is_heading = (
+            line.startswith('# ') or  # H1
+            (line.startswith('## ') and not line.startswith('### ')) or  # H2
+            (line.startswith('### ') and not line.startswith('#### ')) or  # H3
+            (line.startswith('#### ') and not line.startswith('##### ')) or  # H4
+            re.match(r'^\d+\.\d+\s+', line)  # Numbered subheadings like "3.6 SWOT Analysis"
+        )
+        
+        # Check if this is bold text
+        is_bold_text = (
+            (line.startswith('**') and line.endswith('**') and len(line) > 4) or  # Bold headings
+            (re.match(r'^\*\*.*?\*\*:', line) and len(line) > 4)  # Bold text before colon as heading
+        )
+
+        # Check if this is a bold list item (e.g., "- **Item**")
+        is_bold_list_item = re.match(r'^[-*]\s*\*\*(.*?)\*\*$', line)
+        
+        # Special handling for bold text following numbered subheadings
+        should_create_new_group = False
+        
+        if is_heading:
+            # Always create new group for regular headings
+            should_create_new_group = True
+            print(f"DEBUG: Line {i+1} '{line[:50]}...' - Regular heading, creating new group")
+        elif is_bold_text:
+            # Check if we should treat this bold text as content for a numbered subheading
+            if groups and groups[-1].get('subheading_type') == 'h3':
+                # Check if the previous group's subheading looks like a numbered subheading
+                previous_subheading = groups[-1].get('subheading', '')
+                if re.match(r'^\d+\.\d+\s+', previous_subheading):
+                    # This is content for a numbered subheading, add to previous group
+                    groups[-1]['content_lines'].append(line)
+                    print(f"DEBUG: Line {i+1} '{line[:50]}...' - Adding to previous numbered subheading '{previous_subheading[:30]}...'")
+                    continue  # Skip creating new group
+                else:
+                    # Not a numbered subheading, treat as new heading
+                    should_create_new_group = True
+                    print(f"DEBUG: Line {i+1} '{line[:50]}...' - Treating as NEW HEADING (not numbered subheading)")
+            else:
+                # No previous group or not a numbered subheading, treat as new heading
+                should_create_new_group = True
+                print(f"DEBUG: Line {i+1} '{line[:50]}...' - Treating as NEW HEADING (no numbered subheading)")
+        elif is_bold_list_item:
+            # If it's a bold list item, treat it as a new heading
+            should_create_new_group = True
+            print(f"DEBUG: Line {i+1} '{line[:50]}...' - Bold list item, creating new group")
+        
+        if should_create_new_group:
+            # Save previous group if it exists
+            if current_group:
+                current_group['content'] = '\n'.join(current_group['content_lines'])
+                groups.append(current_group)
+                print(f"DEBUG: Saved group '{current_group.get('subheading_clean', 'Unknown')[:30]}...' with {len(current_group['content_lines'])} content lines")
+            
+            # Clean markdown symbols BEFORE determining type and storing
+            clean_text = line
+            heading_type = 'text'
+            
+            if line.startswith('# '):
+                clean_text = line[2:].strip()  # Remove "# "
+                heading_type = 'h1'
+            elif line.startswith('## '):
+                clean_text = line[3:].strip()  # Remove "## "
+                heading_type = 'h2'
+            elif line.startswith('### '):
+                clean_text = line[4:].strip()  # Remove "### "
+                heading_type = 'h3'
+            elif line.startswith('#### '):
+                clean_text = line[5:].strip()  # Remove "#### "
+                heading_type = 'h4'
+            elif re.match(r'^\d+\.\d+\s+', line):
+                clean_text = line.strip()  # Keep numbered headings as-is
+                heading_type = 'numbered'
+            elif is_bold_text:
+                # Remove ** markers from bold text
+                clean_text = clean_markdown_from_line(line.strip())
+                heading_type = 'bold'
+            elif is_bold_list_item:
+                # Extract the bold text from list item and treat as H3 subheading
+                # Remove the list marker and ** markers
+                clean_text = re.sub(r'^[-*]\s*\*\*(.*?)\*\*', r'\1', line.strip())
+                heading_type = 'h3'  # Treat as H3 subheading
+            
+            print(f"DEBUG: Creating new group '{clean_text[:30]}...' (type: {heading_type})")
+            
+            # Start new group with cleaned text
+            current_group = {
+                'subheading': line,  # Keep original for reference
+                'content_lines': [],
+                'content': '',
+                'subheading_clean': clean_text,  # Pre-cleaned text
+                'subheading_type': heading_type
+            }
+        else:
+            # Add to current group's content - clean the line
+            if current_group:
+                cleaned_line = clean_markdown_from_line(line)
+                current_group['content_lines'].append(cleaned_line)
+                if i < 5:  # Log first few content lines
+                    print(f"DEBUG: Added content line to group '{current_group.get('subheading_clean', 'Unknown')[:30]}...': '{cleaned_line[:50]}...'")
+            else:
+                # Content before any subheading - create a default group
+                if not groups or groups[-1].get('subheading') != '## Introduction':
+                    cleaned_line = clean_markdown_from_line(line)
+                    current_group = {
+                        'subheading': '## Introduction',
+                        'content_lines': [cleaned_line],
+                        'content': '',
+                        'subheading_clean': 'Introduction',
+                        'subheading_type': 'h2'
+                    }
+    
+    # Don't forget the last group
+    if current_group:
+        current_group['content'] = '\n'.join(current_group['content_lines'])
+        groups.append(current_group)
+        print(f"DEBUG: Saved final group '{current_group.get('subheading_clean', 'Unknown')[:30]}...' with {len(current_group['content_lines'])} content lines")
+    
+    # Add metadata to each group
+    for i, group in enumerate(groups):
+        group['group_id'] = f"group_{i}"
+        group['content_length'] = len(group['content'])
+        group['word_count'] = len(group['content'].split()) if group['content'] else 0
+        group['has_charts'] = 'CHART' in group['content'].upper() if group['content'] else False
+        group['line_count'] = len([line for line in group['content'].split('\n') if line.strip()])
+    
+    print(f"DEBUG: Created {len(groups)} groups total")
+    return groups
+
+def extract_key_phrases(content: str) -> List[tuple]:
+    """Extract key phrases from content for grouping metadata"""
+    if not content:
+        return []
+    
+    # Simple key phrase extraction
+    words = re.findall(r'\b\w+\b', content.lower())
+    word_freq = {}
+    
+    for word in words:
+        if len(word) > 3:  # Only words longer than 3 characters
+            word_freq[word] = word_freq.get(word, 0) + 1
+    
+    # Return top 5 most frequent words
+    return sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
+
+def get_content_groups_info(content: str) -> Dict[str, Any]:
+    """Get detailed information about content groups for analysis and debugging"""
+    if not content:
+        return {"groups": [], "summary": {"total_groups": 0, "total_content_length": 0}}
+    
+    groups = parse_content_into_groups(content)
+    
+    # Add key phrases to each group
+    for group in groups:
+        group['key_phrases'] = extract_key_phrases(group['content'])
+    
+    # Calculate summary statistics
+    total_content_length = sum(group['content_length'] for group in groups)
+    total_word_count = sum(group['word_count'] for group in groups)
+    groups_with_charts = sum(1 for group in groups if group['has_charts'])
+    
+    summary = {
+        "total_groups": len(groups),
+        "total_content_length": total_content_length,
+        "total_word_count": total_word_count,
+        "groups_with_charts": groups_with_charts,
+        "average_group_size": total_content_length / len(groups) if groups else 0,
+        "largest_group": max(groups, key=lambda g: g['content_length'])['subheading_clean'] if groups else None,
+        "smallest_group": min(groups, key=lambda g: g['content_length'])['subheading_clean'] if groups else None
+    }
+    
+    return {
+        "groups": groups,
+        "summary": summary
+    }

app/DocumentGeneration/live_pdf_generator.py

@@ -0,0 +1,126 @@
+# Live PDF Generator Module
+# Enables real-time PDF updates as content changes
+
+import asyncio
+import io
+import tempfile
+import os
+from typing import Dict, Any, Optional, AsyncGenerator
+from fpdf import FPDF
+import base64
+
+import sys
+import os
+sys.path.append(os.path.dirname(__file__))
+from pdf_generator import create_pdf_document
+from models import ExportRequest
+
+class LivePDFGenerator:
+    """Generates and streams PDF updates in real-time"""
+    
+    def __init__(self):
+        self.active_sessions: Dict[str, 'PDFSession'] = {}
+    
+    async def create_live_session(self, business_plan_id: str, initial_request: ExportRequest) -> str:
+        """Create a new live PDF session"""
+        session_id = f"pdf_session_{business_plan_id}_{int(asyncio.get_event_loop().time())}"
+        
+        session = PDFSession(session_id, business_plan_id, initial_request)
+        self.active_sessions[session_id] = session
+        
+        # Generate initial PDF
+        await session.update_pdf(initial_request)
+        
+        return session_id
+    
+    async def update_session(self, session_id: str, updated_request: ExportRequest) -> bool:
+        """Update an existing PDF session with new content"""
+        if session_id not in self.active_sessions:
+            return False
+        
+        session = self.active_sessions[session_id]
+        await session.update_pdf(updated_request)
+        return True
+    
+    async def stream_pdf_updates(self, session_id: str) -> AsyncGenerator[bytes, None]:
+        """Stream PDF updates as they occur"""
+        if session_id not in self.active_sessions:
+            return
+        
+        session = self.active_sessions[session_id]
+        async for pdf_chunk in session.stream_updates():
+            yield pdf_chunk
+    
+    def close_session(self, session_id: str):
+        """Close and cleanup a PDF session"""
+        if session_id in self.active_sessions:
+            del self.active_sessions[session_id]
+
+class PDFSession:
+    """Individual PDF session that manages real-time updates"""
+    
+    def __init__(self, session_id: str, business_plan_id: str, initial_request: ExportRequest):
+        self.session_id = session_id
+        self.business_plan_id = business_plan_id
+        self.current_request = initial_request
+        self.update_queue = asyncio.Queue()
+        self.is_active = True
+        self.last_pdf_bytes: Optional[bytes] = None
+        
+    async def update_pdf(self, new_request: ExportRequest):
+        """Update the PDF with new content"""
+        self.current_request = new_request
+        
+        try:
+            # Generate new PDF
+            pdf_bytes, filename = create_pdf_document(new_request)
+            self.last_pdf_bytes = pdf_bytes
+            
+            # Notify subscribers of update
+            await self.update_queue.put({
+                'type': 'pdf_update',
+                'data': base64.b64encode(pdf_bytes).decode('utf-8'),
+                'filename': filename,
+                'timestamp': asyncio.get_event_loop().time()
+            })
+            
+        except Exception as e:
+            # Notify subscribers of error
+            await self.update_queue.put({
+                'type': 'pdf_error',
+                'error': str(e),
+                'timestamp': asyncio.get_event_loop().time()
+            })
+    
+    async def stream_updates(self) -> AsyncGenerator[bytes, None]:
+        """Stream PDF updates as they occur"""
+        while self.is_active:
+            try:
+                # Wait for updates with timeout
+                update = await asyncio.wait_for(self.update_queue.get(), timeout=30.0)
+                
+                if update['type'] == 'pdf_update':
+                    # Send SSE event for PDF update
+                    event_data = f"event: pdf_update\ndata: {{\"data\": \"{update['data']}\", \"filename\": \"{update['filename']}\"}}\n\n"
+                    yield event_data.encode('utf-8')
+                    
+                elif update['type'] == 'pdf_error':
+                    # Send SSE event for error
+                    error_data = f"event: pdf_error\ndata: {{\"error\": \"{update['error']}\"}}\n\n"
+                    yield error_data.encode('utf-8')
+                    
+            except asyncio.TimeoutError:
+                # Send keep-alive
+                yield b": keep-alive\n\n"
+            except Exception as e:
+                # Send error event
+                error_data = f"event: stream_error\ndata: {str(e)}\n\n"
+                yield error_data.encode('utf-8')
+                break
+    
+    def close(self):
+        """Close this session"""
+        self.is_active = False
+
+# Global instance
+live_pdf_generator = LivePDFGenerator()

app/DocumentGeneration/markdown_renderer.py

@@ -0,0 +1,759 @@
+# Markdown Renderer Module
+# Contains all markdown rendering functions for both PDF and Word
+
+import re
+import base64
+import os
+import sys
+import tempfile
+from typing import List, Dict, Any, Optional
+
+# Import from the same directory (Document Generation)
+from grouped import parse_content_into_groups, should_break_page_for_group
+from chart_generator import create_chart_from_data
+
+def clean_markdown_text(text: str) -> str:
+    """Clean markdown formatting for PDF generation - PRESERVE HEADINGS"""
+    if not text:
+        return ""
+    
+    # Remove markdown formatting BUT PRESERVE HEADING STRUCTURE
+    cleaned = text
+    
+    # PRESERVE HEADINGS - don't strip the # markers, keep them for rendering
+    # We'll handle styling at render time instead of stripping them
+    
+    # Remove bold, italic formatting - strip ** or * symbols
+    cleaned = re.sub(r'\*\*(.*?)\*\*', r'\1', cleaned)  # Remove bold
+    cleaned = re.sub(r'\*(.*?)\*', r'\1', cleaned)  # Remove italic
+    cleaned = re.sub(r'`(.*?)`', r'\1', cleaned)  # Remove code
+    cleaned = re.sub(r'~~(.*?)~~', r'\1', cleaned)  # Remove strikethrough
+    
+    # Remove links (keep text)
+    cleaned = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', cleaned)  # Remove links, keep text
+    cleaned = re.sub(r'!\[([^\]]*)\]\([^)]+\)', '', cleaned)  # Remove images
+    
+    # Remove list markers (more aggressive)
+    cleaned = re.sub(r'^\s*[-*+]\s*', '', cleaned, flags=re.MULTILINE)  # Remove list markers
+    cleaned = re.sub(r'^\s*\d+\.\s*', '', cleaned, flags=re.MULTILINE)  # Remove numbered list markers
+    cleaned = re.sub(r'^\s*[-*+]\s*', '', cleaned, flags=re.MULTILINE)  # Remove any remaining list markers
+    
+    # Remove blockquotes
+    cleaned = re.sub(r'^\s*>\s*', '', cleaned, flags=re.MULTILINE)  # Remove blockquotes
+    
+    # Remove horizontal rules
+    cleaned = re.sub(r'^\s*[-*_]{3,}\s*$', '', cleaned, flags=re.MULTILINE)  # Remove horizontal rules
+    
+    # Remove code blocks
+    cleaned = re.sub(r'```[\s\S]*?```', '', cleaned)  # Remove code blocks
+    cleaned = re.sub(r'`.*?`', '', cleaned)  # Remove any remaining inline code
+    
+    # Remove emphasis markers - strip ** or * symbols
+    cleaned = re.sub(r'_{1,2}(.*?)_{1,2}', r'\1', cleaned)  # Remove underscores
+    cleaned = re.sub(r'\*{1,2}(.*?)\*{1,2}', r'\1', cleaned)  # Remove asterisks
+    
+    # PRESERVE CHART DATA MARKERS for inline processing
+    # DO NOT REMOVE chart markers - they will be processed inline
+    # cleaned = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', cleaned, flags=re.DOTALL)
+    # cleaned = re.sub(r'<!--CHARTDATASTART-->.*$', '', cleaned, flags=re.DOTALL)
+    # cleaned = re.sub(r'<!--CHARTDATAEND-->', '', cleaned)
+    
+    # REMOVE CHART DATA MARKERS for PDF rendering since they're not being processed
+    cleaned = re.sub(r'<!--CHART_DATA_START-->.*?<!--CHART_DATA_END-->', '', cleaned, flags=re.DOTALL)
+    cleaned = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', cleaned, flags=re.DOTALL)
+    
+    # Remove any remaining HTML-like tags
+    cleaned = re.sub(r'<[^>]+>', '', cleaned)
+    
+    # Clean up extra whitespace and formatting
+    cleaned = re.sub(r'\n\s*\n\s*\n+', '\n\n', cleaned)  # Remove excessive line breaks
+    cleaned = re.sub(r'^\s+', '', cleaned, flags=re.MULTILINE)  # Remove leading whitespace
+    cleaned = re.sub(r'\s+$', '', cleaned, flags=re.MULTILINE)  # Remove trailing whitespace
+    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
+    
+    # Final cleanup
+    cleaned = cleaned.strip()
+    
+    return cleaned
+
+def clean_text_for_pdf(text: str) -> str:
+    """Clean text specifically for PDF generation, handling Unicode issues"""
+    if not text:
+        return ""
+    
+    # First clean markdown
+    cleaned = clean_markdown_text(text)
+    
+    # Replace problematic Unicode characters with ASCII equivalents
+    unicode_replacements = {
+        '\u2019': "'",  # Right single quotation mark
+        '\u2018': "'",  # Left single quotation mark
+        '\u201C': '"',  # Left double quotation mark
+        '\u201D': '"',  # Right double quotation mark
+        '\u2013': '-',  # En dash
+        '\u2014': '--', # Em dash
+        '\u2022': '•',  # Bullet
+        '\u2026': '...', # Horizontal ellipsis
+        '\u00A0': ' ',  # Non-breaking space
+        '\u00B0': '°',  # Degree sign
+        '\u00AE': '(R)', # Registered trademark
+        '\u2122': '(TM)', # Trademark
+        '\u00A9': '(C)', # Copyright
+    }
+    
+    for unicode_char, replacement in unicode_replacements.items():
+        cleaned = cleaned.replace(unicode_char, replacement)
+
+    # Additional space normalization after Unicode replacements to prevent double spaces
+    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
+    
+    return cleaned
+
+def process_content_with_inline_charts(doc, content: str, business_idea: str):
+    """Process content and render charts inline where they appear in the text"""
+    try:
+        from docx.shared import Inches
+    except ImportError:
+        raise Exception("python-docx is not installed. Please install it with: pip install python-docx")
+    
+    # Split content by chart markers - handle both formats
+    chart_pattern = r'<!--CHART_DATA_START-->(.*?)<!--CHART_DATA_END-->'
+    parts = re.split(chart_pattern, content, flags=re.DOTALL)
+    
+    # If no charts found, try alternative format
+    if len(parts) == 1:
+        chart_pattern = r'<!--CHARTDATASTART-->(.*?)<!--CHARTDATAEND-->'
+        parts = re.split(chart_pattern, content, flags=re.DOTALL)
+    
+    for i, part in enumerate(parts):
+        if i % 2 == 0:  # Regular content
+            if part.strip():
+                render_markdown_to_docx_grouped(doc, part.strip())
+        else:  # Chart data
+            try:
+                chart_array = eval(part.strip())
+                for chart_item in chart_array:
+                    if len(chart_item) >= 5:
+                        chart_type = chart_item[1]
+                        chart_title = chart_item[2]
+                        data = chart_item[4]
+                        
+                        # Add chart title
+                        doc.add_heading(f"{chart_title}", level=2)
+                        
+                        # Create and add chart
+                        chart_info = {
+                            "type": chart_type,
+                            "title": chart_title,
+                            "data": data
+                        }
+                        
+                        chart_bytes = create_chart_from_data(chart_info, business_idea)
+                        
+                        if chart_bytes:
+                            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
+                                tmp_img.write(chart_bytes)
+                                temp_img_path = tmp_img.name
+                            
+                            # Add image to Word document
+                            doc.add_picture(temp_img_path, width=Inches(6.0))  # 6 inches width
+                            
+                            # Clean up temp file
+                            os.remove(temp_img_path)
+            except Exception as e:
+                # If chart processing fails, just render the raw content
+                if part.strip():
+                    render_markdown_to_docx_grouped(doc, part.strip())
+
+
+def render_markdown_to_pdf(pdf, content: str, primary_color, accent_color, text_color):
+    """Render markdown content to PDF with proper heading styling and page break logic"""
+    if not content:
+        return
+    
+    lines = content.split('\n')
+    current_y = pdf.get_y()
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            # Check if we need a page break for empty line
+            if current_y + 10 > 280:  # 280mm is roughly where we want to break
+                pdf.add_page()
+                current_y = 25
+            else:
+                pdf.ln(3)  # Consistent space for empty lines
+                current_y = pdf.get_y()
+            continue
+        
+        # Calculate estimated height needed for this line
+        estimated_height = 12  # Base height for text
+        
+        # Handle different heading levels
+        if line.startswith("# "):    # H1 - Main heading (like "Company Profile")
+            estimated_height = 25  # Heading + line + spacing
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            text = line[2:].strip()
+            pdf.set_font("Arial", "B", 20)  # Bold, size 20
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 10, text)
+            
+            # Calculate text width and make line autofit
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 12, 160)  # Add 12mm padding, max 160mm
+            
+            # Add subtle line under main heading - consistent with section titles
+            pdf.set_draw_color(221, 221, 221)  # Lighter gray line (#DDDDDD)
+            pdf.set_line_width(0.3)  # Thin line
+            pdf.line(25, current_y + 10, 25 + line_width, current_y + 10)
+            
+            current_y = pdf.get_y()
+            pdf.ln(8)  # Consistent space after main heading
+            current_y = pdf.get_y()
+            
+        elif line.startswith("## ") or re.match(r'^\d+\.\d+\s+', line):   # H2 - Subheading or numbered subheading
+            estimated_height = 20  # Subheading + line + spacing
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            text = line[3:].strip() if line.startswith("## ") else line.strip()
+            pdf.set_font("Arial", "B", 16)  # Bold, size 16
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, text)
+            
+            # Calculate text width and make line autofit
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 10, 160)  # Add 10mm padding, max 160mm
+            
+            # Add subtle line under subheading - consistent styling
+            pdf.set_draw_color(221, 221, 221)  # Lighter gray line (#DDDDDD)
+            pdf.set_line_width(0.3)  # Thin line
+            pdf.line(25, current_y + 8, 25 + line_width, current_y + 8)
+            
+            current_y = pdf.get_y()
+            pdf.ln(6)  # Consistent space after subheading
+            current_y = pdf.get_y()
+            
+        elif re.match(r'^\d+\.\d+\s+[A-Z]', line):  # Numbered subheadings like "3.6 SWOT Analysis"
+            estimated_height = 20  # Subheading + line + spacing
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            text = line.strip()
+            pdf.set_font("Arial", "B", 16)  # Bold, size 16
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, text)
+
+            
+            current_y = pdf.get_y()
+            pdf.ln(6)  # Consistent space after subheading
+            current_y = pdf.get_y()
+            
+        elif line.startswith("### ") or line.startswith("#### "):  # H3/H4 - Smaller subheadings
+            estimated_height = 18  # Subheading + spacing
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            text = line[4:].strip() if line.startswith("### ") else line[5:].strip()
+            pdf.set_font("Arial", "B", 14)  # Bold, size 14
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, text)
+            
+            current_y = pdf.get_y()
+            pdf.ln(4)  # Consistent space after subheading
+            current_y = pdf.get_y()
+            
+        elif line.startswith("**") and line.endswith("**"):  # Bold text that might be a heading
+            text = line.strip()  # Keep ** markers
+            # Check if this looks like a main heading (no numbers, not too long)
+            if not re.match(r'^\d+\.', text) and len(text) < 50:
+                estimated_height = 22  # Heading + line + spacing
+                if current_y + estimated_height > 280:
+                    pdf.add_page()
+                    current_y = 25
+                
+                pdf.set_font("Arial", "B", 18)  # Bold, size 18
+                pdf.set_text_color(*primary_color)  # Black
+                pdf.set_xy(25, current_y)
+                pdf.multi_cell(160, 9, text)
+                
+                current_y = pdf.get_y()
+                pdf.ln(6)  # Consistent space after heading
+                current_y = pdf.get_y()
+            else:
+                # Regular bold text
+                estimated_height = 12
+                if current_y + estimated_height > 280:
+                    pdf.add_page()
+                    current_y = 25
+                
+                pdf.set_font("Arial", "B", 12)  # Bold, size 12
+                pdf.set_text_color(*text_color)  # Dark gray
+                pdf.set_xy(25, current_y)
+                pdf.multi_cell(160, 8, text)
+                current_y = pdf.get_y()
+            
+        else:  # Normal paragraph text
+            # For long paragraphs, estimate height based on text length
+            estimated_height = max(12, len(line) // 80 * 12)  # Rough estimate
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            pdf.set_font("Arial", "", 12)  # Regular font, size 12
+            pdf.set_text_color(*text_color)  # Dark gray
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
+            current_y = pdf.get_y()
+
+
+def render_markdown_to_pdf_grouped(pdf, content: str, primary_color, accent_color, text_color):
+    """Render markdown content to PDF with subheading-content grouping and smart page breaks"""
+    if not content:
+        return
+    
+    print(f"DEBUG: render_markdown_to_pdf_grouped called with content length: {len(content)}")
+    print(f"DEBUG: FULL CONTENT:")
+    print("=" * 80)
+    print(content)
+    print("=" * 80)
+    
+    # Parse content into groups
+    groups = parse_content_into_groups(content)
+    
+    for group in groups:
+        subheading = group['subheading']
+        group_content = group['content']
+        subheading_type = group['subheading_type']
+        
+        # Get current Y position from PDF
+        current_y = pdf.get_y()
+        page_height = 280  # Approximate usable page height
+        
+        # Use smart page break logic
+        if should_break_page_for_group(pdf, group, current_y, page_height):
+            pdf.add_page()
+            current_y = 25
+            pdf.set_y(current_y)  # Set the PDF's Y position
+        
+        # Render subheading based on type - using original styling
+        # Use the pre-cleaned text from the group
+        text = group['subheading_clean']
+        
+        if subheading_type == 'h1':
+            pdf.set_font("Arial", "B", 20)  # Bold, size 20 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 10, text)
+            
+            # Calculate text width and make line autofit
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 12, 160)  # Add 12mm padding, max 160mm
+            
+            # Add subtle line under main heading - consistent with section titles
+            pdf.set_draw_color(221, 221, 221)  # Lighter gray line (#DDDDDD)
+            pdf.set_line_width(0.3)  # Thin line
+            pdf.line(25, current_y + 10, 25 + line_width, current_y + 10)
+            
+            current_y = pdf.get_y()
+            pdf.ln(8)  # Consistent space after main heading
+            current_y = pdf.get_y()
+            
+        elif subheading_type == 'h2':
+            pdf.set_font("Arial", "B", 18)  # Bold, size 18 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 9, text)
+            
+            # Add underline (original styling)
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 12, 160)
+            pdf.set_draw_color(221, 221, 221)  # Light gray line
+            pdf.set_line_width(0.3)
+            pdf.line(25, current_y + 9, 25 + line_width, current_y + 9)
+            
+            current_y = pdf.get_y()
+            pdf.ln(6)  # Space after subheading
+            current_y = pdf.get_y()
+            
+        elif subheading_type == 'h3':
+            pdf.set_font("Arial", "B", 14)  # Bold, size 14 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, text)
+            
+            current_y = pdf.get_y()
+            pdf.ln(4)  # Space after subheading
+            current_y = pdf.get_y()
+            
+        elif subheading_type == 'h4':
+            pdf.set_font("Arial", "B", 12)  # Bold, size 12 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 7, text)
+            
+            current_y = pdf.get_y()
+            pdf.ln(3)  # Space after subheading
+            current_y = pdf.get_y()
+            
+        elif subheading_type == 'bold':
+            line_height_heading = 9 # For size 18 heading
+            line_height_text = 8 # For size 12 text
+            
+            if not re.match(r'^\d+\.', text) and len(text) < 80:
+                # Main heading style
+                pdf.set_font("Arial", "B", 12) # Bold, size 12
+                pdf.set_text_color(*primary_color) # Black
+                pdf.set_xy(25, current_y)
+                pdf.multi_cell(160, 8, text) # Multi-cell for text
+                current_y = pdf.get_y() # Get updated Y position
+                pdf.ln(6)
+                current_y = pdf.get_y()
+            else:
+                # Regular bold text
+                pdf.set_font("Arial", "B", 12) # Bold, size 12
+                pdf.set_text_color(*text_color) # Dark gray
+                pdf.set_xy(25, current_y)
+                pdf.multi_cell(160, 8, text) # Multi-cell for text
+                current_y = pdf.get_y() # Get updated Y position
+            
+        elif subheading_type == 'numbered':
+            pdf.set_font("Arial", "B", 18)  # Bold, size 18 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 9, text)
+            
+            # Add underline (original styling)
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 12, 160)
+            pdf.set_draw_color(221, 221, 221)  # Light gray line
+            pdf.set_line_width(0.3)
+            pdf.line(25, current_y + 9, 25 + line_width, current_y + 9)
+            
+            current_y = pdf.get_y()
+            pdf.ln(6)  # Space after subheading
+            current_y = pdf.get_y()
+        
+        # Render grouped content with simple styling
+        if group_content:
+            content_lines = group_content.split('\n')
+            for line in content_lines:
+                if line.strip():
+                    # Check if line contains text ending with ":" that should be bold
+                    if ':' in line:
+                        # Split the line by ":" to separate the label from the content
+                        parts = line.split(':', 1)  # Split only on first ":"
+                        if len(parts) == 2:
+                            label = parts[0].strip()
+                            content = parts[1].strip()
+                            
+                            # Render label in bold
+                            pdf.set_font("Arial", "B", 12)  # Bold
+                            pdf.set_text_color(*text_color)
+                            pdf.set_xy(25, current_y)
+                            pdf.multi_cell(160, 8, label + ":")
+                            current_y = pdf.get_y()
+                            
+                            # Render content in regular font
+                            if content:
+                                pdf.set_font("Arial", "", 12)  # Regular
+                                pdf.set_text_color(*text_color)
+                                pdf.set_xy(25, current_y)
+                                pdf.multi_cell(160, 8, content, align='L')  # Left align to prevent text justification
+                                current_y = pdf.get_y()
+                        else:
+                            # No content after ":", just render the whole line
+                            pdf.set_font("Arial", "B", 12)  # Bold for labels ending with ":"
+                            pdf.set_text_color(*text_color)
+                            pdf.set_xy(25, current_y)
+                            pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
+                            current_y = pdf.get_y()
+                    elif ' - ' in line:
+                        # Split the line by " - " to separate the label from the content
+                        parts = line.split(' - ', 1)  # Split only on first " - "
+                        if len(parts) == 2:
+                            label = parts[0].strip()
+                            content = parts[1].strip()
+                            
+                            # Render label in bold
+                            pdf.set_font("Arial", "B", 12)  # Bold
+                            pdf.set_text_color(*text_color)
+                            pdf.set_xy(25, current_y)
+                            pdf.multi_cell(160, 8, label + " -")
+                            current_y = pdf.get_y()
+                            
+                            # Render content in regular font
+                            if content:
+                                pdf.set_font("Arial", "", 12)  # Regular
+                                pdf.set_text_color(*text_color)
+                                pdf.set_xy(25, current_y)
+                                pdf.multi_cell(160, 8, content, align='L')  # Left align to prevent text justification
+                                current_y = pdf.get_y()
+                        else:
+                            # No content after " - ", just render the whole line
+                            pdf.set_font("Arial", "B", 12)  # Bold for labels ending with " -"
+                            pdf.set_text_color(*text_color)
+                            pdf.set_xy(25, current_y)
+                            pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
+                            current_y = pdf.get_y()
+                    else:
+                        # Regular paragraph rendering without mixed text processing
+                        pdf.set_font("Arial", "", 12)
+                        pdf.set_text_color(*text_color)
+                        pdf.set_xy(25, current_y)
+                        pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
+                        current_y = pdf.get_y()  # Update current_y after each line
+                else:
+                    # Empty line spacing
+                    pdf.ln(3)
+                    current_y = pdf.get_y()  # Update current_y after spacing
+
+
+def render_markdown_to_docx(doc, content: str):
+    """Render markdown content to Word document with proper heading styling"""
+    if not content:
+        return
+    
+    lines = content.split('\n')
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            doc.add_paragraph()  # Empty paragraph for spacing
+            continue
+        
+        # Handle different heading levels
+        if line.startswith("# "):    # H1 - Main heading (like "Company Profile")
+            text = line[2:].strip()
+            doc.add_heading(text, level=1)
+        elif line.startswith("## ") or re.match(r'^\d+\.\d+\s+', line):   # H2 - Subheading or numbered subheading
+            text = line[3:].strip() if line.startswith("## ") else line.strip()
+            doc.add_heading(text, level=2)
+        elif re.match(r'^\d+\.\d+\s+[A-Z]', line):  # Numbered subheadings like "3.6 SWOT Analysis"
+            text = line.strip()
+            doc.add_heading(text, level=2)
+        elif line.startswith("### ") or line.startswith("#### "):  # H3/H4 - Smaller subheadings
+            text = line[4:].strip() if line.startswith("### ") else line[5:].strip()
+            doc.add_heading(text, level=3)
+        elif line.startswith("**") and line.endswith("**"):  # Bold text that might be a heading
+            text = line.strip()  # Keep ** markers
+            # Check if this looks like a main heading (no numbers, not too long)
+            if not re.match(r'^\d+\.', text) and len(text) < 50:
+                doc.add_heading(text, level=1)  # Treat as main heading
+            else:
+                # Regular bold text
+                doc.add_paragraph(text)
+        else:  # Normal paragraph text
+            # Check if line contains text ending with ":" that should be bold
+            if ':' in line:
+                # Split the line by ":" to separate the label from the content
+                parts = line.split(':', 1)  # Split only on first ":"
+                if len(parts) == 2:
+                    label = parts[0].strip()
+                    content = parts[1].strip()
+                    
+                    # Create paragraph with mixed formatting
+                    paragraph = doc.add_paragraph()
+                    # Add label in bold
+                    run = paragraph.add_run(label + ":")
+                    run.bold = True
+                    # Add content in regular font
+                    if content:
+                        run = paragraph.add_run(" " + content)
+                        run.bold = False
+                else:
+                    # No content after ":", just render the whole line in bold
+                    paragraph = doc.add_paragraph(line)
+                    paragraph.runs[0].bold = True
+            elif ' - ' in line:
+                # Split the line by " - " to separate the label from the content
+                parts = line.split(' - ', 1)  # Split only on first " - "
+                if len(parts) == 2:
+                    label = parts[0].strip()
+                    content = parts[1].strip()
+                    
+                    # Create paragraph with mixed formatting
+                    paragraph = doc.add_paragraph()
+                    # Add label in bold
+                    run = paragraph.add_run(label + " -")
+                    run.bold = True
+                    # Add content in regular font
+                    if content:
+                        run = paragraph.add_run(" " + content)
+                        run.bold = False
+                else:
+                    # No content after " - ", just render the whole line in bold
+                    paragraph = doc.add_paragraph(line)
+                    paragraph.runs[0].bold = True
+            else:
+                doc.add_paragraph(line)
+
+
+def render_markdown_to_docx_grouped(doc, content: str):
+    """Render markdown content to Word document with subheading-content grouping and smart page breaks"""
+    if not content:
+        return
+    
+    # Parse content into groups
+    groups = parse_content_into_groups(content)
+    
+    for i, group in enumerate(groups):
+        subheading = group['subheading']
+        group_content = group['content']
+        subheading_type = group['subheading_type']
+        
+        # Add page break before group if it's not the first group and the previous group was large
+        if i > 0:
+            # Check if we should add a page break to keep groups together
+            # This is a simple heuristic - in Word, we rely more on the natural flow
+            # but we can add manual page breaks for very large groups
+            if group['content_length'] > 1000:  # Large group threshold
+                doc.add_page_break()
+        
+        # Render subheading based on type - using original styling
+        # Use the pre-cleaned text from the group
+        text = group['subheading_clean']
+        
+        if subheading_type == 'h1':
+            doc.add_heading(text, level=1)
+        elif subheading_type == 'h2':
+            doc.add_heading(text, level=2)
+        elif subheading_type == 'h3':
+            doc.add_heading(text, level=3)
+        elif subheading_type == 'h4':
+            doc.add_heading(text, level=4)
+        elif subheading_type == 'bold':
+            if not re.match(r'^\d+\.', text) and len(text) < 80:
+                # Simple paragraph with bold text
+                paragraph = doc.add_paragraph(text)
+                paragraph.style = doc.styles['Heading 1'] # Apply heading style
+            else:
+                # Regular paragraph
+                doc.add_paragraph(text)
+        elif subheading_type == 'numbered':
+            doc.add_heading(text, level=2)
+        
+        # Render grouped content with simple styling
+        if group_content:
+            content_lines = group_content.split('\n')
+            for line in content_lines:
+                if line.strip():
+                    # Check if line contains text ending with ":" that should be bold
+                    if ':' in line:
+                        # Split the line by ":" to separate the label from the content
+                        parts = line.split(':', 1)  # Split only on first ":"
+                        if len(parts) == 2:
+                            label = parts[0].strip()
+                            content = parts[1].strip()
+                            
+                            # Create paragraph with mixed formatting
+                            paragraph = doc.add_paragraph()
+                            # Add label in bold
+                            run = paragraph.add_run(label + ":")
+                            run.bold = True
+                            # Add content in regular font
+                            if content:
+                                run = paragraph.add_run(" " + content)
+                                run.bold = False
+                        else:
+                            # No content after ":", just render the whole line in bold
+                            paragraph = doc.add_paragraph(line)
+                            paragraph.runs[0].bold = True
+                    elif ' - ' in line:
+                        # Split the line by " - " to separate the label from the content
+                        parts = line.split(' - ', 1)  # Split only on first " - "
+                        if len(parts) == 2:
+                            label = parts[0].strip()
+                            content = parts[1].strip()
+                            
+                            # Create paragraph with mixed formatting
+                            paragraph = doc.add_paragraph()
+                            # Add label in bold
+                            run = paragraph.add_run(label + " -")
+                            run.bold = True
+                            # Add content in regular font
+                            if content:
+                                run = paragraph.add_run(" " + content)
+                                run.bold = False
+                        else:
+                            # No content after " - ", just render the whole line in bold
+                            paragraph = doc.add_paragraph(line)
+                            paragraph.runs[0].bold = True
+                    else:
+                        # Simple paragraph addition without mixed text processing
+                        doc.add_paragraph(line)
+                else:
+                    doc.add_paragraph()  # Empty paragraph for spacing
+
+
+
+def clean_text_for_docx(text: str) -> str:
+    # Replace problematic Unicode characters with ASCII equivalents
+    unicode_replacements = {
+        '\u2019': "'",  # Right single quotation mark
+        '\u2018': "'",  # Left single quotation mark
+        '\u201C': '"',  # Left double quotation mark
+        '\u201D': '"',  # Right double quotation mark
+        '\u2013': '-',  # En dash
+        '\u2014': '--', # Em dash
+        '\u2022': '•',  # Bullet
+        '\u2026': '...', # Horizontal ellipsis
+        '\u00A0': ' ',  # Non-breaking space
+        '\u00B0': '°',  # Degree sign
+        '\u00AE': '(R)', # Registered trademark
+        '\u2122': '(TM)', # Trademark
+        '\u00A9': '(C)', # Copyright
+    }
+    
+    for unicode_char, replacement in unicode_replacements.items():
+        text = text.replace(unicode_char, replacement)
+    
+    # Simple text cleaning - keep basic punctuation and common symbols
+    text = ''.join(char for char in text if ord(char) < 128 or char in '•°$€£¥₹₩₽₪₺₴₼₸₾֏₲₡₣₦₵₨₱₫₭៛৳؋﷼%')
+    
+    return text
+
+
+
+
+
+
+
+
+
+def clean_unicode_for_pdf(text: str) -> str:
+    # Replace problematic Unicode characters with ASCII equivalents
+    unicode_replacements = {
+        '\u2019': "'",  # Right single quotation mark
+        '\u2018': "'",  # Left single quotation mark
+        '\u201C': '"',  # Left double quotation mark
+        '\u201D': '"',  # Right double quotation mark
+        '\u2013': '-',  # En dash
+        '\u2014': '--', # Em dash
+        '\u2022': '•',  # Bullet
+        '\u2026': '...', # Horizontal ellipsis
+        '\u00A0': ' ',  # Non-breaking space
+        '\u00B0': '°',  # Degree sign
+        '\u00AE': '(R)', # Registered trademark
+        '\u2122': '(TM)', # Trademark
+        '\u00A9': '(C)', # Copyright
+    }
+    
+    for unicode_char, replacement in unicode_replacements.items():
+        text = text.replace(unicode_char, replacement)
+    
+    # Simple text cleaning - keep basic punctuation and common symbols
+    text = ''.join(char for char in text if ord(char) < 128 or char in '•°$€£¥₹₩₽₪₺₴₼₸₾֏₲₡₣₦₵₨₱₫₭៛৳؋﷼%')
+    
+    return text
+

app/DocumentGeneration/mixed.py

@@ -0,0 +1,6 @@
+# This file has been removed as all its functions are not present in maintest.txt
+# Functions removed:
+# - make_sentences_ending_with_colon_bold()
+# - _render_mixed_text_to_pdf()
+# - clean_bold_text_for_pdf()
+# - process_bold_text_for_docx()

app/DocumentGeneration/table_of_content.py

@@ -0,0 +1,205 @@
+# Table of Contents Module
+# Contains functions to generate TOC AFTER content is placed with real page numbers
+
+import re
+import os
+import sys
+from typing import List, Dict, Any
+
+# Add the parent directory to sys.path to import from models.py and constants.py
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from models import ExportSection
+from constants import SECTION_ORDER
+
+def extract_first_heading_from_content(content: str) -> str:
+    """Extract the first heading from markdown content"""
+    if not content:
+        return ""
+    
+    lines = content.split('\n')
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        
+        # Check for markdown headings (# ## ### etc.)
+        if line.startswith('#'):
+            # Extract heading text without the # symbols
+            heading_text = re.sub(r'^#+\s*', '', line).strip()
+            if heading_text:
+                return heading_text
+        
+        # Check for bold headings (**text**)
+        elif line.startswith('**') and line.endswith('**') and len(line) > 4:
+            # Extract text from bold markers
+            heading_text = line[2:-2].strip()
+            if heading_text:
+                return heading_text
+    
+    return ""
+
+def generate_table_of_contents_after_content(sections: List[ExportSection], section_page_map: Dict[str, int], business_idea: str) -> List[Dict[str, Any]]:
+    """Generate TOC AFTER all content is placed, using REAL page numbers from section_page_map
+    This ensures accurate page numbers based on actual content placement"""
+    toc_items = []
+    
+    # Create a mapping from section titles to section objects for easy lookup
+    section_map = {section.title: section for section in sections}
+    
+    # Add business plan sections in the predefined SECTION_ORDER
+    for i, expected_title in enumerate(SECTION_ORDER):
+        # Find the corresponding section - try multiple matching strategies
+        section = None
+        
+        # Strategy 1: Exact title match
+        section = section_map.get(expected_title)
+        
+        # Strategy 2: Case-insensitive match
+        if not section:
+            for section_title, section_obj in section_map.items():
+                if section_title.lower() == expected_title.lower():
+                    section = section_obj
+                    break
+        
+        # Strategy 3: Partial match (e.g., "Company Profile" matches "Company Profile Section")
+        if not section:
+            for section_title, section_obj in section_map.items():
+                if (expected_title.lower() in section_title.lower() or 
+                    section_title.lower() in expected_title.lower()):
+                    section = section_obj
+                    break
+        
+        # Strategy 4: Key-based match (remove 'prompt_' prefix and match)
+        if not section:
+            for section_obj in sections:
+                if section_obj.key:
+                    key_clean = section_obj.key.replace('prompt_', '') if section_obj.key.startswith('prompt_') else section_obj.key
+                    if key_clean.lower() == expected_title.lower().replace(' ', '').replace('&', ''):
+                        section = section_obj
+                        break
+        
+        # Only add sections that have actual content AND real page numbers - NO DUMMY DATA
+        has_content = bool(section and section.content and section.content.strip())
+        if has_content:
+            # Get the REAL page number from section_page_map
+            real_page = section_page_map.get(section.title, 0)
+            if real_page > 0:  # Only add if we have a real page number
+                # Extract the actual heading from markdown content
+                actual_heading = extract_first_heading_from_content(section.content)
+                
+                # Use the actual heading from markdown content, fallback to expected title
+                toc_title = actual_heading if actual_heading else expected_title
+                
+                toc_items.append({
+                    "title": toc_title,  # Use actual heading from markdown content
+                    "level": 1,
+                    "page": real_page,  # REAL page number from actual content placement
+                    "section_type": "section",
+                    "has_content": True,
+                    "section_obj": section  # Store reference to actual section
+                })
+    
+    return toc_items
+
+def add_table_of_contents_page(pdf, toc_items: List[Dict[str, Any]], business_idea: str):
+    """Add a professional table of contents page with REAL page numbers"""
+    
+    # TOC items are already in the correct order and have real page numbers
+    sorted_toc_items = toc_items
+    
+    # Professional color scheme - Refined for bank/investor presentation
+    primary_color = (0, 0, 0)        # Black - for headings
+    accent_color = (75, 0, 130)      # Navy purple - for accent lines and highlights
+    text_color = (51, 51, 51)        # Dark gray - for body text
+    light_gray = (221, 221, 221)     # Lighter gray - for subtle lines (#DDDDDD)
+    navy_color = (25, 25, 112)       # Navy blue - for TOC and emphasis
+    
+    # Page title - more compact
+    pdf.set_font("Arial", "B", 20)  # Reduced from 24 to 20
+    pdf.set_text_color(*primary_color)
+    pdf.set_xy(25, 20)  # Reduced from 25 to 20
+    pdf.cell(0, 15, "Table of Contents", ln=True)  # Reduced from 18 to 15
+    
+    # Calculate text width and make line autofit
+    text_width = pdf.get_string_width("Table of Contents")
+    line_width = min(text_width + 12, 160)  # Add 12mm padding, max 160mm
+    
+    # Removed purple accent line under TOC title
+    
+    # TOC content - optimized for single page layout
+    y_position = 50  # Reduced from 60 to 50
+    pages_used = 1
+    
+    for item in sorted_toc_items:
+        # Only add new page if absolutely necessary (very close to bottom)
+        if y_position > 290:  # Very close to bottom margin
+            pdf.add_page()
+            y_position = 25
+            pages_used += 1
+        
+        # Indent based on level - better indentation
+        indent = 0 if item["level"] == 1 else 20  # Increased indent for subsections
+        
+        # Font and color based on level - ALL sections same color
+        if item["level"] == 1:
+            pdf.set_font("Arial", "B", 12)
+            pdf.set_text_color(*navy_color)  # Navy blue for all main entries
+        else:
+            pdf.set_font("Arial", "", 10)
+            pdf.set_text_color(*text_color)
+        
+        # Title with hyperlink
+        title_width = pdf.get_string_width(item["title"])
+        pdf.set_xy(25 + indent, y_position)
+        try:
+            # FPDF2 hyperlinks: test both 0-based and 1-based indexing
+            # First try 1-based (no subtraction)
+            target_page = item["page"]
+            # Try different FPDF2 link methods
+            if hasattr(pdf, 'add_link'):
+                link_id = pdf.add_link()
+                pdf.set_link(link_id, page=target_page)
+                pdf.link(25 + indent, y_position, title_width, 8, link_id)
+            else:
+                pdf.link(25 + indent, y_position, title_width, 8, dest=target_page)
+        except:
+            pass  # If hyperlink fails, continue without it
+        pdf.cell(title_width, 8, item["title"], ln=False)
+        
+        # Dots leading to page number
+        pdf.set_font("Arial", "", 8)
+        pdf.set_text_color(128, 128, 128)  # Medium gray for dots
+        
+        # Calculate dots position
+        title_width = pdf.get_string_width(item["title"])
+        dots_start = 25 + indent + title_width + 5
+        dots_end = 160
+        
+        # Draw dots
+        for x in range(int(dots_start), int(dots_end), 3):
+            pdf.set_xy(x, y_position + 3)
+            pdf.cell(1, 1, ".", ln=False)
+        
+        # Page number with hyperlink - NOW USING REAL PAGE NUMBERS
+        page_number_width = pdf.get_string_width(str(item["page"]))
+        pdf.set_xy(160, y_position)
+        try:
+            # FPDF2 hyperlinks: test both 0-based and 1-based indexing
+            # First try 1-based (no subtraction)
+            target_page = item["page"]
+            # Try different FPDF2 link methods
+            if hasattr(pdf, 'add_link'):
+                link_id = pdf.add_link()
+                pdf.set_link(link_id, page=target_page)
+                pdf.link(160, y_position, page_number_width, 8, link_id)
+            else:
+                pdf.link(160, y_position, page_number_width, 8, dest=target_page)
+        except:
+            pass  # If hyperlink fails, continue without it
+        pdf.cell(0, 8, str(item["page"]), ln=False)
+        
+        # Reduced spacing between items for better page utilization
+        y_position += 8  # Reduced from 10 to 8 for even tighter spacing
+    
+    # Add some spacing at the end
+    pdf.ln(20)

app/__init__.py

@@ -0,0 +1,29 @@
+# App Package
+# This file makes the app directory a proper Python package
+
+import os
+import sys
+
+# Add the current directory to sys.path
+current_dir = os.path.dirname(__file__)
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+# Import main modules for easy access
+from models import ExportRequest, ExportSection, ExportResponse, SectionJob, BatchGenerateRequest, GenerateRequest, CreatePlanRequest
+from constants import SECTION_ORDER, SECTION_MAP, SECTION_COLUMNS
+from utils import sort_sections_by_order
+
+__all__ = [
+    'ExportRequest',
+    'ExportSection', 
+    'ExportResponse',
+    'SectionJob',
+    'BatchGenerateRequest',
+    'GenerateRequest',
+    'CreatePlanRequest',
+    'SECTION_ORDER',
+    'SECTION_MAP',
+    'SECTION_COLUMNS',
+    'sort_sections_by_order'
+]

app/constants.py

@@ -0,0 +1,41 @@
+# Constants and Configuration
+# Contains constants and configuration values to avoid circular imports
+
+# Human-readable section titles for TOC and display
+SECTION_ORDER = [
+    "Executive Summary",
+    "Company Profile", 
+    "Market Analysis",
+    "Product or Service",
+    "Business Model",
+    "Marketing & Growth",
+    "Operations Plan",
+    "Management Team",
+    "Financial Plan & Funding"
+]
+
+# Database helper constants
+SECTION_MAP = {
+    "prompt_ExecutiveSummary": ("executiveSummary", "executiveSummaryComplete", "executiveSummaryGenerating"),
+    "prompt_CompanyProfile": ("companyProfile", "companyProfileComplete", "companyProfileGenerating"),
+    "prompt_MarketAnalysis": ("marketAnalysis", "marketAnalysisComplete", "marketAnalysisGenerating"),
+    "prompt_ProductOrService": ("productOrService", "productOrServiceComplete", "productOrServiceGenerating"),
+    "prompt_BusinessModel": ("businessModel", "businessModelComplete", "businessModelGenerating"),
+    "prompt_MarketingGrowth": ("marketingGrowth", "marketingGrowthComplete", "marketingGrowthGenerating"),
+    "prompt_OperationsPlan": ("operationsPlan", "operationsPlanComplete", "operationsPlanGenerating"),
+    "prompt_ManagementTeam": ("managementTeam", "managementTeamComplete", "managementTeamGenerating"),
+    "prompt_FinancialPlanFunding": ("financialPlanFunding", "financialPlanFundingComplete", "financialPlanFundingGenerating"),
+}
+
+# Database column names for sections
+SECTION_COLUMNS = [
+    "executiveSummary",
+    "companyProfile",
+    "marketAnalysis",
+    "productOrService",
+    "businessModel",
+    "marketingGrowth",
+    "operationsPlan",
+    "managementTeam",
+    "financialPlanFunding",
+]

app/main.py

@@ -0,0 +1,1741 @@
+##########################
+#        NEW MAIN APP        #
+##########################
+import os
+import asyncio
+import asyncpg
+import logging
+from typing import List, Dict, Any, Optional, Literal
+import re
+import time
+import ssl
+import json
+from datetime import datetime
+import pathlib as Path
+import uuid
+import base64
+import io
+import tempfile
+
+# ──────────────────────────────────────────────────────────────────────────────
+# CUID generator (25-char, starts with "c")
+# ──────────────────────────────────────────────────────────────────────────────
+import hashlib, socket, random
+import matplotlib
+
+# Fix matplotlib permission issues by setting cache directory to a writable location
+os.environ['MPLCONFIGDIR'] = '/tmp/matplotlib_cache'
+matplotlib.use('Agg')  # Use non-interactive backend for server environments
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+_CUID_COUNTER = 0
+def _base36(n: int) -> str:
+    chars = "0123456789abcdefghijklmnopqrstuvwxyz"
+    if n == 0: return "0"
+    s = []
+    nn = abs(n)
+    while nn:
+        nn, r = divmod(nn, 36)
+        s.append(chars[r])
+    s = "".join(reversed(s))
+    return "-" + s if n < 0 else s
+
+def _pad36(n: int, width: int) -> str:
+    s = _base36(n)
+    return s.rjust(width, "0")[-width:]
+
+def _fingerprint_block() -> str:
+    src = f"{socket.gethostname()}-{os.getpid()}"
+    h = int(hashlib.md5(src.encode()).hexdigest(), 16)
+    return _pad36(h, 4)
+
+def _rand_block() -> str:
+    # 36^4 = 1,679,616; use 20 random bits then base36-pad to 4 chars
+    return _pad36(random.SystemRandom().getrandbits(20), 4)
+
+def new_cuid() -> str:
+    global _CUID_COUNTER
+    ts = int(time.time() * 1000)
+    _CUID_COUNTER = (_CUID_COUNTER + 1) % (36**4)  # 0..36^4-1
+    return "c" + _pad36(ts, 8) + _pad36(_CUID_COUNTER, 4) + _fingerprint_block() + _rand_block() + _rand_block()
+
+from dotenv import load_dotenv
+load_dotenv()  # Load environment variables from .env into os.environ
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import Query
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from starlette.responses import StreamingResponse
+from typing import AsyncIterator
+from collections import defaultdict
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+import asyncpg
+from jose import jwt, JWTError
+
+# LangChain / LLMs
+from langchain_openai import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from langchain.schema.runnable import RunnableSequence
+from langchain.schema import AIMessage
+from langchain.llms.base import LLM
+
+from huggingface_hub import InferenceClient
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Document Generation Imports
+# ──────────────────────────────────────────────────────────────────────────────
+import sys
+import os
+
+# Add the Document Generation and Currency Mapping paths to sys.path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'DocumentGeneration'))
+sys.path.append(os.path.join(os.path.dirname(__file__), 'CurrencyMapping'))
+
+# Import models
+from models import ExportRequest, ExportSection, ExportResponse, SectionJob, BatchGenerateRequest, GenerateRequest, CreatePlanRequest
+
+# Import constants
+from constants import SECTION_ORDER, SECTION_MAP, SECTION_COLUMNS
+
+# Import utilities
+from utils import sort_sections_by_order
+
+# Now import the modules
+import sys
+import os
+
+# Add the Document Generation and Currency Mapping paths to sys.path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'DocumentGeneration'))
+sys.path.append(os.path.join(os.path.dirname(__file__), 'CurrencyMapping'))
+
+from DocumentGeneration.pdf_generator import create_pdf_document
+from DocumentGeneration.word_generator import create_word_document
+from DocumentGeneration.live_pdf_generator import live_pdf_generator
+from DocumentGeneration.chart_generator import parse_embedded_chart_data, create_chart_from_data
+from DocumentGeneration.table_of_content import generate_table_of_contents_after_content, add_table_of_contents_page
+from DocumentGeneration.document_helpers import (
+    extract_business_name_from_content,
+    filter_empty_sections,
+    extract_subheadings,
+    remove_duplicate_headings
+)
+from DocumentGeneration.grouped import parse_content_into_groups, extract_key_phrases, get_content_groups_info
+from DocumentGeneration.markdown_renderer import (
+    clean_text_for_pdf,
+    render_markdown_to_pdf,
+    render_markdown_to_pdf_grouped,
+    render_markdown_to_docx,
+    render_markdown_to_docx_grouped,
+    clean_text_for_docx
+)
+from CurrencyMapping.currency_mapping import convert_currency_symbols_to_iso
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Logging
+# ──────────────────────────────────────────────────────────────────────────────
+logging.basicConfig(level=logging.INFO)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# SSE broker
+# ──────────────────────────────────────────────────────────────────────────────
+# --- In-memory SSE broker keyed by businessPlanId ---
+SUBSCRIBERS: dict[str, set[asyncio.Queue[str]]] = defaultdict(set)
+
+def _sse_format(event: str, payload: dict) -> str:
+    return f"event: {event}\n" f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
+
+async def _publish(plan_id: str, event: str, payload: dict) -> None:
+    msg = _sse_format(event, payload)
+    for q in list(SUBSCRIBERS.get(plan_id, set())):
+        try:
+            q.put_nowait(msg)
+        except Exception:
+            SUBSCRIBERS[plan_id].discard(q)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Environment checks
+# ──────────────────────────────────────────────────────────────────────────────
+def check_environment_variables():
+    hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    if not hf_token:
+        logging.warning("⚠️ HUGGINGFACEHUB_API_TOKEN not set. Hugging Face models will not work properly.")
+    else:
+        logging.info("✅ HUGGINGFACEHUB_API_TOKEN is set")
+    
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        logging.warning("⚠️ OPENAI_API_KEY not set. OpenAI GPT models will not work properly.")
+    else:
+        logging.info("✅ OPENAI_API_KEY is set")
+
+check_environment_variables()
+
+logging.info("=" * 80)
+logging.info("MODEL SIZE LIMITATIONS:")
+logging.info("The free tier of Hugging Face Inference API limits models to 10GB.")
+logging.info("Large models like Qwen-2.5-7B (15GB) and Llama-2-7B (13GB) exceed this limit.")
+logging.info("We've configured smaller alternative models as replacements.")
+logging.info("For full-sized models, upgrade to Hugging Face Pro subscription.")
+logging.info("=" * 80)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# FastAPI app & CORS
+# ──────────────────────────────────────────────────────────────────────────────
+app = FastAPI()
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    start_time = time.time()
+    response = await call_next(request)
+    process_time = time.time() - start_time
+    logging.info(f"Request: {request.method} {request.url.path} - Status: {response.status_code} - Time: {process_time:.2f}s")
+    return response
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=["*"]
+)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Allow all origins (adjust for production usage)
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+# Fixed list of business questions (order matters)
+# ───────────────────────────────────��──────────────────────────────────────────
+QUESTIONS = [
+    "What is your business name?",
+    "What product or service do you offer?",
+    "Who is your target customer?",
+    "What problem does your business solve?",
+    "Who are your competitors?",
+    "What is your unique value proposition?",
+    "What is your pricing strategy?",
+    "What are your short-term goals?",
+    "What are your long-term goals?",
+    "How will you acquire customers?",
+]
+
+# ──────────────────────────────────────────────────────────────────────────────
+# SectionKey type
+# ──────────────────────────────────────────────────────────────────────────────
+SectionKey = Literal[
+    "prompt_ExecutiveSummary","prompt_CompanyProfile","prompt_MarketAnalysis",
+    "prompt_ProductOrService","prompt_BusinessModel","prompt_MarketingGrowth",
+    "prompt_OperationsPlan","prompt_ManagementTeam","prompt_FinancialPlanFunding"
+]
+
+class SectionJob(BaseModel):
+    sectionKey: SectionKey
+    # The server will load prompt/model defaults from GeneratePrompt.
+    # Client MAY override but is not required to send these.
+    prompt: Optional[str] = None
+    promptVariables: Dict[str, str] = {}
+    model: Optional[str] = None
+    provider: Optional[str] = None
+    temperature: Optional[float] = None
+    maxTokens: Optional[int] = None
+
+# Database helper constants
+
+# Database helper functions
+
+
+
+def extract_summary_from_markdown(markdown_text: str, max_length: int = 200) -> str:
+    """Extract a summary from markdown text, removing headers and formatting"""
+    if not markdown_text:
+        return ""
+    
+    # Try to find the first header as a title
+    lines = markdown_text.split('\n')
+    for line in lines:
+        if line.strip().startswith('#'):
+            header_text = re.sub(r'^#+\s*', '', line.strip())
+            if header_text:
+                return header_text[:max_length]
+    
+    # Fallback to first non-empty line
+    for line in lines:
+        clean_line = re.sub(r'[*_`~#]', '', line.strip())
+        if clean_line:
+            return clean_line[:max_length]
+    
+    return "Generated Business Plan"
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Helpers for status flags
+# ──────────────────────────────────────────────────────────────────────────────
+async def _ensure_sections_row(pool, business_plan_id: str) -> None:
+    async with pool.acquire() as conn:
+        await conn.execute(
+            'INSERT INTO "BusinessPlanSection" ("id","businessPlanId","updatedAt") '
+            'VALUES ($1,$2, now()) ON CONFLICT ("businessPlanId") DO NOTHING',
+            new_cuid(), business_plan_id
+        )
+
+async def charge_full_plan_once(
+    pool,
+    *,
+    business_plan_id: str,
+    user_id: Optional[str],
+    plan_type: Optional[str],
+) -> tuple[bool, int]:
+    """
+    Charges ONE credit for a full-plan generation, once per business_plan_id.
+    Returns (charged_now, current_credits_after).
+    - Only runs for plan_type == 'full' and authenticated users.
+    - Idempotent via CreditCharge(businessPlanId) unique constraint.
+    - Updates User.currentCredits -= 1 and User.totalUsedCredits += 1 atomically.
+    """
+    if plan_type != "full":
+        return (False, -1)
+    if not user_id:
+        # Full plans require a signed-in user (credits live on users)
+        raise HTTPException(status_code=401, detail="Sign in required to generate a full plan.")
+
+
+    async with pool.acquire() as conn:
+        # If we've already charged this plan, just return current credits tally.
+        already = await conn.fetchval(
+            'SELECT 1 FROM "CreditCharge" WHERE "businessPlanId"=$1',
+            business_plan_id,
+        )
+        if already:
+            # return current balance for UI if you want to display it
+            bal = await conn.fetchval(
+                'SELECT "currentCredits" FROM "User" WHERE "id"=$1',
+                user_id,
+            )
+            return (False, int(bal) if bal is not None else -1)
+
+        # Charge once in a transaction; guards concurrency
+        async with conn.transaction():
+            # Lock the user row
+            row = await conn.fetchrow(
+                'SELECT "currentCredits","totalUsedCredits" FROM "User" WHERE "id"=$1 FOR UPDATE',
+                user_id,
+            )
+            if not row:
+                raise HTTPException(status_code=404, detail="User not found.")
+            current = int(row["currentCredits"] or 0)
+            if current <= 0:
+                raise HTTPException(status_code=402, detail="Insufficient credits.")
+
+            # Deduct and increment usage
+            await conn.execute(
+                'UPDATE "User" SET "currentCredits" = "currentCredits" - 1, "totalUsedCredits" = "totalUsedCredits" + 1 WHERE "id"=$1',
+                user_id,
+            )
+            # Mark this plan as charged
+            await conn.execute(
+                'INSERT INTO "CreditCharge" ("id","businessPlanId","userId") VALUES ($1,$2,$3)',
+                new_cuid(), business_plan_id, user_id,
+            )
+
+            # Return new balance
+            new_bal = await conn.fetchval(
+                'SELECT "currentCredits" FROM "User" WHERE "id"=$1',
+                user_id,
+            )
+            return (True, int(new_bal) if new_bal is not None else -1)
+
+async def _set_section_status(pool, *, business_plan_id: str, section_key: str, generating: bool, complete: bool) -> None:
+    if section_key not in SECTION_MAP:
+        return
+    _, col_complete, col_generating = SECTION_MAP[section_key]
+    async with pool.acquire() as conn:
+        await conn.execute(
+            f'''
+            UPDATE "BusinessPlanSection"
+            SET "{col_generating}"=$2,
+                "{col_complete}"=$3,
+                "updatedAt"=now()
+            WHERE "businessPlanId"=$1
+            ''',
+            business_plan_id, generating, complete
+        )
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Request model
+# ──────────────────────────────────────────────────────────────────────────────
+class GenerateRequest(BaseModel):
+    answers: List[str]
+    model: str
+    prompt: str
+    promptVariables: Dict[str, str]
+    provider: str
+    temperature: float
+    maxTokens: int
+    # NEW — optional, for persistence & ownership
+    businessPlanId: Optional[str] = None
+    planType: Optional[str] = "free"
+    userId: Optional[str] = None           # will be overridden by verified JWT
+    anonymousId: Optional[str] = None
+    countryCode: Optional[str] = None
+    sectionKey: Optional[str] = None       # e.g. "prompt_ExecutiveSummary"
+    returnContent: Optional[bool] = False  # NEW — default to id-only responses 
+
+# ──────────────────────────────────────────────────────────────────────────────
+# LLM plumbing
+# ──────────────────────────────────────────────────────────────────────────────
+def clean_markdown_text(text: str) -> str:
+    """Clean markdown formatting for PDF generation - PRESERVE HEADINGS"""
+    if not text:
+        return ""
+    
+    # Remove markdown formatting BUT PRESERVE HEADING STRUCTURE
+    cleaned = text
+    
+    # PRESERVE HEADINGS - don't strip the # markers, keep them for rendering
+    # We'll handle styling at render time instead of stripping them
+    
+    # Keep bold, italic formatting - don't strip ** or * symbols
+    # cleaned = re.sub(r'\*\*(.*?)\*\*', r'\1', cleaned)  # Remove bold - COMMENTED OUT
+    # cleaned = re.sub(r'\*(.*?)\*', r'\1', cleaned)  # Remove italic - COMMENTED OUT
+    cleaned = re.sub(r'`(.*?)`', r'\1', cleaned)  # Remove code
+    cleaned = re.sub(r'~~(.*?)~~', r'\1', cleaned)  # Remove strikethrough
+    
+    # Remove links (keep text)
+    cleaned = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', cleaned)  # Remove links, keep text
+    cleaned = re.sub(r'!\[([^\]]*)\]\([^)]+\)', '', cleaned)  # Remove images
+    
+    # Remove list markers (more aggressive)
+    cleaned = re.sub(r'^\s*[-*+]\s*', '', cleaned, flags=re.MULTILINE)  # Remove list markers
+    cleaned = re.sub(r'^\s*\d+\.\s*', '', cleaned, flags=re.MULTILINE)  # Remove numbered list markers
+    cleaned = re.sub(r'^\s*[-*+]\s*', '', cleaned, flags=re.MULTILINE)  # Remove any remaining list markers
+    
+    # Remove blockquotes
+    cleaned = re.sub(r'^\s*>\s*', '', cleaned, flags=re.MULTILINE)  # Remove blockquotes
+    
+    # Remove horizontal rules
+    cleaned = re.sub(r'^\s*[-*_]{3,}\s*$', '', cleaned, flags=re.MULTILINE)  # Remove horizontal rules
+    
+    # Remove code blocks
+    cleaned = re.sub(r'```[\s\S]*?```', '', cleaned)  # Remove code blocks
+    cleaned = re.sub(r'`.*?`', '', cleaned)  # Remove any remaining inline code
+    
+    # Keep emphasis markers - don't strip ** or * symbols
+    # cleaned = re.sub(r'_{1,2}(.*?)_{1,2}', r'\1', cleaned)  # Remove underscores - COMMENTED OUT
+    # cleaned = re.sub(r'\*{1,2}(.*?)\*{1,2}', r'\1', cleaned)  # Remove asterisks - COMMENTED OUT
+    
+    # REMOVE RAW CHART DATA MARKERS (CRITICAL FIX)
+    cleaned = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', cleaned, flags=re.DOTALL)
+    cleaned = re.sub(r'<!--CHARTDATASTART-->.*$', '', cleaned, flags=re.DOTALL)
+    cleaned = re.sub(r'<!--CHARTDATAEND-->', '', cleaned)
+    
+    # Remove any remaining HTML-like tags
+    cleaned = re.sub(r'<[^>]+>', '', cleaned)
+    
+    # Clean up extra whitespace and formatting
+    cleaned = re.sub(r'\n\s*\n\s*\n+', '\n\n', cleaned)  # Remove excessive line breaks
+    cleaned = re.sub(r'^\s+', '', cleaned, flags=re.MULTILINE)  # Remove leading whitespace
+    cleaned = re.sub(r'\s+$', '', cleaned, flags=re.MULTILINE)  # Remove trailing whitespace
+    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
+    
+    # Final cleanup
+    cleaned = cleaned.strip()
+    
+    return cleaned
+
+
+def generate_model_output(model: str, provider: str, api_key: str, prompt: str, max_tokens: int = 4000) -> str:
+    try:
+        logging.info(f"Initializing InferenceClient with provider: {provider}")
+        client = InferenceClient(provider=provider, api_key=api_key)
+        logging.info(f"Sending request to model: {model} with prompt length: {len(prompt)} and max_tokens: {max_tokens}")
+        completion = client.chat.completions.create(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=max_tokens,
+        )
+        logging.info(f"Successfully received response from model: {model} with content length: {len(completion.choices[0].message.content)}")
+        return completion.choices[0].message.content
+    except Exception as e:
+        error_message = f"Error generating output with model {model}: {str(e)}"
+        logging.error(error_message)
+        raise Exception(error_message) from e
+
+class HFInferenceLLM(LLM):
+    model: str = None
+    provider: str = "hf-inference"
+    api_key: str = ""
+    max_tokens: int = 4000
+
+    def __init__(self, model: str, provider: str = "hf-inference", api_key: str = "", max_tokens: int = 4000):
+        super().__init__()
+        self.model = model
+        self.provider = provider
+        self.api_key = api_key
+        self.max_tokens = max_tokens
+        
+        if not api_key:
+            logging.error(f"No API key provided for model {model}")
+            raise ValueError(f"API key is required for Hugging Face Inference API access to {model}")
+        try:
+            _ = InferenceClient(provider=provider, api_key=api_key)
+            logging.info(f"Successfully initialized client for model: {model}")
+        except Exception as e:
+            logging.error(f"Failed to initialize client for model {model}: {str(e)}")
+            raise ValueError(f"Could not initialize Hugging Face client for {model}: {str(e)}")
+
+    @property
+    def _llm_type(self) -> str:
+        return "hf_inference"
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        return generate_model_output(
+            model=self.model,
+            provider=self.provider,
+            api_key=self.api_key,
+            prompt=prompt,
+            max_tokens=self.max_tokens
+        )
+
+    def get_num_tokens(self, prompt: str) -> int:
+        return len(prompt.split())
+
+# def get_llm(model_name: str, provider: str = "hf-inference"):
+#     hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+#     if not hf_token:
+#         logging.error("HUGGINGFACEHUB_API_TOKEN environment variable not set")
+#         raise ValueError("HUGGINGFACEHUB_API_TOKEN environment variable is required for Hugging Face models")
+        
+#     if model_name == "BPGenerateAI":
+#         openai_api_key = os.getenv("OPENAI_API_KEY")
+#         if not openai_api_key:
+#             logging.error("OPENAI_API_KEY environment variable not set")
+#             raise ValueError("OPENAI_API_KEY environment variable is required for GPT models")
+#         return ChatOpenAI(
+#             model_name="gpt-4.1-mini",
+#             temperature=0.7,
+#             max_tokens=6000,
+#             openai_api_key=openai_api_key
+#         )
+#     elif model_name == "BPSuggestionsAI":
+#         openai_api_key = os.getenv("OPENAI_API_KEY")
+#         if not openai_api_key:
+#             logging.error("OPENAI_API_KEY environment variable not set")
+#             raise ValueError("OPENAI_API_KEY environment variable is required for GPT models")
+#         return ChatOpenAI(
+#             model_name="gpt-4.1-nano",
+#             temperature=0.7,
+#             max_tokens=4000,
+#             openai_api_key=openai_api_key
+#         )
+#     elif model_name.lower() == "gpt-4.1-nano":
+#         openai_api_key = os.getenv("OPENAI_API_KEY")
+#         if not openai_api_key:
+#             raise ValueError("OPENAI_API_KEY is required for GPT models")
+#         return ChatOpenAI(
+#             model_name="gpt-4.1-nano",
+#             temperature=0.7,
+#             max_tokens=4000,
+#             openai_api_key=openai_api_key
+#         )
+#     else:
+#         return HFInferenceLLM(
+#             model=model_name,
+#             provider=provider,
+#             api_key=hf_token,
+#             max_tokens=4000
+#         )
+def get_llm(model_name: str, provider: str):
+    """
+    Strict provider routing.
+    - provider='openai' -> use OpenAI (requires OPENAI_API_KEY)
+    - provider in {'hf-inference','together'} -> use Hugging Face InferenceClient (requires HUGGINGFACEHUB_API_TOKEN)
+    - No automatic fallbacks.
+    """
+    if not provider:
+        raise ValueError("No provider specified. Set provider to 'openai', 'hf-inference', or 'together'.")
+    provider = provider.lower()
+
+    supported = {"openai", "hf-inference", "together"}
+    if provider not in supported:
+        raise ValueError(f"Unsupported provider '{provider}'. Must be one of {sorted(supported)}.")
+
+    # ─────────────────────────────────────────────────────────────
+    # OPENAI
+    # ─────────────────────────────────────────────────────────────
+    if provider == "openai":
+        openai_api_key = os.getenv("OPENAI_API_KEY")
+        if not openai_api_key:
+            raise ValueError("OPENAI_API_KEY is required when provider='openai'.")
+
+        # Map your aliases to concrete OpenAI models; allow raw names too.
+        if model_name == "BPGenerateAI":
+            model = "gpt-4.1-mini"
+            max_tokens = 6000
+        elif model_name in ("BPSuggestionsAI", "gpt-4.1-nano"):
+            model = "gpt-4.1-nano"
+            max_tokens = 4000
+        else:
+            model = model_name
+            max_tokens = 4000
+
+        return ChatOpenAI(
+            model_name=model,
+            temperature=0.7,
+            max_tokens=max_tokens,
+            openai_api_key=openai_api_key,
+        )
+
+    # ─────────────────────────────────────────────────────────────
+    # HF Inference (and compatible providers like 'together')
+    # ─────────────────────────────────────────────────────────────
+    hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    if not hf_token:
+        raise ValueError(f"HUGGINGFACEHUB_API_TOKEN is required when provider='{provider}'.")
+
+    # Map your aliases to HF models; allow raw names too.
+    if model_name == "BPGenerateAI":
+        model = "mistralai/Mistral-7B-Instruct-v0.3"
+        max_tokens = 4000
+    elif model_name == "BPSuggestionsAI":
+        model = "Qwen/Qwen2.5-3B-Instruct"  # smaller/faster for suggestions
+        max_tokens = 4000
+    else:
+        model = model_name
+        max_tokens = 4000
+
+    return HFInferenceLLM(
+        model=model,
+        provider=provider,           # 'hf-inference' or 'together'
+        api_key=hf_token,
+        max_tokens=max_tokens
+    )
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Supabase JWT verification
+# ──────────────────────────────────────────────────────────────────────────────
+SUPABASE_JWT_SECRET = os.getenv("SUPABASE_JWT_SECRET")
+SUPABASE_JWT_AUD = os.getenv("SUPABASE_JWT_AUD")  # optional; e.g. "authenticated"
+
+def _get_bearer_token(request: Request) -> Optional[str]:
+    auth = request.headers.get("Authorization", "")
+    if auth.startswith("Bearer "):
+        return auth.split(" ", 1)[1].strip()
+    return None
+
+def get_user_id_from_request(request: Request) -> Optional[str]:
+    token = _get_bearer_token(request)
+    if not token or not SUPABASE_JWT_SECRET:
+        return None
+    # basic shape check: header.payload.signature
+    if token.count(".") != 2:
+        logging.info("Authorization header present but not a JWT; skipping verification.")
+        return None
+    try:
+        if SUPABASE_JWT_AUD:
+            payload = jwt.decode(token, SUPABASE_JWT_SECRET, algorithms=["HS256"], audience=SUPABASE_JWT_AUD)
+        else:
+            payload = jwt.decode(token, SUPABASE_JWT_SECRET, algorithms=["HS256"])
+        return payload.get("sub")
+    except JWTError as e:
+        logging.warning(f"JWT verification failed: {e}")
+        return None
+
+def verify_supabase_jwt(token: str) -> Optional[str]:
+    """
+    Verify a Supabase JWT token and return the user ID (sub claim).
+    
+    Args:
+        token: The JWT token string
+        
+    Returns:
+        The user ID from the 'sub' claim, or None if verification fails
+    """
+    if not token or not SUPABASE_JWT_SECRET:
+        return None
+    
+    # basic shape check: header.payload.signature
+    if token.count(".") != 2:
+        logging.info("Token is not a valid JWT format; skipping verification.")
+        return None
+    
+    try:
+        if SUPABASE_JWT_AUD:
+            payload = jwt.decode(token, SUPABASE_JWT_SECRET, algorithms=["HS256"], audience=SUPABASE_JWT_AUD)
+        else:
+            payload = jwt.decode(token, SUPABASE_JWT_SECRET, algorithms=["HS256"])
+        return payload.get("sub")
+    except JWTError as e:
+        logging.warning(f"JWT verification failed: {e}")
+        return None
+
+# --- Ownership resolver: prefer verified user; else anonymous ---
+def resolve_owner(request: Request, provided_anonymous_id: Optional[str]) -> tuple[Optional[str], Optional[str]]:
+    """
+    Returns (user_id, anonymous_id):
+    - If Authorization JWT is present and valid -> (user_id, None)
+    - Else -> (None, provided_anonymous_id or None)
+    """
+    user_id = get_user_id_from_request(request)
+    if user_id:
+        return user_id, None
+    return None, (provided_anonymous_id or None)
+
+# --- Optional: guard plan ownership to prevent hijacking ---
+async def assert_plan_ownership(pool, *, business_plan_id: str, user_id: Optional[str], anonymous_id: Optional[str]) -> None:
+    """
+    - If plan has a userId: only that user can modify it.
+    - If plan has an anonymousId: only the same anonymousId can modify it.
+    - If plan has neither: allow (legacy).
+    Raises HTTPException(403) if not allowed.
+    """
+    if not business_plan_id:
+        return
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow('SELECT "userId","anonymousId" FROM "BusinessPlan" WHERE id=$1', business_plan_id)
+        if not row:
+            return
+        plan_user = row["userId"]
+        plan_anon = row["anonymousId"]
+
+        # If plan belongs to a user, you must be that user
+        if plan_user:
+            if not user_id or user_id != plan_user:
+                raise HTTPException(status_code=403, detail="Not allowed to modify this plan (user mismatch).")
+
+        # If plan belongs to an anonymous identity, you must present the same anonymousId
+        if plan_anon and not plan_user:
+            if anonymous_id != plan_anon:
+                raise HTTPException(status_code=403, detail="Not allowed to modify this plan (anonymous mismatch).")
+# ──────────────────────────────────────────────────────────────────────────────
+# Database (asyncpg pooled)
+# ──────────────────────────────────────────────────────────────────────────────
+DATABASE_URL = os.getenv("DATABASE_URL")  # pooled endpoint recommended (6543)
+DB_CA_CERT_PEM  = os.getenv("DB_CA_CERT_PEM")
+
+@app.on_event("startup")
+async def startup_event():
+    if not DATABASE_URL:
+        logging.error("DATABASE_URL not set; DB writes disabled.")
+        return
+
+    if not DB_CA_CERT_PEM:
+        raise RuntimeError("DB_CA_CERT_PEM is not set. Provide the PEM certificate content in the environment.")
+
+    # Convert '\n' sequences to real newlines if needed
+    pem = DB_CA_CERT_PEM.replace("\\n", "\n")
+
+    ssl_ctx = ssl.create_default_context()
+    # Load the PEM content directly from env
+    ssl_ctx.load_verify_locations(cadata=pem)
+    ssl_ctx.check_hostname = True
+    ssl_ctx.verify_mode = ssl.CERT_REQUIRED
+
+    app.state.db_pool = await asyncpg.create_pool(
+        dsn=DATABASE_URL,
+        ssl=ssl_ctx,
+        min_size=0,
+        max_size=8,
+        command_timeout=15.0,
+        statement_cache_size=0,
+    )
+    logging.info("✅ DB pool initialized")
+    
+    # Create CreditCharge table for tracking one-time charges per plan
+    async with app.state.db_pool.acquire() as conn:
+        await conn.execute(
+            '''
+            CREATE TABLE IF NOT EXISTS "CreditCharge" (
+              "id"             text PRIMARY KEY,
+              "businessPlanId" text UNIQUE NOT NULL,
+              "userId"         text NOT NULL,
+              "createdAt"      timestamptz NOT NULL DEFAULT now()
+            );
+            '''
+        )
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    pool = getattr(app.state, "db_pool", None)
+    if pool:
+        await pool.close()
+        logging.info("✅ DB pool closed")
+# ───────────────────────────────────────────────────────────────────��──────────
+# Section mapping & helpers
+# ──────────────────────────────────────────────────────────────────────────────
+SECTION_MAP = {
+    "prompt_ExecutiveSummary": ("executiveSummary", "isExecutiveSummaryComplete", "isExecutiveSummaryGenerating"),
+    "prompt_CompanyProfile": ("companyProfile", "isCompanyProfileComplete", "isCompanyProfileGenerating"),
+    "prompt_MarketAnalysis": ("marketAnalysis", "isMarketAnalysisComplete", "isMarketAnalysisGenerating"),
+    "prompt_ProductOrService": ("productOrService", "isProductOrServiceComplete", "isProductOrServiceGenerating"),
+    "prompt_BusinessModel": ("businessModel", "isBusinessModelComplete", "isBusinessModelGenerating"),
+    "prompt_MarketingGrowth": ("marketingGrowth", "isMarketingGrowthComplete", "isMarketingGrowthGenerating"),
+    "prompt_OperationsPlan": ("operationsPlan", "isOperationsPlanComplete", "isOperationsPlanGenerating"),
+    "prompt_ManagementTeam": ("managementTeam", "isManagementTeamComplete", "isManagementTeamGenerating"),
+    "prompt_FinancialPlanFunding": ("financialPlanFunding", "isFinancialPlanFundingComplete", "isFinancialPlanFundingGenerating"),
+}
+
+# Database column names for sections (using the consolidated definition above)
+
+def extract_summary_from_markdown(md: str) -> str:
+    m = re.search(r"^\s*#{1,2}\s+(.+)", md, flags=re.MULTILINE)
+    if m:
+        return m.group(1).strip()[:250]
+    return (md.strip().split("\n", 1)[0] if md.strip() else "Generated Business Plan")[:250]
+
+async def _get_generate_prompt(pool, key: str):
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow(
+            'SELECT "key","title","promptTemplate","inputVariables","defaultModel","defaultProvider",'
+            '"defaultTemp","defaultMaxTokens","defaultCountry","isActive" '
+            'FROM "GeneratePrompt" WHERE "key"=$1 AND "isActive"=TRUE',
+            key,
+        )
+        return row
+
+def _plan_key_for_section(base_key: str, plan_type: str) -> str:
+    # free plan uses *_Free prompts except FinancialPlanFunding
+    if plan_type == "free" and base_key != "prompt_FinancialPlanFunding":
+        return f"{base_key}_Free"
+    return base_key
+
+# --- helpers: country/currency mapping ---
+
+def _country_name_from_code(code: Optional[str], default_name: Optional[str]) -> str:
+    if not code:
+        return default_name or "South Africa"
+    m = {
+        "ZA": "South Africa","US": "United States","GB": "United Kingdom","DE": "Germany","FR": "France",
+        "NG": "Nigeria","KE": "Kenya","IN": "India","AU": "Australia","CA": "Canada","BR": "Brazil",
+        "NL": "Netherlands","ES": "Spain","IT": "Italy","IE": "Ireland","SG": "Singapore","AE": "United Arab Emirates"
+    }
+    return m.get(code.upper(), default_name or code)
+
+def _currency_from_country_code(code: Optional[str], fallback_country_name: Optional[str]) -> str:
+    # prefer code, else derive from country name, else USD
+    if code:
+        m = {
+            "ZA": "ZAR","US": "USD","GB": "GBP","DE": "EUR","FR": "EUR","NL": "EUR","ES": "EUR","IT": "EUR","IE":"EUR",
+            "NG": "NGN","KE": "KES","IN": "INR","AU": "AUD","CA": "CAD","BR": "BRL","SG":"SGD","AE":"AED"
+        }
+        if code.upper() in m:
+            return m[code.upper()]
+    if fallback_country_name:
+        name = fallback_country_name.lower()
+        if "south africa" in name: return "ZAR"
+        if any(x in name for x in ["united states","usa","america"]): return "USD"
+        if "united kingdom" in name or "uk" in name: return "GBP"
+        if any(x in name for x in ["germany","france","netherlands","spain","italy","ireland"]): return "EUR"
+        if "nigeria" in name: return "NGN"
+        if "kenya" in name: return "KES"
+        if "india" in name: return "INR"
+        if "australia" in name: return "AUD"
+        if "canada" in name: return "CAD"
+        if "brazil" in name: return "BRL"
+        if "singapore" in name: return "SGD"
+        if "emirates" in name or "uae" in name: return "AED"
+    return "USD"
+
+def _compose_prompt_vars(
+    *,
+    gp_row,
+    answers: List[str],
+    business_idea: Optional[str],
+    country_code: Optional[str],
+    section_title: str,
+    feedback: Optional[str],
+) -> Dict[str, str]:
+    """
+    Build exactly the variables that the GeneratePrompt row declares in inputVariables.
+    Examples we've seen: ["business_context","country","currency","q_and_a"].
+    """
+
+    # Parse declared input variables from DB (stringified JSON)
+    try:
+        declared = json.loads(gp_row["inputVariables"] or "[]")
+    except Exception:
+        declared = []
+
+    # Precompute building blocks we might map into the declared names
+    now_iso = datetime.utcnow().isoformat()
+    country_name = _country_name_from_code(country_code, gp_row.get("defaultCountry"))
+    currency = _currency_from_country_code(country_code, country_name)
+
+    # Build a Q&A string (or JSON) from your QUESTIONS & answers array
+    # (safe against length mismatch; unanswered = "N/A")
+    qa_lines = []
+    for i, q in enumerate(QUESTIONS):
+        a = answers[i] if i < len(answers) and answers[i] else "N/A"
+        qa_lines.append(f"{q} -> {a}")
+    qa_text = "\n".join(qa_lines)
+
+    # Business context: prefer explicit business_idea, else stitch from first answers
+    business_context = (business_idea or "").strip()
+    if not business_context:
+        # use first two answers as a minimal context
+        name = answers[0] if len(answers) > 0 else ""
+        offering = answers[1] if len(answers) > 1 else ""
+        business_context = (name + " — " + offering).strip(" —")
+
+    # We'll fill only what the prompt expects. If nothing declared, we fall back
+    # to a generic superset (backward compat).
+    declared = declared if isinstance(declared, list) else []
+
+    # Canonical mapping for common keys you're using in GeneratePrompt
+    mapping = {
+        "business_context": business_context,
+        "q_and_a": qa_text,
+        "country": country_name,
+        "currency": currency,
+
+        # Optional alternates you might have in some prompts
+        "section_title": section_title,
+        "current_date": now_iso,
+        "feedback": feedback or "",
+        "answers_json": json.dumps(answers or []),
+        "businessIdea": business_idea or "",  # if some prompts still use old name
+        "countryCode": country_code or "",    # if some prompts still use old name
+    }
+
+    if declared:
+        # Return exactly the keys the prompt asked for; raise obvious gaps to logs
+        out = {}
+        for key in declared:
+            out[key] = mapping.get(key, "")
+        return out
+
+    # Fallback for prompts that didn't declare inputVariables
+    return {
+        "business_context": business_context,
+        "q_and_a": qa_text,
+        "country": country_name,
+        "currency": currency,
+        "section_title": section_title,
+        "current_date": now_iso,
+        "feedback": feedback or "",
+        "answers_json": json.dumps(answers or []),
+    }
+
+async def _ensure_business_plan(pool, *, bp_id: Optional[str], summary: str, full_plan: str,
+                                model: str, answers: List[str], plan_type: Optional[str],
+                                user_id: Optional[str], anon_id: Optional[str],
+                                country_code: Optional[str]) -> str:
+    async with pool.acquire() as conn:
+        if bp_id:
+            exists = await conn.fetchval('SELECT 1 FROM "BusinessPlan" WHERE id = $1', bp_id)
+            if exists:
+                await conn.execute(
+                    'UPDATE "BusinessPlan" SET '
+                    '"summary"=$1, "model"=$2, "answers"=$3, '
+                    '"planType"=COALESCE($4,\'free\'), "countryCode"=$5, '
+                    '"updatedAt"=now(), "userId"=COALESCE($6,"userId") '
+                    'WHERE id=$7',
+                    summary, model, answers, plan_type, country_code, user_id, bp_id
+                )
+                return bp_id
+
+        new_id = new_cuid()
+        row = await conn.fetchrow(
+            'INSERT INTO "BusinessPlan" '
+            '("id","summary","fullPlan","model","answers","planType","userId","anonymousId","countryCode","updatedAt") '
+            'VALUES ($1,$2,$3,$4,$5,COALESCE($6,\'free\'),$7,$8,$9, now()) '
+            'RETURNING id',
+            new_id, summary, "", model, answers, plan_type, user_id, anon_id, country_code  # fullPlan is intentionally ""
+        )
+        return row["id"]
+
+# async def _upsert_section(pool, *, business_plan_id: str, section_key: str, content: str) -> None:
+#     if section_key not in SECTION_MAP:
+#         logging.warning(f"Unknown section_key '{section_key}', skipping section save.")
+#         return
+
+#     col_content, col_complete, col_generating = SECTION_MAP[section_key]
+#     set_clause = f'"{col_content}" = $2, "{col_complete}" = TRUE, "{col_generating}" = FALSE'
+
+#     async with pool.acquire() as conn:
+#         # ensure row exists with a generated id
+#         await conn.execute(
+#             'INSERT INTO "BusinessPlanSection" ("id","businessPlanId") '
+#             'VALUES ($1,$2) '
+#             'ON CONFLICT ("businessPlanId") DO NOTHING',
+#             str(uuid.uuid4()), business_plan_id
+#         )
+#         # update content + flags
+#         await conn.execute(
+#             f'UPDATE "BusinessPlanSection" SET {set_clause} WHERE "businessPlanId" = $1',
+#             business_plan_id, content
+#         )
+async def _upsert_section(pool, *, business_plan_id: str, section_key: str, content: str) -> None:
+    if section_key not in SECTION_MAP:
+        logging.warning(f"Unknown section_key '{section_key}', skipping section save.")
+        return
+
+    col_content, col_complete, col_generating = SECTION_MAP[section_key]
+    # bump updatedAt on every write
+    set_clause = (
+        f'"{col_content}" = $2, '
+        f'"{col_complete}" = TRUE, '
+        f'"{col_generating}" = FALSE, '
+        f'"updatedAt" = now()'
+    )
+
+    async with pool.acquire() as conn:
+        # ensure row exists, and give updatedAt a value to satisfy NOT NULL
+        await conn.execute(
+            'INSERT INTO "BusinessPlanSection" ("id","businessPlanId","updatedAt") '
+            'VALUES ($1,$2, now()) '
+            'ON CONFLICT ("businessPlanId") DO NOTHING',
+            new_cuid(), business_plan_id
+        )
+        # update content + flags (+ updatedAt)
+        await conn.execute(
+            f'UPDATE "BusinessPlanSection" SET {set_clause} WHERE "businessPlanId" = $1',
+            business_plan_id, content
+        )
+
+async def _recompute_full_plan(pool, *, business_plan_id: str) -> str:
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow(
+            'SELECT * FROM "BusinessPlanSection" WHERE "businessPlanId" = $1',
+            business_plan_id
+        )
+        if not row:
+            return ""
+        parts = []
+        for col in SECTION_ORDER:
+            txt = row.get(col)
+            if txt:
+                parts.append(txt.strip())
+        full_plan = "\n\n".join(parts)
+        return full_plan  # Do not persist fullPlan; caller may use it for summary only
+
+def _all_sections_present(row: asyncpg.Record) -> bool:
+    return all(bool(row.get(col)) for col in SECTION_ORDER)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Endpoints
+# ──────────────────────────────────────────────────────────────────────────────
+@app.get("/suggestions", response_model=Dict[str, Any])
+async def get_suggestions(
+    business_idea: str,
+    model: str,
+    question: str,
+    prompt: str,
+    provider: str,
+    temperature: float,
+    maxTokens: int,
+    exclude: List[str] = Query([])
+) -> Dict[str, Any]:
+    try:
+        formatted_prompt = prompt.format(
+            business_idea=business_idea,
+            question=question,
+            exclude=", ".join(exclude) if exclude else ""
+        )
+        llm = get_llm(model, provider)
+        if hasattr(llm, 'temperature'):
+            llm.temperature = temperature
+        if hasattr(llm, 'max_tokens'):
+            llm.max_tokens = maxTokens
+
+        suggestion_prompt = PromptTemplate(input_variables=[], template=formatted_prompt)
+        suggestion_chain: RunnableSequence = suggestion_prompt | llm
+        raw_result = await asyncio.to_thread(suggestion_chain.invoke, {})
+
+        if isinstance(raw_result, AIMessage):
+            raw_text = raw_result.content
+        elif isinstance(raw_result, (list, tuple)) and raw_result and isinstance(raw_result[0], AIMessage):
+            raw_text = "\n".join(msg.content for msg in raw_result)
+        else:
+            raw_text = str(raw_result)
+
+        suggestion_array = [
+            re.sub(r'^\s*[\-\d\.\)\s]+', '', line).strip()
+            for line in raw_text.split("\n")
+            if line.strip()
+        ]
+        if not suggestion_array:
+            suggestion_array = ["No suggestions available"]
+        return {"suggestions": suggestion_array}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating suggestions: {str(e)}")
+    
+class CreatePlanRequest(BaseModel):
+    answers: List[str] = []
+    planType: Optional[str] = "free"
+    countryCode: Optional[str] = None
+    anonymousId: Optional[str] = None
+    businessIdea: Optional[str] = None
+
+@app.post("/plan")
+async def create_plan_shell(request: Request, data: CreatePlanRequest):
+    pool = getattr(app.state, "db_pool", None)
+    if not pool:
+        raise HTTPException(status_code=500, detail="DB not initialized")
+
+    # Resolve owner (JWT beats anonymousId)
+    user_id, anon_id = resolve_owner(request, data.anonymousId)
+
+    # Create a new plan row (server-minted id) + blank sections row
+    bp_id = await _ensure_business_plan(
+        pool,
+        bp_id=None,  # <- server generates the id; client never sends one
+        summary="Generating…",
+        full_plan="",
+        model="unknown",
+        answers=data.answers or [],
+        plan_type=data.planType,
+        user_id=user_id,
+        anon_id=anon_id,
+        country_code=data.countryCode,
+    )
+    await _ensure_sections_row(pool, bp_id)
+
+    # Tell subscribers a plan exists
+    await _publish(bp_id, "plan.created", {"businessPlanId": bp_id})
+
+    return {"businessPlanId": bp_id}
+    
+@app.post("/generate/batch")
+async def generate_business_plan_batch(request: Request, data: BatchGenerateRequest):
+    try:
+        pool = getattr(app.state, "db_pool", None)
+        if not pool:
+            raise HTTPException(status_code=500, detail="DB not initialized")
+
+        # ① Resolve owner (JWT wins; else anonymous)
+        user_id, anon_id = resolve_owner(request, data.anonymousId)
+        logging.info(f"[owner] user_id={user_id} anon_id={anon_id} planType={data.planType} planId={data.businessPlanId}")
+
+        # ② (Optional) Guard ownership of existing plan
+        if data.businessPlanId:
+            await assert_plan_ownership(pool, business_plan_id=data.businessPlanId, user_id=user_id, anonymous_id=anon_id)
+
+        # ③ Create/ensure plan shell
+        bp_id = await _ensure_business_plan(
+            pool,
+            bp_id=data.businessPlanId,
+            summary="Generating…",
+            full_plan="",
+            model="unknown",
+            answers=data.answers,
+            plan_type=data.planType,
+            user_id=user_id,
+            anon_id=anon_id,
+            country_code=data.countryCode,
+        )
+        logging.info(f"[plan] ensured id={bp_id} linked to user_id={user_id} anon_id={anon_id}")
+
+        # after ensure plan id
+        await _publish(bp_id, "plan.created", {"businessPlanId": bp_id})
+
+        await _ensure_sections_row(pool, bp_id)
+
+        # 🔐 Charge exactly once per full plan (no charge for 'free' or anon)
+        charged_now, remaining = await charge_full_plan_once(
+            pool,
+            business_plan_id=bp_id,
+            user_id=user_id,
+            plan_type=data.planType,
+        )
+
+        # Mark all sections as generating
+        for job in data.sections:
+            await _set_section_status(
+                pool, business_plan_id=bp_id, section_key=job.sectionKey, generating=True, complete=False
+            )
+            await _publish(bp_id, "section.started", {
+                "businessPlanId": bp_id,
+                "sectionKey": job.sectionKey,
+            })
+
+        sem = asyncio.Semaphore(3)
+
+        async def run_job(job: SectionJob):
+            async with sem:
+                # 1) Resolve plan-specific key (base for full, *_Free for free except funding)
+                effective_key = _plan_key_for_section(job.sectionKey, data.planType or "free")
+
+                # 2) Load GeneratePrompt row
+                gp = await _get_generate_prompt(pool, effective_key)
+                if not gp:
+                    raise HTTPException(status_code=400, detail=f"No active GeneratePrompt for key {effective_key}")
+
+                # 3) Resolve model/provider/temp/max (client overrides optional)
+                resolved_model = job.model or gp["defaultModel"]
+                resolved_provider = (job.provider or gp["defaultProvider"]).lower()
+                resolved_temp = job.temperature if job.temperature is not None else float(gp["defaultTemp"])
+                resolved_max = job.maxTokens if job.maxTokens is not None else int(gp["defaultMaxTokens"])
+
+                # 4) Compose variables server-side (respect declared inputVariables)
+                vars_for_prompt = _compose_prompt_vars(
+                    gp_row=gp,
+                    answers=data.answers,
+                    business_idea=data.businessIdea or (data.answers[0] if data.answers else None),
+                    country_code=data.countryCode,
+                    section_title=gp["title"],
+                    feedback=data.feedback,
+                )
+
+                # 5) Prompt + LLM + chain
+                llm = get_llm(resolved_model, resolved_provider)
+                if hasattr(llm, "temperature"): llm.temperature = resolved_temp
+                if hasattr(llm, "max_tokens"): llm.max_tokens = resolved_max
+
+                template = job.prompt or gp["promptTemplate"]
+                prompt_t = PromptTemplate(input_variables=list(vars_for_prompt.keys()), template=template)
+                chain: RunnableSequence = prompt_t | llm
+                raw = await asyncio.to_thread(chain.invoke, vars_for_prompt)
+                text = raw.content if isinstance(raw, AIMessage) else str(raw)
+
+                # 6) Save section & clear flags
+                await _upsert_section(pool, business_plan_id=bp_id, section_key=job.sectionKey, content=text)
+                await _publish(bp_id, "section.complete", {
+                    "businessPlanId": bp_id,
+                    "sectionKey": job.sectionKey,
+                })
+                return resolved_model
+
+        resolved_models = await asyncio.gather(*(run_job(job) for job in data.sections))
+        model_for_plan = next((m for m in resolved_models if m), "unknown")
+
+        # Recompose full plan & update summary
+        full_plan = await _recompute_full_plan(pool, business_plan_id=bp_id)
+        summary = extract_summary_from_markdown(full_plan)
+
+        await _ensure_business_plan(
+            pool,
+            bp_id=bp_id,
+            summary=summary,
+            full_plan=full_plan,
+            model=model_for_plan,
+            answers=data.answers,
+            plan_type=data.planType,
+            user_id=user_id,
+            anon_id=anon_id,
+            country_code=data.countryCode,
+        )
+
+        await _publish(bp_id, "plan.updated", {
+            "businessPlanId": bp_id,
+            "summary": summary,
+            "fullPlanLength": len(full_plan or ""),
+        })
+        await _publish(bp_id, "plan.complete", {
+            "businessPlanId": bp_id,
+            "completedKeys": [j.sectionKey for j in data.sections],
+        })
+
+        return {
+            "businessPlanId": bp_id,
+            "status": "complete",
+            "completedKeys": [j.sectionKey for j in data.sections],
+            "fullPlanLength": len(full_plan or ""),
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Batch generation failed: {e}")
+    
+@app.get("/plan/{businessPlanId}/status")
+async def get_plan_status(businessPlanId: str):
+    pool = getattr(app.state, "db_pool", None)
+    if not pool:
+        raise HTTPException(status_code=500, detail="DB not initialized")
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow('SELECT * FROM "BusinessPlanSection" WHERE "businessPlanId"=$1', businessPlanId)
+        if not row:
+            return {"exists": False}
+        # Build per-section status
+        statuses = {}
+        for key, (col, complete_col, gen_col) in SECTION_MAP.items():
+            statuses[key] = {"isGenerating": bool(row.get(gen_col)), "isComplete": bool(row.get(complete_col))}
+        all_done = all(s["isComplete"] for s in statuses.values())
+        return {"exists": True, "allComplete": all_done, "sections": statuses}
+
+@app.get("/events/plan/{businessPlanId}")
+async def sse_plan(businessPlanId: str):
+    async def event_gen() -> AsyncIterator[bytes]:
+        q: asyncio.Queue[str] = asyncio.Queue(maxsize=200)
+        SUBSCRIBERS[businessPlanId].add(q)
+        try:
+            yield b": connected\n\n"
+            while True:
+                try:
+                    msg = await asyncio.wait_for(q.get(), timeout=15)
+                    yield msg.encode("utf-8")
+                except asyncio.TimeoutError:
+                    yield b": keep-alive\n\n"
+        except asyncio.CancelledError:
+            pass
+        finally:
+            SUBSCRIBERS[businessPlanId].discard(q)
+
+    return StreamingResponse(
+        event_gen(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+    )
+
+
+
+@app.post("/generate")
+async def generate_business_plan(request: Request, data: GenerateRequest):
+    """
+    Generate a business plan using the provided prompt template and variables,
+    then persist to Supabase Postgres. Ownership is derived from the verified JWT.
+    """
+    try:
+        logging.info(f"Initializing model: {data.model} with provider: {data.provider}")
+        llm_selected = get_llm(data.model, data.provider)  # provider is used in get_llm for HF models
+
+        if hasattr(llm_selected, 'temperature'):
+            llm_selected.temperature = data.temperature
+        if hasattr(llm_selected, 'max_tokens'):
+            llm_selected.max_tokens = data.maxTokens
+
+        plan_prompt = PromptTemplate(
+            input_variables=list(data.promptVariables.keys()),
+            template=data.prompt
+        )
+        plan_chain: RunnableSequence = plan_prompt | llm_selected
+        logging.info(f"Generating business plan with model: {data.model}")
+
+        raw_plan = await asyncio.to_thread(plan_chain.invoke, data.promptVariables)
+
+        if isinstance(raw_plan, AIMessage):
+            plan_text = raw_plan.content
+        elif isinstance(raw_plan, (list, tuple)) and raw_plan and isinstance(raw_plan[0], AIMessage):
+            plan_text = "\n".join(msg.content for msg in raw_plan)
+        else:
+            plan_text = str(raw_plan)
+
+        # ① Resolve owner consistently (JWT wins)
+        user_id, anon_id = resolve_owner(request, data.anonymousId)
+        logging.info(f"[owner] user_id={user_id} anon_id={anon_id} planType={data.planType} planId={data.businessPlanId}")
+
+        # ② (Optional) Guard ownership if an existing plan is referenced
+        if data.businessPlanId:
+            pool = getattr(app.state, "db_pool", None)
+            if not pool:
+                raise HTTPException(status_code=500, detail="DB not initialized")
+            await assert_plan_ownership(pool, business_plan_id=data.businessPlanId, user_id=user_id, anonymous_id=anon_id)
+
+        # If generating a specific section, publish section.started before LLM generation
+        if data.sectionKey and data.businessPlanId:
+            pool = getattr(app.state, "db_pool", None)
+            if pool:
+                await _publish(data.businessPlanId, "section.started", {
+                    "businessPlanId": data.businessPlanId,
+                    "sectionKey": data.sectionKey,
+                })
+
+        # ── Persist
+        pool = getattr(app.state, "db_pool", None)
+        summary = extract_summary_from_markdown(plan_text)
+
+        if not pool:
+            logging.warning("DB pool not available; skipping persistence.")
+            return {
+                "summary": summary or "Generated Business Plan",
+                "plan": plan_text,
+            }
+
+        # If generating a specific section
+        if data.sectionKey:
+            business_plan_id = await _ensure_business_plan(
+                pool,
+                bp_id=data.businessPlanId,
+                summary=summary,
+                full_plan="",  # recomputed after section save
+                model=data.model,
+                answers=data.answers,
+                plan_type=data.planType,
+                user_id=user_id,
+                anon_id=anon_id,
+                country_code=data.countryCode,
+            )
+            logging.info(f"[plan] ensured section id={business_plan_id} linked to user_id={user_id} anon_id={anon_id}")
+
+            # mark generating True in the DB for this section...
+            await _publish(business_plan_id, "section.started", {
+                "businessPlanId": business_plan_id,
+                "sectionKey": data.sectionKey,
+            })
+
+            await _upsert_section(
+                pool,
+                business_plan_id=business_plan_id,
+                section_key=data.sectionKey,
+                content=plan_text
+            )
+
+            # ...generate text, save to this section, set generating False, set section complete...
+            await _publish(business_plan_id, "section.complete", {
+                "businessPlanId": business_plan_id,
+                "sectionKey": data.sectionKey,
+            })
+
+            # Recompute full plan after section write
+            full_plan = await _recompute_full_plan(pool, business_plan_id=business_plan_id)
+
+            # if you recompute summary here, also:
+            await _publish(business_plan_id, "plan.updated", {
+                "businessPlanId": business_plan_id,
+                "summary": summary,
+                "fullPlanLength": len(full_plan or ""),
+            })
+
+            # Optional: mark complete if all sections present
+            is_complete = False
+            async with pool.acquire() as conn:
+                row = await conn.fetchrow(
+                    'SELECT * FROM "BusinessPlanSection" WHERE "businessPlanId"=$1',
+                    business_plan_id
+                )
+                if row:
+                    is_complete = _all_sections_present(row)
+
+            resp = {
+                "summary": summary,
+                "plan": plan_text,
+                "sections": [{"key": data.sectionKey, "content": plan_text}],
+                "isComplete": True,  # this means "this section completed"
+                "currentSection": data.sectionKey,
+                "businessPlanId": business_plan_id,
+            }
+            return resp 
+
+        # Non-section — treat as a whole plan
+        business_plan_id = await _ensure_business_plan(
+            pool,
+            bp_id=data.businessPlanId,
+            summary=summary,
+            full_plan="",   # do not persist the full combined text
+            model=data.model,
+            answers=data.answers,
+            plan_type=data.planType,
+            user_id=user_id,
+            anon_id=anon_id,
+            country_code=data.countryCode,
+        )
+        logging.info(f"[plan] ensured whole plan id={business_plan_id} linked to user_id={user_id} anon_id={anon_id}")
+
+        resp = {
+            "businessPlanId": business_plan_id,
+            "sectionKey": None,
+            "isComplete": True,  # whole-plan path implies one-shot completion
+        }
+        if data.returnContent:
+            resp.update({
+                "summary": summary,
+                "plan": plan_text,
+            })
+        return resp
+
+    except Exception as e:
+        error_message = f"Error initializing model {data.model}: {str(e)}"
+        logging.error(error_message)
+        raise HTTPException(status_code=500, detail=error_message)
+
+
+@app.post("/export", response_model=ExportResponse)
+async def export_business_plan(request: ExportRequest):
+    """
+    Export a business plan in the specified format (PDF or Word).
+    This endpoint creates documents and returns them as base64 data for frontend upload to UploadThing.
+    
+    FLOW: Server generates document → Returns base64 data → Frontend uploads to UploadThing → User gets download link
+    """
+    try:
+        # Duplicate detection (best-effort; non-fatal if bookkeeping fails)
+        try:
+            request_id = str(id(request))
+            request_fingerprint = f"{request.businessIdea}_{request.format}_{len(request.sections)}_{hash(str(request.sections))}"
+            current_time = time.time()
+            if hasattr(export_business_plan, 'last_requests'):
+                # Clean old requests (older than 5 seconds)
+                export_business_plan.last_requests = {
+                    fp: timestamp for fp, timestamp in export_business_plan.last_requests.items()
+                    if current_time - timestamp < 5
+                }
+                # Check for duplicate
+                if request_fingerprint in export_business_plan.last_requests:
+                    raise HTTPException(
+                        status_code=429,
+                        detail="Duplicate export request detected. Please wait a few seconds before trying again."
+                    )
+            else:
+                export_business_plan.last_requests = {}
+            # Record this request
+            export_business_plan.last_requests[request_fingerprint] = current_time
+        except HTTPException:
+            raise
+        except Exception:
+            # Do not block export on dedupe bookkeeping errors
+            pass
+
+        
+        # Validate request format
+        if request.format not in ["pdf", "word"]:
+            raise HTTPException(status_code=400, detail="Invalid format. Only 'pdf' and 'word' are supported.")
+        
+        # Validate required fields
+        if not request.summary:
+            raise HTTPException(status_code=400, detail="Summary is required for export.")
+        
+        if not request.sections:
+            raise HTTPException(status_code=400, detail="Sections are required for export.")
+        
+        if len(request.sections) == 0:
+            raise HTTPException(status_code=400, detail="At least one section is required for export.")
+        
+        # Check section content and shape
+        for i, section in enumerate(request.sections):
+            title = getattr(section, 'title', None)
+            if not title or not str(title).strip():
+                raise HTTPException(status_code=400, detail=f"Section at index {i} is missing a title.")
+            if not section.content or not section.content.strip():
+                raise HTTPException(status_code=400, detail=f"Section '{title}' has no content.")
+        
+        # logging.info(f"Exporting business plan for: {request.businessIdea} in {request.format.upper()} format")
+        # logging.info(f"Request has {len(request.sections)} sections and summary length: {len(request.summary)}")
+        
+        # Debug section information
+        for i, section in enumerate(request.sections):
+            # logging.info(f"Section {i+1}: '{section.title}' (key: {section.key}) - Content length: {len(section.content) if section.content else 0}")
+            if section.content:
+                # logging.info(f"  First 100 chars: {section.content[:100]}...")
+                pass
+            else:
+                # logging.info(f"  No content")
+                pass
+        
+        # Check required packages before proceeding
+        try:
+            if request.format == "pdf":
+                import fpdf
+            else:
+                import docx
+        except ImportError as import_error:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Required package not available: {str(import_error)}"
+            )
+        
+        # Create the document based on format
+        try:
+            if request.format == "pdf":
+                doc_bytes, filename = create_pdf_document(request)
+            else:  # word
+                doc_bytes, filename = create_word_document(request)
+            # Basic sanity check on output
+            if not doc_bytes or (isinstance(doc_bytes, (bytes, bytearray)) and len(doc_bytes) < 1000):
+                raise HTTPException(status_code=500, detail=f"Generated {request.format.upper()} appears empty or invalid.")
+        except HTTPException:
+            raise
+        except ImportError as import_error:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Missing required package for {request.format.upper()} generation: {str(import_error)}"
+            )
+        except Exception as doc_error:
+            # logging.error(f"Document creation failed: {doc_error}")
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to create {request.format.upper()} document: {str(doc_error)}"
+            )
+        
+        # Return document data to frontend for UploadThing upload
+        try:
+            # Encode document bytes as base64 for frontend transmission
+            import base64
+            document_data = base64.b64encode(doc_bytes).decode('utf-8')
+            
+            response = ExportResponse(
+                success=True,
+                downloadUrl="",  # Will be set by frontend after UploadThing upload
+                filename=filename,
+                size=len(doc_bytes),
+                message=f"Document generated successfully as {request.format.upper()}. Ready for frontend upload to UploadThing.",
+                documentData=document_data  # Base64 encoded document data
+            )
+            
+            return response
+                
+        except Exception as data_error:
+            # logging.error(f"Failed to prepare document data: {data_error}")
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Failed to prepare document data: {str(data_error)}"
+            )
+        
+    except HTTPException:
+        # Re-raise HTTP exceptions (validation errors)
+        raise
+    except Exception as e:
+        # Catch any other unexpected errors
+        error_message = f"Export failed: {str(e)}"
+        # logging.error(error_message)
+        raise HTTPException(status_code=500, detail=error_message)
+        
+
+@app.get("/download/{filename}")
+async def download_file(filename: str):
+    """Download endpoint to serve the generated export files"""
+    file_path = os.path.join("temp_exports", filename)
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    return FileResponse(file_path, filename=filename)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Live PDF Generation Endpoints
+# ──────────────────────────────────────────────────────────────────────────────
+
+@app.post("/live-pdf/start")
+async def start_live_pdf_session(request: Request, data: ExportRequest):
+    """Start a live PDF session that streams updates as content changes"""
+    try:
+        # Create a new live PDF session
+        session_id = await live_pdf_generator.create_live_session(
+            data.businessIdea or "default", 
+            data
+        )
+        
+        return {
+            "success": True,
+            "session_id": session_id,
+            "message": "Live PDF session started successfully"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to start live PDF session: {str(e)}")
+
+@app.post("/live-pdf/update/{session_id}")
+async def update_live_pdf_session(session_id: str, data: ExportRequest):
+    """Update an existing live PDF session with new content"""
+    try:
+        success = await live_pdf_generator.update_session(session_id, data)
+        
+        if not success:
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        return {
+            "success": True,
+            "message": "PDF updated successfully"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to update PDF: {str(e)}")
+
+@app.get("/live-pdf/stream/{session_id}")
+async def stream_live_pdf_updates(session_id: str):
+    """Stream live PDF updates using Server-Sent Events"""
+    async def event_generator():
+        async for chunk in live_pdf_generator.stream_pdf_updates(session_id):
+            yield chunk
+    
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Headers": "*"
+        }
+    )
+
+@app.delete("/live-pdf/close/{session_id}")
+async def close_live_pdf_session(session_id: str):
+    """Close and cleanup a live PDF session"""
+    try:
+        live_pdf_generator.close_session(session_id)
+        
+        return {
+            "success": True,
+            "message": "Live PDF session closed successfully"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to close session: {str(e)}")
+@app.get("/")
+def root():
+    return {"status": "FastAPI is running 🚀"}
+
+# @app.get("/test-toc")
+# def test_toc():
+#     """Test endpoint to verify TOC generation"""
+#     from app.main import generate_table_of_contents_after_content, ExportSection
+    
+#     # Create test sections
+#     test_sections = [
+#         ExportSection(
+#             key="prompt_ExecutiveSummary",
+#             title="Executive Summary",
+#             content="# Executive Summary\n\nThis is a test executive summary with some content."
+#         ),
+#         ExportSection(
+#             key="prompt_CompanyProfile", 
+#             title="Company Profile",
+#             content="# Company Profile\n\nThis is a test company profile section."
+#         ),
+#         ExportSection(
+#             key="prompt_MarketAnalysis",
+#             title="Market Analysis", 
+#             content="# Market Analysis\n\nThis is a test market analysis section."
+#         )
+#     ]
+    
+#     # Generate TOC
+#     toc_items = generate_table_of_contents_after_content(test_sections, {}, "Test Business")
+    
+#     return {
+#         "test_sections": [{"title": s.title, "key": s.key, "content_length": len(s.content)} for s in test_sections],
+#         "toc_items": toc_items,
+#         "toc_count": len(toc_items)
+#     }
+
+# @app.get("/health")
+# def health_check():
+#     hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+#     openai_api_key = os.getenv("OPENAI_API_KEY")
+    
+#     status = {
+#         "api": "healthy",
+#         "models": {}
+#     }
+    
+#     models_to_check = ["Mistral", "Qwen-2.5", "Llama", "Gemma", "Phi-3"]
+    
+#     for model_name in models_to_check:
+#         try:
+#             if model_name == "":
+#                 client = InferenceClient(provider="hf-inference", api_key=hf_token)
+#                 client.model_info("mistralai/Mistral-7B-Instruct-v0.3")
+#                 status["models"][model_name] = "available"
+#             elif model_name == "Qwen-2.5":
+#                 client = InferenceClient(provider="hf-inference", api_key=hf_token)
+#                 client.model_info("Qwen/Qwen2.5-7B-Instruct")
+#                 status["models"][model_name] = "available"
+#             elif model_name == "Llama":
+#                 client = InferenceClient(provider="hf-inference", api_key=hf_token)
+#                 client.model_info("meta-llama/Llama-2-7b-chat-hf")
+#                 status["models"][model_name] = "available"
+#             else:
+#                 status["models"][model_name] = "not checked"
+#         except Exception as e:
+#             status["models"][model_name] = f"error: {str(e)}"
+    
+#     status["models"]["GPT"] = "available" if openai_api_key else "unavailable (missing API key)"
+#     return status
+
+

app/models.py

@@ -0,0 +1,61 @@
+# Models and Data Structures
+# Contains Pydantic models and data structures to avoid circular imports
+
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional, Literal
+
+class ExportSection(BaseModel):
+    """Represents a section of content for export"""
+    title: str
+    content: str
+    key: Optional[str] = None
+    order: Optional[int] = None
+
+class ExportRequest(BaseModel):
+    """Request model for document export"""
+    sections: List[ExportSection]
+    businessIdea: str
+    summary: str
+    format: Literal["pdf", "word"] = "pdf"
+    chartImages: Optional[List[str]] = None
+    includeCharts: bool = True
+    includeTOC: bool = True
+
+class ExportResponse(BaseModel):
+    """Response model for document export"""
+    success: bool
+    message: str
+    filename: Optional[str] = None
+    size: Optional[int] = None
+    downloadUrl: Optional[str] = None
+    documentData: Optional[str] = None
+
+class SectionJob(BaseModel):
+    """Job model for section generation"""
+    businessPlanId: str
+    sectionKey: str
+    businessIdea: str
+    countryCode: Optional[str] = None
+    defaultCountry: Optional[str] = None
+
+class BatchGenerateRequest(BaseModel):
+    """Request model for batch generation"""
+    businessPlanId: str
+    businessIdea: str
+    sections: List[str]
+    countryCode: Optional[str] = None
+    defaultCountry: Optional[str] = None
+
+class GenerateRequest(BaseModel):
+    """Request model for single section generation"""
+    businessPlanId: str
+    sectionKey: str
+    businessIdea: str
+    countryCode: Optional[str] = None
+    defaultCountry: Optional[str] = None
+
+class CreatePlanRequest(BaseModel):
+    """Request model for creating a new business plan"""
+    businessIdea: str
+    countryCode: Optional[str] = None
+    defaultCountry: Optional[str] = None

app/utils.py

@@ -0,0 +1,42 @@
+# Utility functions shared across modules
+# This file helps break circular imports between main.py and pdf_generator.py
+
+from typing import List
+from models import ExportSection
+from constants import SECTION_ORDER
+
+def sort_sections_by_order(sections: List[ExportSection]) -> List[ExportSection]:
+    """Sort sections according to the predefined SECTION_ORDER to ensure correct numerical ordering"""
+    # Create a mapping from section title to order index
+    order_map = {title: index for index, title in enumerate(SECTION_ORDER)}
+    
+    def get_section_order(section: ExportSection) -> int:
+        # Try to match by exact title first
+        if section.title in order_map:
+            order_index = order_map[section.title]
+            return order_index
+        
+        # Try case-insensitive matching
+        section_title_lower = section.title.lower()
+        for order_title, order_index in order_map.items():
+            if order_title.lower() == section_title_lower:
+                return order_index
+        
+        # Try to match by key (remove 'prompt_' prefix if present)
+        key_clean = section.key.replace('prompt_', '') if section.key.startswith('prompt_') else section.key
+        if key_clean in order_map:
+            order_index = order_map[key_clean]
+            return order_index
+        
+        # Try partial matching for keys
+        for order_title, order_index in order_map.items():
+            if key_clean.lower() in order_title.lower() or order_title.lower() in key_clean.lower():
+                return order_index
+        
+        # If no match found, put at the end
+        return len(SECTION_ORDER)
+    
+    # Sort sections by their order
+    sorted_sections = sorted(sections, key=get_section_order)
+    
+    return sorted_sections

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "planify",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

requirements.txt

@@ -0,0 +1,20 @@
+fastapi
+uvicorn
+langchain
+langchain-openai
+langgraph
+openai
+pydantic
+python-dotenv
+huggingface-hub
+typing-extensions
+supabase>=2.6.0
+asyncpg
+python-jose[cryptography]
+python-docx==0.8.11
+fpdf2
+Pillow==10.0.0
+requests
+PyJWT
+matplotlib
+numpy