ctxintel 0.1.0__py3-none-any.whl

ctxintel/__init__.py

@@ -0,0 +1,16 @@
+"""ctxintel — Context Operating System for LLM Applications."""
+
+from ctxintel.pipeline import ContextIntel
+from ctxintel.models import Message, Memory, ContextResult
+from ctxintel.presets import PRESETS, load_preset, list_presets
+
+__version__ = "0.1.0"
+__all__ = [
+    "ContextIntel",
+    "Message",
+    "Memory",
+    "ContextResult",
+    "PRESETS",
+    "load_preset",
+    "list_presets",
+]

ctxintel/compressor.py

@@ -0,0 +1,122 @@
+"""Message compressor using extractive summarization (sumy LSA) with fallback."""
+
+import warnings
+from typing import Dict, List, Optional
+
+from ctxintel.models import Message
+
+try:
+    from sumy.parsers.plaintext import PlaintextParser
+    from sumy.nlp.tokenizers import Tokenizer
+    from sumy.summarizers.lsa import LsaSummarizer
+    from sumy.nlp.stemmers import Stemmer
+    _HAS_SUMY = True
+except ImportError:
+    _HAS_SUMY = False
+    warnings.warn(
+        "sumy not found. Compression will use a simpler sentence-based fallback. "
+        "Install with: pip install sumy",
+        stacklevel=2,
+    )
+
+
+class Compressor:
+    """Compresses low-importance messages into a summary while preserving critical ones.
+
+    Uses sumy's LSA summarizer for extractive summarization (zero AI API calls).
+    Falls back to a simple first-N-sentences approach if sumy is unavailable.
+    """
+
+    def compress(
+        self,
+        messages: List[Message],
+        preserve: Optional[List[str]] = None,
+        threshold: float = 0.4,
+    ) -> List[Message]:
+        """Compress messages below the importance threshold into a summary.
+
+        Args:
+            messages: Ranked list of Message objects.
+            preserve: Category names to preserve (unused — preserved flag is on Message).
+            threshold: Messages below this importance score get compressed.
+
+        Returns:
+            List of messages with low-importance ones replaced by a summary.
+        """
+        keep_msgs = [m for m in messages if m.importance >= threshold or m.preserved]
+        compress_msgs = [m for m in messages if m.importance < threshold and not m.preserved]
+
+        if not compress_msgs:
+            return keep_msgs
+
+        combined_text = " ".join(m.content for m in compress_msgs)
+
+        # If the compressed content is very short, just drop it —
+        # a summary message would be larger than the original filler
+        if len(combined_text) < 50:
+            return keep_msgs
+
+        summary = self._summarize(combined_text, len(compress_msgs))
+
+        # Only inject summary if it's actually shorter than the combined original
+        if len(summary) >= len(combined_text):
+            return keep_msgs
+
+        summary_msg = Message(
+            role="system",
+            content=f"[Earlier context summary]: {summary}",
+            importance=0.85,
+            preserved=True,
+        )
+        return [summary_msg] + keep_msgs
+
+    def estimate_reduction(self, messages: List[Message], threshold: float = 0.4) -> Dict:
+        """Preview compression stats without actually compressing.
+
+        Args:
+            messages: Ranked list of Message objects.
+            threshold: Importance threshold for compression.
+
+        Returns:
+            Dict with total_messages, will_keep, will_compress, estimated_reduction_pct.
+        """
+        keep = sum(1 for m in messages if m.importance >= threshold or m.preserved)
+        compress = sum(1 for m in messages if m.importance < threshold and not m.preserved)
+        total = len(messages)
+        return {
+            "total_messages": total,
+            "will_keep": keep,
+            "will_compress": compress,
+            "estimated_reduction_pct": round(compress / max(total, 1) * 100, 1),
+        }
+
+    def _summarize(self, text: str, msg_count: int) -> str:
+        """Summarize text using sumy LSA or a sentence-based fallback."""
+        if _HAS_SUMY:
+            return self._summarize_lsa(text, msg_count)
+        return self._summarize_fallback(text)
+
+    def _summarize_lsa(self, text: str, msg_count: int) -> str:
+        """Use sumy's LSA summarizer for extractive summarization."""
+        try:
+            sentence_count = max(3, min(7, msg_count // 3))
+            parser = PlaintextParser.from_string(text, Tokenizer("english"))
+            stemmer = Stemmer("english")
+            summarizer = LsaSummarizer(stemmer)
+            sentences = summarizer(parser.document, sentence_count)
+            summary = " ".join(str(s) for s in sentences)
+            if not summary.strip():
+                return self._summarize_fallback(text)
+            return summary
+        except Exception as exc:
+            warnings.warn(f"sumy LSA failed ({exc}). Using fallback.", stacklevel=2)
+            return self._summarize_fallback(text)
+
+    def _summarize_fallback(self, text: str) -> str:
+        """Simple fallback: take the first 5 sentences."""
+        sentences = text.split(". ")
+        selected = sentences[:5]
+        result = ". ".join(selected)
+        if not result.endswith("."):
+            result += "."
+        return result

ctxintel/data/patterns.yaml

@@ -0,0 +1,183 @@
+categories:
+
+  user_name:
+    patterns:
+      - "my name is {X}"
+      - "i am {X}"
+      - "call me {X}"
+      - "i go by {X}"
+    priority: high
+
+  user_preference:
+    patterns:
+      - "i prefer {X}"
+      - "i like {X}"
+      - "i love {X}"
+      - "i always use {X}"
+      - "my favorite {X}"
+      - "my favourite {X}"
+      - "i enjoy {X}"
+      - "i work best with {X}"
+    priority: high
+
+  task:
+    patterns:
+      - "build {X}"
+      - "create {X}"
+      - "implement {X}"
+      - "i need {X}"
+      - "i need to {X}"
+      - "i want to {X}"
+      - "we need to {X}"
+      - "fix {X}"
+      - "add {X}"
+      - "make {X}"
+      - "develop {X}"
+      - "write {X}"
+      - "design {X}"
+    priority: high
+
+  decision:
+    patterns:
+      - "decided to {X}"
+      - "we decided {X}"
+      - "going with {X}"
+      - "we will use {X}"
+      - "confirmed {X}"
+      - "agreed to {X}"
+      - "we are using {X}"
+      - "we chose {X}"
+      - "settled on {X}"
+    priority: high
+
+  constraint:
+    patterns:
+      - "don't {X}"
+      - "do not {X}"
+      - "never {X}"
+      - "avoid {X}"
+      - "must not {X}"
+      - "should not {X}"
+      - "no {X}"
+      - "without {X}"
+      - "exclude {X}"
+    priority: high
+
+  coding_language:
+    patterns:
+      - "using {X}"
+      - "written in {X}"
+      - "in {X}"
+      - "with {X}"
+    keywords:
+      - python
+      - javascript
+      - typescript
+      - go
+      - golang
+      - rust
+      - java
+      - ruby
+      - php
+      - swift
+      - kotlin
+      - c++
+      - "c#"
+      - scala
+    priority: high
+
+  framework:
+    patterns:
+      - "using {X}"
+      - "with {X}"
+      - "built on {X}"
+    keywords:
+      - flask
+      - django
+      - fastapi
+      - react
+      - vue
+      - angular
+      - nextjs
+      - express
+      - spring
+      - rails
+      - laravel
+      - svelte
+      - nuxt
+    priority: medium
+
+  cloud_provider:
+    patterns:
+      - "on {X}"
+      - "deploy to {X}"
+      - "hosted on {X}"
+      - "running on {X}"
+    keywords:
+      - aws
+      - gcp
+      - azure
+      - vercel
+      - heroku
+      - railway
+      - render
+      - digitalocean
+      - cloudflare
+    priority: medium
+
+  architecture:
+    patterns:
+      - "using {X}"
+      - "following {X}"
+      - "architecture is {X}"
+      - "structured as {X}"
+    keywords:
+      - microservices
+      - monolith
+      - serverless
+      - event-driven
+      - rest
+      - graphql
+      - grpc
+      - websockets
+      - mvc
+      - clean architecture
+    priority: medium
+
+spacy_entity_map:
+  PERSON: "person_mentioned"
+  ORG: "organization"
+  PRODUCT: "product"
+  GPE: "location"
+  LOC: "location"
+  DATE: "temporal_reference"
+  TIME: "temporal_reference"
+  MONEY: "budget_constraint"
+  PERCENT: "metric"
+
+dependency_verbs:
+  - deploy
+  - use
+  - build
+  - integrate
+  - avoid
+  - implement
+  - install
+  - configure
+  - connect
+  - migrate
+
+emphasis_signals:
+  high:
+    - "very important"
+    - "critical"
+    - "must"
+    - "always remember"
+    - "don't forget"
+    - "crucial"
+    - "essential"
+  medium:
+    - "important"
+    - "remember"
+    - "please note"
+    - "keep in mind"