@researai/deepscientist 1.5.16 → 1.6.0

package/src/deepscientist/memory/service.py

@@ -5,16 +5,24 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
+from ..config import ConfigManager
 from ..shared import append_jsonl, ensure_dir, generate_id, slugify, utc_now
 from .frontmatter import dump_markdown_document, load_markdown_document, load_markdown_document_from_text
 
 MEMORY_KINDS = ("papers", "ideas", "decisions", "episodes", "knowledge", "templates")
+MEMORY_READ_VISIBILITY_MODES = ("independent", "shared_across_quests")
+SHARED_MEMORY_DOCUMENT_PREFIX = "sharedmemory::"
 
 
 class MemoryService:
     def __init__(self, home: Path) -> None:
         self.home = home
 
+    @staticmethod
+    def normalize_read_visibility_mode(value: Any) -> str:
+        normalized = str(value or "independent").strip().lower() or "independent"
+        return normalized if normalized in MEMORY_READ_VISIBILITY_MODES else "independent"
+
     @staticmethod
     def _normalize_tags(tags: list[str] | str | None) -> list[str]:
         if tags is None:
@@ -66,6 +74,12 @@ class MemoryService:
         quest_root: Path | None = None,
     ) -> Path:
         if path:
+            shared = self.parse_shared_document_id(path)
+            if shared is not None:
+                source_quest_id, relative = shared
+                shared_candidate = self.home / "quests" / source_quest_id / "memory" / relative
+                if shared_candidate.exists():
+                    return shared_candidate
             candidate = Path(path)
             if candidate.exists():
                 return candidate
@@ -77,6 +91,39 @@ class MemoryService:
                     return candidate
         raise FileNotFoundError("Memory card not found")
 
+    def read_visibility_mode(self) -> str:
+        config = ConfigManager(self.home).load_runtime_config()
+        memory = config.get("memory") if isinstance(config.get("memory"), dict) else {}
+        return self.normalize_read_visibility_mode(memory.get("read_visibility_mode"))
+
+    def shared_read_enabled(self) -> bool:
+        return self.read_visibility_mode() == "shared_across_quests"
+
+    def _iter_initialized_quest_roots(self):
+        quests_root = self.home / "quests"
+        if not quests_root.exists():
+            return
+        for quest_yaml in sorted(quests_root.glob("*/quest.yaml")):
+            quest_root = quest_yaml.parent
+            yield quest_root.name, quest_root
+
+    @staticmethod
+    def _shared_document_id(*, source_quest_id: str, relative_path: str) -> str:
+        relative = str(relative_path or "").lstrip("/")
+        return f"{SHARED_MEMORY_DOCUMENT_PREFIX}{source_quest_id}::{relative}"
+
+    @staticmethod
+    def parse_shared_document_id(document_id: str) -> tuple[str, str] | None:
+        raw = str(document_id or "").strip()
+        if not raw.startswith(SHARED_MEMORY_DOCUMENT_PREFIX):
+            return None
+        _prefix, quest_id, relative = (raw.split("::", 2) + ["", "", ""])[:3]
+        quest_id = quest_id.strip()
+        relative = relative.lstrip("/")
+        if not quest_id or not relative:
+            return None
+        return quest_id, relative
+
     def _normalize_metadata(
         self,
         *,
@@ -100,6 +147,84 @@ class MemoryService:
         seed["scope"] = scope
         return seed
 
+    def _list_cards_from_root(
+        self,
+        *,
+        root: Path,
+        kind: str | None = None,
+        writable: bool = True,
+        scope: str | None = None,
+        source_quest_id: str | None = None,
+        shared: bool = False,
+    ) -> list[dict]:
+        cards: list[dict] = []
+        if not root.exists():
+            return cards
+        pattern = f"{kind}/*.md" if kind else "*/*.md"
+        for path in sorted(root.glob(pattern)):
+            if not path.is_file():
+                continue
+            relative = path.relative_to(root).as_posix()
+            metadata, body = load_markdown_document(path)
+            entry = {
+                "id": metadata.get("id"),
+                "title": metadata.get("title", path.stem),
+                "type": metadata.get("type"),
+                "path": str(path),
+                "document_id": (
+                    self._shared_document_id(source_quest_id=source_quest_id, relative_path=relative)
+                    if shared and source_quest_id
+                    else f"memory::{relative}"
+                ),
+                "excerpt": body.strip().splitlines()[0] if body.strip() else "",
+                "updated_at": metadata.get("updated_at"),
+                "writable": writable,
+                "scope": scope,
+                "shared": shared,
+            }
+            if source_quest_id:
+                entry["source_quest_id"] = source_quest_id
+            cards.append(entry)
+        return cards
+
+    @staticmethod
+    def _card_timestamp(card: dict[str, Any]) -> float:
+        updated_at = str(card.get("updated_at") or "").strip()
+        try:
+            return datetime.fromisoformat(updated_at).timestamp() if updated_at else float("-inf")
+        except ValueError:
+            return float("-inf")
+
+    @classmethod
+    def _visible_card_sort_key(cls, card: dict[str, Any], *, active_quest_id: str | None = None) -> tuple[int, float, str]:
+        source_quest_id = str(card.get("source_quest_id") or "").strip()
+        scope = str(card.get("scope") or "").strip()
+        if active_quest_id and source_quest_id and source_quest_id == active_quest_id:
+            rank = 0
+        elif scope in {"quest", "shared_quest"}:
+            rank = 1
+        elif scope == "global":
+            rank = 2
+        else:
+            rank = 3
+        return (rank, -cls._card_timestamp(card), str(card.get("path") or ""))
+
+    def _visible_quest_roots(
+        self,
+        *,
+        active_quest_root: Path,
+        active_quest_id: str,
+        include_shared: bool,
+    ) -> list[tuple[str, Path, bool]]:
+        roots: list[tuple[str, Path, bool]] = [(active_quest_id, active_quest_root, False)]
+        if not include_shared:
+            return roots
+        for quest_id, quest_root in self._iter_initialized_quest_roots() or []:
+            if quest_id == active_quest_id:
+                continue
+            roots.append((quest_id, quest_root, True))
+        return roots
+
     def write_card(
         self,
         *,
@@ -167,22 +292,14 @@ class MemoryService:
         kind: str | None = None,
     ) -> list[dict]:
         root = self._root_for(scope, quest_root)
-        cards: list[dict] = []
-        pattern = f"{kind}/*.md" if kind else "*/*.md"
-        for path in sorted(root.glob(pattern)):
-            metadata, body = load_markdown_document(path)
-            cards.append(
-                {
-                    "id": metadata.get("id"),
-                    "title": metadata.get("title", path.stem),
-                    "type": metadata.get("type"),
-                    "path": str(path),
-                    "document_id": f"memory::{path.relative_to(root).as_posix()}",
-                    "excerpt": body.strip().splitlines()[0] if body.strip() else "",
-                    "updated_at": metadata.get("updated_at"),
-                    "writable": True,
-                }
-            )
+        cards = self._list_cards_from_root(
+            root=root,
+            kind=kind,
+            writable=True,
+            scope=scope,
+            source_quest_id=quest_root.name if scope == "quest" and quest_root is not None else None,
+            shared=False,
+        )
         return cards[-limit:]
 
     def list_recent(
@@ -223,6 +340,76 @@ class MemoryService:
         matches.sort(key=self._card_sort_key, reverse=True)
         return matches[:limit]
 
+    def list_visible_quest_cards(
+        self,
+        *,
+        active_quest_root: Path,
+        active_quest_id: str | None = None,
+        limit: int = 30,
+        kind: str | None = None,
+        include_shared: bool | None = None,
+    ) -> list[dict]:
+        resolved_active_quest_id = str(active_quest_id or active_quest_root.name).strip() or active_quest_root.name
+        shared_enabled = self.shared_read_enabled() if include_shared is None else bool(include_shared)
+        if not shared_enabled:
+            return self.list_cards(scope="quest", quest_root=active_quest_root, limit=limit, kind=kind)
+
+        cards: list[dict] = []
+        for quest_id, quest_root, shared in self._visible_quest_roots(
+            active_quest_root=active_quest_root,
+            active_quest_id=resolved_active_quest_id,
+            include_shared=shared_enabled,
+        ):
+            cards.extend(
+                self._list_cards_from_root(
+                    root=quest_root / "memory",
+                    kind=kind,
+                    writable=not shared,
+                    scope="shared_quest" if shared else "quest",
+                    source_quest_id=quest_id,
+                    shared=shared,
+                )
+            )
+        cards.sort(key=lambda item: self._visible_card_sort_key(item, active_quest_id=resolved_active_quest_id))
+        return cards[:limit]
+
+    def search_visible_quest_cards(
+        self,
+        query: str,
+        *,
+        active_quest_root: Path,
+        active_quest_id: str | None = None,
+        limit: int = 20,
+        kind: str | None = None,
+        include_shared: bool | None = None,
+    ) -> list[dict]:
+        resolved_active_quest_id = str(active_quest_id or active_quest_root.name).strip() or active_quest_root.name
+        shared_enabled = self.shared_read_enabled() if include_shared is None else bool(include_shared)
+        if not shared_enabled:
+            return self.search(query, scope="quest", quest_root=active_quest_root, limit=limit, kind=kind)
+
+        query_lower = query.lower()
+        matches: list[dict] = []
+        for quest_id, quest_root, shared in self._visible_quest_roots(
+            active_quest_root=active_quest_root,
+            active_quest_id=resolved_active_quest_id,
+            include_shared=shared_enabled,
+        ):
+            cards = self._list_cards_from_root(
+                root=quest_root / "memory",
+                kind=kind,
+                writable=not shared,
+                scope="shared_quest" if shared else "quest",
+                source_quest_id=quest_id,
+                shared=shared,
+            )
+            for card in cards:
+                content = Path(card["path"]).read_text(encoding="utf-8").lower()
+                if query_lower in content:
+                    matches.append(card)
+        matches.sort(key=lambda item: self._visible_card_sort_key(item, active_quest_id=resolved_active_quest_id))
+        return matches[:limit]
+
     def promote_to_global(
         self,
         *,

package/src/deepscientist/process_control.py

@@ -69,7 +69,14 @@ def terminate_process_ids(
             taskkill_args = ["taskkill", "/PID", str(process_pid), "/T"]
             if force:
                 taskkill_args.append("/F")
-            subprocess.run(taskkill_args, check=False, capture_output=True, text=True)
+            subprocess.run(
+                taskkill_args,
+                check=False,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+            )
             if not force and is_process_alive(process_pid):
                 try:
                     os.kill(process_pid, signal.SIGTERM)