llm-tool-cli 0.2.0__py3-none-any.whl

llm_tool_cli/paths/tests/test_globs.py

@@ -0,0 +1,137 @@
+from pathlib import Path
+
+import pytest
+from pytest_mock import MockerFixture
+
+from llm_tool_cli.paths import FileGlobPattern, ProjectPathId, ProjectRootPath, glob_capture_names, match_glob
+from llm_tool_cli.paths.errors import InvalidGlobPattern, InvalidProjectPath, PathResolutionFailed
+from llm_tool_cli.paths.globs import _compile_glob, _pattern_parts
+
+
+class TestPatternParts:
+    def test_resolves_literal_prefix_before_normalizing_remaining_parts(self, tmp_path: Path) -> None:
+        assert _pattern_parts(FileGlobPattern("nested/../**/*.py"), ProjectRootPath(tmp_path)).unwrap() == (
+            "**",
+            "*.py",
+        )
+
+    def test_root_metacharacters_are_literal(self, tmp_path: Path) -> None:
+        root = tmp_path / "[project]*?"
+        root.mkdir()
+        (root / "link").symlink_to(root)
+
+        assert _pattern_parts(FileGlobPattern("link/*.py"), ProjectRootPath(root)).is_err(InvalidProjectPath)
+
+    def test_resolution_failure_retains_the_cause(self, tmp_path: Path, mocker: MockerFixture) -> None:
+        cause = PermissionError("denied")
+        mocker.patch.object(Path, "resolve", side_effect=cause)
+
+        failure = _pattern_parts(FileGlobPattern("src/*.py"), ProjectRootPath(tmp_path)).unwrap_err()[0]
+
+        assert isinstance(failure, PathResolutionFailed)
+        assert failure.path == str(tmp_path / "src/*.py")
+        assert failure.cause == cause
+
+    @pytest.mark.parametrize("pattern", ["", ".", "../*", "@/../*", "@/", "@/a//b"])
+    def test_invalid_path_is_not_a_pattern(self, tmp_path: Path, pattern: str) -> None:
+        assert _pattern_parts(FileGlobPattern(pattern), ProjectRootPath(tmp_path)).is_err(InvalidProjectPath)
+
+
+class TestCompileGlob:
+    @pytest.mark.parametrize(
+        ("pattern", "matching", "nonmatching", "recursive"),
+        [
+            ("*.py", "a.py", "dir/a.py", False),
+            ("a?.py", "a1.py", "a/1.py", False),
+            ("[ab].py", "a.py", "c.py", False),
+            ("[!a].py", "b.py", "a.py", False),
+            ("[a-z].py", "b.py", "B.py", False),
+            ("star[*].py", "star*.py", "starfile.py", False),
+            ("[[]file].py", "[file].py", "file.py", False),
+            ("[]].py", "].py", "a.py", False),
+            ("[**].py", "*.py", "dir/a.py", False),
+            ("[abc", "[abc", "a", False),
+            ("[a/b]", "[a/b]", "a", False),
+            ("**/*.py", "a.py", "a.txt", True),
+            ("a**.py", "a/deep/file.py", "b.py", True),
+            ("**", "line\nbreak.py", "", True),
+            ("{variable}", "{variable}", "value", False),
+            ("a\\b", "a\\b", "a/b", False),
+        ],
+    )
+    def test_wildcard_semantics(self, pattern: str, matching: str, nonmatching: str, recursive: bool) -> None:
+        compiled, actual_recursive = _compile_glob(FileGlobPattern(pattern)).unwrap()
+
+        assert compiled.fullmatch(matching) is not None
+        if nonmatching:
+            assert compiled.fullmatch(nonmatching) is None
+        assert actual_recursive == recursive
+
+    @pytest.mark.parametrize("pattern", ["{*bad-name}", "{**}", "{***name}", "{*unclosed", "{*x}/{**x}"])
+    def test_invalid_captures_return_diagnostics(self, pattern: str) -> None:
+        failure = _compile_glob(FileGlobPattern(pattern)).unwrap_err()[0]
+
+        assert isinstance(failure, InvalidGlobPattern)
+        assert failure.code == "invalid_glob_pattern"
+        assert failure.pattern == pattern
+        assert failure.reason
+
+
+class TestGlobCaptureNames:
+    def test_extracts_captures_without_interpreting_templates_or_escaped_stars(self) -> None:
+        assert glob_capture_names(FileGlobPattern("{base}/{**package}/{*module}.py")).unwrap() == {
+            "package",
+            "module",
+        }
+        assert glob_capture_names(FileGlobPattern("{[*]literal}.py")).unwrap() == set()
+        assert glob_capture_names(FileGlobPattern("")).unwrap() == set()
+
+    def test_invalid_capture_names_are_rejected(self) -> None:
+        assert glob_capture_names(FileGlobPattern("{*bad-name}")).is_err(InvalidGlobPattern)
+
+
+class TestMatchGlob:
+    @pytest.mark.parametrize(
+        ("pattern", "path", "expected"),
+        [
+            ("src/{**package}/{*module}.py", "@/src/core/api.py", {"package": "core", "module": "api"}),
+            ("src/{**package}/{*module}.py", "@/src/api.py", {"package": "", "module": "api"}),
+            ("src/{**module_path}.py", "@/src/core/api.py", {"module_path": "core/api"}),
+            ("src/{**module_path}.py", "@/src/api.py", {"module_path": "api"}),
+            ("src/{*module}.py", "@/src/core/api.py", None),
+            ("src/{*module}.py", "@/src/.py", {"module": ""}),
+            ("src/{**package}/{*module}.py", "@/src/one/two/api.py", {"package": "one/two", "module": "api"}),
+            ("src/*.py", "@/src/file.py", {}),
+            ("src/**", "@/src", None),
+        ],
+    )
+    def test_matches_missing_references(
+        self, tmp_path: Path, pattern: str, path: str, expected: dict[str, str] | None
+    ) -> None:
+        assert match_glob(ProjectPathId(path), FileGlobPattern(pattern), tmp_path).unwrap() == expected
+
+    def test_does_not_resolve_glob_syntax_as_a_symlink(self, tmp_path: Path) -> None:
+        (tmp_path / "src").mkdir()
+        (tmp_path / "src/*.py").symlink_to(tmp_path / "missing")
+
+        assert match_glob(ProjectPathId("@/src/a.py"), FileGlobPattern("@/src/*.py"), tmp_path).unwrap() == {}
+
+    @pytest.mark.parametrize("pattern", ["link/*.py", "link/../*.py", "@/link/*.py"])
+    def test_literal_symlink_prefix_is_rejected(self, tmp_path: Path, pattern: str) -> None:
+        (tmp_path / "link").symlink_to(tmp_path)
+
+        assert match_glob(ProjectPathId("@/a.py"), FileGlobPattern(pattern), tmp_path).is_err(InvalidProjectPath)
+
+    def test_root_resolution_precedes_pattern_validation(self, tmp_path: Path) -> None:
+        root = tmp_path / "loop"
+        root.symlink_to(root)
+
+        assert match_glob(ProjectPathId("@/a.py"), FileGlobPattern("@/../*"), root).is_err(PathResolutionFailed)
+
+    def test_absolute_and_home_patterns(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("HOME", str(tmp_path))
+        for pattern in [str(tmp_path / "*.py"), "~/*.py"]:
+            assert match_glob(ProjectPathId("@/a.py"), FileGlobPattern(pattern), tmp_path).unwrap() == {}
+
+    def test_syntax_failures_are_preserved(self, tmp_path: Path) -> None:
+        assert match_glob(ProjectPathId("@/a.py"), FileGlobPattern("{*bad-name}"), tmp_path).is_err(InvalidGlobPattern)

llm_tool_cli/paths/tests/test_normalization.py

@@ -0,0 +1,163 @@
+from pathlib import Path
+
+import pytest
+
+from llm_tool_cli.paths import is_project_path_id, normalize_project_path_id, project_path_parts
+from llm_tool_cli.paths.errors import InvalidProjectPath
+
+
+class TestProjectPathParts:
+    @pytest.mark.parametrize(
+        ("value", "expected"),
+        [
+            ("@/LICENSE", ("LICENSE",)),
+            ("@/notes/Project Plan.md", ("notes", "Project Plan.md")),
+            ("@/Case/FILE", ("Case", "FILE")),
+            ("@/café/資料", ("café", "資料")),
+            ("@/ directory / file ", (" directory ", " file ")),
+            ("@/a/.../b", ("a", "...", "b")),
+            ("@/~/file", ("~", "file")),
+            ("@/a\\b/file", ("a\\b", "file")),
+            ("@/name:section", ("name:section",)),
+            ("@/src/{**package}/*.[pP][yY]", ("src", "{**package}", "*.[pP][yY]")),
+        ],
+    )
+    def test_extracts_components(self, value: str, expected: tuple[str, ...]) -> None:
+        identifier = normalize_project_path_id(value).unwrap()
+
+        assert project_path_parts(identifier) == expected
+
+
+class TestIsProjectPathId:
+    @pytest.mark.parametrize(
+        "value",
+        [
+            "@/README.md",
+            "@/README",
+            "@/LICENSE",
+            "@/Makefile",
+            "@/assets",
+            "@/assets/archive",
+            "@/src/package",
+            "@/notes/Проектный план",
+            "@/notes/project plan.md",
+            "@/Case/FILE",
+            "@/ directory / file ",
+            "@/a/.../b",
+            "@/~/file",
+            "@/a\\b/file",
+            "@/name:section",
+            "@/src/{**package_path}/*.[pP][yY]",
+        ],
+    )
+    def test_accepts_canonical_project_paths(self, value: str) -> None:
+        assert is_project_path_id(value)
+
+    @pytest.mark.parametrize(
+        "value",
+        [
+            "",
+            "@",
+            "@file",
+            "file",
+            "./file",
+            "/project/file",
+            " @/file",
+            "@/",
+            "@/.",
+            "@/..",
+            "@//file",
+            "@/a//b",
+            "@/a/",
+            "@/a/..",
+            "@/../a",
+            "@/a/../../a",
+        ],
+    )
+    def test_rejects_malformed_project_paths(self, value: str) -> None:
+        assert not is_project_path_id(value)
+
+    @pytest.mark.parametrize("value", ["@/./a", "@/a/.", "@/a/../b", "@/a/b/.."])
+    def test_rejects_paths_requiring_normalization(self, value: str) -> None:
+        assert not is_project_path_id(value)
+
+    @pytest.mark.parametrize("value", [None, 1, b"@/file", [], {}, Path("@/file")])
+    def test_rejects_non_strings(self, value: object) -> None:
+        assert not is_project_path_id(value)
+
+
+class TestNormalizeProjectPathId:
+    @pytest.mark.parametrize(
+        ("value", "expected"),
+        [
+            ("@/file", "@/file"),
+            ("@/a/./b/../c", "@/a/c"),
+            ("@/./a", "@/a"),
+            ("@/a/.", "@/a"),
+            ("@/a/b/..", "@/a"),
+            ("@/a/../b", "@/b"),
+            ("@/a/b/../../c", "@/c"),
+        ],
+    )
+    def test_normalization(self, value: str, expected: str) -> None:
+        normalized = normalize_project_path_id(value).unwrap()
+
+        assert normalized == expected
+        assert normalize_project_path_id(normalized).unwrap() == normalized
+
+    @pytest.mark.parametrize(
+        "value",
+        [
+            "",
+            "@",
+            "@file",
+            "file",
+            "./file",
+            "/file",
+            " @/file",
+            "@/",
+            "@/.",
+            "@/..",
+            "@//file",
+            "@/a//b",
+            "@/a/",
+            "@/a/..",
+            "@/a/../.",
+            "@/../a",
+            "@/a/../../a",
+        ],
+    )
+    def test_invalid_path(self, value: str) -> None:
+        errors = normalize_project_path_id(value).unwrap_err()
+
+        assert len(errors) == 1
+        error = errors[0]
+        assert isinstance(error, InvalidProjectPath)
+        assert error.code == "invalid_project_path"
+        assert error.path == value.strip()
+
+    @pytest.mark.parametrize(
+        "value",
+        [
+            "@/Case/FILE",
+            "@/café/資料",
+            "@/ directory / file ",
+            "@/a/.../b",
+            "@/~/file",
+            "@/a\\b/file",
+            "@/name:section",
+            "@/src/{**package_path}/*.[pP][yY]",
+        ],
+    )
+    def test_preserves_segment_text(self, value: str) -> None:
+        assert normalize_project_path_id(value).unwrap() == value
+
+    def test_structured_error(self) -> None:
+        error = normalize_project_path_id("@/../file").unwrap_err()[0]
+
+        assert error.as_record() == {
+            "type": "error",
+            "code": "invalid_project_path",
+            "message": error.format_message(),
+            "path": "@/../file",
+        }

llm_tool_cli/protocol/__init__.py

@@ -0,0 +1,4 @@
+from llm_tool_cli.protocol.entities import Protocol
+from llm_tool_cli.protocol.serialization import to_jsonl
+
+__all__ = ["Protocol", "to_jsonl"]

llm_tool_cli/protocol/cell_shortcuts.py

@@ -0,0 +1,39 @@
+from llm_tool_cli.core.errors import EnvironmentError
+from llm_tool_cli.paths import ProjectConfigPath
+from llm_tool_cli.protocol.logic_cells import ContentCell, EnvironmentErrorCell
+from llm_tool_cli.protocol.output_cells.base import MetaValue
+
+
+def operation_succeeded(message: str, **meta: MetaValue) -> ContentCell:
+    return ContentCell(
+        kind="operation_succeeded",
+        media_type="text/markdown",
+        content=message,
+        meta={"type": "operation_succeeded", **meta},
+    )
+
+
+def configuration_created(path: ProjectConfigPath) -> ContentCell:
+    return operation_succeeded("Configuration created.", path=str(path))
+
+
+def operation_failed(message: str, **meta: MetaValue) -> ContentCell:
+    return ContentCell(kind="operation_failed", media_type="text/markdown", content=message, meta=meta)
+
+
+def info(message: str, **meta: MetaValue) -> ContentCell:
+    return ContentCell(kind="info", media_type="text/markdown", content=message, meta=meta)
+
+
+def skill(document: str, content: str) -> ContentCell:
+    return ContentCell(
+        kind="skill", media_type="text/markdown", content=content, meta={"type": "skill", "document": document}
+    )
+
+
+def version(value: str) -> ContentCell:
+    return ContentCell(kind="version", meta={"type": "version", "version": value})
+
+
+def environment_error(error: EnvironmentError) -> EnvironmentErrorCell:
+    return EnvironmentErrorCell(error=error)

llm_tool_cli/protocol/entities.py

@@ -0,0 +1,7 @@
+import enum
+
+
+class Protocol(enum.StrEnum):
+    human = "human"
+    llm = "llm"
+    automation = "automation"

llm_tool_cli/protocol/errors.py

@@ -0,0 +1,21 @@
+"""Internal failures in output protocol construction and formatting."""
+
+from typing import ClassVar
+
+from llm_tool_cli.core import errors as core_errors
+
+
+class InternalError(core_errors.InternalError):
+    """Base for internal output protocol failures."""
+
+
+class ContentWithoutMediaType(InternalError):
+    message_template: ClassVar[str] = "Cannot set content when media_type is None."
+
+
+class UnsupportedFormatterMode(InternalError):
+    message_template: ClassVar[str] = "Formatter for mode '{mode}' is not implemented."
+
+
+class JournalConversionUnsupported(InternalError):
+    message_template: ClassVar[str] = "Cell '{cell_type}' does not support journal conversion."

llm_tool_cli/protocol/journal.py

@@ -0,0 +1,21 @@
+import datetime
+
+import pydantic
+
+from llm_tool_cli.core.entities import BaseEntity
+
+
+class JournalRecord(BaseEntity):
+    """Protocol-independent journal data, ready for an external processor."""
+
+    message: str
+    timestamp: datetime.datetime = pydantic.Field(default_factory=lambda: datetime.datetime.now(datetime.UTC))
+    actor_id: str | None = None
+    attributes: dict[str, pydantic.JsonValue] = pydantic.Field(default_factory=dict)
+
+    def as_dict(self) -> dict[str, pydantic.JsonValue]:
+        """Flatten attributes without allowing them to replace common fields."""
+        fields = self.model_dump(mode="json")
+        attributes = fields.pop("attributes")
+        fields["timestamp"] = self.timestamp.isoformat()
+        return {**attributes, **fields}

llm_tool_cli/protocol/logic_cells/__init__.py

@@ -0,0 +1,4 @@
+from llm_tool_cli.protocol.logic_cells.content import ContentCell
+from llm_tool_cli.protocol.logic_cells.environment_error import EnvironmentErrorCell
+
+__all__ = ["ContentCell", "EnvironmentErrorCell"]

llm_tool_cli/protocol/logic_cells/base.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from typing import assert_never
+
+import pydantic
+
+from llm_tool_cli.core.entities import BaseEntity
+from llm_tool_cli.protocol.entities import Protocol
+from llm_tool_cli.protocol.errors import JournalConversionUnsupported
+from llm_tool_cli.protocol.journal import JournalRecord
+from llm_tool_cli.protocol.output_cells.base import OutputCell
+
+
+class LogicCell(BaseEntity, ABC):
+    """Application data projected into prepared output cells for a protocol."""
+
+    is_journal: bool = pydantic.Field(default=False, exclude=True)
+    is_warning: bool = pydantic.Field(default=False, exclude=True)
+
+    def to_journal_record(self) -> JournalRecord:
+        """Journal-capable cells must describe their event explicitly."""
+        raise JournalConversionUnsupported(details={"cell_type": type(self).__name__})
+
+    def render(self, protocol: Protocol) -> list[OutputCell]:
+        match protocol:
+            case Protocol.human:
+                return self.render_human()
+            case Protocol.llm:
+                return self.render_llm()
+            case Protocol.automation:
+                return self.render_automation()
+            case _:
+                assert_never(protocol)
+
+    @abstractmethod
+    def render_human(self) -> list[OutputCell]: ...  # noqa: E704
+
+    @abstractmethod
+    def render_llm(self) -> list[OutputCell]: ...  # noqa: E704
+
+    @abstractmethod
+    def render_automation(self) -> list[OutputCell]: ...  # noqa: E704

llm_tool_cli/protocol/logic_cells/content.py

@@ -0,0 +1,26 @@
+from typing import Literal, Self
+
+import pydantic
+
+from llm_tool_cli.protocol.errors import ContentWithoutMediaType
+from llm_tool_cli.protocol.logic_cells.uniform import UniformCell
+from llm_tool_cli.protocol.output_cells.base import MetaValue, OutputCell
+
+
+class ContentCell(UniformCell):
+    """Prepared content and metadata shared by all output protocols."""
+
+    is_journal: Literal[False] = pydantic.Field(default=False, exclude=True)
+    kind: str
+    media_type: str | None = None
+    content: str | None = None
+    meta: dict[str, MetaValue] = pydantic.Field(default_factory=dict)
+
+    @pydantic.model_validator(mode="after")
+    def validate_content(self) -> Self:
+        if self.media_type is None and self.content is not None:
+            raise ContentWithoutMediaType()
+        return self
+
+    def _render(self, cell_type: type[OutputCell]) -> OutputCell:
+        return cell_type(kind=self.kind, media_type=self.media_type, content=self.content, meta=self.meta)

llm_tool_cli/protocol/logic_cells/environment_error.py

@@ -0,0 +1,36 @@
+from llm_tool_cli.core.errors import EnvironmentError
+from llm_tool_cli.protocol.journal import JournalRecord
+from llm_tool_cli.protocol.logic_cells.uniform import UniformCell
+from llm_tool_cli.protocol.output_cells import HumanErrorOutputCell
+from llm_tool_cli.protocol.output_cells.base import OutputCell, to_meta_value
+
+
+class EnvironmentErrorCell(UniformCell):
+    """An operational failure retained as typed data until projection."""
+
+    error: EnvironmentError
+
+    def render_human(self) -> list[OutputCell]:
+        return [self._render(HumanErrorOutputCell)]
+
+    def to_journal_record(self) -> JournalRecord:
+        fields = self.error.as_record()
+        message = str(fields.pop("message"))
+        # Native error records already contain JSON-compatible serialized context.
+        return JournalRecord(message=message, attributes=fields)  # type: ignore[arg-type]
+
+    def _render(self, cell_type: type[OutputCell]) -> OutputCell:
+        record = self.error.as_record()
+        content = str(record.pop("message"))
+        fixes = [fix.format(error=self.error).strip() for fix in self.error.ways_to_fix]
+        if len(fixes) == 1:
+            content = f"{content}\nWay to fix: {fixes[0]}"
+        elif fixes:
+            guidance = "\n".join(f"- {fix}" for fix in fixes)
+            content = f"{content}\n\nWays to fix:\n\n{guidance}"
+        return cell_type(
+            kind="error",
+            media_type="text/markdown",
+            content=content,
+            meta={key: to_meta_value(value) for key, value in record.items()},
+        )

llm_tool_cli/protocol/logic_cells/journal.py

@@ -0,0 +1,44 @@
+import datetime
+
+import pydantic
+
+from llm_tool_cli.protocol.journal import JournalRecord
+from llm_tool_cli.protocol.logic_cells.base import LogicCell
+from llm_tool_cli.protocol.output_cells.base import OutputCell, to_meta_value
+from llm_tool_cli.protocol.output_cells.journal import JournalAutomationOutputCell, JournalTextOutputCell
+
+
+class JournalCell(LogicCell):
+    """A journal event with compact text and structured automation projections."""
+
+    is_journal: bool = pydantic.Field(default=True, exclude=True)
+    timestamp: datetime.datetime = pydantic.Field(default_factory=lambda: datetime.datetime.now(datetime.UTC))
+    actor_id: str | None = None
+    message: str
+
+    def to_journal_record(self) -> JournalRecord:
+        return JournalRecord(
+            message=self.message,
+            timestamp=self.timestamp,
+            actor_id=self.actor_id,
+            attributes=self.model_dump(mode="json", exclude={"message", "timestamp", "actor_id"}),
+        )
+
+    def human_line(self) -> str:
+        return f"{self.timestamp.time().isoformat('seconds')} <{self.actor_id or '-'}> {self.message}"
+
+    def llm_line(self) -> str:
+        return f"{self.timestamp.isoformat()} <{self.actor_id or '-'}> {self.message}"
+
+    def render_human(self) -> list[OutputCell]:
+        return [JournalTextOutputCell.build(kind="journal", media_type="text/plain", content=self.human_line())]
+
+    def render_llm(self) -> list[OutputCell]:
+        return [JournalTextOutputCell.build(kind="journal", media_type="text/plain", content=self.llm_line())]
+
+    def render_automation(self) -> list[OutputCell]:
+        return [
+            JournalAutomationOutputCell.build_meta(
+                kind="journal", **{key: to_meta_value(value) for key, value in self.model_dump(mode="json").items()}
+            )
+        ]

llm_tool_cli/protocol/logic_cells/tests/test_base.py

@@ -0,0 +1,47 @@
+import pytest
+
+from llm_tool_cli.protocol import Protocol
+from llm_tool_cli.protocol.errors import JournalConversionUnsupported
+from llm_tool_cli.protocol.logic_cells.base import LogicCell
+from llm_tool_cli.protocol.output_cells import AutomationOutputCell, HumanOutputCell
+from llm_tool_cli.protocol.output_cells.base import OutputCell
+
+
+class ExampleLogicCell(LogicCell):
+    items: tuple[str, ...]
+
+    def render_human(self) -> list[OutputCell]:
+        return [HumanOutputCell.build_markdown(kind="item", content=item) for item in self.items]
+
+    def render_llm(self) -> list[OutputCell]:
+        return []
+
+    def render_automation(self) -> list[OutputCell]:
+        return [AutomationOutputCell.build_meta(kind="items", items=list(self.items))]
+
+
+class TestLogicCell:
+    def test_to_journal_record__unsupported_conversion_is_explicit(self) -> None:
+        cell = ExampleLogicCell(items=("first", "second"))
+
+        with pytest.raises(JournalConversionUnsupported) as caught:
+            cell.to_journal_record()
+
+        assert caught.value.details == {"cell_type": "ExampleLogicCell"}
+
+    @pytest.mark.parametrize(
+        ("protocol", "expected"),
+        (
+            (Protocol.human, [("item", "first"), ("item", "second")]),
+            (Protocol.llm, []),
+            (Protocol.automation, [("items", None)]),
+        ),
+    )
+    def test_render__dispatches_to_protocol_projection(
+        self, protocol: Protocol, expected: list[tuple[str, str | None]]
+    ) -> None:
+        cell = ExampleLogicCell(items=("first", "second"))
+
+        result = cell.render(protocol)
+
+        assert [(output.kind, output.content) for output in result] == expected

llm_tool_cli/protocol/logic_cells/tests/test_content.py

@@ -0,0 +1,59 @@
+import pydantic
+import pytest
+
+from llm_tool_cli.protocol import Protocol
+from llm_tool_cli.protocol.errors import ContentWithoutMediaType
+from llm_tool_cli.protocol.logic_cells import ContentCell
+from llm_tool_cli.protocol.output_cells import AutomationOutputCell, HumanOutputCell, LLMOutputCell
+from llm_tool_cli.protocol.output_cells.base import OutputCell
+
+
+class TestContentCell:
+    def test_validation__prohibits_journaling_generic_content(self) -> None:
+        with pytest.raises(pydantic.ValidationError):
+            ContentCell.model_validate({"kind": "document", "is_journal": True})
+
+    @pytest.mark.parametrize(
+        ("protocol", "cell_type"),
+        [
+            (Protocol.human, HumanOutputCell),
+            (Protocol.llm, LLMOutputCell),
+            (Protocol.automation, AutomationOutputCell),
+        ],
+    )
+    @pytest.mark.parametrize(("media_type", "content"), [("text/markdown", "café"), (None, None), ("text/plain", "")])
+    def test_render__preserves_payload_and_creates_fresh_output(
+        self, protocol: Protocol, cell_type: type[OutputCell], media_type: str | None, content: str | None
+    ) -> None:
+        cell = ContentCell(
+            kind="item",
+            media_type=media_type,
+            content=content,
+            meta={"labels": ["one", "two"], "enabled": True, "empty": None},
+        )
+        original = cell.model_dump()
+
+        first = cell.render(protocol)
+        second = cell.render(protocol)
+
+        assert len(first) == len(second) == 1
+        assert isinstance(first[0], cell_type)
+        assert isinstance(second[0], cell_type)
+        assert first[0].model_dump(exclude={"id"}) == second[0].model_dump(exclude={"id"}) == original
+        assert first[0].id.version == second[0].id.version == 4
+        assert first[0].id != second[0].id
+        assert cell.model_dump() == original
+
+    @pytest.mark.parametrize("content", ["text", ""])
+    def test_validate_content__rejects_missing_media_type(self, content: str) -> None:
+        with pytest.raises(ContentWithoutMediaType):
+            ContentCell(kind="item", content=content)
+
+    def test_render__preserves_reserved_metadata_fields(self) -> None:
+        cell = ContentCell(kind="item", meta={"id": "custom", "content": "metadata", "kind": "metadata_kind"})
+
+        output = cell.render(Protocol.automation)[0]
+
+        assert output.kind == "item"
+        assert output.content is None
+        assert output.meta == cell.meta