devsper 2.1.6__py3-none-any.whl

devsper/tools/memory/delete_memory.py

@@ -0,0 +1,25 @@
+"""Delete a memory entry by id."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.memory.memory_store import get_default_store
+
+
+class DeleteMemoryTool(Tool):
+    name = "delete_memory"
+    description = "Delete a stored memory entry by its id."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "memory_id": {"type": "string", "description": "Id of the memory to delete"},
+        },
+        "required": ["memory_id"],
+    }
+
+    def run(self, **kwargs) -> str:
+        memory_id = kwargs.get("memory_id")
+        if not memory_id or not isinstance(memory_id, str):
+            return "Error: memory_id must be a non-empty string"
+        store = get_default_store()
+        deleted = store.delete(memory_id)
+        return "Deleted." if deleted else "Memory not found."

devsper/tools/memory/list_memory.py

@@ -0,0 +1,34 @@
+"""List stored memory entries with optional type filter."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.memory.memory_store import get_default_store
+from devsper.memory.memory_types import MemoryType
+
+
+class ListMemoryTool(Tool):
+    name = "list_memory"
+    description = "List stored memory entries. Optionally filter by type and limit."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "memory_type": {"type": "string", "description": "Optional: episodic, semantic, artifact, research"},
+            "limit": {"type": "integer", "description": "Max entries to return (default 20)"},
+        },
+    }
+
+    def run(self, **kwargs) -> str:
+        store = get_default_store()
+        mt = kwargs.get("memory_type")
+        limit = kwargs.get("limit", 20)
+        if not isinstance(limit, int) or limit < 1:
+            limit = 20
+        try:
+            memory_type = MemoryType(mt.lower()) if mt else None
+        except (ValueError, AttributeError):
+            memory_type = None
+        records = store.list_memory(memory_type=memory_type, limit=limit)
+        if not records:
+            return "No memory entries."
+        lines = [f"- {r.id} [{r.memory_type.value}] {r.content[:150]}{'...' if len(r.content) > 150 else ''}" for r in records]
+        return "\n".join(lines)

devsper/tools/memory/search_memory.py

@@ -0,0 +1,36 @@
+"""Semantic search over stored memory."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.memory.memory_store import get_default_store
+from devsper.memory.memory_index import MemoryIndex
+
+
+class SearchMemoryTool(Tool):
+    name = "search_memory"
+    description = "Search stored memory by semantic similarity to a query text. Returns top matches."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "query": {"type": "string", "description": "Search query"},
+            "top_k": {"type": "integer", "description": "Max number of results (default 5)"},
+        },
+        "required": ["query"],
+    }
+
+    def run(self, **kwargs) -> str:
+        query = kwargs.get("query", "")
+        if not query or not isinstance(query, str):
+            return "Error: query must be a non-empty string"
+        top_k = kwargs.get("top_k", 5)
+        if not isinstance(top_k, int) or top_k < 1:
+            top_k = 5
+        store = get_default_store()
+        index = MemoryIndex(store)
+        records = index.query_memory(query, top_k=top_k)
+        if not records:
+            return "No matching memory found."
+        lines = []
+        for r in records:
+            lines.append(f"[{r.id}] ({r.memory_type.value}) {r.content[:300]}{'...' if len(r.content) > 300 else ''}")
+        return "\n".join(lines)

devsper/tools/memory/store_memory.py

@@ -0,0 +1,47 @@
+"""Store a memory entry (content, type, tags, source_task)."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.memory.memory_store import get_default_store, generate_memory_id
+from devsper.memory.memory_types import MemoryRecord, MemoryType
+from devsper.memory.memory_index import MemoryIndex
+
+
+class StoreMemoryTool(Tool):
+    name = "store_memory"
+    description = "Store a memory entry with content, type (episodic/semantic/artifact/research), optional tags and source_task."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "content": {"type": "string", "description": "Content to store"},
+            "memory_type": {"type": "string", "description": "One of: episodic, semantic, artifact, research"},
+            "tags": {"type": "array", "items": {"type": "string"}, "description": "Optional tags"},
+            "source_task": {"type": "string", "description": "Optional source task id or description"},
+        },
+        "required": ["content"],
+    }
+
+    def run(self, **kwargs) -> str:
+        content = kwargs.get("content", "")
+        if not content or not isinstance(content, str):
+            return "Error: content must be a non-empty string"
+        try:
+            mt = MemoryType((kwargs.get("memory_type") or "semantic").lower())
+        except ValueError:
+            return "Error: memory_type must be one of episodic, semantic, artifact, research"
+        tags = kwargs.get("tags") or []
+        if isinstance(tags, str):
+            tags = [t.strip() for t in tags.split(",") if t.strip()]
+        source_task = kwargs.get("source_task") or ""
+        store = get_default_store()
+        index = MemoryIndex(store)
+        record = MemoryRecord(
+            id=generate_memory_id(),
+            memory_type=mt,
+            content=content,
+            tags=tags,
+            source_task=source_task,
+        )
+        record = index.ensure_embedding(record)
+        mid = store.store(record)
+        return f"Stored memory id: {mid}"

devsper/tools/memory/summarize_memory.py

@@ -0,0 +1,41 @@
+"""Summarize stored memory (e.g. by type or recent N)."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.memory.memory_store import get_default_store
+from devsper.memory.memory_types import MemoryType
+
+
+class SummarizeMemoryTool(Tool):
+    name = "summarize_memory"
+    description = "Summarize stored memory: counts by type and optional short list of recent entries."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "memory_type": {"type": "string", "description": "Optional: episodic, semantic, artifact, research"},
+            "limit": {"type": "integer", "description": "Include up to N recent entries in summary (default 5)"},
+        },
+    }
+
+    def run(self, **kwargs) -> str:
+        store = get_default_store()
+        mt = kwargs.get("memory_type")
+        limit = kwargs.get("limit", 5)
+        if not isinstance(limit, int) or limit < 0:
+            limit = 5
+        try:
+            memory_type = MemoryType(mt.lower()) if mt else None
+        except (ValueError, AttributeError):
+            memory_type = None
+        records = store.list_memory(memory_type=memory_type, limit=1000)
+        total = len(records)
+        by_type: dict[str, int] = {}
+        for r in records:
+            k = r.memory_type.value
+            by_type[k] = by_type.get(k, 0) + 1
+        lines = [f"Total: {total} entries.", "By type: " + ", ".join(f"{k}={v}" for k, v in sorted(by_type.items()))]
+        if limit > 0 and records:
+            lines.append(f"\nRecent (up to {limit}):")
+            for r in records[:limit]:
+                lines.append(f"  - [{r.memory_type.value}] {r.content[:100]}{'...' if len(r.content) > 100 else ''}")
+        return "\n".join(lines)

devsper/tools/memory/tag_memory.py

@@ -0,0 +1,47 @@
+"""Add or replace tags on a memory entry."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.memory.memory_store import get_default_store
+from devsper.memory.memory_types import MemoryRecord, MemoryType
+from devsper.memory.memory_index import MemoryIndex
+
+
+class TagMemoryTool(Tool):
+    name = "tag_memory"
+    description = "Add or replace tags on an existing memory entry by id."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "memory_id": {"type": "string", "description": "Id of the memory"},
+            "tags": {"type": "array", "items": {"type": "string"}, "description": "Tags to set (replaces existing if replace=true)"},
+            "replace": {"type": "boolean", "description": "If true, replace existing tags; else append (default false)"},
+        },
+        "required": ["memory_id", "tags"],
+    }
+
+    def run(self, **kwargs) -> str:
+        memory_id = kwargs.get("memory_id")
+        tags = kwargs.get("tags") or []
+        replace = kwargs.get("replace", False)
+        if not memory_id or not isinstance(memory_id, str):
+            return "Error: memory_id must be a non-empty string"
+        if not isinstance(tags, list):
+            tags = [str(tags)]
+        tags = [str(t).strip() for t in tags if str(t).strip()]
+        store = get_default_store()
+        record = store.retrieve(memory_id)
+        if not record:
+            return "Memory not found."
+        new_tags = tags if replace else list(dict.fromkeys(record.tags + tags))
+        updated = MemoryRecord(
+            id=record.id,
+            memory_type=record.memory_type,
+            timestamp=record.timestamp,
+            source_task=record.source_task,
+            content=record.content,
+            tags=new_tags,
+            embedding=record.embedding,
+        )
+        store.store(updated)
+        return f"Tags updated: {new_tags}"

devsper/tools/pipelines.py

@@ -0,0 +1,92 @@
+"""
+Tool pipeline engine: chain tools so output of one feeds into the next.
+
+Example: docproc → entity_extractor → knowledge_graph_builder.
+Agents may invoke pipelines instead of single tools.
+"""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import get
+from devsper.tools.tool_runner import run_tool
+
+# Key used to pass previous stage output into the next tool's args
+PIPELINE_INPUT_KEY = "input"
+
+
+class ToolPipeline:
+    """
+    A chain of tools. run() executes each in order; each tool's output
+    is passed as PIPELINE_INPUT_KEY to the next. Initial args go to the first tool.
+    """
+
+    def __init__(self, tools: list[str] | list[Tool], name: str = "") -> None:
+        """
+        tools: list of tool names (str) or Tool instances. Names are resolved via registry.
+        name: optional pipeline name for display/registry.
+        """
+        self._tool_refs: list[tuple[str, Tool | None]] = []
+        for t in tools:
+            if isinstance(t, Tool):
+                self._tool_refs.append((t.name, t))
+            else:
+                self._tool_refs.append((str(t), get(str(t))))
+        self.name = name or "pipeline_" + "_".join(n for n, _ in self._tool_refs[:3])
+
+    @property
+    def tools(self) -> list[Tool]:
+        """Resolved list of Tool instances (skips unresolved names)."""
+        return [t for _, t in self._tool_refs if t is not None]
+
+    def run(self, **kwargs) -> str:
+        """
+        Run the pipeline: first tool gets kwargs; each next tool gets
+        PIPELINE_INPUT_KEY set to the previous tool's string output.
+        Returns the last tool's output, or an error message.
+        """
+        if not self._tool_refs:
+            return "Pipeline has no tools."
+        current_input: str | None = None
+        for i, (tool_name, tool) in enumerate(self._tool_refs):
+            if tool is None:
+                return f"Tool not found: {tool_name}"
+            if i == 0:
+                args = dict(kwargs)
+            else:
+                args = {PIPELINE_INPUT_KEY: current_input or ""}
+            result = run_tool(tool.name, args)
+            if (
+                result.startswith("Error:")
+                or result.startswith("Tool not found:")
+                or result.startswith("Validation error:")
+            ):
+                return result
+            current_input = result
+        return current_input or ""
+
+
+def build_pipeline(*tool_names: str, name: str = "") -> ToolPipeline:
+    """Build a pipeline from a sequence of tool names. Example: build_pipeline('docproc_corpus_pipeline', 'knowledge_graph_extractor')."""
+    return ToolPipeline(list(tool_names), name=name)
+
+
+class PipelineAsTool(Tool):
+    """Exposes a ToolPipeline as a Tool so agents can invoke it by name."""
+
+    def __init__(self, pipeline: ToolPipeline, description: str = "") -> None:
+        self._pipeline = pipeline
+        self.name = pipeline.name
+        self.description = (
+            description
+            or f"Run pipeline: {' → '.join(n for n, _ in pipeline._tool_refs)}"
+        )
+        # Merge required keys from first tool if available
+        first_tool = pipeline.tools[0] if pipeline.tools else None
+        self.input_schema = (
+            getattr(first_tool, "input_schema", {"type": "object", "properties": {}})
+            if first_tool
+            else {"type": "object", "properties": {}}
+        )
+        self.category = "pipeline"
+
+    def run(self, **kwargs) -> str:
+        return self._pipeline.run(**kwargs)

devsper/tools/registry.py

@@ -0,0 +1,39 @@
+"""
+Tool registry: register, get, and list tools by name.
+
+Tools register themselves when their module is imported (see each category __init__.py).
+"""
+
+from devsper.tools.base import Tool
+
+_tools: dict[str, Tool] = {}
+
+
+def register(tool: Tool) -> None:
+    """Register a tool by name. Overwrites if the name already exists."""
+    _tools[tool.name] = tool
+
+
+def get(name: str) -> Tool | None:
+    """Return the tool with the given name, or None if not found."""
+    return _tools.get(name)
+
+
+def get_with_mcp_fallback(name: str) -> Tool | None:
+    """
+    Return the tool by name. If not found and name has no dot (e.g. 'list_dir'),
+    look for a single MCP-style tool whose name ends with '.' + name (e.g. 'filesystem.list_dir').
+    Lets agents use short names when only one such MCP tool is registered.
+    """
+    t = _tools.get(name)
+    if t is not None:
+        return t
+    if "." in name:
+        return None
+    candidates = [t for t in _tools.values() if t.name.endswith("." + name)]
+    return candidates[0] if len(candidates) == 1 else None
+
+
+def list_tools() -> list[Tool]:
+    """Return all registered tools."""
+    return list(_tools.values())

devsper/tools/research/__init__.py

@@ -0,0 +1,12 @@
+"""Research tools: web search, Wikipedia, arXiv, paper analysis, etc."""
+
+from devsper.tools.research.web_search import WebSearchTool
+from devsper.tools.research.duckduckgo_search import DuckDuckGoSearchTool
+from devsper.tools.research.wikipedia_lookup import WikipediaLookupTool
+from devsper.tools.research.arxiv_search import ArxivSearchTool
+from devsper.tools.research.arxiv_download import ArxivDownloadTool
+from devsper.tools.research.paper_summarizer import PaperSummarizerTool
+from devsper.tools.research.citation_extractor import CitationExtractorTool
+from devsper.tools.research.topic_cluster import TopicClusterTool
+from devsper.tools.research.research_question_generator import ResearchQuestionGeneratorTool
+from devsper.tools.research.paper_metadata_extractor import PaperMetadataExtractorTool

devsper/tools/research/arxiv_download.py

@@ -0,0 +1,55 @@
+"""Fetch arXiv paper metadata and optionally download PDF URL."""
+
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class ArxivDownloadTool(Tool):
+    """Get arXiv paper metadata and PDF link by arXiv ID (e.g. 2401.12345 or 2401.12345v1)."""
+
+    name = "arxiv_download"
+    description = "Get arXiv paper metadata and PDF URL by ID. Does not download file to disk."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "arxiv_id": {"type": "string", "description": "arXiv ID (e.g. 2401.12345)"},
+        },
+        "required": ["arxiv_id"],
+    }
+
+    def run(self, **kwargs) -> str:
+        arxiv_id = (kwargs.get("arxiv_id") or "").strip()
+        if not arxiv_id:
+            return "Error: arxiv_id must be a non-empty string"
+        try:
+            url = f"http://export.arxiv.org/api/query?id_list={arxiv_id}"
+            req = urllib.request.Request(url, headers={"User-Agent": "devsper/1.0"})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                root = ET.fromstring(resp.read())
+            ns = {"atom": "http://www.w3.org/2005/Atom"}
+            entry = root.find("atom:entry", ns)
+            if entry is None:
+                return f"No paper found for arXiv ID: {arxiv_id}"
+            id_el = entry.find("atom:id", ns)
+            title_el = entry.find("atom:title", ns)
+            summary_el = entry.find("atom:summary", ns)
+            authors = [a.find("atom:name", ns).text for a in entry.findall("atom:author", ns) if a.find("atom:name", ns) is not None]
+            link_pdf = None
+            for link in entry.findall("atom:link", ns):
+                if link.get("title") == "pdf":
+                    link_pdf = link.get("href")
+                    break
+            aid = (id_el.text or "").split("/")[-1] if id_el is not None else arxiv_id
+            title = (title_el.text or "").strip().replace("\n", " ") if title_el is not None else ""
+            abstract = (summary_el.text or "").strip().replace("\n", " ") if summary_el is not None else ""
+            pdf_line = f"PDF: {link_pdf}" if link_pdf else "PDF link not found"
+            return f"ID: {aid}\nTitle: {title}\nAuthors: {', '.join(authors or [])}\nAbstract: {abstract}\n{pdf_line}"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(ArxivDownloadTool())

devsper/tools/research/arxiv_search.py

@@ -0,0 +1,58 @@
+"""Search the arXiv API for papers."""
+
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class ArxivSearchTool(Tool):
+    """Search arXiv for papers by query. Returns titles, authors, abstracts, and IDs."""
+
+    name = "arxiv_search"
+    description = "Search arXiv. Returns paper titles, authors, abstracts, and arxiv IDs."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "query": {"type": "string", "description": "Search query"},
+            "max_results": {"type": "integer", "description": "Max results (default 5)"},
+        },
+        "required": ["query"],
+    }
+
+    def run(self, **kwargs) -> str:
+        query = kwargs.get("query")
+        max_results = kwargs.get("max_results", 5)
+        if not query or not isinstance(query, str):
+            return "Error: query must be a non-empty string"
+        if not isinstance(max_results, int) or max_results < 1:
+            max_results = 5
+        try:
+            url = "http://export.arxiv.org/api/query?" + urllib.parse.urlencode({
+                "search_query": f"all:{query}",
+                "start": 0,
+                "max_results": max_results,
+            })
+            req = urllib.request.Request(url, headers={"User-Agent": "devsper/1.0"})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                root = ET.fromstring(resp.read())
+            ns = {"atom": "http://www.w3.org/2005/Atom"}
+            entries = root.findall("atom:entry", ns)
+            lines = []
+            for e in entries:
+                id_el = e.find("atom:id", ns)
+                title_el = e.find("atom:title", ns)
+                summary_el = e.find("atom:summary", ns)
+                authors = [a.find("atom:name", ns).text for a in e.findall("atom:author", ns) if a.find("atom:name", ns) is not None]
+                arxiv_id = (id_el.text or "").split("/")[-1] if id_el is not None else ""
+                title = (title_el.text or "").strip().replace("\n", " ") if title_el is not None else ""
+                abstract = (summary_el.text or "").strip().replace("\n", " ")[:500] if summary_el is not None else ""
+                lines.append(f"ID: {arxiv_id}\nTitle: {title}\nAuthors: {', '.join(authors)}\nAbstract: {abstract}...")
+            return "\n\n---\n\n".join(lines) if lines else "No results found."
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(ArxivSearchTool())

devsper/tools/research/citation_extractor.py

@@ -0,0 +1,35 @@
+"""Extract citation-like patterns from text (e.g. Author et al. (Year), [1], etc.)."""
+
+import re
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class CitationExtractorTool(Tool):
+    """Extract citation-like patterns from text: (Author et al., 20XX), [1], etc."""
+
+    name = "citation_extractor"
+    description = "Extract citation patterns from text: (Author et al., year), [n], numbered refs."
+    input_schema = {
+        "type": "object",
+        "properties": {"text": {"type": "string", "description": "Text that may contain citations"}},
+        "required": ["text"],
+    }
+
+    def run(self, **kwargs) -> str:
+        text = kwargs.get("text")
+        if text is None:
+            return "Error: text is required"
+        if not isinstance(text, str):
+            text = str(text)
+        paren = re.findall(r'\([^)]*?\b(?:et\s+al\.?|&\s*[^)]+)[^)]*?\d{4}[^)]*\)', text, re.I)
+        bracket = re.findall(r'\[\d+(?:\s*[-–,]\s*\d+)*\]', text)
+        author_year = re.findall(r'\([A-Z][a-z]+(?:\s+et\s+al\.?)?,?\s*\d{4}\)', text)
+        all_refs = list(dict.fromkeys(paren + bracket + author_year))
+        if not all_refs:
+            return "No citation patterns found."
+        return "Extracted citations:\n" + "\n".join(all_refs)
+
+
+register(CitationExtractorTool())

devsper/tools/research/duckduckgo_search.py

@@ -0,0 +1,42 @@
+"""DuckDuckGo search via duckduckgo-search package."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class DuckDuckGoSearchTool(Tool):
+    """Search using DuckDuckGo. Requires duckduckgo-search package."""
+
+    name = "duckduckgo_search"
+    description = "Search DuckDuckGo for a query. Returns titles, snippets, and URLs."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "query": {"type": "string", "description": "Search query"},
+            "max_results": {"type": "integer", "description": "Max results (default 5)"},
+        },
+        "required": ["query"],
+    }
+
+    def run(self, **kwargs) -> str:
+        query = kwargs.get("query")
+        max_results = kwargs.get("max_results", 5)
+        if not query or not isinstance(query, str):
+            return "Error: query must be a non-empty string"
+        if not isinstance(max_results, int) or max_results < 1:
+            max_results = 5
+        try:
+            from duckduckgo_search import DDGS
+            with DDGS() as ddgs:
+                results = list(ddgs.text(query, max_results=max_results))
+            if not results:
+                return "No results found."
+            lines = [f"- {r.get('title', '')} | {r.get('href', '')}\n  {r.get('body', '')}" for r in results]
+            return "\n\n".join(lines)
+        except ImportError:
+            return "Error: Install duckduckgo-search (pip install duckduckgo-search)."
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(DuckDuckGoSearchTool())

devsper/tools/research/paper_metadata_extractor.py

@@ -0,0 +1,45 @@
+"""Extract paper metadata (title, authors, year) from bib-like or plain text."""
+
+import re
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class PaperMetadataExtractorTool(Tool):
+    """Extract title, authors, and year from bib-like text or structured paragraphs."""
+
+    name = "paper_metadata_extractor"
+    description = "Extract title, authors, year from bib-style or plain text."
+    input_schema = {
+        "type": "object",
+        "properties": {"text": {"type": "string", "description": "Bib entry or text containing title/author/year"}},
+        "required": ["text"],
+    }
+
+    def run(self, **kwargs) -> str:
+        text = kwargs.get("text")
+        if text is None:
+            return "Error: text is required"
+        if not isinstance(text, str):
+            text = str(text)
+        out = []
+        title_match = re.search(r"title\s*=\s*[{\"]([^}\"]+)[}\"]", text, re.I)
+        if title_match:
+            out.append(f"Title: {title_match.group(1).strip()}")
+        author_match = re.search(r"author\s*=\s*[{\"]([^}\"]+)[}\"]", text, re.I)
+        if author_match:
+            out.append(f"Authors: {author_match.group(1).strip()}")
+        year_match = re.search(r"year\s*=\s*[\"]?(\d{4})[\"]?", text)
+        if year_match:
+            out.append(f"Year: {year_match.group(1)}")
+        if not out and re.search(r"\d{4}", text):
+            years = re.findall(r"\b(19\d{2}|20\d{2})\b", text)
+            if years:
+                out.append(f"Year: {years[0]}")
+        if not out:
+            return "No structured metadata found. Try bib-style or explicit title/author/year."
+        return "\n".join(out)
+
+
+register(PaperMetadataExtractorTool())

devsper/tools/research/paper_summarizer.py

@@ -0,0 +1,41 @@
+"""Summarize paper text by truncation and key sentence extraction heuristics."""
+
+import re
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class PaperSummarizerTool(Tool):
+    """Produce a short summary of paper text (first N chars and first few sentences). No LLM."""
+
+    name = "paper_summarizer"
+    description = "Summarize paper/abstract text: first 500 chars and first 3 sentences."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "text": {"type": "string", "description": "Paper abstract or body text"},
+            "max_chars": {"type": "integer", "description": "Max characters in summary (default 500)"},
+        },
+        "required": ["text"],
+    }
+
+    def run(self, **kwargs) -> str:
+        text = kwargs.get("text")
+        max_chars = kwargs.get("max_chars", 500)
+        if text is None:
+            return "Error: text is required"
+        if not isinstance(text, str):
+            text = str(text)
+        if not isinstance(max_chars, int) or max_chars < 1:
+            max_chars = 500
+        text = text.strip()
+        if not text:
+            return "Error: text is empty"
+        head = text[:max_chars] + ("..." if len(text) > max_chars else "")
+        sentences = re.split(r'(?<=[.!?])\s+', text)
+        first_sentences = " ".join(sentences[:3]) if sentences else head
+        return f"Summary (first {max_chars} chars):\n{head}\n\nKey sentences:\n{first_sentences}"
+
+
+register(PaperSummarizerTool())