kimi-cli 0.44__py3-none-any.whl → 0.78__py3-none-any.whl

kimi_cli/tools/__init__.py

@@ -1,85 +1,93 @@
 import json
-from pathlib import Path
+from typing import cast
 
-import streamingjson
+import streamingjson  # type: ignore[reportMissingTypeStubs]
+from kaos.path import KaosPath
 from kosong.utils.typing import JsonType
 
 from kimi_cli.utils.string import shorten_middle
 
 
-def extract_subtitle(lexer: streamingjson.Lexer, tool_name: str) -> str | None:
+class SkipThisTool(Exception):
+    """Raised when a tool decides to skip itself from the loading process."""
+
+    pass
+
+
+def extract_key_argument(json_content: str | streamingjson.Lexer, tool_name: str) -> str | None:
+    if isinstance(json_content, streamingjson.Lexer):
+        json_str = json_content.complete_json()
+    else:
+        json_str = json_content
     try:
-        curr_args: JsonType = json.loads(lexer.complete_json())
+        curr_args: JsonType = json.loads(json_str)
     except json.JSONDecodeError:
         return None
     if not curr_args:
         return None
-    subtitle: str = ""
+    key_argument: str = ""
     match tool_name:
         case "Task":
             if not isinstance(curr_args, dict) or not curr_args.get("description"):
                 return None
-            subtitle = str(curr_args["description"])
+            key_argument = str(curr_args["description"])
+        case "CreateSubagent":
+            if not isinstance(curr_args, dict) or not curr_args.get("name"):
+                return None
+            key_argument = str(curr_args["name"])
         case "SendDMail":
-            return "El Psy Kongroo"
+            return None
         case "Think":
             if not isinstance(curr_args, dict) or not curr_args.get("thought"):
                 return None
-            subtitle = str(curr_args["thought"])
+            key_argument = str(curr_args["thought"])
         case "SetTodoList":
-            if not isinstance(curr_args, dict) or not curr_args.get("todos"):
-                return None
-            if not isinstance(curr_args["todos"], list):
-                return None
-            for todo in curr_args["todos"]:
-                if not isinstance(todo, dict) or not todo.get("title"):
-                    continue
-                subtitle += f"• {todo['title']}"
-                if todo.get("status"):
-                    subtitle += f" [{todo['status']}]"
-                subtitle += "\n"
-            return "\n" + subtitle.strip()
-        case "Bash":
+            return None
+        case "Shell":
             if not isinstance(curr_args, dict) or not curr_args.get("command"):
                 return None
-            subtitle = str(curr_args["command"])
+            key_argument = str(curr_args["command"])
         case "ReadFile":
             if not isinstance(curr_args, dict) or not curr_args.get("path"):
                 return None
-            subtitle = _normalize_path(str(curr_args["path"]))
+            key_argument = _normalize_path(str(curr_args["path"]))
         case "Glob":
             if not isinstance(curr_args, dict) or not curr_args.get("pattern"):
                 return None
-            subtitle = str(curr_args["pattern"])
+            key_argument = str(curr_args["pattern"])
         case "Grep":
             if not isinstance(curr_args, dict) or not curr_args.get("pattern"):
                 return None
-            subtitle = str(curr_args["pattern"])
+            key_argument = str(curr_args["pattern"])
         case "WriteFile":
             if not isinstance(curr_args, dict) or not curr_args.get("path"):
                 return None
-            subtitle = _normalize_path(str(curr_args["path"]))
+            key_argument = _normalize_path(str(curr_args["path"]))
         case "StrReplaceFile":
             if not isinstance(curr_args, dict) or not curr_args.get("path"):
                 return None
-            subtitle = _normalize_path(str(curr_args["path"]))
+            key_argument = _normalize_path(str(curr_args["path"]))
         case "SearchWeb":
             if not isinstance(curr_args, dict) or not curr_args.get("query"):
                 return None
-            subtitle = str(curr_args["query"])
+            key_argument = str(curr_args["query"])
         case "FetchURL":
             if not isinstance(curr_args, dict) or not curr_args.get("url"):
                 return None
-            subtitle = str(curr_args["url"])
+            key_argument = str(curr_args["url"])
         case _:
-            subtitle = "".join(lexer.json_content)
-    if tool_name not in ["SetTodoList"]:
-        subtitle = shorten_middle(subtitle, width=50)
-    return subtitle
+            if isinstance(json_content, streamingjson.Lexer):
+                # lexer.json_content is list[str] based on streamingjson source code
+                content: list[str] = cast(list[str], json_content.json_content)  # type: ignore[reportUnknownMemberType]
+                key_argument = "".join(content)
+            else:
+                key_argument = json_content
+    key_argument = shorten_middle(key_argument, width=50)
+    return key_argument
 
 
 def _normalize_path(path: str) -> str:
-    cwd = str(Path.cwd().absolute())
+    cwd = str(KaosPath.cwd().canonical())
     if path.startswith(cwd):
         path = path[len(cwd) :].lstrip("/\\")
     return path

kimi_cli/tools/display.py

@@ -0,0 +1,25 @@
+from typing import Literal
+
+from kosong.tooling import DisplayBlock
+from pydantic import BaseModel
+
+
+class DiffDisplayBlock(DisplayBlock):
+    """Display block describing a file diff."""
+
+    type: str = "diff"
+    path: str
+    old_text: str
+    new_text: str
+
+
+class TodoDisplayItem(BaseModel):
+    title: str
+    status: Literal["pending", "in_progress", "done"]
+
+
+class TodoDisplayBlock(DisplayBlock):
+    """Display block describing a todo list update."""
+
+    type: str = "todo"
+    items: list[TodoDisplayItem]

kimi_cli/tools/dmail/__init__.py

@@ -1,24 +1,25 @@
 from pathlib import Path
 from typing import override
 
-from kosong.tooling import CallableTool2, ToolError, ToolReturnType
+from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnValue
 
 from kimi_cli.soul.denwarenji import DenwaRenji, DenwaRenjiError, DMail
+from kimi_cli.tools.utils import load_desc
 
 NAME = "SendDMail"
 
 
-class SendDMail(CallableTool2):
+class SendDMail(CallableTool2[DMail]):
     name: str = NAME
-    description: str = (Path(__file__).parent / "dmail.md").read_text(encoding="utf-8")
+    description: str = load_desc(Path(__file__).parent / "dmail.md")
     params: type[DMail] = DMail
 
-    def __init__(self, denwa_renji: DenwaRenji, **kwargs):
-        super().__init__(**kwargs)
+    def __init__(self, denwa_renji: DenwaRenji) -> None:
+        super().__init__()
         self._denwa_renji = denwa_renji
 
     @override
-    async def __call__(self, params: DMail) -> ToolReturnType:
+    async def __call__(self, params: DMail) -> ToolReturnValue:
         try:
             self._denwa_renji.send_dmail(params)
         except DenwaRenjiError as e:
@@ -27,12 +28,11 @@ class SendDMail(CallableTool2):
                 message=f"Failed to send D-Mail. Error: {str(e)}",
                 brief="Failed to send D-Mail",
             )
-        # always return an error because a successful SendDMail call will never return
-        return ToolError(
+        return ToolOk(
             output="",
             message=(
-                "If you see this message, the D-Mail was not sent successfully. "
+                "If you see this message, the D-Mail was NOT sent successfully. "
                 "This may be because some other tool that needs approval was rejected."
             ),
-            brief="D-Mail not sent",
+            brief="El Psy Kongroo",
         )

kimi_cli/tools/dmail/dmail.md

@@ -1,15 +1,17 @@
 Send a message to the past, just like sending a D-Mail in Steins;Gate.
 
-You can see some `user` messages with `CHECKPOINT {checkpoint_id}` wrapped in `<system>` tags in the context. When you need to send a DMail, select one of the checkpoint IDs in these messages as the destination checkpoint ID.
+This tool is provided to enable you to proactively manage the context. You can see some `user` messages with text `CHECKPOINT {checkpoint_id}` wrapped in `<system>` tags in the context. When you feel there is too much irrelevant information in the current context, you can send a D-Mail to revert the context to a previous checkpoint with a message containing only the useful information. When you send a D-Mail, you must specify an existing checkpoint ID from the before-mentioned messages.
 
-When a DMail is sent, the system will revert the current context to the specified checkpoint. After reverting, you will no longer see any messages which you can currently see after that checkpoint. The message in the DMail will be appended to the end of the context. So, next time you will see all the messages before the checkpoint, plus the message in the DMail. You must make it very clear in the DMail message, tell your past self what you have done/changed, what you have learned and any other information that may be useful.
+Typical scenarios you may want to send a D-Mail:
 
-When sending a DMail, DO NOT do much explanation to the user. The user do not care about this. Just explain to your past self.
+- You read a file, found it very large and most of the content is not relevant to the current task. In this case you can send a D-Mail immediately to the checkpoint before you read the file and give your past self only the useful part.
+- You searched the web, the result is large.
+  - If you got what you need, you may send a D-Mail to the checkpoint before you searched the web and put only the useful result in the mail message.
+  - If you did not get what you need, you may send a D-Mail to tell your past self to try another query.
+- You wrote some code and it did not work as expected. You spent many struggling steps to fix it but the process is not relevant to the ultimate goal. In this case you can send a D-Mail to the checkpoint before you wrote the code and give your past self the fixed version of the code and tell yourself no need to write it again because you already wrote to the filesystem.
 
-Here are some typical scenarios you may want to send a DMail:
+After a D-Mail is sent, the system will revert the current context to the specified checkpoint, after which, you will no longer see any messages which you can now see after that checkpoint. The message in the D-Mail will be appended to the end of the context. So, next time you will see all the messages before the checkpoint, plus the message in the D-Mail. You must make it very clear in the message, tell your past self what you have done/changed, what you have learned and any other information that may be useful, so that your past self can continue the task without confusion and will not repeat the steps you have already done.
 
-- You read a file, found it very large and most of the content is not relevant to the current task. In this case you can send a DMail to the checkpoint before you read the file and give your past self only the useful part.
-- You searched the web, found the result very large.
-  - If you got what you need, you may send a DMail to the checkpoint before you searched the web and give your past self the useful part.
-  - If you did not get what you need, you may send a DMail to tell your past self to try another query.
-- You wrote some code and it did not work as expected. You spent many struggling steps to fix it but the process is not relevant to the ultimate goal. In this case you can send a DMail to the checkpoint before you wrote the code and give your past self the fixed version of the code and tell yourself no need to write it again because you already wrote to the filesystem.
+You must understand that, unlike D-Mail in Steins;Gate, the D-Mail you send here will not revert the filesystem or any external state. That means, you are basically folding the recent messages in your context into a single message, which can significantly reduce the waste of context window.
+
+When sending a D-Mail, DO NOT explain to the user. The user do not care about this. Just explain to your past self.

kimi_cli/tools/file/__init__.py

@@ -13,8 +13,7 @@ class FileActions(str, Enum):
 
 
 from .glob import Glob  # noqa: E402
-from .grep import Grep  # noqa: E402
-from .patch import PatchFile  # noqa: E402
+from .grep_local import Grep  # noqa: E402
 from .read import ReadFile  # noqa: E402
 from .replace import StrReplaceFile  # noqa: E402
 from .write import WriteFile  # noqa: E402
@@ -25,5 +24,4 @@ __all__ = (
     "Grep",
     "WriteFile",
     "StrReplaceFile",
-    "PatchFile",
 )

kimi_cli/tools/file/glob.py

@@ -1,15 +1,15 @@
 """Glob tool implementation."""
 
-import asyncio
 from pathlib import Path
 from typing import override
 
-import aiofiles.os
-from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
+from kaos.path import KaosPath
+from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnValue
 from pydantic import BaseModel, Field
 
-from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
+from kimi_cli.soul.agent import BuiltinSystemPromptArgs
 from kimi_cli.tools.utils import load_desc
+from kimi_cli.utils.path import is_within_directory, list_directory
 
 MAX_MATCHES = 1000
 
@@ -38,17 +38,16 @@ class Glob(CallableTool2[Params]):
     )
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
-        super().__init__(**kwargs)
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs) -> None:
+        super().__init__()
         self._work_dir = builtin_args.KIMI_WORK_DIR
 
     async def _validate_pattern(self, pattern: str) -> ToolError | None:
         """Validate that the pattern is safe to use."""
         if pattern.startswith("**"):
-            # TODO: give a `ls -la` result as the output
-            ls_result = await aiofiles.os.listdir(self._work_dir)
+            ls_result = await list_directory(self._work_dir)
             return ToolError(
-                output="\n".join(ls_result),
+                output=ls_result,
                 message=(
                     f"Pattern `{pattern}` starts with '**' which is not allowed. "
                     "This would recursively search all directories and may include large "
@@ -60,13 +59,12 @@ class Glob(CallableTool2[Params]):
             )
         return None
 
-    def _validate_directory(self, directory: Path) -> ToolError | None:
+    async def _validate_directory(self, directory: KaosPath) -> ToolError | None:
         """Validate that the directory is safe to search."""
-        resolved_dir = directory.resolve()
-        resolved_work_dir = self._work_dir.resolve()
+        resolved_dir = directory.canonical()
 
         # Ensure the directory is within work directory
-        if not str(resolved_dir).startswith(str(resolved_work_dir)):
+        if not is_within_directory(resolved_dir, self._work_dir):
             return ToolError(
                 message=(
                     f"`{directory}` is outside the working directory. "
@@ -77,14 +75,14 @@ class Glob(CallableTool2[Params]):
         return None
 
     @override
-    async def __call__(self, params: Params) -> ToolReturnType:
+    async def __call__(self, params: Params) -> ToolReturnValue:
         try:
             # Validate pattern safety
             pattern_error = await self._validate_pattern(params.pattern)
             if pattern_error:
                 return pattern_error
 
-            dir_path = Path(params.directory) if params.directory else self._work_dir
+            dir_path = KaosPath(params.directory) if params.directory else self._work_dir
 
             if not dir_path.is_absolute():
                 return ToolError(
@@ -96,30 +94,29 @@ class Glob(CallableTool2[Params]):
                 )
 
             # Validate directory safety
-            dir_error = self._validate_directory(dir_path)
+            dir_error = await self._validate_directory(dir_path)
             if dir_error:
                 return dir_error
 
-            if not dir_path.exists():
+            if not await dir_path.exists():
                 return ToolError(
                     message=f"`{params.directory}` does not exist.",
                     brief="Directory not found",
                 )
-            if not dir_path.is_dir():
+            if not await dir_path.is_dir():
                 return ToolError(
                     message=f"`{params.directory}` is not a directory.",
                     brief="Invalid directory",
                 )
 
-            def _glob(pattern: str) -> list[Path]:
-                return list(dir_path.glob(pattern))
-
             # Perform the glob search - users can use ** directly in pattern
-            matches = await asyncio.to_thread(_glob, params.pattern)
+            matches: list[KaosPath] = []
+            async for match in dir_path.glob(params.pattern):
+                matches.append(match)
 
             # Filter out directories if not requested
             if not params.include_dirs:
-                matches = [p for p in matches if p.is_file()]
+                matches = [p for p in matches if await p.is_file()]
 
             # Sort for consistent output
             matches.sort()

kimi_cli/tools/file/grep.md

@@ -1,5 +1,5 @@
 A powerful search tool based-on ripgrep.
 
 **Tips:**
-- ALWAYS use Grep tool instead of running `grep` or `rg` command with Bash tool.
+- ALWAYS use Grep tool instead of running `grep` or `rg` command with Shell tool.
 - Use the ripgrep pattern syntax, not grep syntax. E.g. you need to escape braces like `\\{` to search for `{`.

kimi_cli/tools/file/{grep.py → grep_local.py}

@@ -1,20 +1,26 @@
+"""
+The local version of the Grep tool using ripgrep.
+Be cautious that `KaosPath` is not used in this implementation.
+"""
+
 import asyncio
-import os
 import platform
 import shutil
 import stat
 import tarfile
 import tempfile
+import zipfile
 from pathlib import Path
 from typing import override
 
 import aiohttp
-import ripgrepy
-from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
+import ripgrepy  # type: ignore[reportMissingTypeStubs]
+from kosong.tooling import CallableTool2, ToolError, ToolReturnValue
 from pydantic import BaseModel, Field
 
 import kimi_cli
 from kimi_cli.share import get_share_dir
+from kimi_cli.tools.utils import ToolResultBuilder, load_desc
 from kimi_cli.utils.aiohttp import new_client_session
 from kimi_cli.utils.logging import logger
 
@@ -113,7 +119,7 @@ _RG_DOWNLOAD_LOCK = asyncio.Lock()
 
 
 def _rg_binary_name() -> str:
-    return "rg.exe" if os.name == "nt" else "rg"
+    return "rg.exe" if platform.system() == "Windows" else "rg"
 
 
 def _find_existing_rg(bin_name: str) -> Path | None:
@@ -121,6 +127,7 @@ def _find_existing_rg(bin_name: str) -> Path | None:
     if share_bin.is_file():
         return share_bin
 
+    assert kimi_cli.__file__ is not None
     local_dep = Path(kimi_cli.__file__).parent / "deps" / "bin" / bin_name
     if local_dep.is_file():
         return local_dep
@@ -148,6 +155,8 @@ def _detect_target() -> str | None:
         os_name = "apple-darwin"
     elif sys_name == "Linux":
         os_name = "unknown-linux-musl" if arch == "x86_64" else "unknown-linux-gnu"
+    elif sys_name == "Windows":
+        os_name = "pc-windows-msvc"
     else:
         logger.error("Unsupported operating system for ripgrep: {sys_name}", sys_name=sys_name)
         return None
@@ -160,7 +169,9 @@ async def _download_and_install_rg(bin_name: str) -> Path:
     if not target:
         raise RuntimeError("Unsupported platform for ripgrep download")
 
-    filename = f"ripgrep-{RG_VERSION}-{target}.tar.gz"
+    is_windows = "windows" in target
+    archive_ext = "zip" if is_windows else "tar.gz"
+    filename = f"ripgrep-{RG_VERSION}-{target}.{archive_ext}"
     url = f"{RG_BASE_URL}/{filename}"
     logger.info("Downloading ripgrep from {url}", url=url)
 
@@ -183,19 +194,30 @@ async def _download_and_install_rg(bin_name: str) -> Path:
                 raise RuntimeError("Failed to download ripgrep binary") from exc
 
             try:
-                with tarfile.open(tar_path, "r:gz") as tar:
-                    member = next(
-                        (m for m in tar.getmembers() if Path(m.name).name == bin_name),
-                        None,
-                    )
-                    if not member:
-                        raise RuntimeError("Ripgrep binary not found in archive")
-                    extracted = tar.extractfile(member)
-                    if not extracted:
-                        raise RuntimeError("Failed to extract ripgrep binary")
-                    with open(destination, "wb") as dest_fh:
-                        shutil.copyfileobj(extracted, dest_fh)
-            except (tarfile.TarError, OSError) as exc:
+                if is_windows:
+                    with zipfile.ZipFile(tar_path, "r") as zf:
+                        member_name = next(
+                            (name for name in zf.namelist() if Path(name).name == bin_name),
+                            None,
+                        )
+                        if not member_name:
+                            raise RuntimeError("Ripgrep binary not found in archive")
+                        with zf.open(member_name) as source, open(destination, "wb") as dest_fh:
+                            shutil.copyfileobj(source, dest_fh)
+                else:
+                    with tarfile.open(tar_path, "r:gz") as tar:
+                        member = next(
+                            (m for m in tar.getmembers() if Path(m.name).name == bin_name),
+                            None,
+                        )
+                        if not member:
+                            raise RuntimeError("Ripgrep binary not found in archive")
+                        extracted = tar.extractfile(member)
+                        if not extracted:
+                            raise RuntimeError("Failed to extract ripgrep binary")
+                        with open(destination, "wb") as dest_fh:
+                            shutil.copyfileobj(extracted, dest_fh)
+            except (zipfile.BadZipFile, tarfile.TarError, OSError) as exc:
                 raise RuntimeError("Failed to extract ripgrep archive") from exc
 
     destination.chmod(destination.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
@@ -220,12 +242,15 @@ async def _ensure_rg_path() -> str:
 
 class Grep(CallableTool2[Params]):
     name: str = "Grep"
-    description: str = (Path(__file__).parent / "grep.md").read_text(encoding="utf-8")
+    description: str = load_desc(Path(__file__).parent / "grep.md")
     params: type[Params] = Params
 
     @override
-    async def __call__(self, params: Params) -> ToolReturnType:
+    async def __call__(self, params: Params) -> ToolReturnValue:
         try:
+            builder = ToolResultBuilder()
+            message = ""
+
             # Initialize ripgrep with pattern and path
             rg_path = await _ensure_rg_path()
             logger.debug("Using ripgrep binary: {rg_bin}", rg_bin=rg_path)
@@ -261,7 +286,7 @@ class Grep(CallableTool2[Params]):
                 rg = rg.count_matches()
 
             # Execute search
-            result = rg.run()
+            result = rg.run(universal_newlines=False)
 
             # Get results
             output = result.as_string
@@ -272,12 +297,15 @@ class Grep(CallableTool2[Params]):
                 if len(lines) > params.head_limit:
                     lines = lines[: params.head_limit]
                     output = "\n".join(lines)
+                    message = f"Results truncated to first {params.head_limit} lines"
                     if params.output_mode in ["content", "files_with_matches", "count_matches"]:
                         output += f"\n... (results truncated to {params.head_limit} lines)"
 
             if not output:
-                return ToolOk(output="", message="No matches found")
-            return ToolOk(output=output)
+                return builder.ok(message="No matches found")
+
+            builder.write(output)
+            return builder.ok(message=message)
 
         except Exception as e:
             return ToolError(

kimi_cli/tools/file/read.md

@@ -3,12 +3,30 @@ Read content from a file.
 **Tips:**
 - Make sure you follow the description of each tool parameter.
 - A `<system>` tag will be given before the read file content.
-- Content will be returned with a line number before each line like `cat -n` format.
-- Use `line_offset` and `n_lines` parameters when you only need to read a part of the file.
-- The maximum number of lines that can be read at once is ${MAX_LINES}.
-- Any lines longer than ${MAX_LINE_LENGTH} characters will be truncated, ending with "...".
-- The system will notify you when there is any limitation hit when reading the file.
+- The system will notify you when there is anything wrong when reading the file.
 - This tool is a tool that you typically want to use in parallel. Always read multiple files in one response when possible.
-- This tool can only read text files. To list directories, you must use the Glob tool or `ls` command via the Bash tool. To read other file types, use appropriate commands via the Bash tool.
+- This tool can only read text, image and video files. To list directories, you must use the Glob tool or `ls` command via the Shell tool. To read other file types, use appropriate commands via the Shell tool.
 - If the file doesn't exist or path is invalid, an error will be returned.
 - If you want to search for a certain content/pattern, prefer Grep tool over ReadFile.
+- For text files:
+  - Content will be returned with a line number before each line like `cat -n` format.
+  - Use `line_offset` and `n_lines` parameters when you only need to read a part of the file.
+  - The maximum number of lines that can be read at once is ${MAX_LINES}.
+  - Any lines longer than ${MAX_LINE_LENGTH} characters will be truncated, ending with "...".
+{% if "image_in" in capabilities and "video_in" in capabilities %}
+- For image and video files:
+  - Content will be returned in a form that you can view and understand. Feel confident to read image/video files with this tool.
+  - The maximum size that can be read is ${MAX_MEDIA_BYTES} bytes. An error will be returned if the file is larger than this limit.
+{% elif "image_in" in capabilities %}
+- For image files:
+  - Content will be returned in a form that you can view and understand. Feel confident to read image files with this tool.
+  - The maximum size that can be read is ${MAX_MEDIA_BYTES} bytes. An error will be returned if the file is larger than this limit.
+- Other media files (e.g., video, PDFs) are not supported by this tool. Use other proper tools to process them.
+{% elif "video_in" in capabilities %}
+- For video files:
+  - Content will be returned in a form that you can view and understand. Feel confident to read video files with this tool.
+  - The maximum size that can be read is ${MAX_MEDIA_BYTES} bytes. An error will be returned if the file is larger than this limit.
+- Other media files (e.g., image, PDFs) are not supported by this tool. Use other proper tools to process them.
+{% else %}
+- Media files (e.g., image, video, PDFs) are not supported by this tool. Use other proper tools to process them.
+{% endif %}