zettcode 0.1.0__py3-none-any.whl

zettcode/tui_framework/events.py

@@ -0,0 +1,37 @@
+"""Framework input events."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class EventType(StrEnum):
+    KEY = "key"
+    TEXT = "text"
+    PASTE = "paste"
+    MOUSE = "mouse"
+    RESIZE = "resize"
+    RENDER = "render"
+
+
+class MouseAction(StrEnum):
+    DOWN = "down"
+    UP = "up"
+    MOVE = "move"
+    SCROLL_UP = "scroll_up"
+    SCROLL_DOWN = "scroll_down"
+
+
+@dataclass(frozen=True, slots=True)
+class InputEvent:
+    type: EventType
+    key: str = ""
+    text: str = ""
+    x: int = 0
+    y: int = 0
+    button: int = 0
+    action: MouseAction | None = None
+    shift: bool = False
+    alt: bool = False
+    control: bool = False

zettcode/tui_framework/input.py

@@ -0,0 +1,163 @@
+"""Incremental terminal byte-stream decoder."""
+
+from __future__ import annotations
+
+import re
+
+from .events import EventType, InputEvent, MouseAction
+
+_MOUSE = re.compile(rb"^\x1b\[<(\d+);(\d+);(\d+)([Mm])")
+_KEYS = {
+    b"\x1b[A": "up",
+    b"\x1b[B": "down",
+    b"\x1b[C": "right",
+    b"\x1b[D": "left",
+    b"\x1b[H": "home",
+    b"\x1b[F": "end",
+    b"\x1b[1~": "home",
+    b"\x1b[4~": "end",
+    b"\x1b[5~": "page_up",
+    b"\x1b[6~": "page_down",
+    b"\x1b[3~": "delete",
+    b"\x1b[2~": "insert",
+    b"\x1b[Z": "backtab",
+    b"\x1b[1;5D": "ctrl_left",
+    b"\x1b[1;5C": "ctrl_right",
+    b"\x1b[1;3D": "alt_left",
+    b"\x1b[1;3C": "alt_right",
+    b"\x1b[1;5H": "ctrl_home",
+    b"\x1b[1;5F": "ctrl_end",
+}
+_CONTROL_KEYS = {
+    0x01: "ctrl_a",
+    0x02: "ctrl_b",
+    0x03: "ctrl_c",
+    0x04: "ctrl_d",
+    0x05: "ctrl_e",
+    0x06: "ctrl_f",
+    0x07: "ctrl_g",
+    0x09: "tab",
+    0x0A: "enter",
+    0x0B: "ctrl_k",
+    0x0C: "ctrl_l",
+    0x0D: "enter",
+    0x0E: "ctrl_n",
+    0x10: "ctrl_p",
+    0x12: "ctrl_r",
+    0x14: "ctrl_t",
+    0x15: "ctrl_u",
+    0x17: "ctrl_w",
+    0x19: "ctrl_y",
+    0x1A: "ctrl_z",
+    0x1F: "ctrl_underscore",
+    0x7F: "backspace",
+    0x08: "backspace",
+}
+
+
+class InputDecoder:
+    """Decode fragmented UTF-8, keyboard, paste, and SGR mouse input."""
+
+    def __init__(self) -> None:
+        self.buffer = bytearray()
+
+    def feed(self, data: bytes) -> list[InputEvent]:
+        self.buffer.extend(data)
+        events: list[InputEvent] = []
+        while self.buffer:
+            event, consumed, incomplete = self._next()
+            if incomplete:
+                break
+            if consumed == 0:
+                consumed = 1
+            del self.buffer[:consumed]
+            if event is not None:
+                events.append(event)
+        return events
+
+    def flush_escape(self) -> InputEvent | None:
+        """Resolve an isolated ESC after the terminal's sequence timeout."""
+        if self.buffer == b"\x1b":
+            self.buffer.clear()
+            return InputEvent(EventType.KEY, key="escape")
+        return None
+
+    def _next(self) -> tuple[InputEvent | None, int, bool]:
+        data = bytes(self.buffer)
+        if data.startswith(b"\x1b[200~"):
+            end = data.find(b"\x1b[201~", 6)
+            if end < 0:
+                return None, 0, True
+            return InputEvent(EventType.PASTE, text=data[6:end].decode("utf-8", "replace")), end + 6, False
+
+        mouse = _MOUSE.match(data)
+        if mouse:
+            code, x, y = (int(mouse.group(index)) for index in (1, 2, 3))
+            suffix = mouse.group(4)
+            action = _mouse_action(code, suffix)
+            return (
+                InputEvent(
+                    EventType.MOUSE,
+                    x=max(0, x - 1),
+                    y=max(0, y - 1),
+                    button=code & 3,
+                    action=action,
+                    shift=bool(code & 4),
+                    alt=bool(code & 8),
+                    control=bool(code & 16),
+                ),
+                mouse.end(),
+                False,
+            )
+
+        for sequence, key in sorted(_KEYS.items(), key=lambda item: len(item[0]), reverse=True):
+            if data.startswith(sequence):
+                return InputEvent(EventType.KEY, key=key), len(sequence), False
+            if sequence.startswith(data):
+                return None, 0, True
+
+        first = data[0]
+        if first in _CONTROL_KEYS:
+            return InputEvent(EventType.KEY, key=_CONTROL_KEYS[first]), 1, False
+        if first == 0x1B:
+            if len(data) == 1:
+                return None, 0, True
+            if data[1] in (0x0A, 0x0D):
+                return InputEvent(EventType.KEY, key="alt_enter"), 2, False
+            if data[1] in (0x08, 0x7F):
+                return InputEvent(EventType.KEY, key="alt_backspace"), 2, False
+            if 0x20 <= data[1] < 0x7F:
+                return InputEvent(EventType.KEY, key=chr(data[1]), alt=True), 2, False
+            return InputEvent(EventType.KEY, key="escape"), 1, False
+        if first < 0x20:
+            return None, 1, False
+
+        length = _utf8_length(first)
+        if len(data) < length:
+            return None, 0, True
+        try:
+            text = data[:length].decode("utf-8")
+        except UnicodeDecodeError:
+            text = "�"
+            length = 1
+        return InputEvent(EventType.TEXT, text=text), length, False
+
+
+def _utf8_length(first: int) -> int:
+    if first < 0x80:
+        return 1
+    if first & 0xE0 == 0xC0:
+        return 2
+    if first & 0xF0 == 0xE0:
+        return 3
+    if first & 0xF8 == 0xF0:
+        return 4
+    return 1
+
+
+def _mouse_action(code: int, suffix: bytes) -> MouseAction:
+    if code & 64:
+        return MouseAction.SCROLL_DOWN if code & 1 else MouseAction.SCROLL_UP
+    if code & 32:
+        return MouseAction.MOVE
+    return MouseAction.UP if suffix == b"m" else MouseAction.DOWN

zettcode/tui_framework/screen.py

@@ -0,0 +1,214 @@
+"""Cell canvas and ANSI differential renderer."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from io import StringIO
+from typing import TextIO
+
+from wcwidth import wcwidth
+
+
+@dataclass(frozen=True, slots=True)
+class Style:
+    """Terminal style independent from ANSI encoding."""
+
+    foreground: str | None = None
+    background: str | None = None
+    bold: bool = False
+    italic: bool = False
+    dim: bool = False
+    reverse: bool = False
+
+
+DEFAULT_STYLE = Style()
+
+
+@dataclass(frozen=True, slots=True)
+class Span:
+    """One styled text fragment."""
+
+    text: str
+    style: Style = DEFAULT_STYLE
+
+
+@dataclass(frozen=True, slots=True)
+class TextLine:
+    """One logical line with optional component-owned metadata."""
+
+    spans: tuple[Span, ...] = ()
+    metadata: object | None = None
+
+    @property
+    def text(self) -> str:
+        return "".join(span.text for span in self.spans)
+
+
+@dataclass(frozen=True, slots=True)
+class Cell:
+    """One terminal column; wide glyph tails use continuation=True."""
+
+    character: str = " "
+    style: Style = DEFAULT_STYLE
+    continuation: bool = False
+
+
+@dataclass(slots=True)
+class Canvas:
+    """Clipped two-dimensional cell buffer."""
+
+    width: int
+    height: int
+    cells: list[list[Cell]] = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.cells = [[Cell() for _ in range(self.width)] for _ in range(self.height)]
+
+    def set_cell(self, x: int, y: int, character: str, style: Style = DEFAULT_STYLE) -> int:
+        """Draw one printable glyph and return its display width."""
+        character_width = wcwidth(character)
+        # Never let model or tool output inject terminal control sequences into
+        # the renderer. Combining marks are the only zero-width input retained.
+        if character_width < 0:
+            character = "�"
+            character_width = 1
+        if not (0 <= y < self.height) or x >= self.width:
+            return character_width
+        width = character_width
+        if width == 0:
+            if x > 0:
+                previous = self.cells[y][x - 1]
+                self.cells[y][x - 1] = Cell(previous.character + character, previous.style, previous.continuation)
+            return 0
+        if x < 0 or x + width > self.width:
+            return width
+        self.cells[y][x] = Cell(character, style)
+        for offset in range(1, width):
+            self.cells[y][x + offset] = Cell("", style, continuation=True)
+        return width
+
+    def draw_text(
+        self,
+        x: int,
+        y: int,
+        text: str,
+        style: Style = DEFAULT_STYLE,
+        *,
+        max_width: int | None = None,
+        tab_size: int = 4,
+    ) -> int:
+        """Draw one unwrapped line and return consumed columns."""
+        used = 0
+        limit = self.width - x if max_width is None else min(max_width, self.width - x)
+        for character in text:
+            if character in "\r\n":
+                break
+            if character == "\t":
+                spaces = tab_size - ((x + used) % tab_size)
+                spaces = min(spaces, max(0, limit - used))
+                self.fill(x + used, y, spaces, 1, style)
+                used += spaces
+                continue
+            width = wcwidth(character)
+            width = width if width >= 0 else 1
+            if used + width > limit:
+                break
+            self.set_cell(x + used, y, character, style)
+            used += width
+        return used
+
+    def draw_spans(self, x: int, y: int, spans: tuple[Span, ...], *, max_width: int | None = None) -> int:
+        """Draw styled fragments without crossing the requested width."""
+        used = 0
+        limit = self.width - x if max_width is None else min(max_width, self.width - x)
+        for span in spans:
+            if used >= limit:
+                break
+            used += self.draw_text(x + used, y, span.text, span.style, max_width=limit - used)
+        return used
+
+    def fill(self, x: int, y: int, width: int, height: int, style: Style, character: str = " ") -> None:
+        """Fill one clipped rectangle."""
+        for row in range(max(0, y), min(self.height, y + height)):
+            for column in range(max(0, x), min(self.width, x + width)):
+                self.cells[row][column] = Cell(character, style)
+
+
+class DifferentialRenderer:
+    """Write only changed cell ranges since the previous frame."""
+
+    def __init__(self, output: TextIO) -> None:
+        self.output = output
+        self.previous: Canvas | None = None
+
+    def reset(self) -> None:
+        self.previous = None
+
+    def render(self, canvas: Canvas, *, cursor: tuple[int, int] | None = None) -> None:
+        full = self.previous is None or (self.previous.width, self.previous.height) != (canvas.width, canvas.height)
+        stream = StringIO()
+        if full:
+            stream.write("\x1b[2J")
+        for y, row in enumerate(canvas.cells):
+            previous_row = None if full or self.previous is None else self.previous.cells[y]
+            if previous_row == row:
+                continue
+            start, end = _changed_bounds(row, previous_row)
+            stream.write(f"\x1b[{y + 1};{start + 1}H")
+            active_style: Style | None = None
+            for cell in row[start : end + 1]:
+                if cell.continuation:
+                    continue
+                if cell.style != active_style:
+                    stream.write(_ansi_style(cell.style))
+                    active_style = cell.style
+                stream.write(cell.character or " ")
+            stream.write("\x1b[0m")
+        if cursor is None:
+            stream.write("\x1b[?25l")
+        else:
+            x, y = cursor
+            stream.write(f"\x1b[{y + 1};{x + 1}H\x1b[?25h")
+        self.output.write(stream.getvalue())
+        self.output.flush()
+        self.previous = canvas
+
+
+def _changed_bounds(row: list[Cell], previous: list[Cell] | None) -> tuple[int, int]:
+    """Return a glyph-safe inclusive range containing every changed cell."""
+    if previous is None:
+        return 0, len(row) - 1
+
+    changed = [index for index, cell in enumerate(row) if cell != previous[index]]
+    start, end = changed[0], changed[-1]
+
+    # A wide glyph occupies a leading cell plus one or more continuation cells.
+    # Include its leader so replacing either half never leaves a stale terminal glyph.
+    while start > 0 and (row[start].continuation or previous[start].continuation):
+        start -= 1
+    while end + 1 < len(row) and (row[end + 1].continuation or previous[end + 1].continuation):
+        end += 1
+    return start, end
+
+
+def _ansi_style(style: Style) -> str:
+    codes = ["0"]
+    if style.bold:
+        codes.append("1")
+    if style.dim:
+        codes.append("2")
+    if style.italic:
+        codes.append("3")
+    if style.reverse:
+        codes.append("7")
+    if style.foreground:
+        codes.append(_truecolor(style.foreground, foreground=True))
+    if style.background:
+        codes.append(_truecolor(style.background, foreground=False))
+    return f"\x1b[{';'.join(codes)}m"
+
+
+def _truecolor(value: str, *, foreground: bool) -> str:
+    value = value.removeprefix("#")
+    red, green, blue = (int(value[index : index + 2], 16) for index in (0, 2, 4))
+    return f"{'38' if foreground else '48'};2;{red};{green};{blue}"

zettcode/tui_framework/terminal.py

@@ -0,0 +1,118 @@
+"""TTY ownership and asynchronous input."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import signal
+import sys
+from collections.abc import Callable
+from types import TracebackType
+from typing import TextIO
+
+from .events import EventType, InputEvent
+from .input import InputDecoder
+
+# Raw-mode input, SIGWINCH, and add_reader on stdin are POSIX-only. Keep the
+# import safe on Windows so the rest of ZettCode still loads, and fail with a
+# clear message when a TUI is actually requested there.
+POSIX = os.name == "posix"
+
+
+class Terminal:
+    """Own raw mode and restore the user's terminal on every exit path."""
+
+    def __init__(self, *, input_fd: int | None = None, output: TextIO | None = None) -> None:
+        self.input_fd = sys.stdin.fileno() if input_fd is None else input_fd
+        self.output = sys.stdout if output is None else output
+        self._attributes: list | None = None
+
+    @property
+    def size(self) -> tuple[int, int]:
+        size = shutil.get_terminal_size((80, 24))
+        return max(20, size.columns), max(8, size.lines)
+
+    def __enter__(self) -> Terminal:
+        if not POSIX:
+            raise RuntimeError("ZettCode TUI requires a POSIX terminal")
+        import termios
+        import tty
+
+        if not os.isatty(self.input_fd) or not self.output.isatty():
+            raise RuntimeError("ZettCode TUI requires an interactive terminal")
+        self._attributes = termios.tcgetattr(self.input_fd)
+        tty.setraw(self.input_fd)
+        self.write("\x1b[?1049h\x1b[?7l\x1b[?25l\x1b[?2004h\x1b[?1000h\x1b[?1003h\x1b[?1006h")
+        return self
+
+    def __exit__(
+        self,
+        exception_type: type[BaseException] | None,
+        exception: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.write("\x1b[0m\x1b[?25h\x1b[?7h\x1b[?1000l\x1b[?1003l\x1b[?1006l\x1b[?2004l\x1b[?1049l")
+        if self._attributes is not None:
+            import termios
+
+            termios.tcsetattr(self.input_fd, termios.TCSADRAIN, self._attributes)
+            self._attributes = None
+
+    def write(self, value: str) -> None:
+        self.output.write(value)
+        self.output.flush()
+
+
+class AsyncInput:
+    """Publish decoded terminal input into one application queue."""
+
+    def __init__(self, terminal: Terminal, publish: Callable[[InputEvent], None]) -> None:
+        self.terminal = terminal
+        self.publish = publish
+        self.decoder = InputDecoder()
+        self.loop: asyncio.AbstractEventLoop | None = None
+        self._previous_resize_handler = None
+        self._escape_handle: asyncio.TimerHandle | None = None
+
+    def start(self) -> None:
+        self.loop = asyncio.get_running_loop()
+        self.loop.add_reader(self.terminal.input_fd, self._read_ready)
+        if hasattr(signal, "SIGWINCH"):
+            self._previous_resize_handler = signal.getsignal(signal.SIGWINCH)
+            self.loop.add_signal_handler(signal.SIGWINCH, self._resize)
+
+    def close(self) -> None:
+        if self.loop is None:
+            return
+        self.loop.remove_reader(self.terminal.input_fd)
+        if hasattr(signal, "SIGWINCH"):
+            self.loop.remove_signal_handler(signal.SIGWINCH)
+        if self._escape_handle is not None:
+            self._escape_handle.cancel()
+            self._escape_handle = None
+        if hasattr(signal, "SIGWINCH") and callable(self._previous_resize_handler):
+            signal.signal(signal.SIGWINCH, self._previous_resize_handler)
+        self.loop = None
+
+    def _read_ready(self) -> None:
+        try:
+            data = os.read(self.terminal.input_fd, 65536)
+        except OSError:
+            return
+        if self._escape_handle is not None:
+            self._escape_handle.cancel()
+            self._escape_handle = None
+        for event in self.decoder.feed(data):
+            self.publish(event)
+        if self.decoder.buffer == b"\x1b" and self.loop is not None:
+            self._escape_handle = self.loop.call_later(0.03, self._flush_escape)
+
+    def _resize(self) -> None:
+        self.publish(InputEvent(EventType.RESIZE))
+
+    def _flush_escape(self) -> None:
+        self._escape_handle = None
+        event = self.decoder.flush_escape()
+        if event is not None:
+            self.publish(event)

zettcode-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.5
+Name: zettcode
+Version: 0.1.0
+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
+Author: Chang-LeHung
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,coding-agent,llm,terminal,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Requires-Dist: pyperclip<2,>=1.9
+Requires-Dist: wcwidth<1,>=0.2
+Requires-Dist: zett-agent==0.1.0
+Description-Content-Type: text/markdown
+
+# ZettCode
+
+ZettCode is a focused terminal coding agent built on `zett-agent`. Its TUI owns
+raw terminal input, component layout, mouse interaction, and cell-level
+differential rendering directly; it does not use prompt-toolkit or another TUI
+framework.
+
+The agent runtime is published separately as
+[`zett-agent`](https://github.com/Chang-LeHung/zett-agent); this repository owns
+only the terminal client.
+
+## Install
+
+ZettCode needs Python 3.14 or newer and is published on PyPI as `zettcode`:
+
+```bash
+uv tool install zettcode
+# or
+pip install zettcode
+```
+
+## Run
+
+DeepSeek:
+
+```bash
+export DEEPSEEK_API_KEY=...
+zettcode --provider deepseek --model deepseek-chat
+```
+
+OpenAI or an OpenAI-compatible endpoint:
+
+```bash
+export OPENAI_API_KEY=...
+zettcode --provider openai --model gpt-5-mini
+zettcode --provider openai --model my-model --base-url https://example.com/v1
+```
+
+Pass a workspace path as the final argument. It defaults to the current directory.
+Session data is stored in `~/.zettcode/sessions.sqlite3` by default.
+
+From a source checkout, run the same commands through `uv`:
+
+```bash
+uv sync
+uv run zettcode --provider deepseek --model deepseek-chat
+```
+
+## Keys
+
+- `Enter`: send
+- `Esc`, then `Enter`: insert a newline
+- `Ctrl-C`: stop the active request, or clear the input
+- `Ctrl-D`: delete the next character; exit when the input is empty and the agent is idle
+- `Ctrl-A` / `Ctrl-E`, `Home` / `End`: move to the start or end of the current line
+- `Ctrl-B` / `Ctrl-F`, `Left` / `Right`: move by one character
+- `Alt-B` / `Alt-F`, `Ctrl-Left` / `Ctrl-Right`: move by one word
+- `Ctrl-Home` / `Ctrl-End`, `Alt-<` / `Alt->`: move to the start or end of the whole input
+- `Ctrl-U` / `Ctrl-K`: delete to the start or end of the current line
+- `Ctrl-W` / `Alt-Backspace`, `Alt-D`: delete the previous or next word
+- `Ctrl-Y`: paste the last text removed with a line or word deletion
+- `Ctrl-Z` / `Ctrl-_`: undo the latest input edit
+- `Up` / `Down`: move between input lines, then browse submitted input history
+- `Ctrl-P` / `Ctrl-N`: browse submitted input history directly
+- `Ctrl-R`: search backward through submitted input history
+- `Ctrl-L`: redraw the terminal
+- `Ctrl-T`: expand or collapse the latest thinking block
+- `Page Up` / `Page Down`: scroll history while keeping the composer focused
+- Click the transcript and use `Up` / `Down`, `Home` / `End` to browse it
+- Drag in the transcript to select text; dragging past an edge automatically scrolls
+- Double-click a transcript row to select the complete visible line
+- `Shift`-click extends the existing selection
+- Completed mouse selections are copied to the system clipboard automatically
+- `Ctrl-C` also copies a transcript selection and returns focus to the input
+- `Tab` / `Shift-Tab`: complete slash commands
+
+Thinking is collapsed by default. Click a Thinking row to inspect it; moving the
+pointer outside that block collapses it again. Tool calls keep their output and
+completion status visible in the transcript. Active thinking and tool rows use a
+low-frequency moving highlight wave with an animated activity icon. Tool results show a five-row preview by default;
+click a completed tool row to expand it. Expanded output is still bounded so a
+large command result cannot take over the terminal or exhaust renderer memory.
+
+Assistant text renders common terminal-friendly Markdown: bold and emphasis,
+headings, inline and fenced code, links, quotes, unordered bullet lists, and
+GFM-style tables. Tables preserve left, center, and right alignment, account for
+wide CJK characters, and fit or truncate columns to the current terminal width.
+
+Use `/help` inside the application to see session commands.

zettcode-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+zettcode/__init__.py,sha256=xH18ql2SktiD5p1dRVP7VS1bpsXKhG--wllDyw65Tpg,201
+zettcode/cli.py,sha256=2qGRfZYWp_YBqhcb999AVZDTK-8yhU498Th0LoiYOKY,3077
+zettcode/config.py,sha256=u5ZFOO6F5sQvPWte7tdi4VxdI3p37qU7gfLWMk7uotM,2493
+zettcode/runtime.py,sha256=y6yPj0dO5xjVztTmvZHBVMMMGbumRFeOBAE8XDu8kI4,4445
+zettcode/tui.py,sha256=5VZXegTI6ROOFs2EvisB0JRnC1VmiFvnxpQwpa2ZrJg,37433
+zettcode/tui_framework/__init__.py,sha256=4-ykS_KrpI9V3W4q2mcwGe_87moNZEpTNZnVEuMdp-U,679
+zettcode/tui_framework/application.py,sha256=5PwqmxVG7MewlcOUBuNu0jdI8RaS9YBhWHazvccGECo,3174
+zettcode/tui_framework/components.py,sha256=bm6RH5f9cbwrlYUt_NSbcsZonlEYaOczV6FFwJ_1ePg,31111
+zettcode/tui_framework/events.py,sha256=OGa15-_WEB0Cb8Bq_p8R6kI-xjihqAVyGV1XwcDRtZw,685
+zettcode/tui_framework/input.py,sha256=pHTX89NH8JEY73KHBBc8QoHFa1w7C8nvIxVvvc1ugPU,4944
+zettcode/tui_framework/screen.py,sha256=XJCvJ_Muvyaj1mnMkqybWLLl2ZO3Xl0lfAKLPFsaklk,7332
+zettcode/tui_framework/terminal.py,sha256=naowmJgZQCBOoJZSeMMBky7HHpsju-Y0WkDM-1VWWXw,4291
+zettcode-0.1.0.dist-info/METADATA,sha256=9QtQu7O0t9L73_4Ku6lHPa9qF7EHycd3fZsrOsJOy58,4368
+zettcode-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+zettcode-0.1.0.dist-info/entry_points.txt,sha256=NAGIYd8zCFIJdjAjPsYQ28tOKZOoWB_N-CQUT-a-9zA,47
+zettcode-0.1.0.dist-info/licenses/LICENSE,sha256=O9b87-u8V1aSp6xkr9qnbHZIJAWNV6m04GEQjycLLiw,1069
+zettcode-0.1.0.dist-info/RECORD,,

zettcode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

zettcode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zettcode = zettcode.cli:main

zettcode-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chang-LeHung
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.