forgeoptimizer 0.1.0__py3-none-any.whl

forgecli/optimizer/ranker.py

@@ -0,0 +1,37 @@
+"""Ranks chunks by relevance to a query."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from forgecli.optimizer.chunker import Chunk
+
+
+class Ranker:
+    """Default ranker based on simple lexical overlap.
+
+    The interface is deliberately small: ``score(query, chunk)`` returns a
+    float; higher is more relevant. Real implementations may use
+    embeddings, BM25, or graph-based signals.
+    """
+
+    def score(self, query: str, chunk: Chunk) -> float:
+        """Score a single ``chunk`` against ``query``."""
+        if not query or not chunk.text:
+            return 0.0
+        q_tokens = self._tokenize(query)
+        c_tokens = set(self._tokenize(chunk.text))
+        if not q_tokens:
+            return 0.0
+        hits = sum(1 for token in q_tokens if token in c_tokens)
+        return hits / max(len(q_tokens), 1)
+
+    def rank(self, query: str, chunks: Iterable[Chunk]) -> list[tuple[Chunk, float]]:
+        """Return ``chunks`` paired with scores, sorted descending by score."""
+        scored = [(chunk, self.score(query, chunk)) for chunk in chunks]
+        scored.sort(key=lambda pair: pair[1], reverse=True)
+        return scored
+
+    @staticmethod
+    def _tokenize(text: str) -> list[str]:
+        return [tok.lower() for tok in text.split() if tok]

forgecli/optimizer/summarizer.py

@@ -0,0 +1,44 @@
+"""Summarization interface (placeholder)."""
+
+from __future__ import annotations
+
+from forgecli.core.service import Service
+from forgecli.optimizer.chunker import Chunk
+from forgecli.providers.base import ChatMessage, ChatRequest, Provider, Role
+
+
+class Summarizer(Service):
+    """Condenses a sequence of chunks using a chat provider.
+
+    The summarizer is intentionally a thin wrapper around :class:`Provider`
+    so we can swap between AI-backed and heuristic implementations without
+    touching call sites.
+    """
+
+    name = "optimizer.summarizer"
+
+    def __init__(self, provider: Provider, *, model: str | None = None) -> None:
+        super().__init__()
+        self._provider = provider
+        self._model = model
+
+    async def summarize(self, chunks: list[Chunk], *, max_words: int = 200) -> str:
+        """Return a textual summary of ``chunks`` (placeholder)."""
+        joined = "\n\n".join(c.text for c in chunks)
+        if not joined:
+            return ""
+        request = ChatRequest(
+            model=self._model,
+            messages=[
+                ChatMessage(
+                    role=Role.SYSTEM,
+                    content=(
+                        "You are a concise code-aware summarizer. "
+                        f"Respond in at most {max_words} words."
+                    ),
+                ),
+                ChatMessage(role=Role.USER, content=joined),
+            ],
+        )
+        response = await self._provider.chat(request)
+        return response.message.content