T1: restructure to domain/application/infrastructure + schema version 1

- Move cashflow_model/ -> domain/
- Move engine/ -> application/
- Move cli/, sync/, ai/ -> infrastructure/
- Update all imports across codebase and tests
- Add version=1 to FinancialModel.to_dict() with migration hook in from_dict
- Update pyproject.toml: cf entry point and packages.find

Tests: 63/63 pass.

domain/__init__.py

@@ -0,0 +1,22 @@
+from domain.account import Account
+from domain.asset import Asset
+from domain.currency import CURRENCY_SYMBOLS, CurrencyConverter, CurrencyError, ExchangeRate
+from domain.liability import Liability
+from domain.model import FinancialModel
+from domain.recurring import RecurringCashflow
+from domain.scenario import ForecastScenario
+from domain.transaction import Transaction
+
+__all__ = [
+    "Account",
+    "Transaction",
+    "RecurringCashflow",
+    "Asset",
+    "Liability",
+    "ForecastScenario",
+    "FinancialModel",
+    "ExchangeRate",
+    "CurrencyConverter",
+    "CurrencyError",
+    "CURRENCY_SYMBOLS",
+]

domain/account.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass, field
+from uuid import UUID, uuid4
+
+
+@dataclass
+class Account:
+    id: UUID = field(default_factory=uuid4)
+    name: str = ""
+    currency: str = "USD"
+    balance: float = 0.0
+
+    def to_dict(self) -> dict:
+        return {
+            "id": str(self.id),
+            "name": self.name,
+            "currency": self.currency,
+            "balance": self.balance,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Account":
+        return cls(
+            id=UUID(data["id"]),
+            name=data["name"],
+            currency=data.get("currency", "USD"),
+            balance=data.get("balance", 0.0),
+        )

domain/asset.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass, field
+from uuid import UUID, uuid4
+
+
+@dataclass
+class Asset:
+    id: UUID = field(default_factory=uuid4)
+    name: str = ""
+    value: float = 0.0
+    growth_rate: float = 0.0
+
+    def to_dict(self) -> dict:
+        return {
+            "id": str(self.id),
+            "name": self.name,
+            "value": self.value,
+            "growth_rate": self.growth_rate,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Asset":
+        return cls(
+            id=UUID(data["id"]),
+            name=data["name"],
+            value=data.get("value", 0.0),
+            growth_rate=data.get("growth_rate", 0.0),
+        )

domain/currency.py

@@ -0,0 +1,79 @@
+from dataclasses import dataclass
+
+CURRENCY_SYMBOLS = {
+    "RUB": "₽",
+    "USD": "$",
+    "EUR": "€",
+    "GBP": "£",
+    "CNY": "¥",
+    "JPY": "¥",
+    "KZT": "₸",
+    "UAH": "₴",
+}
+
+
+@dataclass
+class ExchangeRate:
+    from_currency: str = "USD"
+    to_currency: str = "RUB"
+    rate: float = 80.0
+
+    def to_dict(self) -> dict:
+        return {
+            "from_currency": self.from_currency,
+            "to_currency": self.to_currency,
+            "rate": self.rate,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ExchangeRate":
+        return cls(
+            from_currency=data.get("from_currency", "USD"),
+            to_currency=data.get("to_currency", "RUB"),
+            rate=data.get("rate", 80.0),
+        )
+
+
+DEFAULT_RATES: list[ExchangeRate] = [
+    ExchangeRate(from_currency="USD", to_currency="RUB", rate=80.0),
+]
+
+
+class CurrencyError(Exception):
+    pass
+
+
+class CurrencyConverter:
+    def __init__(self, rates: list[ExchangeRate] | None = None):
+        self._rates: dict[tuple[str, str], float] = {}
+        if rates:
+            for r in rates:
+                self.set_rate(r.from_currency, r.to_currency, r.rate)
+
+    def set_rate(self, from_currency: str, to_currency: str, rate: float) -> None:
+        if rate <= 0:
+            raise CurrencyError(f"Rate must be positive: {rate}")
+        self._rates[(from_currency, to_currency)] = rate
+        inverse = 1.0 / rate
+        self._rates[(to_currency, from_currency)] = inverse
+
+    def get_rate(self, from_currency: str, to_currency: str) -> float:
+        if from_currency == to_currency:
+            return 1.0
+        try:
+            return self._rates[(from_currency, to_currency)]
+        except KeyError:
+            raise CurrencyError(f"No exchange rate: {from_currency} → {to_currency}")
+
+    def convert(self, amount: float, from_currency: str, to_currency: str) -> float:
+        if from_currency == to_currency:
+            return amount
+        rate = self.get_rate(from_currency, to_currency)
+        return round(amount * rate, 2)
+
+    def get_symbol(self, currency: str) -> str:
+        return CURRENCY_SYMBOLS.get(currency, currency)
+
+    @classmethod
+    def with_defaults(cls) -> "CurrencyConverter":
+        return cls(DEFAULT_RATES)

domain/liability.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass, field
+from uuid import UUID, uuid4
+
+
+@dataclass
+class Liability:
+    id: UUID = field(default_factory=uuid4)
+    name: str = ""
+    balance: float = 0.0
+    interest: float = 0.0
+    payment: float = 0.0
+
+    def to_dict(self) -> dict:
+        return {
+            "id": str(self.id),
+            "name": self.name,
+            "balance": self.balance,
+            "interest": self.interest,
+            "payment": self.payment,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Liability":
+        return cls(
+            id=UUID(data["id"]),
+            name=data["name"],
+            balance=data.get("balance", 0.0),
+            interest=data.get("interest", 0.0),
+            payment=data.get("payment", 0.0),
+        )

domain/model.py

@@ -0,0 +1,78 @@
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from domain.account import Account
+from domain.asset import Asset
+from domain.currency import DEFAULT_RATES, ExchangeRate
+from domain.liability import Liability
+from domain.recurring import RecurringCashflow
+from domain.scenario import ForecastScenario
+from domain.transaction import Transaction
+
+
+@dataclass
+class FinancialModel:
+    base_currency: str = "RUB"
+    accounts: list[Account] = field(default_factory=list)
+    transactions: list[Transaction] = field(default_factory=list)
+    recurring: list[RecurringCashflow] = field(default_factory=list)
+    assets: list[Asset] = field(default_factory=list)
+    liabilities: list[Liability] = field(default_factory=list)
+    scenarios: list[ForecastScenario] = field(default_factory=list)
+    exchange_rates: list[ExchangeRate] = field(default_factory=lambda: DEFAULT_RATES.copy())
+
+    SCHEMA_VERSION = 1
+
+    def to_dict(self) -> dict:
+        return {
+            "version": self.SCHEMA_VERSION,
+            "base_currency": self.base_currency,
+            "accounts": [a.to_dict() for a in self.accounts],
+            "transactions": [t.to_dict() for t in self.transactions],
+            "recurring": [r.to_dict() for r in self.recurring],
+            "assets": [a.to_dict() for a in self.assets],
+            "liabilities": [li.to_dict() for li in self.liabilities],
+            "scenarios": [s.to_dict() for s in self.scenarios],
+            "exchange_rates": [r.to_dict() for r in self.exchange_rates],
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "FinancialModel":
+        version = data.get("version", 0)
+        if version == 0:
+            return cls._from_v0(data)
+        if version == 1:
+            return cls._from_v1(data)
+        raise ValueError(f"Unsupported FinancialModel version: {version}")
+
+    @classmethod
+    def _from_v1(cls, data: dict) -> "FinancialModel":
+        return cls(
+            base_currency=data.get("base_currency", "RUB"),
+            accounts=[Account.from_dict(a) for a in data.get("accounts", [])],
+            transactions=[Transaction.from_dict(t) for t in data.get("transactions", [])],
+            recurring=[RecurringCashflow.from_dict(r) for r in data.get("recurring", [])],
+            assets=[Asset.from_dict(a) for a in data.get("assets", [])],
+            liabilities=[Liability.from_dict(li) for li in data.get("liabilities", [])],
+            scenarios=[ForecastScenario.from_dict(s) for s in data.get("scenarios", [])],
+            exchange_rates=[ExchangeRate.from_dict(r) for r in data.get("exchange_rates", [])],
+        )
+
+    @classmethod
+    def _from_v0(cls, data: dict) -> "FinancialModel":
+        # Legacy: файлы, сохранённые до введения version. Совпадает по структуре с v1.
+        return cls._from_v1(data)
+
+    def save(self, path: str | Path) -> None:
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.to_dict(), f, indent=2, ensure_ascii=False)
+
+    @classmethod
+    def load(cls, path: str | Path) -> "FinancialModel":
+        path = Path(path)
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return cls.from_dict(data)

domain/recurring.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass, field
+from uuid import UUID, uuid4
+
+
+@dataclass
+class RecurringCashflow:
+    id: UUID = field(default_factory=uuid4)
+    start_date: str = ""
+    end_date: str = ""
+    frequency: str = "monthly"
+    amount: float = 0.0
+    category: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "id": str(self.id),
+            "start_date": self.start_date,
+            "end_date": self.end_date,
+            "frequency": self.frequency,
+            "amount": self.amount,
+            "category": self.category,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "RecurringCashflow":
+        return cls(
+            id=UUID(data["id"]),
+            start_date=data.get("start_date", ""),
+            end_date=data.get("end_date", ""),
+            frequency=data.get("frequency", "monthly"),
+            amount=data.get("amount", 0.0),
+            category=data.get("category", ""),
+        )

domain/scenario.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass, field
+from uuid import UUID, uuid4
+
+
+@dataclass
+class ForecastScenario:
+    id: UUID = field(default_factory=uuid4)
+    name: str = "baseline"
+    income_multiplier: float = 1.0
+    expense_multiplier: float = 1.0
+    growth_multiplier: float = 1.0
+    description: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "id": str(self.id),
+            "name": self.name,
+            "income_multiplier": self.income_multiplier,
+            "expense_multiplier": self.expense_multiplier,
+            "growth_multiplier": self.growth_multiplier,
+            "description": self.description,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ForecastScenario":
+        return cls(
+            id=UUID(data["id"]),
+            name=data["name"],
+            income_multiplier=data.get("income_multiplier", 1.0),
+            expense_multiplier=data.get("expense_multiplier", 1.0),
+            growth_multiplier=data.get("growth_multiplier", 1.0),
+            description=data.get("description", ""),
+        )

domain/transaction.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass, field
+from uuid import UUID, uuid4
+
+
+@dataclass
+class Transaction:
+    id: UUID = field(default_factory=uuid4)
+    date: str = ""
+    account: str = ""
+    category: str = ""
+    amount: float = 0.0
+    description: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "id": str(self.id),
+            "date": self.date,
+            "account": self.account,
+            "category": self.category,
+            "amount": self.amount,
+            "description": self.description,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Transaction":
+        return cls(
+            id=UUID(data["id"]),
+            date=data["date"],
+            account=data.get("account", ""),
+            category=data.get("category", ""),
+            amount=data.get("amount", 0.0),
+            description=data.get("description", ""),
+        )