iil-task-scorer 0.1.0__tar.gz

iil_task_scorer-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: iil-task-scorer
+Version: 0.1.0
+Summary: Shared scoring and routing engine for task complexity estimation
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+
+# task-scorer
+
+Shared scoring and routing engine for task complexity estimation.
+
+Zero-dependency Python package that provides weighted multi-dimension
+keyword scoring with sigmoid confidence calibration. Consolidates
+scoring logic from BFAgent (TestRequirement, LLMRouter) and
+Orchestrator MCP (analyzer).
+
+**ADR**: [ADR-023 Shared Scoring and Routing Engine](../../docs/adr/ADR-023-shared-scoring-routing-engine.md)
+
+## Installation
+
+```bash
+# From git (recommended for Docker)
+pip install "task-scorer @ git+ssh://git@github.com/achimdehnert/platform.git@main#subdirectory=packages/task_scorer"
+
+# Local development
+pip install -e ".[dev]"
+```
+
+## Usage
+
+```python
+from task_scorer import score_task, ScoringConfig, Tier
+
+# With defaults
+result = score_task("fix the authentication bug in the API")
+print(result.top_type)    # "security"
+print(result.tier)        # Tier.HIGH
+print(result.confidence)  # 0.87
+print(result.signals)     # ["security(auth)", "bug(fix)"]
+print(result.is_ambiguous)  # False
+
+# With custom config (e.g. from DB lookup tables)
+config = ScoringConfig(
+    keywords={"security": ["auth", "cve", "credential"]},
+    weights={"security": 2.0},
+    tier_boundaries=(0.5, 1.5),
+)
+result = score_task("check auth flow", config=config)
+
+# With structured metadata
+result = score_task(
+    "refactor the authentication module",
+    category="security",
+    acceptance_criteria_count=5,
+    files_affected=8,
+)
+```
+
+## API
+
+### `score_task(description, config=None, category=None, acceptance_criteria_count=0, files_affected=0) -> ScoringResult`
+
+Main entry point. Scores a task description against all configured
+task types using weighted keyword matching.
+
+### `ScoringResult`
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `scores` | `dict[str, float]` | All type scores |
+| `top_type` | `str` | Highest scoring type |
+| `tier` | `Tier` | LOW / MEDIUM / HIGH |
+| `confidence` | `float` | Sigmoid confidence [0, 1] |
+| `signals` | `list[str]` | Debug signals |
+| `is_ambiguous` | `bool` | True if confidence < threshold |
+| `raw_score` | `float` | Winner's weighted score |
+
+### `ScoringConfig`
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `keywords` | `dict[str, list[str]]` | 10 types, 85 keywords | Task type keywords |
+| `weights` | `dict[str, float]` | 0.5 - 1.5 | Type weight multipliers |
+| `tier_boundaries` | `tuple[float, float]` | (1.0, 4.0) | LOW/MEDIUM/HIGH boundaries |
+| `confidence_steepness` | `float` | 8.0 | Sigmoid steepness |
+| `confidence_threshold` | `float` | 0.65 | Ambiguity threshold |
+
+## Testing
+
+```bash
+cd packages/task_scorer
+pip install -e ".[dev]"
+python3 -m pytest tests/ -v
+```
+
+## Architecture
+
+```
+src/task_scorer/
+├── __init__.py    # Public API exports
+├── types.py       # ScoringConfig, ScoringResult, Tier, DEFAULT_KEYWORDS
+└── scorer.py      # score_task, _score_all_types, _sigmoid_confidence
+```
+
+- **Zero dependencies** — stdlib only (math, dataclasses, enum)
+- **Frozen dataclasses** — immutable config and results
+- **Config injection** — defaults in code, DB-driven override via ScoringConfig
+- **Tenant-agnostic** — pure function, no database access

iil_task_scorer-0.1.0/README.md

@@ -0,0 +1,101 @@
+# task-scorer
+
+Shared scoring and routing engine for task complexity estimation.
+
+Zero-dependency Python package that provides weighted multi-dimension
+keyword scoring with sigmoid confidence calibration. Consolidates
+scoring logic from BFAgent (TestRequirement, LLMRouter) and
+Orchestrator MCP (analyzer).
+
+**ADR**: [ADR-023 Shared Scoring and Routing Engine](../../docs/adr/ADR-023-shared-scoring-routing-engine.md)
+
+## Installation
+
+```bash
+# From git (recommended for Docker)
+pip install "task-scorer @ git+ssh://git@github.com/achimdehnert/platform.git@main#subdirectory=packages/task_scorer"
+
+# Local development
+pip install -e ".[dev]"
+```
+
+## Usage
+
+```python
+from task_scorer import score_task, ScoringConfig, Tier
+
+# With defaults
+result = score_task("fix the authentication bug in the API")
+print(result.top_type)    # "security"
+print(result.tier)        # Tier.HIGH
+print(result.confidence)  # 0.87
+print(result.signals)     # ["security(auth)", "bug(fix)"]
+print(result.is_ambiguous)  # False
+
+# With custom config (e.g. from DB lookup tables)
+config = ScoringConfig(
+    keywords={"security": ["auth", "cve", "credential"]},
+    weights={"security": 2.0},
+    tier_boundaries=(0.5, 1.5),
+)
+result = score_task("check auth flow", config=config)
+
+# With structured metadata
+result = score_task(
+    "refactor the authentication module",
+    category="security",
+    acceptance_criteria_count=5,
+    files_affected=8,
+)
+```
+
+## API
+
+### `score_task(description, config=None, category=None, acceptance_criteria_count=0, files_affected=0) -> ScoringResult`
+
+Main entry point. Scores a task description against all configured
+task types using weighted keyword matching.
+
+### `ScoringResult`
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `scores` | `dict[str, float]` | All type scores |
+| `top_type` | `str` | Highest scoring type |
+| `tier` | `Tier` | LOW / MEDIUM / HIGH |
+| `confidence` | `float` | Sigmoid confidence [0, 1] |
+| `signals` | `list[str]` | Debug signals |
+| `is_ambiguous` | `bool` | True if confidence < threshold |
+| `raw_score` | `float` | Winner's weighted score |
+
+### `ScoringConfig`
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `keywords` | `dict[str, list[str]]` | 10 types, 85 keywords | Task type keywords |
+| `weights` | `dict[str, float]` | 0.5 - 1.5 | Type weight multipliers |
+| `tier_boundaries` | `tuple[float, float]` | (1.0, 4.0) | LOW/MEDIUM/HIGH boundaries |
+| `confidence_steepness` | `float` | 8.0 | Sigmoid steepness |
+| `confidence_threshold` | `float` | 0.65 | Ambiguity threshold |
+
+## Testing
+
+```bash
+cd packages/task_scorer
+pip install -e ".[dev]"
+python3 -m pytest tests/ -v
+```
+
+## Architecture
+
+```
+src/task_scorer/
+├── __init__.py    # Public API exports
+├── types.py       # ScoringConfig, ScoringResult, Tier, DEFAULT_KEYWORDS
+└── scorer.py      # score_task, _score_all_types, _sigmoid_confidence
+```
+
+- **Zero dependencies** — stdlib only (math, dataclasses, enum)
+- **Frozen dataclasses** — immutable config and results
+- **Config injection** — defaults in code, DB-driven override via ScoringConfig
+- **Tenant-agnostic** — pure function, no database access

iil_task_scorer-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "iil-task-scorer"
+version = "0.1.0"
+description = "Shared scoring and routing engine for task complexity estimation"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+# Zero runtime dependencies — stdlib only
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.4",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W", "UP", "B", "SIM"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

iil_task_scorer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

iil_task_scorer-0.1.0/src/iil_task_scorer.egg-info/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: iil-task-scorer
+Version: 0.1.0
+Summary: Shared scoring and routing engine for task complexity estimation
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+
+# task-scorer
+
+Shared scoring and routing engine for task complexity estimation.
+
+Zero-dependency Python package that provides weighted multi-dimension
+keyword scoring with sigmoid confidence calibration. Consolidates
+scoring logic from BFAgent (TestRequirement, LLMRouter) and
+Orchestrator MCP (analyzer).
+
+**ADR**: [ADR-023 Shared Scoring and Routing Engine](../../docs/adr/ADR-023-shared-scoring-routing-engine.md)
+
+## Installation
+
+```bash
+# From git (recommended for Docker)
+pip install "task-scorer @ git+ssh://git@github.com/achimdehnert/platform.git@main#subdirectory=packages/task_scorer"
+
+# Local development
+pip install -e ".[dev]"
+```
+
+## Usage
+
+```python
+from task_scorer import score_task, ScoringConfig, Tier
+
+# With defaults
+result = score_task("fix the authentication bug in the API")
+print(result.top_type)    # "security"
+print(result.tier)        # Tier.HIGH
+print(result.confidence)  # 0.87
+print(result.signals)     # ["security(auth)", "bug(fix)"]
+print(result.is_ambiguous)  # False
+
+# With custom config (e.g. from DB lookup tables)
+config = ScoringConfig(
+    keywords={"security": ["auth", "cve", "credential"]},
+    weights={"security": 2.0},
+    tier_boundaries=(0.5, 1.5),
+)
+result = score_task("check auth flow", config=config)
+
+# With structured metadata
+result = score_task(
+    "refactor the authentication module",
+    category="security",
+    acceptance_criteria_count=5,
+    files_affected=8,
+)
+```
+
+## API
+
+### `score_task(description, config=None, category=None, acceptance_criteria_count=0, files_affected=0) -> ScoringResult`
+
+Main entry point. Scores a task description against all configured
+task types using weighted keyword matching.
+
+### `ScoringResult`
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `scores` | `dict[str, float]` | All type scores |
+| `top_type` | `str` | Highest scoring type |
+| `tier` | `Tier` | LOW / MEDIUM / HIGH |
+| `confidence` | `float` | Sigmoid confidence [0, 1] |
+| `signals` | `list[str]` | Debug signals |
+| `is_ambiguous` | `bool` | True if confidence < threshold |
+| `raw_score` | `float` | Winner's weighted score |
+
+### `ScoringConfig`
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `keywords` | `dict[str, list[str]]` | 10 types, 85 keywords | Task type keywords |
+| `weights` | `dict[str, float]` | 0.5 - 1.5 | Type weight multipliers |
+| `tier_boundaries` | `tuple[float, float]` | (1.0, 4.0) | LOW/MEDIUM/HIGH boundaries |
+| `confidence_steepness` | `float` | 8.0 | Sigmoid steepness |
+| `confidence_threshold` | `float` | 0.65 | Ambiguity threshold |
+
+## Testing
+
+```bash
+cd packages/task_scorer
+pip install -e ".[dev]"
+python3 -m pytest tests/ -v
+```
+
+## Architecture
+
+```
+src/task_scorer/
+├── __init__.py    # Public API exports
+├── types.py       # ScoringConfig, ScoringResult, Tier, DEFAULT_KEYWORDS
+└── scorer.py      # score_task, _score_all_types, _sigmoid_confidence
+```
+
+- **Zero dependencies** — stdlib only (math, dataclasses, enum)
+- **Frozen dataclasses** — immutable config and results
+- **Config injection** — defaults in code, DB-driven override via ScoringConfig
+- **Tenant-agnostic** — pure function, no database access

iil_task_scorer-0.1.0/src/iil_task_scorer.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/iil_task_scorer.egg-info/PKG-INFO
+src/iil_task_scorer.egg-info/SOURCES.txt
+src/iil_task_scorer.egg-info/dependency_links.txt
+src/iil_task_scorer.egg-info/requires.txt
+src/iil_task_scorer.egg-info/top_level.txt
+src/task_scorer/__init__.py
+src/task_scorer/scorer.py
+src/task_scorer/types.py
+tests/test_scorer.py

iil_task_scorer-0.1.0/src/iil_task_scorer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

iil_task_scorer-0.1.0/src/iil_task_scorer.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+pytest>=7.0
+pytest-cov>=4.0
+ruff>=0.4

iil_task_scorer-0.1.0/src/iil_task_scorer.egg-info/top_level.txt

@@ -0,0 +1 @@
+task_scorer

iil_task_scorer-0.1.0/src/task_scorer/__init__.py

@@ -0,0 +1,33 @@
+"""
+Shared Scoring and Routing Engine for task complexity estimation.
+
+Zero-dependency Python package that provides weighted multi-dimension
+keyword scoring with sigmoid confidence calibration. Consolidates
+scoring logic from BFAgent (TestRequirement, LLMRouter) and
+Orchestrator MCP (analyzer).
+
+Usage:
+    from task_scorer import score_task, ScoringConfig
+
+    # With defaults
+    result = score_task("fix the authentication bug in the API")
+    print(result.tier)        # Tier.HIGH
+    print(result.top_type)    # "security"
+    print(result.confidence)  # 0.87
+
+    # With custom config (e.g. from DB)
+    config = ScoringConfig(keywords={"security": ["auth", "cve"]})
+    result = score_task("check auth flow", config=config)
+"""
+
+from .scorer import score_task
+from .types import ScoringConfig, ScoringResult, Tier
+
+__all__ = [
+    "score_task",
+    "ScoringConfig",
+    "ScoringResult",
+    "Tier",
+]
+
+__version__ = "0.1.0"

iil_task_scorer-0.1.0/src/task_scorer/scorer.py

@@ -0,0 +1,216 @@
+"""
+Core scoring engine for task complexity estimation.
+
+Implements weighted multi-dimension keyword scoring with sigmoid
+confidence calibration. Inspired by ClawRouter's 14-dimension
+scoring approach, adapted for server-side Python use.
+
+This module is the single entry point for scoring. It has zero
+external dependencies (stdlib math only).
+"""
+
+from __future__ import annotations
+
+import math
+
+from .types import ScoringConfig, ScoringResult, Tier
+
+
+def score_task(
+    description: str,
+    config: ScoringConfig | None = None,
+    category: str | None = None,
+    acceptance_criteria_count: int = 0,
+    files_affected: int = 0,
+) -> ScoringResult:
+    """Score a task description and return complexity assessment.
+
+    This is the main public API. It scores the description against
+    all configured task types using weighted keyword matching, then
+    maps the result to a complexity tier with confidence.
+
+    Args:
+        description: Task description text to score.
+        config: Optional custom scoring config. Uses defaults if None.
+        category: Optional task category (e.g. 'security', 'refactor').
+            Adds bonus score if it matches a task type.
+        acceptance_criteria_count: Number of acceptance criteria.
+            More criteria = higher complexity signal.
+        files_affected: Number of files likely affected.
+            More files = higher complexity signal.
+
+    Returns:
+        ScoringResult with scores, tier, confidence, and signals.
+    """
+    if config is None:
+        config = ScoringConfig()
+
+    scores, signals = _score_all_types(
+        description=description,
+        keywords=config.keywords,
+        weights=config.weights,
+    )
+
+    # Bonus signals from structured metadata
+    bonus = _metadata_bonus(
+        category=category,
+        acceptance_criteria_count=acceptance_criteria_count,
+        files_affected=files_affected,
+    )
+
+    # Apply metadata bonus to matching task type
+    if category and category in scores:
+        scores[category] += bonus
+        if bonus > 0:
+            signals.append(f"category_bonus({category}={bonus:.1f})")
+
+    # Find winner and runner-up
+    sorted_types = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+    winner_type, winner_score = sorted_types[0]
+    runner_up_score = sorted_types[1][1] if len(sorted_types) > 1 else 0.0
+
+    # Handle no-match case
+    if winner_score == 0.0:
+        return ScoringResult(
+            scores=scores,
+            top_type="feature",
+            tier=Tier.LOW,
+            confidence=0.5,
+            signals=["no keywords matched"],
+            is_ambiguous=True,
+            raw_score=0.0,
+        )
+
+    # Compute confidence via sigmoid on score gap
+    confidence = _sigmoid_confidence(
+        winner_score=winner_score,
+        runner_up_score=runner_up_score,
+        steepness=config.confidence_steepness,
+    )
+
+    # Map raw score to tier
+    tier = _score_to_tier(winner_score, config.tier_boundaries)
+
+    # Check ambiguity
+    is_ambiguous = confidence < config.confidence_threshold
+
+    return ScoringResult(
+        scores=scores,
+        top_type=winner_type,
+        tier=tier,
+        confidence=round(confidence, 4),
+        signals=signals,
+        is_ambiguous=is_ambiguous,
+        raw_score=round(winner_score, 4),
+    )
+
+
+def _score_all_types(
+    description: str,
+    keywords: dict[str, list[str]],
+    weights: dict[str, float],
+) -> tuple[dict[str, float], list[str]]:
+    """Score description against all task types.
+
+    For each task type, computes:
+        hit_ratio = matched_keywords / total_keywords
+        weighted_score = hit_ratio * type_weight
+
+    Returns (scores_dict, signals_list).
+    """
+    desc_lower = description.lower()
+    scores: dict[str, float] = {}
+    signals: list[str] = []
+
+    for task_type, kw_list in keywords.items():
+        if not kw_list:
+            scores[task_type] = 0.0
+            continue
+
+        matches = [kw for kw in kw_list if kw in desc_lower]
+
+        if not matches:
+            scores[task_type] = 0.0
+            continue
+
+        hit_ratio = len(matches) / len(kw_list)
+        type_weight = weights.get(task_type, 1.0)
+        score = hit_ratio * type_weight
+
+        scores[task_type] = round(score, 4)
+        signals.append(f"{task_type}({', '.join(matches[:3])})")
+
+    return scores, signals
+
+
+def _sigmoid_confidence(
+    winner_score: float,
+    runner_up_score: float,
+    steepness: float,
+) -> float:
+    """Compute confidence via sigmoid on score gap.
+
+    Maps the gap between winner and runner-up through a sigmoid
+    function to produce a value in (0, 1). A large gap = high
+    confidence; small gap = low confidence (~0.5).
+
+    Args:
+        winner_score: Score of the winning task type.
+        runner_up_score: Score of the second-place task type.
+        steepness: Sigmoid curve steepness (default 8.0).
+
+    Returns:
+        Confidence value in (0.0, 1.0).
+    """
+    gap = winner_score - runner_up_score
+    return 1.0 / (1.0 + math.exp(-steepness * gap))
+
+
+def _score_to_tier(
+    score: float,
+    boundaries: tuple[float, float],
+) -> Tier:
+    """Map a raw weighted score to a complexity tier.
+
+    Args:
+        score: The winning type's weighted score.
+        boundaries: (low_max, medium_max) thresholds.
+
+    Returns:
+        Tier.LOW, Tier.MEDIUM, or Tier.HIGH.
+    """
+    low_max, medium_max = boundaries
+
+    if score <= low_max:
+        return Tier.LOW
+    if score <= medium_max:
+        return Tier.MEDIUM
+    return Tier.HIGH
+
+
+def _metadata_bonus(
+    category: str | None,
+    acceptance_criteria_count: int,
+    files_affected: int,
+) -> float:
+    """Compute bonus score from structured task metadata.
+
+    Mirrors the heuristic signals from BFAgent's TestRequirement
+    and LLMRouter that use category, criteria count, and file
+    count as scoring dimensions beyond keyword matching.
+
+    Returns a bonus value to add to the matching task type score.
+    """
+    bonus = 0.0
+
+    if acceptance_criteria_count >= 5:
+        bonus += 0.4
+    elif acceptance_criteria_count >= 2:
+        bonus += 0.2
+
+    if files_affected > 5:
+        bonus += 0.5
+    elif files_affected > 2:
+        bonus += 0.2
+
+    return bonus

iil_task_scorer-0.1.0/src/task_scorer/types.py

@@ -0,0 +1,139 @@
+"""
+Type definitions for task_scorer.
+
+All public types used by the scoring engine. Uses stdlib-only
+dataclasses (no Pydantic) to maintain zero-dependency constraint.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class Tier(Enum):
+    """Complexity tier for a scored task."""
+
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+@dataclass(frozen=True)
+class ScoringConfig:
+    """Configuration for the scoring engine.
+
+    All fields have sensible defaults. Override individual fields
+    to customize scoring behavior (e.g. inject DB-driven keywords).
+
+    Attributes:
+        keywords: Mapping of task_type -> list of keywords.
+            Each keyword is matched as a substring in the description.
+        weights: Mapping of task_type -> weight multiplier.
+            Higher weight = stronger signal when keywords match.
+        tier_boundaries: (low_max, medium_max) score thresholds.
+            score <= low_max -> LOW, score <= medium_max -> MEDIUM, else HIGH.
+        confidence_steepness: Sigmoid steepness for confidence calibration.
+            Higher = sharper transition between confident/uncertain.
+        confidence_threshold: Below this confidence, result is flagged
+            as ambiguous (result.is_ambiguous = True).
+    """
+
+    keywords: dict[str, list[str]] = field(default_factory=dict)
+    weights: dict[str, float] = field(default_factory=dict)
+    tier_boundaries: tuple[float, float] = (1.0, 4.0)
+    confidence_steepness: float = 8.0
+    confidence_threshold: float = 0.65
+
+    def __post_init__(self) -> None:
+        """Apply defaults for missing keywords/weights."""
+        if not self.keywords:
+            # frozen=True requires object.__setattr__
+            object.__setattr__(self, "keywords", DEFAULT_KEYWORDS.copy())
+        if not self.weights:
+            object.__setattr__(self, "weights", DEFAULT_WEIGHTS.copy())
+
+
+@dataclass(frozen=True)
+class ScoringResult:
+    """Result of scoring a task description.
+
+    Attributes:
+        scores: All type scores: {"security": 1.5, "bug": 0.3, ...}.
+        top_type: Highest scoring type (e.g. "security").
+        tier: Mapped complexity tier (LOW/MEDIUM/HIGH).
+        confidence: Sigmoid confidence [0.0, 1.0] based on score gap.
+        signals: Debug signals showing which keywords matched.
+        is_ambiguous: True if confidence < threshold.
+        raw_score: The winning type's raw weighted score.
+    """
+
+    scores: dict[str, float]
+    top_type: str
+    tier: Tier
+    confidence: float
+    signals: list[str]
+    is_ambiguous: bool
+    raw_score: float
+
+
+# ============================================================================
+# DEFAULT CONFIGURATION
+# Unified keyword set from BFAgent + Orchestrator + ClawRouter analysis.
+# See ADR-023 Appendix A for divergence analysis.
+# ============================================================================
+
+DEFAULT_KEYWORDS: dict[str, list[str]] = {
+    "architecture": [
+        "architecture", "architektur", "design", "adr", "strategy",
+        "integration", "pattern", "diagram",
+    ],
+    "security": [
+        "security", "auth", "authentication", "authorization",
+        "permission", "credential", "secret", "vulnerability", "cve",
+    ],
+    "breaking_change": [
+        "breaking", "migrate", "migration", "deprecate", "remove",
+        "drop support", "incompatible",
+    ],
+    "feature": [
+        "feature", "add", "implement", "create", "new",
+        "build", "introduce",
+    ],
+    "bug": [
+        "bug", "fix", "issue", "error", "broken",
+        "crash", "regression", "fails",
+    ],
+    "refactor": [
+        "refactor", "clean", "improve", "optimize", "optimization",
+        "simplify", "extract", "reorganize", "caching", "performance",
+    ],
+    "test": [
+        "test", "spec", "coverage", "pytest", "assert",
+        "mock", "fixture", "integration",
+    ],
+    "docs": [
+        "doc", "readme", "comment", "docstring", "documentation",
+        "sphinx", "changelog",
+    ],
+    "lint": [
+        "lint", "format", "formatting", "style", "ruff", "flake8",
+    ],
+    "typo": [
+        "typo", "spelling", "minor", "whitespace", "css",
+        "label", "text", "button", "spacing", "icon",
+    ],
+}
+
+DEFAULT_WEIGHTS: dict[str, float] = {
+    "architecture": 1.5,
+    "security": 1.5,
+    "breaking_change": 1.4,
+    "feature": 1.0,
+    "bug": 1.0,
+    "refactor": 0.9,
+    "test": 0.8,
+    "docs": 0.7,
+    "lint": 0.6,
+    "typo": 0.5,
+}

iil_task_scorer-0.1.0/tests/test_scorer.py

@@ -0,0 +1,322 @@
+"""
+Tests for the task_scorer package.
+
+Covers: score_task, _score_all_types, _sigmoid_confidence,
+_score_to_tier, _metadata_bonus, ScoringConfig defaults,
+custom config injection, edge cases.
+"""
+
+import pytest
+
+from task_scorer import ScoringConfig, ScoringResult, Tier, score_task
+from task_scorer.scorer import (
+    _metadata_bonus,
+    _score_all_types,
+    _score_to_tier,
+    _sigmoid_confidence,
+)
+
+
+# ============================================================================
+# _score_all_types
+# ============================================================================
+
+class TestScoreAllTypes:
+    """Tests for weighted keyword scoring."""
+
+    def test_should_return_scores_for_all_types(self) -> None:
+        config = ScoringConfig()
+        scores, signals = _score_all_types(
+            "hello world", config.keywords, config.weights,
+        )
+        assert len(scores) == len(config.keywords)
+
+    def test_should_score_zero_for_no_matches(self) -> None:
+        config = ScoringConfig()
+        scores, signals = _score_all_types(
+            "xyzzy", config.keywords, config.weights,
+        )
+        assert all(v == 0.0 for v in scores.values())
+        assert signals == []
+
+    def test_should_score_bug_highest_for_bug_text(self) -> None:
+        config = ScoringConfig()
+        scores, _ = _score_all_types(
+            "fix the bug crash error", config.keywords, config.weights,
+        )
+        max_type = max(scores, key=scores.get)
+        assert max_type == "bug"
+        assert scores["bug"] > 0
+
+    def test_should_score_security_highest_for_auth(self) -> None:
+        config = ScoringConfig()
+        scores, _ = _score_all_types(
+            "fix auth permission credential vulnerability",
+            config.keywords, config.weights,
+        )
+        max_type = max(scores, key=scores.get)
+        assert max_type == "security"
+
+    def test_should_generate_signals_for_matches(self) -> None:
+        config = ScoringConfig()
+        _, signals = _score_all_types(
+            "refactor and clean the code", config.keywords, config.weights,
+        )
+        assert any("refactor" in s for s in signals)
+
+    def test_should_handle_empty_keyword_list(self) -> None:
+        scores, signals = _score_all_types(
+            "test", {"custom": []}, {"custom": 1.0},
+        )
+        assert scores["custom"] == 0.0
+
+    def test_should_apply_weights(self) -> None:
+        scores_high, _ = _score_all_types(
+            "auth", {"security": ["auth"]}, {"security": 2.0},
+        )
+        scores_low, _ = _score_all_types(
+            "auth", {"security": ["auth"]}, {"security": 0.5},
+        )
+        assert scores_high["security"] > scores_low["security"]
+
+
+# ============================================================================
+# _sigmoid_confidence
+# ============================================================================
+
+class TestSigmoidConfidence:
+    """Tests for sigmoid confidence calibration."""
+
+    def test_should_return_0_5_for_zero_gap(self) -> None:
+        conf = _sigmoid_confidence(0.5, 0.5, steepness=8.0)
+        assert conf == pytest.approx(0.5, abs=0.01)
+
+    def test_should_return_high_for_large_gap(self) -> None:
+        conf = _sigmoid_confidence(1.0, 0.0, steepness=8.0)
+        assert conf > 0.95
+
+    def test_should_return_low_for_negative_gap(self) -> None:
+        conf = _sigmoid_confidence(0.0, 1.0, steepness=8.0)
+        assert conf < 0.05
+
+    def test_should_be_monotonically_increasing(self) -> None:
+        c1 = _sigmoid_confidence(0.5, 0.4, steepness=8.0)
+        c2 = _sigmoid_confidence(0.5, 0.2, steepness=8.0)
+        c3 = _sigmoid_confidence(0.5, 0.0, steepness=8.0)
+        assert c1 < c2 < c3
+
+    def test_should_respect_steepness(self) -> None:
+        c_flat = _sigmoid_confidence(0.6, 0.4, steepness=2.0)
+        c_steep = _sigmoid_confidence(0.6, 0.4, steepness=20.0)
+        # Steeper sigmoid = more extreme confidence for same gap
+        assert c_steep > c_flat
+
+
+# ============================================================================
+# _score_to_tier
+# ============================================================================
+
+class TestScoreToTier:
+    """Tests for score-to-tier mapping."""
+
+    def test_should_return_low_for_small_score(self) -> None:
+        assert _score_to_tier(0.5, (1.0, 4.0)) == Tier.LOW
+
+    def test_should_return_medium_for_mid_score(self) -> None:
+        assert _score_to_tier(2.0, (1.0, 4.0)) == Tier.MEDIUM
+
+    def test_should_return_high_for_large_score(self) -> None:
+        assert _score_to_tier(5.0, (1.0, 4.0)) == Tier.HIGH
+
+    def test_should_handle_boundary_low_max(self) -> None:
+        assert _score_to_tier(1.0, (1.0, 4.0)) == Tier.LOW
+
+    def test_should_handle_boundary_medium_max(self) -> None:
+        assert _score_to_tier(4.0, (1.0, 4.0)) == Tier.MEDIUM
+
+    def test_should_respect_custom_boundaries(self) -> None:
+        assert _score_to_tier(0.3, (0.2, 0.5)) == Tier.MEDIUM
+        assert _score_to_tier(0.6, (0.2, 0.5)) == Tier.HIGH
+
+
+# ============================================================================
+# _metadata_bonus
+# ============================================================================
+
+class TestMetadataBonus:
+    """Tests for metadata bonus scoring."""
+
+    def test_should_return_zero_for_no_metadata(self) -> None:
+        assert _metadata_bonus(None, 0, 0) == 0.0
+
+    def test_should_add_bonus_for_many_criteria(self) -> None:
+        bonus = _metadata_bonus(None, 5, 0)
+        assert bonus == pytest.approx(0.4)
+
+    def test_should_add_bonus_for_some_criteria(self) -> None:
+        bonus = _metadata_bonus(None, 3, 0)
+        assert bonus == pytest.approx(0.2)
+
+    def test_should_add_bonus_for_many_files(self) -> None:
+        bonus = _metadata_bonus(None, 0, 6)
+        assert bonus == pytest.approx(0.5)
+
+    def test_should_add_bonus_for_some_files(self) -> None:
+        bonus = _metadata_bonus(None, 0, 3)
+        assert bonus == pytest.approx(0.2)
+
+    def test_should_combine_criteria_and_files(self) -> None:
+        bonus = _metadata_bonus(None, 5, 6)
+        assert bonus == pytest.approx(0.9)
+
+
+# ============================================================================
+# score_task (integration)
+# ============================================================================
+
+class TestScoreTask:
+    """Integration tests for the main score_task function."""
+
+    def test_should_return_scoring_result(self) -> None:
+        result = score_task("fix the bug")
+        assert isinstance(result, ScoringResult)
+        assert isinstance(result.tier, Tier)
+        assert 0 <= result.confidence <= 1
+
+    def test_should_detect_clear_bug(self) -> None:
+        result = score_task("fix the bug crash error regression")
+        assert result.top_type == "bug"
+        assert result.confidence > 0.7
+
+    def test_should_detect_clear_security(self) -> None:
+        result = score_task("auth permission credential vulnerability")
+        assert result.top_type == "security"
+        assert result.confidence > 0.7
+
+    def test_should_detect_architecture(self) -> None:
+        result = score_task("design the architecture pattern strategy")
+        assert result.top_type == "architecture"
+
+    def test_should_detect_refactor(self) -> None:
+        result = score_task("refactor clean improve optimize simplify")
+        assert result.top_type == "refactor"
+
+    def test_should_detect_docs(self) -> None:
+        result = score_task("update readme docstring documentation")
+        assert result.top_type == "docs"
+
+    def test_should_default_to_feature_no_keywords(self) -> None:
+        result = score_task("do something completely random xyzzy")
+        assert result.top_type == "feature"
+        assert result.confidence == 0.5
+        assert result.is_ambiguous is True
+
+    def test_should_handle_empty_string(self) -> None:
+        result = score_task("")
+        assert result.top_type == "feature"
+        assert result.is_ambiguous is True
+
+    def test_should_flag_ambiguous_on_low_confidence(self) -> None:
+        result = score_task("fix the architecture docs")
+        # Multiple types match = lower confidence
+        assert result.confidence < 1.0
+
+    def test_should_include_signals(self) -> None:
+        result = score_task("fix bug and add feature")
+        assert len(result.signals) >= 2
+
+    def test_should_include_all_scores(self) -> None:
+        result = score_task("fix the bug")
+        assert "bug" in result.scores
+        assert "security" in result.scores
+
+    def test_should_apply_category_bonus(self) -> None:
+        result_no_cat = score_task("fix something")
+        result_with_cat = score_task("fix something", category="security")
+        # Category bonus shouldn't change score if no security keywords
+        assert result_no_cat.scores.get("security", 0) == result_with_cat.scores.get("security", 0)
+
+    def test_should_apply_criteria_bonus(self) -> None:
+        result = score_task(
+            "security auth vulnerability",
+            category="security",
+            acceptance_criteria_count=6,
+        )
+        assert result.top_type == "security"
+        assert "category_bonus" in " ".join(result.signals)
+
+    def test_should_apply_files_bonus_with_category(self) -> None:
+        result = score_task(
+            "security auth vulnerability",
+            category="security",
+            files_affected=10,
+        )
+        assert result.scores["security"] > 0
+
+    def test_should_be_idempotent(self) -> None:
+        r1 = score_task("fix the authentication bug")
+        r2 = score_task("fix the authentication bug")
+        assert r1.top_type == r2.top_type
+        assert r1.confidence == r2.confidence
+        assert r1.tier == r2.tier
+
+
+# ============================================================================
+# ScoringConfig
+# ============================================================================
+
+class TestScoringConfig:
+    """Tests for config defaults and custom injection."""
+
+    def test_should_have_defaults(self) -> None:
+        config = ScoringConfig()
+        assert len(config.keywords) > 0
+        assert len(config.weights) > 0
+        assert config.confidence_steepness == 8.0
+
+    def test_should_accept_custom_keywords(self) -> None:
+        custom = ScoringConfig(
+            keywords={"custom_type": ["alpha", "beta"]},
+            weights={"custom_type": 1.0},
+        )
+        result = score_task("alpha beta gamma", config=custom)
+        assert result.top_type == "custom_type"
+
+    def test_should_accept_custom_boundaries(self) -> None:
+        narrow = ScoringConfig(tier_boundaries=(0.1, 0.2))
+        result = score_task("fix the bug", config=narrow)
+        # With very narrow boundaries, most scores should be HIGH
+        assert result.tier == Tier.HIGH
+
+    def test_should_accept_custom_steepness(self) -> None:
+        flat = ScoringConfig(confidence_steepness=1.0)
+        steep = ScoringConfig(confidence_steepness=50.0)
+        r_flat = score_task("fix the bug crash", config=flat)
+        r_steep = score_task("fix the bug crash", config=steep)
+        # Steeper produces more extreme confidence
+        assert r_steep.confidence >= r_flat.confidence
+
+    def test_should_be_frozen(self) -> None:
+        config = ScoringConfig()
+        with pytest.raises(AttributeError):
+            config.confidence_steepness = 99.0
+
+
+# ============================================================================
+# Tier enum
+# ============================================================================
+
+class TestTier:
+    """Tests for Tier enum values."""
+
+    def test_should_have_three_values(self) -> None:
+        assert len(Tier) == 3
+
+    def test_should_have_string_values(self) -> None:
+        assert Tier.LOW.value == "low"
+        assert Tier.MEDIUM.value == "medium"
+        assert Tier.HIGH.value == "high"
+
+    def test_should_be_constructible_from_string(self) -> None:
+        assert Tier("low") == Tier.LOW
+        assert Tier("high") == Tier.HIGH