klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/core/reminders.py

@@ -1,17 +1,29 @@
-import json
+import hashlib
+import re
+import shlex
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Awaitable, Callable
 
 from pydantic import BaseModel
 
 from klaude_code import const
 from klaude_code.core.tool import BashTool, ReadTool, reset_tool_context, set_tool_context_from_session
+from klaude_code.core.tool.file._utils import hash_text_sha256
 from klaude_code.protocol import model, tools
 from klaude_code.session import Session
+from klaude_code.skill import get_skill
 
 type Reminder = Callable[[Session], Awaitable[model.DeveloperMessageItem | None]]
 
 
+# Match @ preceded by whitespace, start of line, or → (ReadTool line number arrow)
+AT_FILE_PATTERN = re.compile(r'(?:(?<!\S)|(?<=\u2192))@("(?P<quoted>[^\"]+)"|(?P<plain>\S+))')
+
+# Match $skill or ¥skill at the beginning of the first line
+SKILL_PATTERN = re.compile(r"^[$¥](?P<skill>\S+)")
+
+
 def get_last_new_user_input(session: Session) -> str | None:
     """Get last user input & developer message (CLAUDE.md) from conversation history. if there's a tool result after user input, return None"""
     result: list[str] = []
@@ -26,56 +38,165 @@ def get_last_new_user_input(session: Session) -> str | None:
     return "\n\n".join(result)
 
 
-async def at_file_reader_reminder(
-    session: Session,
-) -> model.DeveloperMessageItem | None:
-    """Parse @foo/bar to read"""
-    last_user_input = get_last_new_user_input(session)
-    if not last_user_input or "@" not in last_user_input.strip():
-        return None
+@dataclass
+class AtPatternSource:
+    """Represents an @ pattern with its source file (if from a memory file)."""
+
+    pattern: str
+    mentioned_in: str | None = None
+
+
+def _extract_at_patterns(content: str) -> list[str]:
+    """Extract @ patterns from content."""
+    patterns: list[str] = []
+    if "@" in content:
+        for match in AT_FILE_PATTERN.finditer(content):
+            path_str = match.group("quoted") or match.group("plain")
+            if path_str:
+                patterns.append(path_str)
+    return patterns
+
+
+def get_at_patterns_with_source(session: Session) -> list[AtPatternSource]:
+    """Get @ patterns from last user input and developer messages, preserving source info."""
+    patterns: list[AtPatternSource] = []
+
+    for item in reversed(session.conversation_history):
+        if isinstance(item, model.ToolResultItem):
+            break
+
+        if isinstance(item, model.UserMessageItem):
+            content = item.content or ""
+            for path_str in _extract_at_patterns(content):
+                patterns.append(AtPatternSource(pattern=path_str, mentioned_in=None))
+            break
+
+        if isinstance(item, model.DeveloperMessageItem) and item.memory_mentioned:
+            for memory_path, mentioned_patterns in item.memory_mentioned.items():
+                for pattern in mentioned_patterns:
+                    patterns.append(AtPatternSource(pattern=pattern, mentioned_in=memory_path))
+    return patterns
 
-    at_patterns: list[str] = []
 
-    for item in last_user_input.strip().split():
-        if item.startswith("@") and len(item) > 1:
-            at_patterns.append(item.lower().strip("@"))
+def get_skill_from_user_input(session: Session) -> str | None:
+    """Get $skill reference from the first line of last user input."""
+    for item in reversed(session.conversation_history):
+        if isinstance(item, model.ToolResultItem):
+            return None
+        if isinstance(item, model.UserMessageItem):
+            content = item.content or ""
+            first_line = content.split("\n", 1)[0]
+            m = SKILL_PATTERN.match(first_line)
+            if m:
+                return m.group("skill")
+            return None
+    return None
+
+
+def _is_tracked_file_unchanged(session: Session, path: str) -> bool:
+    status = session.file_tracker.get(path)
+    if status is None or status.content_sha256 is None:
+        return False
+
+    try:
+        current_mtime = Path(path).stat().st_mtime
+    except (OSError, FileNotFoundError):
+        return False
+
+    if current_mtime == status.mtime:
+        return True
 
-    if len(at_patterns) == 0:
+    current_sha256 = _compute_file_content_sha256(path)
+    return current_sha256 is not None and current_sha256 == status.content_sha256
+
+
+async def _load_at_file_recursive(
+    session: Session,
+    pattern: str,
+    at_files: dict[str, model.AtPatternParseResult],
+    collected_images: list[model.ImageURLPart],
+    visited: set[str],
+    base_dir: Path | None = None,
+    mentioned_in: str | None = None,
+) -> None:
+    """Recursively load @ file references."""
+    path = (base_dir / pattern).resolve() if base_dir else Path(pattern).resolve()
+    path_str = str(path)
+
+    if path_str in visited:
+        return
+    visited.add(path_str)
+
+    context_token = set_tool_context_from_session(session)
+    try:
+        if path.exists() and path.is_file():
+            if _is_tracked_file_unchanged(session, path_str):
+                return
+            args = ReadTool.ReadArguments(file_path=path_str)
+            tool_result = await ReadTool.call_with_args(args)
+            at_files[path_str] = model.AtPatternParseResult(
+                path=path_str,
+                tool_name=tools.READ,
+                result=tool_result.output or "",
+                tool_args=args.model_dump_json(exclude_none=True),
+                operation="Read",
+                images=tool_result.images,
+                mentioned_in=mentioned_in,
+            )
+            if tool_result.images:
+                collected_images.extend(tool_result.images)
+
+            # Recursively parse @ references from ReadTool output
+            output = tool_result.output or ""
+            if "@" in output:
+                for match in AT_FILE_PATTERN.finditer(output):
+                    nested = match.group("quoted") or match.group("plain")
+                    if nested:
+                        await _load_at_file_recursive(
+                            session,
+                            nested,
+                            at_files,
+                            collected_images,
+                            visited,
+                            base_dir=path.parent,
+                            mentioned_in=path_str,
+                        )
+        elif path.exists() and path.is_dir():
+            quoted_path = shlex.quote(path_str)
+            args = BashTool.BashArguments(command=f"ls {quoted_path}")
+            tool_result = await BashTool.call_with_args(args)
+            at_files[path_str] = model.AtPatternParseResult(
+                path=path_str + "/",
+                tool_name=tools.BASH,
+                result=tool_result.output or "",
+                tool_args=args.model_dump_json(exclude_none=True),
+                operation="List",
+            )
+    finally:
+        reset_tool_context(context_token)
+
+
+async def at_file_reader_reminder(
+    session: Session,
+) -> model.DeveloperMessageItem | None:
+    """Parse @foo/bar to read, with recursive loading of nested @ references"""
+    at_pattern_sources = get_at_patterns_with_source(session)
+    if not at_pattern_sources:
         return None
 
     at_files: dict[str, model.AtPatternParseResult] = {}  # path -> content
     collected_images: list[model.ImageURLPart] = []
-
-    for pattern in at_patterns:
-        path = Path(pattern).resolve()
-        context_token = set_tool_context_from_session(session)
-        try:
-            if path.exists() and path.is_file():
-                args = ReadTool.ReadArguments(file_path=str(path))
-                tool_result = await ReadTool.call_with_args(args)
-                at_result = model.AtPatternParseResult(
-                    path=str(path),
-                    tool_name=tools.READ,
-                    result=tool_result.output or "",
-                    tool_args=args.model_dump_json(exclude_none=True),
-                    operation="Read",
-                    images=tool_result.images,
-                )
-                at_files[str(path)] = at_result
-                if tool_result.images:
-                    collected_images.extend(tool_result.images)
-            elif path.exists() and path.is_dir():
-                args = BashTool.BashArguments(command=f"ls {path}")
-                tool_result = await BashTool.call_with_args(args)
-                at_files[str(path)] = model.AtPatternParseResult(
-                    path=str(path) + "/",
-                    tool_name=tools.BASH,
-                    result=tool_result.output or "",
-                    tool_args=args.model_dump_json(exclude_none=True),
-                    operation="List",
-                )
-        finally:
-            reset_tool_context(context_token)
+    visited: set[str] = set()
+
+    for source in at_pattern_sources:
+        await _load_at_file_recursive(
+            session,
+            source.pattern,
+            at_files,
+            collected_images,
+            visited,
+            mentioned_in=source.mentioned_in,
+        )
 
     if len(at_files) == 0:
         return None
@@ -141,16 +262,16 @@ async def todo_not_used_recently_reminder(
         return None
 
     # Count non-todo tool calls since the last TodoWrite
-    other_tool_call_count_befor_last_todo = 0
+    other_tool_call_count_before_last_todo = 0
     for item in reversed(session.conversation_history):
         if isinstance(item, model.ToolCallItem):
             if item.name in (tools.TODO_WRITE, tools.UPDATE_PLAN):
                 break
-            other_tool_call_count_befor_last_todo += 1
-            if other_tool_call_count_befor_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD:
+            other_tool_call_count_before_last_todo += 1
+            if other_tool_call_count_before_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD:
                 break
 
-    not_used_recently = other_tool_call_count_befor_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD
+    not_used_recently = other_tool_call_count_before_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD
 
     if not not_used_recently:
         return None
@@ -180,9 +301,19 @@ async def file_changed_externally_reminder(
     changed_files: list[tuple[str, str, list[model.ImageURLPart] | None]] = []
     collected_images: list[model.ImageURLPart] = []
     if session.file_tracker and len(session.file_tracker) > 0:
-        for path, mtime in session.file_tracker.items():
+        for path, status in session.file_tracker.items():
             try:
-                if Path(path).stat().st_mtime > mtime:
+                current_mtime = Path(path).stat().st_mtime
+
+                changed = False
+                if status.content_sha256 is not None:
+                    current_sha256 = _compute_file_content_sha256(path)
+                    changed = current_sha256 is not None and current_sha256 != status.content_sha256
+                else:
+                    # Backward-compat: old sessions only tracked mtime.
+                    changed = current_mtime != status.mtime
+
+                if changed:
                     context_token = set_tool_context_from_session(session)
                     try:
                         tool_result = await ReadTool.call_with_args(
@@ -219,6 +350,24 @@ async def file_changed_externally_reminder(
     return None
 
 
+def _compute_file_content_sha256(path: str) -> str | None:
+    """Compute SHA-256 for file content using the same decoding behavior as ReadTool."""
+
+    try:
+        suffix = Path(path).suffix.lower()
+        if suffix in {".png", ".jpg", ".jpeg", ".gif", ".webp"}:
+            with open(path, "rb") as f:
+                return hashlib.sha256(f.read()).hexdigest()
+
+        hasher = hashlib.sha256()
+        with open(path, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                hasher.update(line.encode("utf-8"))
+        return hasher.hexdigest()
+    except (FileNotFoundError, IsADirectoryError, OSError, PermissionError, UnicodeDecodeError):
+        return None
+
+
 def get_memory_paths() -> list[tuple[Path, str]]:
     return [
         (
@@ -230,8 +379,8 @@ def get_memory_paths() -> list[tuple[Path, str]]:
             "user's private global instructions for all projects",
         ),
         (Path.cwd() / "AGENTS.md", "project instructions, checked into the codebase"),
-        (Path.cwd() / "AGENT.md", "project instructions, checked into the codebase"),
         (Path.cwd() / "CLAUDE.md", "project instructions, checked into the codebase"),
+        (Path.cwd() / ".claude" / "CLAUDE.md", "project instructions, checked into the codebase"),
     ]
 
 
@@ -263,22 +412,79 @@ async def image_reminder(session: Session) -> model.DeveloperMessageItem | None:
     )
 
 
+async def skill_reminder(session: Session) -> model.DeveloperMessageItem | None:
+    """Load skill content when user references a skill with $skill syntax."""
+    skill_name = get_skill_from_user_input(session)
+    if not skill_name:
+        return None
+
+    # Get the skill from skill module
+    skill = get_skill(skill_name)
+    if not skill:
+        return None
+
+    # Get base directory from skill_path
+    base_dir = str(skill.skill_path.parent) if skill.skill_path else "unknown"
+
+    content = f"""<system-reminder>The user activated the "{skill.name}" skill. Here is the skill content:
+
+<skill>
+<name>{skill.name}</name>
+<base_dir>{base_dir}</base_dir>
+
+{skill.to_prompt()}
+</skill>
+</system-reminder>"""
+
+    return model.DeveloperMessageItem(
+        content=content,
+        skill_name=skill.name,
+    )
+
+
+def _is_memory_loaded(session: Session, path: str) -> bool:
+    """Check if a memory file has already been loaded (tracked with is_memory=True)."""
+    status = session.file_tracker.get(path)
+    return status is not None and status.is_memory
+
+
+def _mark_memory_loaded(session: Session, path: str) -> None:
+    """Mark a file as loaded memory in file_tracker."""
+    try:
+        mtime = Path(path).stat().st_mtime
+    except (OSError, FileNotFoundError):
+        mtime = 0.0
+    try:
+        content_sha256 = hash_text_sha256(Path(path).read_text(encoding="utf-8", errors="replace"))
+    except (OSError, FileNotFoundError, PermissionError, UnicodeDecodeError):
+        content_sha256 = None
+    session.file_tracker[path] = model.FileStatus(mtime=mtime, content_sha256=content_sha256, is_memory=True)
+
+
 async def memory_reminder(session: Session) -> model.DeveloperMessageItem | None:
     """CLAUDE.md AGENTS.md"""
     memory_paths = get_memory_paths()
     memories: list[Memory] = []
     for memory_path, instruction in memory_paths:
-        if memory_path.exists() and memory_path.is_file() and str(memory_path) not in session.loaded_memory:
+        path_str = str(memory_path)
+        if memory_path.exists() and memory_path.is_file() and not _is_memory_loaded(session, path_str):
             try:
                 text = memory_path.read_text()
-                session.loaded_memory.append(str(memory_path))
-                memories.append(Memory(path=str(memory_path), instruction=instruction, content=text))
+                _mark_memory_loaded(session, path_str)
+                memories.append(Memory(path=path_str, instruction=instruction, content=text))
             except (PermissionError, UnicodeDecodeError, OSError):
                 continue
     if len(memories) > 0:
         memories_str = "\n\n".join(
             [f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}" for memory in memories]
         )
+        # Build memory_mentioned: extract @ patterns from each memory's content
+        memory_mentioned: dict[str, list[str]] = {}
+        for memory in memories:
+            patterns = _extract_at_patterns(memory.content)
+            if patterns:
+                memory_mentioned[memory.path] = patterns
+
         return model.DeveloperMessageItem(
             content=f"""<system-reminder>As you answer the user's questions, you can use the following context:
 
@@ -295,56 +501,29 @@ NEVER proactively create documentation files (*.md) or README files. Only create
 IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.
 </system-reminder>""",
             memory_paths=[memory.path for memory in memories],
+            memory_mentioned=memory_mentioned or None,
         )
     return None
 
 
-def get_last_turn_tool_call(session: Session) -> list[model.ToolCallItem]:
-    tool_calls: list[model.ToolCallItem] = []
-    for item in reversed(session.conversation_history):
-        if isinstance(item, model.ToolCallItem):
-            tool_calls.append(item)
-        if isinstance(
-            item,
-            (
-                model.ReasoningEncryptedItem,
-                model.ReasoningTextItem,
-                model.AssistantMessageItem,
-            ),
-        ):
-            break
-    return tool_calls
-
-
 MEMORY_FILE_NAMES = ["CLAUDE.md", "AGENTS.md", "AGENT.md"]
 
 
 async def last_path_memory_reminder(
     session: Session,
 ) -> model.DeveloperMessageItem | None:
-    """When last turn tool call entered a directory (or parent directory) with CLAUDE.md AGENTS.md"""
-    tool_calls = get_last_turn_tool_call(session)
-    if len(tool_calls) == 0:
+    """Load CLAUDE.md/AGENTS.md from directories containing files in file_tracker.
+
+    Uses session.file_tracker to detect accessed paths (works for both tool calls
+    and @ file references). Checks is_memory flag to avoid duplicate loading.
+    """
+    if not session.file_tracker:
         return None
-    paths: list[str] = []
-    for tool_call in tool_calls:
-        if tool_call.name in (tools.READ, tools.EDIT, tools.MULTI_EDIT, tools.WRITE):
-            try:
-                json_dict = json.loads(tool_call.arguments)
-                if path := json_dict.get("file_path", ""):
-                    paths.append(path)
-            except json.JSONDecodeError:
-                continue
-        elif tool_call.name == tools.BASH:
-            # TODO: haiku check file path
-            pass
-    paths = list(set(paths))
+
+    paths = list(session.file_tracker.keys())
     memories: list[Memory] = []
-    if len(paths) == 0:
-        return None
 
     cwd = Path.cwd().resolve()
-    loaded_set: set[str] = set(session.loaded_memory)
     seen_memory_files: set[str] = set()
 
     for p_str in paths:
@@ -372,15 +551,14 @@ async def last_path_memory_reminder(
             for fname in MEMORY_FILE_NAMES:
                 mem_path = current_dir / fname
                 mem_path_str = str(mem_path)
-                if mem_path_str in seen_memory_files or mem_path_str in loaded_set:
+                if mem_path_str in seen_memory_files or _is_memory_loaded(session, mem_path_str):
                     continue
                 if mem_path.exists() and mem_path.is_file():
                     try:
                         text = mem_path.read_text()
                     except (PermissionError, UnicodeDecodeError, OSError):
                         continue
-                    session.loaded_memory.append(mem_path_str)
-                    loaded_set.add(mem_path_str)
+                    _mark_memory_loaded(session, mem_path_str)
                     seen_memory_files.add(mem_path_str)
                     memories.append(
                         Memory(
@@ -394,10 +572,18 @@ async def last_path_memory_reminder(
         memories_str = "\n\n".join(
             [f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}" for memory in memories]
         )
+        # Build memory_mentioned: extract @ patterns from each memory's content
+        memory_mentioned: dict[str, list[str]] = {}
+        for memory in memories:
+            patterns = _extract_at_patterns(memory.content)
+            if patterns:
+                memory_mentioned[memory.path] = patterns
+
         return model.DeveloperMessageItem(
             content=f"""<system-reminder>{memories_str}
 </system-reminder>""",
             memory_paths=[memory.path for memory in memories],
+            memory_mentioned=memory_mentioned or None,
         )
 
 
@@ -409,6 +595,7 @@ ALL_REMINDERS = [
     last_path_memory_reminder,
     at_file_reader_reminder,
     image_reminder,
+    skill_reminder,
 ]
 
 
@@ -435,10 +622,11 @@ def load_agent_reminders(
     reminders.extend(
         [
             memory_reminder,
-            last_path_memory_reminder,
             at_file_reader_reminder,
+            last_path_memory_reminder,
             file_changed_externally_reminder,
             image_reminder,
+            skill_reminder,
         ]
     )