zettcode 0.1.5__tar.gz → 0.1.6__tar.gz

{zettcode-0.1.5 → zettcode-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zettcode
-Version: 0.1.5
+Version: 0.1.6
 Summary: A focused terminal coding agent powered by zett-agent
 Project-URL: Repository, https://github.com/Chang-LeHung/zettcode
 Project-URL: Issues, https://github.com/Chang-LeHung/zettcode/issues

{zettcode-0.1.5 → zettcode-0.1.6}/src/zettcode/__init__.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 #: The one place the version is written. ``pyproject.toml`` reads it from here
 #: and the release workflow checks the tag against it, so a bump is one edit.
-__version__ = "0.1.5"
+__version__ = "0.1.6"
 
 #: Where each public name lives; read by :func:`__getattr__` on first use.
 _EXPORTS = {

{zettcode-0.1.5 → zettcode-0.1.6}/src/zettcode/app/agent/agent/commands.py

@@ -8,6 +8,7 @@ agent is where the shell asks for everything the runtime loaded.
 from __future__ import annotations
 
 from ....plugins import UiRow
+from ....providers import BUILTIN_PROVIDERS, Provider, merge_providers
 from ...commands import Command, CommandContext, CommandResult
 from ..dialogue.mentions import MentionProvider
 from .exports import ExportsMixin
@@ -44,6 +45,11 @@ class CommandsMixin(ExportsMixin):
         """Return the ``@`` resource providers the installed plugins registered."""
         return self.runtime.plugins.mentions
 
+    @property
+    def providers(self) -> tuple[Provider, ...]:
+        """Return the hosts ``/config`` can offer: the built-in ones, then the plugins' own."""
+        return merge_providers(BUILTIN_PROVIDERS, self.runtime.plugins.providers)
+
     @property
     def plugin_failures(self) -> tuple[str, ...]:
         """Return one message per plugin that could not be loaded or activated."""

zettcode-0.1.6/src/zettcode/app/agent/agent/settings.py

@@ -0,0 +1,164 @@
+"""What the reader can change about how the agent runs: model, reasoning effort, shell permission."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+
+from zett_agent.model import ReasoningEffort
+
+from ....config import ModelConfig, _read_models
+from ....config_edit import (
+    ConfigEditError,
+    add_model,
+    file_entries,
+    remove_model,
+    replace_model,
+    write_text_atomically,
+)
+from ....paths import config_path
+from ..permission import PERMISSION_LEVELS, Permission
+from .base import AgentBase
+
+
+class SettingsMixin(AgentBase):
+    """Read and change the model, the reasoning effort, and how much of the shell may run unasked."""
+
+    @property
+    def reduced_motion(self) -> bool:
+        """Return whether decorative animation is disabled."""
+        return self.runtime.config.reduced_motion
+
+    @property
+    def models(self) -> tuple[ModelConfig, ...]:
+        """Return the models available for selection."""
+        return self.runtime.config.models
+
+    @property
+    def active_model(self) -> ModelConfig:
+        """Return the model selected for the next turn."""
+        return self.runtime.active_model
+
+    def find_model(self, name: str) -> ModelConfig | None:
+        """Return the configured model a recorded name stands for, if exactly one does."""
+        return self.runtime.find_model(name)
+
+    def use_model(self, name: str | ModelConfig) -> ModelConfig:
+        """Select a configured model for subsequent turns."""
+        return self.runtime.use_model(name)
+
+    # -- the models in the config file --------------------------------------------------
+    @property
+    def config_file(self) -> Path:
+        """Return the file the models are read from and written to."""
+        return config_path()
+
+    def _read_config_file(self) -> str:
+        """Return the config file's text, or raise :class:`ConfigEditError` saying why not."""
+        path = self.config_file
+        try:
+            return path.read_text(encoding="utf-8")
+        except FileNotFoundError as error:
+            raise ConfigEditError(f"{path} does not exist") from error
+        except (OSError, UnicodeDecodeError) as error:
+            raise ConfigEditError(f"{path} cannot be read: {error}") from error
+
+    def file_models(self) -> tuple[tuple[ModelConfig, Mapping[str, object]], ...]:
+        """Return each model in the file with the keys the file writes for it.
+
+        The file is the source of truth for editing, not the models the session started with: a
+        reader may have changed it by hand since. The keys are what is *written* — a token left to
+        an environment variable is absent — which is what a rewrite has to start from.
+
+        Raises:
+            ConfigEditError: When the file cannot be read, is not valid, or lays its models out in
+                a way the editor cannot safely change.
+        """
+        text = self._read_config_file()
+        path = self.config_file
+        entries = file_entries(text, where=path)
+        try:
+            models = _read_models(entries, path)
+        except ValueError as error:
+            raise ConfigEditError(str(error)) from error
+        return tuple(zip(models, entries, strict=True))
+
+    def _commit_models(self, text: str) -> ModelConfig:
+        """Write the edited text, then make the running session use what it now says.
+
+        The file is written first and the session is changed second, so a write that fails leaves
+        the session as it was, and what the session holds is always something the file holds too.
+        """
+        path = self.config_file
+        try:
+            write_text_atomically(path, text)
+        except OSError as error:
+            raise ConfigEditError(f"{path} could not be written: {error}") from error
+        models = _read_models(file_entries(text, where=path), path)
+        return self.runtime.replace_models(models)
+
+    def add_configured_model(self, entry: Mapping[str, object]) -> ModelConfig:
+        """Add one ``[[models]]`` entry to the file and to this session; return the new model.
+
+        The model in use does not change: adding is not choosing. The new one appears in ``/model``.
+
+        Args:
+            entry: The keys of the new model as the file writes them.
+
+        Raises:
+            ConfigEditError: When the entry is not a model that can be called, or the file cannot
+                be edited. Nothing is written then.
+        """
+        text = add_model(self._read_config_file(), entry, where=self.config_file)
+        self._commit_models(text)
+        return self.runtime.config.models[-1]
+
+    def update_configured_model(self, index: int, entry: Mapping[str, object]) -> ModelConfig:
+        """Rewrite model number ``index`` (from zero) of the file as ``entry``; return the result."""
+        text = replace_model(self._read_config_file(), index, entry, where=self.config_file)
+        self._commit_models(text)
+        return self.runtime.config.models[index]
+
+    def remove_configured_model(self, index: int) -> ModelConfig:
+        """Remove model number ``index`` (from zero) from the file and this session.
+
+        Returns:
+            The model in use afterwards: the one before unless it was the one removed.
+
+        Raises:
+            ConfigEditError: When it is the only model, or the file cannot be edited.
+        """
+        text = remove_model(self._read_config_file(), index, where=self.config_file)
+        return self._commit_models(text)
+
+    @property
+    def effort(self) -> str:
+        """Return the reasoning effort the next request will ask for."""
+        return self.runtime.effort.value
+
+    @property
+    def efforts(self) -> tuple[str, ...]:
+        """Return the reasoning levels the runtime accepts, cheapest first."""
+        return tuple(level.value for level in ReasoningEffort)
+
+    def use_effort(self, name: str) -> str:
+        """Select a reasoning level for later requests and return its value."""
+        return self.runtime.use_effort(name).value
+
+    def approve_all_shell_commands(self) -> None:
+        """Approve every shell command for the rest of this run, without asking."""
+        self.runtime.approve_all_shell_commands()
+
+    @property
+    def permission(self) -> Permission:
+        """Return how much of the shell may run without asking."""
+        return self.runtime.permission
+
+    @property
+    def permissions(self) -> tuple[str, ...]:
+        """Return the permission levels, strictest first."""
+        return tuple(level.value for level in PERMISSION_LEVELS)
+
+    def use_permission(self, name: str | Permission) -> Permission:
+        """Set how much of the shell may run without asking, for the rest of this run."""
+        return self.runtime.use_permission(name)

zettcode-0.1.6/src/zettcode/app/agent/conversation/changes.py

@@ -0,0 +1,64 @@
+"""What a request did to the files, added up: the data behind the summary at the end of a turn."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import PurePath
+
+from .entries import DeleteEntry, Entry, EntryStatus, FileChangeEntry, FileSummary
+
+
+def shown_path(path: str, workspace: PurePath | None) -> str:
+    """Return a file as the reader knows it: relative to the workspace when it is inside it.
+
+    The model names the same file as ``app.py`` in one call and as ``/work/app.py`` in the next, and
+    the summary must not count them twice. Only the text is looked at, never the disk.
+
+    Args:
+        path: The path as the call named it.
+        workspace: The directory the session works in, or ``None`` to leave every path as it is.
+    """
+    if workspace is None or not path:
+        return path
+    candidate = PurePath(path)
+    # Rooted, not only absolute: on Windows ``/work/a.py`` has a root and no drive, which is not
+    # "absolute" to pathlib, and it still has to be compared with the workspace it is inside.
+    if candidate.is_absolute() or candidate.root:
+        try:
+            return candidate.relative_to(workspace).as_posix()
+        except ValueError:
+            return path
+    return candidate.as_posix()
+
+
+def changed_files(entries: Iterable[Entry], workspace: PurePath | None = None) -> tuple[FileSummary, ...]:
+    """Return the files a run of entries changed, each once, in the order they were first touched.
+
+    Only a call that *succeeded* counts: a failed edit changed nothing, and a skipped one never ran.
+    A file changed several times is one row with the totals. A file deleted and then written again is
+    a file that exists, counted from the write, and one written and then deleted is deleted.
+
+    Args:
+        entries: The entries of one request, in order; anything that is not a file change is ignored.
+        workspace: The directory paths are shown relative to.
+    """
+    order: list[str] = []
+    totals: dict[str, FileSummary] = {}
+    for entry in entries:
+        if not isinstance(entry, (FileChangeEntry, DeleteEntry)) or entry.status is not EntryStatus.COMPLETED:
+            continue
+        if not entry.path:
+            continue
+        path = shown_path(entry.path, workspace)
+        if path not in totals:
+            order.append(path)
+            totals[path] = FileSummary(path)
+        current = totals[path]
+        if isinstance(entry, DeleteEntry):
+            totals[path] = FileSummary(path, deleted=True)
+            continue
+        base = FileSummary(path) if current.deleted else current
+        totals[path] = FileSummary(
+            path, base.added + entry.added, base.removed + getattr(entry, "removed", 0), deleted=False
+        )
+    return tuple(totals[path] for path in order)

{zettcode-0.1.5 → zettcode-0.1.6}/src/zettcode/app/agent/conversation/entries.py

@@ -37,6 +37,7 @@ class EntryKind(StrEnum):
             the line it ended on.
         THINKING: Reasoning, or a compaction's summary, with its own clock.
         TOOL: One tool call and its bounded result.
+        CHANGES: The files a request changed, said once when it ends.
     """
 
     WELCOME = "welcome"
@@ -48,6 +49,7 @@ class EntryKind(StrEnum):
     WAIT = "wait"
     THINKING = "thinking"
     TOOL = "tool"
+    CHANGES = "changes"
 
 
 class EntryStatus(StrEnum):
@@ -200,19 +202,117 @@ class ThinkingEntry(TimedEntry):
 
 @dataclass(slots=True, kw_only=True)
 class ToolEntry(TimedEntry):
-    """Expandable tool invocation and bounded result.
+    """One tool call and its bounded result: what every tool has, and nothing only some do.
 
-    ``added`` and ``removed`` are the lines an edit changes, counted from the call's
-    arguments when the row opens; they ride beside the title because the presenter
-    paints them in colours of their own.
+    A tool whose row shows something of its own has an entry of its own that adds it
+    (:class:`ReadEntry`, :class:`WriteEntry`, :class:`EditEntry`); they are all ``tool`` rows,
+    folded and timed alike, and the presenter registry finds the one that draws each by its class.
+    Which class a call gets is decided by the render handler that describes it
+    (:class:`~.rendering.ToolRow`), so nothing here, and nothing in the transcript, names a tool.
     """
 
     kind: EntryKind = field(default=EntryKind.TOOL, init=False)
     call_id: str
     tool: str
     title: str
+    text: str = ""
+    expanded: bool = False
+
+    @property
+    def foldable(self) -> bool:
+        """Return whether there is a body to expand and collapse."""
+        return not self.running and bool(self.text)
+
+
+@dataclass(slots=True, kw_only=True)
+class ReadEntry(ToolEntry):
+    """A file that was read: its body is source code, drawn as the language it is.
+
+    ``language`` names the scanner for the output, or is ``None`` for a file that is not code.
+    """
+
     language: str | None = None
+
+
+@dataclass(slots=True, kw_only=True)
+class FileChangeEntry(ToolEntry):
+    """A tool that changed a file, and the change it made, as rows.
+
+    ``path`` is the file, as the call named it. ``added`` is the number of lines the change adds, drawn
+    beside the title in the colour an addition has. ``diff`` is the change itself (see :data:`~.rendering.DiffRow`), which the row shows in place
+    of the tool's one-line answer once the call has succeeded: the answer says "Wrote 120 bytes", the
+    diff says what was written.
+    """
+
+    path: str = ""
     added: int = 0
+    diff: tuple[tuple[str, str], ...] = ()
+
+    @property
+    def shows_diff(self) -> bool:
+        """Return whether the row's body is its diff: there is one, and the call succeeded.
+
+        A call that failed did not change the file, so a diff of what it meant to do would
+        describe something that did not happen; its error is the body then.
+        """
+        return bool(self.diff) and self.status is EntryStatus.COMPLETED
+
+    @property
+    def foldable(self) -> bool:
+        """Return whether there is a body to expand: the tool's answer, or the diff."""
+        return not self.running and (bool(self.text) or self.shows_diff)
+
+
+@dataclass(slots=True, kw_only=True)
+class WriteEntry(FileChangeEntry):
+    """A file that was written whole: every line of it is an addition.
+
+    The tool overwrites, and what it overwrote is not in the call, so there is nothing to take away
+    from: the diff is the new content as additions, and there is no ``removed`` to count.
+    """
+
+
+@dataclass(slots=True, kw_only=True)
+class EditEntry(FileChangeEntry):
+    """A file that was edited in place: the lines the edits add and remove, and the change.
+
+    ``removed`` is counted from the call's arguments when the row opens, as ``added`` is.
+    """
+
     removed: int = 0
-    text: str = ""
-    expanded: bool = False
+
+
+@dataclass(slots=True, kw_only=True)
+class DeleteEntry(ToolEntry):
+    """A file that was deleted; ``path`` is the file, as the call named it."""
+
+    path: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class FileSummary:
+    """What one request did to one file, in total.
+
+    Attributes:
+        path: The file, relative to the workspace when it is inside it.
+        added: Lines added across every edit and write of it.
+        removed: Lines removed across every edit of it.
+        deleted: The file's last change was its deletion.
+    """
+
+    path: str
+    added: int = 0
+    removed: int = 0
+    deleted: bool = False
+
+
+@dataclass(slots=True, kw_only=True)
+class ChangesEntry(Entry):
+    """The files a request changed, listed once when it ends.
+
+    Never made for a request that changed nothing: a row that says "no changes" would be said after
+    every question.
+    """
+
+    kind: EntryKind = field(default=EntryKind.CHANGES, init=False)
+    files: tuple[FileSummary, ...] = ()