dominicusin · Sep 5, 2026 · Sep 5, 2026 · coderabbitai · Sep 5, 2026 · coderabbitai
@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2026-09-05
+
+### Added
+- **Dependency support**: `depends` field now properly encoded as implications in all solvers.
+  - `Package(depends=["pkg2"])` → `selected(pkg1) ⇒ selected(pkg2)`
+  - Greedy, EnhancedGreedy, Z3, PuLP, OR-Tools, MaxSAT, MiniSAT all respect dependencies
+- **Model encoder** (`core/model_encoder.py`): intermediate constraint layer shared by all solvers
+- **CLI `--depends` flag**: specify dependencies via `-d pkg dep`
+- **CLI `--explain` flag**: shows why packages were excluded (conflicts, missing deps)
+- **Web API `depends` field**: POST `/api/v1/maximize` accepts `depends: [["pkg", "dep"]]`
+- **Web API `explain` flag**: returns exclusion reasons in response
+
+### Changed
+- Solvers now use `ModelConstraints` from `encode_packages()` for consistent constraint encoding
+- Greedy solver sorts by weight (descending) in weighted mode
+
 ## [0.6.1] - 2026-09-04
 
 ### Fixed

@@ -61,7 +61,11 @@ def cli(verbose: bool, quiet: bool, config: str | None):
               help='Формат вывода')
 @click.option('--weights', '-w', type=(str, float), multiple=True,
               help='Веса пакетов (имя,вес)')
-def maximize(packages, manager, solver, conflicts, output, weights):
+@click.option('--depends', '-d', type=(str, str), multiple=True,
+              help='Зависимости пакетов (имя,зависимость)')
+@click.option('--explain', '-e', is_flag=True, default=False,
+              help='Показать причины отбора/отклонения пакетов')
+def maximize(packages, manager, solver, conflicts, output, weights, depends, explain):
     """
     Максимизировать множество пакетов.
 
@@ -105,6 +109,16 @@ def maximize(packages, manager, solver, conflicts, output, weights):
         for pkg in package_objs:
             if pkg.name in conflict_map:
                 pkg.conflicts = conflict_map[pkg.name]
+
+        # Добавление зависимостей
+        dep_map = {}
+        for pkg_name, dep_name in depends:
+            dep_map.setdefault(pkg_name, []).append(dep_name)
+
+        # Применение зависимостей к пакетам
+        for pkg in package_objs:
+            if pkg.name in dep_map:
+                pkg.depends = dep_map[pkg.name]
 
         # Создание словаря весов
         weights_dict = dict(weights) if weights else None
@@ -141,7 +155,38 @@ def maximize(packages, manager, solver, conflicts, output, weights):
             click.echo(f"Входные пакеты: {len(package_objs)}")
             click.echo(f"Выбранные пакеты: {len(result)}")
             click.echo(f"Результат: {', '.join(result)}")
-
+
+            if explain:
+                # Анализ причин
+                selected_set = set(result)
+                all_names = {p.name for p in package_objs}
+                excluded = all_names - selected_set
+
+                if excluded:
+                    click.echo(f"\nПричины отклонения:")
+                    # Используем encoder для получения ограничений
+                    from ..core.model_encoder import encode_packages
+                    constraints = encode_packages(package_objs)
+
+                    for name in sorted(excluded):
+                        reasons = []
+                        # Проверяем конфликты
+                        for a, b in constraints.conflicts:
+                            if a == name and b in selected_set:
+                                reasons.append(f"конфликт с {b}")
+                            elif b == name and a in selected_set:
+                                reasons.append(f"конфликт с {a}")
+
+                        # Проверяем зависимости (если pkg исключён, возможно его зависимости не выбраны)
+                        deps = constraints.dependencies.get(name, [])
+                        for dep in deps:
+                            if dep not in selected_set:
+                                reasons.append(f"не выбрана зависимость {dep}")
+
+                        if reasons:
+                            click.echo(f"  - {name}: {'; '.join(reasons)}")
+                        else:
+                            click.echo(f"  - {name}: не оптимально для данного солвера")
     except Exception as e:
         logger.error(f"Ошибка: {e}", exc_info=True)
         click.echo(f"Ошибка: {e}", err=True)

@@ -1,10 +1,11 @@
 """
-Core module - Ядро системы Package Maximizer.
+Core module — Ядро системы Package Maximizer.
 """
 
 from .enums import PackageManagerType, SolverType, PackageStatus
 from .interfaces import ConstraintSolver, PackageParser, ResultAnalyzer
 from .maximizer import PackageMaximizer
+from .model_encoder import ModelConstraints, encode_packages
 from .package import Package, PackageConstraint
 from .constraints import VersionConstraint, DependencyConstraint, ConflictConstraint, ConstraintParser
 
@@ -16,6 +17,8 @@
     "PackageParser",
     "ResultAnalyzer",
     "PackageMaximizer",
+    "ModelConstraints",
+    "encode_packages",
     "Package",
     "PackageConstraint",
     "VersionConstraint",

@@ -0,0 +1,82 @@
+"""Model encoder — преобразует Package-объекты в набор ограничений для солверов.
+
+Формат ограничений:
+- conflicts: список пар (A, B) — A и B не могут быть выбраны вместе
+- dependencies: словарь {A: [B, C]} — если выбран A, должны быть выбраны B и C
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .package import Package
+
+
+@dataclass
+class ModelConstraints:
+    """Нормализованный набор ограничений для солверов."""
+
+    # Множество всех пакетов
+    packages: list[str] = field(default_factory=list)
+
+    # Конфликтные пары: A и B не могут быть выбраны вместе
+    conflicts: list[tuple[str, str]] = field(default_factory=list)
+
+    # Зависимости: если выбран A, должны быть выбраны B, C, ...
+    dependencies: dict[str, list[str]] = field(default_factory=dict)
+
+    def add_conflict(self, a: str, b: str) -> None:
+        """Добавить конфликт между пакетами a и b."""
+        if a == b:
+            return
+        pair = (min(a, b), max(a, b))
+        if pair not in self.conflicts:
+            self.conflicts.append(pair)
+
+    def add_dependency(self, pkg: str, dep: str) -> None:
+        """Добавить зависимость: pkg требует dep."""
+        if pkg == dep:
+            return
+        if pkg not in self.dependencies:
+            self.dependencies[pkg] = []
+        if dep not in self.dependencies[pkg]:
+            self.dependencies[pkg].append(dep)
+        if pkg not in self.packages:
+            self.packages.append(pkg)
+        if dep not in self.packages:
+            self.packages.append(dep)
+
+
+def encode_packages(packages: list[Package]) -> ModelConstraints:
+    """
+    Преобразовать список Package в ModelConstraints.
+
+    Args:
+        packages: Список пакетов с depends и conflicts
+
+    Returns:
+        ModelConstraints с нормализованными ограничениями
+    """
+    constraints = ModelConstraints()
+
+    # Регистрируем все пакеты
+    for pkg in packages:
+        if pkg.name not in constraints.packages:
+            constraints.packages.append(pkg.name)
+
+    # Кодируем конфликты
+    conflict_pairs: set[tuple[str, str]] = set()
+    for pkg in packages:
+        for conflict in pkg.conflicts or []:
+            if conflict in constraints.packages:
+                pair = (min(pkg.name, conflict), max(pkg.name, conflict))
+                conflict_pairs.add(pair)
+    constraints.conflicts = sorted(conflict_pairs)
+
+    # Кодируем зависимости
+    for pkg in packages:
+        for dep in pkg.depends or []:
+            if dep in constraints.packages:
+                constraints.add_dependency(pkg.name, dep)
+
+    return constraints