testing new features

cli/main.py

@@ -6,7 +6,9 @@ from rich.console import Console
 from rich.table import Table
 
 from ai.assistant import AssistantService
-from cashflow_model import FinancialModel
+from cashflow_model import CurrencyConverter, FinancialModel
+from cli.config import app as config_app
+from cli.i18n import setup_i18n, t
 from engine.forecast import ForecastService
 from engine.scenarios import DEFAULT_SCENARIOS, ScenarioService
 from sync.excel_sync import ExcelSync
@@ -16,12 +18,16 @@ try:
 except (AttributeError, OSError):
     pass
 
-app = typer.Typer(name="cf", help="CashFlow Forecast - personal finance model")
+setup_i18n()
+
+app = typer.Typer(name="cf", help=t("app.help"))
 console = Console()
 
 DATA_DIR = Path("data")
 MODEL_PATH = DATA_DIR / "model.json"
 
+CURRENCY_OPTION = typer.Option(None, "--currency", "-c", help=t("cmd.forecast.opt.currency"))
+
 
 def _load_model() -> FinancialModel:
     if MODEL_PATH.exists():
@@ -33,169 +39,292 @@ def _save_model(model: FinancialModel) -> None:
     model.save(MODEL_PATH)
 
 
+def _get_converter(model: FinancialModel) -> CurrencyConverter:
+    return CurrencyConverter(model.exchange_rates)
+
+
+def _fmt(amount: float, currency: str, symbol: str) -> str:
+    return f"{symbol}{amount:,.2f}"
+
+
+def _resolve_currency(model: FinancialModel, currency: str | None) -> tuple[str, str]:
+    target = currency or model.base_currency
+    converter = _get_converter(model)
+    symbol = converter.get_symbol(target)
+    return target, symbol
+
+
+def _convert_value(
+    converter: CurrencyConverter, amount: float, from_curr: str, to_curr: str
+) -> float:
+    if to_curr == from_curr:
+        return amount
+    return converter.convert(amount, from_curr, to_curr)
+
+
 @app.command()
 def init() -> None:
     """Создать пустую финансовую модель"""
     model = FinancialModel()
     _save_model(model)
-    console.print("[green]OK[/green] Пустая модель создана в data/model.json")
+    console.print(t("cmd.init.ok", path=str(MODEL_PATH)))
 
 
 @app.command()
 def forecast(
-    months: int = typer.Option(12, "--months", "-m", help="Количество месяцев прогноза"),
+    months: int = typer.Option(12, "--months", "-m", help=t("cmd.forecast.opt.months")),
+    currency: str | None = CURRENCY_OPTION,
 ) -> None:
     """Запустить прогноз денежных потоков"""
     model = _load_model()
+    target_curr, symbol = _resolve_currency(model, currency)
+    converter = _get_converter(model)
+    base_curr = model.base_currency
     service = ForecastService(model)
     results = service.forecast_cashflow(months)
     summary = service.summary(months)
 
+    def _cv(val):
+        return _convert_value(converter, val, base_curr, target_curr)
+
+    def _f(val):
+        return _fmt(val, target_curr, symbol)
+
     if results:
-        table = Table(title=f"Прогноз на {months} мес.")
-        table.add_column("Счёт", style="cyan")
-        table.add_column("Месяц", style="white")
-        table.add_column("Баланс", justify="right", style="green")
-        table.add_column("Доход", justify="right")
-        table.add_column("Расход", justify="right")
+        table = Table(title=t("cmd.forecast.title", months=months, currency=target_curr))
+        table.add_column(t("cmd.forecast.col.account"), style="cyan")
+        table.add_column(t("cmd.forecast.col.month"), style="white")
+        table.add_column(t("cmd.forecast.col.balance"), justify="right", style="green")
+        table.add_column(t("cmd.forecast.col.income"), justify="right")
+        table.add_column(t("cmd.forecast.col.expenses"), justify="right")
 
         for r in results:
             table.add_row(
                 r["account"], str(r["month"]),
-                f"${r['balance']:.2f}",
-                f"${r['income']:.2f}",
-                f"${r['expenses']:.2f}",
+                _f(_cv(r["balance"])),
+                _f(_cv(r["income"])),
+                _f(_cv(r["expenses"])),
             )
         console.print(table)
 
-    console.print(f"\n[bold]Итог:[/bold] Баланс: ${summary['total_balance']:.2f} | "
-                  f"Доход: ${summary['total_income']:.2f} | "
-                  f"Расход: ${summary['total_expenses']:.2f}")
+    cb = _cv(summary["total_balance"])
+    ci = _cv(summary["total_income"])
+    ce = _cv(summary["total_expenses"])
+    console.print(t("cmd.forecast.total", balance=_f(cb), income=_f(ci), expenses=_f(ce)))
 
 
 @app.command()
 def scenario(
-    name: str = typer.Argument("baseline", help="Имя сценария: baseline, optimistic, pessimistic"),
-    months: int = typer.Option(12, "--months", "-m", help="Количество месяцев"),
+    name: str = typer.Argument("baseline", help=t("cmd.scenario.arg.name")),
+    months: int = typer.Option(12, "--months", "-m", help=t("cmd.scenario.opt.months")),
+    currency: str | None = CURRENCY_OPTION,
 ) -> None:
     """Применить сценарий и показать прогноз"""
     model = _load_model()
+    target_curr, symbol = _resolve_currency(model, currency)
+    converter = _get_converter(model)
+    base_curr = model.base_currency
     service = ScenarioService(model)
 
     if name in DEFAULT_SCENARIOS:
         scenario_obj = DEFAULT_SCENARIOS[name]
     else:
-        console.print(f"[red]Неизвестный сценарий: {name}[/red]")
-        console.print(f"Доступны: {', '.join(DEFAULT_SCENARIOS.keys())}")
+        console.print(f"[red]{t('cmd.scenario.err.unknown', name=name)}[/red]")
+        console.print(t("cmd.scenario.err.available", scenarios=", ".join(DEFAULT_SCENARIOS.keys())))
         raise typer.Exit(1)
 
     result = service.apply(scenario_obj, months)
-    console.print(f"[bold]Сценарий:[/bold] {result['scenario']}")
+    balance = _convert_value(converter, result["total_balance"], base_curr, target_curr)
+    income = _convert_value(converter, result["total_income"], base_curr, target_curr)
+    expenses = _convert_value(converter, result["total_expenses"], base_curr, target_curr)
+    console.print(f"[bold]{t('cmd.scenario.label')}:[/bold] {result['scenario']}")
     console.print(f"[dim]{result['scenario_description']}[/dim]")
-    console.print(f"Баланс: ${result['total_balance']:.2f}")
-    console.print(f"Доход: ${result['total_income']:.2f}")
-    console.print(f"Расход: ${result['total_expenses']:.2f}")
+    console.print(f"{t('cmd.scenario.label.balance')}: {_fmt(balance, target_curr, symbol)}")
+    console.print(f"{t('cmd.scenario.label.income')}: {_fmt(income, target_curr, symbol)}")
+    console.print(f"{t('cmd.scenario.label.expenses')}: {_fmt(expenses, target_curr, symbol)}")
 
 
 @app.command()
 def whatif(
-    income_mult: float = typer.Option(1.0, "--income", "-i", help="Множитель дохода"),
-    expense_mult: float = typer.Option(1.0, "--expense", "-e", help="Множитель расхода"),
-    growth_mult: float = typer.Option(1.0, "--growth", "-g", help="Множитель роста активов"),
-    months: int = typer.Option(12, "--months", "-m", help="Количество месяцев"),
+    income_mult: float = typer.Option(1.0, "--income", "-i", help=t("cmd.whatif.opt.income")),
+    expense_mult: float = typer.Option(1.0, "--expense", "-e", help=t("cmd.whatif.opt.expense")),
+    growth_mult: float = typer.Option(1.0, "--growth", "-g", help=t("cmd.whatif.opt.growth")),
+    months: int = typer.Option(12, "--months", "-m", help=t("cmd.whatif.opt.months")),
+    currency: str | None = CURRENCY_OPTION,
 ) -> None:
     """What-if анализ с произвольными множителями"""
     model = _load_model()
+    target_curr, symbol = _resolve_currency(model, currency)
+    converter = _get_converter(model)
+    base_curr = model.base_currency
     service = ScenarioService(model)
     result = service.what_if(income_mult, expense_mult, growth_mult, months)
 
-    console.print("[bold]What-if анализ[/bold]")
-    console.print(f"Доход x{income_mult} | Расход x{expense_mult} | Рост x{growth_mult}")
-    console.print(f"Баланс: ${result['total_balance']:.2f}")
-    console.print(f"Доход: ${result['total_income']:.2f}")
-    console.print(f"Расход: ${result['total_expenses']:.2f}")
+    balance = _convert_value(converter, result["total_balance"], base_curr, target_curr)
+    income = _convert_value(converter, result["total_income"], base_curr, target_curr)
+    expenses = _convert_value(converter, result["total_expenses"], base_curr, target_curr)
+    console.print(f"[bold]{t('cmd.whatif.title')}[/bold]")
+    console.print(t("cmd.whatif.params", income=income_mult, expense=expense_mult, growth=growth_mult))
+    console.print(f"{t('cmd.scenario.label.balance')}: {_fmt(balance, target_curr, symbol)}")
+    console.print(f"{t('cmd.scenario.label.income')}: {_fmt(income, target_curr, symbol)}")
+    console.print(f"{t('cmd.scenario.label.expenses')}: {_fmt(expenses, target_curr, symbol)}")
 
 
 @app.command()
 def compare(
-    months: int = typer.Option(12, "--months", "-m", help="Количество месяцев"),
+    months: int = typer.Option(12, "--months", "-m", help=t("cmd.compare.opt.months")),
+    currency: str | None = CURRENCY_OPTION,
 ) -> None:
     """Сравнить все сценарии"""
     model = _load_model()
+    target_curr, symbol = _resolve_currency(model, currency)
+    converter = _get_converter(model)
+    base_curr = model.base_currency
     service = ScenarioService(model)
     results = service.compare(months)
 
-    table = Table(title="Сравнение сценариев")
-    table.add_column("Сценарий", style="cyan")
-    table.add_column("Баланс", justify="right")
-    table.add_column("Доход", justify="right")
-    table.add_column("Расход", justify="right")
+    table = Table(title=t("cmd.compare.title", currency=target_curr))
+    table.add_column(t("cmd.compare.col.scenario"), style="cyan")
+    table.add_column(t("cmd.forecast.col.balance"), justify="right")
+    table.add_column(t("cmd.forecast.col.income"), justify="right")
+    table.add_column(t("cmd.forecast.col.expenses"), justify="right")
 
     for name, r in results.items():
-        table.add_row(
-            name,
-            f"${r['total_balance']:.2f}",
-            f"${r['total_income']:.2f}",
-            f"${r['total_expenses']:.2f}",
-        )
+        b = _convert_value(converter, r["total_balance"], base_curr, target_curr)
+        i = _convert_value(converter, r["total_income"], base_curr, target_curr)
+        e = _convert_value(converter, r["total_expenses"], base_curr, target_curr)
+        fb = _fmt(b, target_curr, symbol)
+        fi = _fmt(i, target_curr, symbol)
+        fe = _fmt(e, target_curr, symbol)
+        table.add_row(name, fb, fi, fe)
     console.print(table)
 
 
 @app.command()
 def import_xlsx(
-    path: str = typer.Argument(..., help="Путь к .xlsx файлу"),
+    path: str = typer.Argument(..., help=t("cmd.import.arg.path")),
 ) -> None:
     """Импорт данных из Excel"""
     sync = ExcelSync()
     try:
         model = sync.import_model(path)
         _save_model(model)
-        console.print(f"[green]OK[/green] Импортировано: {len(model.accounts)} счетов, "
-                      f"{len(model.transactions)} транзакций, "
-                      f"{len(model.recurring)} регулярных платежей, "
-                      f"{len(model.assets)} активов, "
-                      f"{len(model.liabilities)} обязательств")
+        console.print(t("cmd.import.ok",
+                         accounts=len(model.accounts),
+                         transactions=len(model.transactions),
+                         recurring=len(model.recurring),
+                         assets=len(model.assets),
+                         liabilities=len(model.liabilities)))
+        console.print(t("cmd.import.base_currency", currency=model.base_currency))
     except Exception as e:
-        console.print(f"[red]Ошибка импорта: {e}[/red]")
+        console.print(f"[red]{t('cmd.import.err', error=str(e))}[/red]")
         raise typer.Exit(1)
 
 
 @app.command()
 def export_xlsx(
-    path: str = typer.Argument("exports/forecast.xlsx", help="Путь для .xlsx файла"),
+    path: str = typer.Argument("exports/forecast.xlsx", help=t("cmd.export.arg.path")),
 ) -> None:
     """Экспорт модели в Excel"""
     model = _load_model()
     sync = ExcelSync()
     try:
         sync.export_model(model, path)
-        console.print(f"[green]OK[/green] Модель экспортирована в {path}")
+        console.print(t("cmd.export.ok", path=path))
     except Exception as e:
-        console.print(f"[red]Ошибка экспорта: {e}[/red]")
+        console.print(f"[red]{t('cmd.export.err', error=str(e))}[/red]")
         raise typer.Exit(1)
 
 
 @app.command()
 def analyze(
-    months: int = typer.Option(12, "--months", "-m", help="Количество месяцев для анализа"),
+    months: int = typer.Option(12, "--months", "-m", help=t("cmd.analyze.opt.months")),
+    currency: str | None = CURRENCY_OPTION,
 ) -> None:
     """AI-анализ финансовой модели"""
     model = _load_model()
-    assistant = AssistantService(model)
+    target_curr, _ = _resolve_currency(model, currency)
+    converter = _get_converter(model)
+    assistant = AssistantService(model, converter=converter, display_currency=target_curr)
     result = assistant.analyze(months)
 
-    console.print("[bold]Промпт для AI:[/bold]")
+    console.print(f"[bold]{t('cmd.analyze.title.prompt')}:[/bold]")
     console.print(result["prompt"][:500] + "...\n")
 
-    console.print("[bold]Сводка:[/bold]")
-    s = result["summary"]
-    console.print(f"Баланс: ${s['total_balance']:.2f}")
-    console.print(f"Доход: ${s['total_income']:.2f}")
-    console.print(f"Расход: ${s['total_expenses']:.2f}")
-    console.print(
-        "\n[yellow]AI-ответ: заглушка. Подключите реальный API в ai/assistant.py[/yellow]"
-    )
+    console.print(f"[bold]{t('cmd.analyze.title.summary')}:[/bold]")
+    console.print(t("cmd.analyze.base_currency", currency=model.base_currency))
+    console.print(f"\n[yellow]{t('cmd.analyze.stub')}[/yellow]")
 
 
+@app.command()
+def info() -> None:
+    """Сводка всей финансовой модели"""
+    model = _load_model()
+    converter = _get_converter(model)
+    symbol = converter.get_symbol(model.base_currency)
+
+    console.print(f"[bold]{t('cmd.info.metadata')}[/bold]")
+    console.print(f"  {t('cmd.info.base_currency', currency=model.base_currency, symbol=symbol)}")
+    console.print(f"  {t('cmd.info.accounts', count=len(model.accounts))}")
+    console.print(f"  {t('cmd.info.transactions', count=len(model.transactions))}")
+    console.print(f"  {t('cmd.info.recurring', count=len(model.recurring))}")
+    console.print(f"  {t('cmd.info.assets', count=len(model.assets))}")
+    console.print(f"  {t('cmd.info.liabilities', count=len(model.liabilities))}")
+    console.print(f"  {t('cmd.info.rates', count=len(model.exchange_rates))}")
+
+    if model.accounts:
+        tbl = Table(title=t("table.accounts.title"))
+        tbl.add_column(t("table.accounts.col.name"), style="cyan")
+        tbl.add_column(t("table.accounts.col.currency"))
+        tbl.add_column(t("table.accounts.col.balance"), justify="right")
+        for a in model.accounts:
+            tbl.add_row(a.name, a.currency, f"{a.balance:,.2f}")
+        console.print(tbl)
+
+    if model.transactions:
+        tbl = Table(title=t("table.transactions.title"))
+        tbl.add_column(t("table.transactions.col.date"))
+        tbl.add_column(t("table.transactions.col.category"))
+        tbl.add_column(t("table.transactions.col.amount"), justify="right")
+        tbl.add_column(t("table.transactions.col.description"))
+        for tx in model.transactions[:10]:
+            tbl.add_row(tx.date, tx.category, f"{tx.amount:,.2f}", tx.description)
+        if len(model.transactions) > 10:
+            console.print(tbl)
+            console.print(t("cmd.info.more", count=len(model.transactions) - 10))
+        else:
+            console.print(tbl)
+
+    if model.recurring:
+        tbl = Table(title=t("table.recurring.title"))
+        tbl.add_column(t("table.recurring.col.period"))
+        tbl.add_column(t("table.recurring.col.amount"), justify="right")
+        tbl.add_column(t("table.recurring.col.category"))
+        for r in model.recurring:
+            tbl.add_row(r.frequency, f"{r.amount:,.2f}", r.category)
+        console.print(tbl)
+
+    if model.assets:
+        tbl = Table(title=t("table.assets.title"))
+        tbl.add_column(t("table.assets.col.name"), style="cyan")
+        tbl.add_column(t("table.assets.col.value"), justify="right")
+        tbl.add_column(t("table.assets.col.growth"), justify="right")
+        for a in model.assets:
+            tbl.add_row(a.name, f"{a.value:,.2f}", f"{a.growth_rate:.1f}%")
+        console.print(tbl)
+
+    if model.liabilities:
+        tbl = Table(title=t("table.liabilities.title"))
+        tbl.add_column(t("table.liabilities.col.name"), style="cyan")
+        tbl.add_column(t("table.liabilities.col.balance"), justify="right")
+        tbl.add_column(t("table.liabilities.col.rate"), justify="right")
+        tbl.add_column(t("table.liabilities.col.payment"), justify="right")
+        for li in model.liabilities:
+            tbl.add_row(li.name, f"{li.balance:,.2f}", f"{li.interest:.1f}%", f"{li.payment:,.2f}")
+        console.print(tbl)
+
+
+app.add_typer(config_app)
+
 if __name__ == "__main__":
     app()