goondan 0.1.0__tar.gz

goondan-0.1.0/.gitignore

@@ -0,0 +1,39 @@
+.DS_Store
+**/.DS_Store
+node_modules/
+**/node_modules/
+dist/
+**/dist/
+/test/
+*.log
+.tmp/
+.vite/
+**/.vite/
+**/tmp-live-config-*/
+mise.local.toml
+**/state/
+.goondan/
+
+# Security - sensitive files
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+*.p12
+*.pfx
+credentials.json
+**/secrets/
+**/.secrets/
+**/oauth/grants/
+**/oauth/sessions/
+
+# Python build and test state
+.venv/
+__pycache__/
+.pytest_cache/
+*.pyc
+*.egg-info/
+
+# pnpm 오프라인 저장소
+.pnpm-store/

goondan-0.1.0/AGENTS.md

@@ -0,0 +1,62 @@
+# goondan Python 패키지
+
+이 패키지는 Goondan 구성 파일을 Python 프로세스에서 직접 실행합니다. 공개 인터페이스와 실행 동작은 TypeScript의 `@goondan/core`, `spec/goondan.schema.json`, `fixtures/conformance/`와 같은 의미를 유지합니다.
+
+## 모듈
+
+`goondan/` 패키지는 TypeScript `packages/core/src`와 대응하는 책임으로 모듈을 나눕니다. 이름이 밑줄로 시작하는 모듈은 패키지 내부용이며, 호스트가 쓰는 이름은 `__init__.py`가 다시 내보냅니다.
+
+| 모듈 | 소유 범위 |
+|---|---|
+| `types.py` | 공개 데이터클래스, 프로토콜, 컨텍스트, 정의 도우미와 오류 클래스 |
+| `_json.py` | 두 호스트가 같은 결과를 만드는 JSON 직렬화와 값 처리 |
+| `_yaml.py` | YAML 해석 규칙, 중복 키·앵커·별칭 판정 |
+| `_schema.py` | `goondan.schema.json` 해석기, 스키마 검사와 오류 정렬 |
+| `_values.py` | 단계 값 형식, 메시지 보강, 제어 결과와 도구 반환값 정규화 |
+| `config.py` | YAML 로딩, `resources` 합성, 상속과 제거, 참조·바인딩 검사 |
+| `template.py` | 구성 로딩 시 읽은 맵만 쓰는 렌더러와 정적 include 해석 |
+| `store.py` | `Store` 프로토콜의 오류와 `InMemoryStore` |
+| `fold.py` | 버전이 붙은 저널 이벤트를 상태 뷰로 재생하는 순수 `fold` |
+| `runtime.py` | `Goondan`과 `create_goondan`, 입력 대기열, 훅, 모델·도구 반복, route, 승인 작업, 임대와 이벤트 |
+| `goondan.schema.json` | `spec/goondan.schema.json`의 패키지 사본 |
+| `models/` | Anthropic과 OpenAI 공식 모델 어댑터 |
+
+모듈은 순환 없이 한 방향으로 가져옵니다. `models/`는 코어 모듈 가운데 `types.py`와 `_json.py`만 가져오므로 어댑터를 설치하지 않아도 런타임은 동작합니다.
+
+## 실행 범위와 호스트 API
+
+군단 객체는 에이전트를 선언 이름으로 식별합니다. `stateful: true`인 에이전트는 세션과 에이전트 이름의 조합마다 대화와 확장 인스턴스를 유지합니다. `stateful: false`인 에이전트는 실행마다 빈 대화와 새 확장 인스턴스를 사용하며 실행 기록은 같은 세션 저널에 남깁니다.
+
+호스트 API는 `run(value, session_id=None, meta=None, agent=..., start_agent=...)`, `abort`, `idle`, `close`, `sessions.delete`, `operations.list`, `operations.decide`입니다. `run`은 수락된 입력의 `session_id`, `turn_id`, `input_id`와 턴 결과 awaitable인 `result`를 가진 핸들을 반환합니다. 진행 중인 세션에 추가로 호출한 `run`은 대상 stateful 인스턴스의 입력 대기열에 합류합니다. `agent`와 `start_agent`는 함께 지정할 수 없습니다.
+
+`session_id`, `turn_id`, `instance`, `execution_id`, `input_id`는 각각 다른 범위를 나타냅니다. 하위 실행의 직접 원인은 `parent_execution_id`, 승인 작업에서 시작한 실행의 원인은 `operation_id`입니다. 직렬화되는 필드는 camelCase를 유지합니다.
+
+`runtime.py`는 일치한 route 분기를 동시에 실행합니다. stateful fan-in은 출발 집합의 실행과 대기 입력이 끝난 뒤 route 선언 순서로 메시지를 합쳐 한 번 실행하고, stateless 에이전트는 도달한 입력마다 독립 실행합니다. 함수 노드는 인스턴스와 대기열 없이 메시지 배열을 변환하고 `route.function` 저널 이벤트를 기록합니다. `$output` route가 없거나 일치하지 않아도 턴은 빈 `outputs`로 성공할 수 있습니다.
+
+## 저널과 승인 작업
+
+세션마다 append 전용 저널 스트림 하나를 둡니다. `Store`는 `append`, `scan`, `head`, `watch`, `acquire_lease`, `delete_session`을 제공하고, 런타임은 `expected`, `write_id`, 임대와 펜싱 토큰으로 상태 변경을 보호합니다. 대화, 승인 작업, 턴과 에이전트 실행 상태는 `fold`의 결과입니다.
+
+현재 지원 범위는 세션당 활성 작성자 하나입니다. 만료되는 임대는 모델 호출, 도구 호출과 승인 대기를 포함한 턴 전체에서 갱신하고, 갱신을 잃으면 실행을 끝낸 뒤 늦은 쓰기를 펜싱으로 거부합니다.
+
+승인 작업의 공개 요청은 `operations.list`와 `operations.decide`입니다. 작업 알림은 `operation.*` 저널·실행 이벤트로 전달하고, 완료 입력은 대상 인스턴스의 입력 대기열에 넣습니다. 세션을 처음 열 때 저널을 재생하여 열린 실행과 턴을 정리하고 승인된 작업과 완료 전달을 자동으로 복구합니다. `inputPatch`는 결정할 때와 실행 직전에 현재 도구 입력 스키마로 검사합니다.
+
+## 훅과 구현 규약
+
+훅 시점은 `onInput`, `onPrompt`, `onStep`, `onModelInput`, `onModelResult`, `onToolCall`, `onToolResult`, `onOutput`, `onError`입니다. `onPrompt` 결과와 `onStep`의 대화 변경은 저널에 기록하고, `onModelInput` 변경은 해당 모델 호출에만 적용합니다.
+
+도구 구현은 내용 부분 배열, `content`를 가진 결과 매핑, 그 밖의 JSON 값 가운데 하나를 반환합니다. 런타임은 `callId`, `name`, `args`를 실행한 호출의 값으로 채우고 정규화한 결과를 `onToolResult`에 전달합니다.
+
+저널 이벤트는 append 직후 같은 봉투로 실행 이벤트 수신자에게 전달합니다. 저장하지 않는 진행 이벤트는 `observational: true`를 가집니다. 에이전트 실행은 `agent.*`, 군단 턴은 `turn.*` 이벤트를 사용합니다.
+
+Python 공개 이름에는 snake_case를 사용합니다. 직렬화되는 메시지, 모델 입력, 도구 호출, 결과, 저널 이벤트와 오류 필드에는 camelCase를 사용합니다.
+
+## 의존성과 패키징
+
+런타임 자체는 Jinja2와 PyYAML만 요구합니다. `goondan.models`는 요청을 httpx로 보내므로 `goondan[models]` 선택 의존성으로 설치합니다.
+
+휠은 `[tool.hatch.build.targets.wheel]`이 결정합니다. 패키징을 바꿨으면 `uv build --wheel`로 만든 휠의 파일 목록에 `goondan/goondan.schema.json`이 있는지 확인합니다.
+
+## 검사
+
+저장소 루트의 `pnpm test:python`은 `python/goondan`에서 `uv run --extra test --extra models python -m pytest`를 실행합니다. `tests/test_conformance.py`는 루트의 공통 사례를 실행하고, `tests/test_schema_sync.py`는 패키지 스키마 사본이 규격과 같은지 확인합니다. 모델 어댑터 검사는 실제 제공자를 호출하지 않습니다.

goondan-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Goondan contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

goondan-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.5
+Name: goondan
+Version: 0.1.0
+Summary: Goondan runtime for Python: runs YAML-declared agents, routes and hooks over a per-session journal
+Project-URL: Homepage, https://github.com/goondan/goondan#readme
+Project-URL: Repository, https://github.com/goondan/goondan
+Project-URL: Issues, https://github.com/goondan/goondan/issues
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agent,goondan,llm,runtime,yaml
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: jinja2<4,>=3.1
+Requires-Dist: pyyaml<7,>=6
+Provides-Extra: models
+Requires-Dist: httpx<1,>=0.27; extra == 'models'
+Provides-Extra: test
+Requires-Dist: httpx<1,>=0.27; extra == 'test'
+Requires-Dist: pytest-asyncio<1,>=0.24; extra == 'test'
+Requires-Dist: pytest<9,>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# goondan
+
+Goondan은 에이전트 구성과 연결을 YAML로 선언하고, TypeScript와 Python 호스트가 같은 구성을 같은 의미로 실행하는 런타임입니다. 이 패키지는 그 Python 호스트입니다.
+
+실행 의미는 [`spec/goondan.md`](https://github.com/goondan/goondan/blob/main/spec/goondan.md)가 규범으로 정하고, 두 호스트가 같은 기대 결과로 통과해야 하는 공통 실행 사례로 검증합니다.
+
+## 설치
+
+```bash
+pip install goondan
+```
+
+공식 Anthropic·OpenAI 어댑터를 함께 쓰려면 `models` 추가 의존을 설치합니다.
+
+```bash
+pip install "goondan[models]"
+```
+
+## 사용
+
+YAML에는 에이전트와 연결, 그리고 모델·도구·함수·확장의 **이름**만 선언합니다. 이름에 해당하는 구현은 호스트가 주입합니다.
+
+```yaml
+# goondan.yaml
+name: hello
+agents:
+  assistant:
+    model: main
+    systemMessage: 질문에 짧게 답합니다.
+routes: [assistant]
+```
+
+```python
+import asyncio
+from goondan import create_goondan, load_config
+from goondan.models import anthropic_model
+
+
+async def main():
+    goondan = create_goondan(
+        config=load_config("."),
+        models={"main": anthropic_model(model="claude-sonnet-5")},
+    )
+    try:
+        run = await goondan.run("Goondan을 설명해 주세요.", session_id="example")
+        result = await run.result
+        print(result["output"])
+    finally:
+        await goondan.close()
+
+
+asyncio.run(main())
+```
+
+`run`은 입력이 세션 저널에 기록되면 실행 핸들을 돌려줍니다. 핸들의 `session_id`, `turn_id`, `input_id`로 진행을 추적하고, 결과가 필요할 때 `result`를 기다립니다.
+
+## 범위
+
+런타임의 책임은 모델 루프, route 실행, 입력 대기열, 저널, 승인 작업과 취소입니다. 도구는 호스트 프로세스 안에서 실행되는 함수이며, 런타임은 샌드박스, 자격 증명 관리, 비용 통제와 관측 백엔드를 제공하지 않습니다. 격리가 필요하면 호스트가 도구 구현 바깥에 연결합니다.
+
+## 문서
+
+- [저장소와 README](https://github.com/goondan/goondan#readme)
+- [실행 규격](https://github.com/goondan/goondan/blob/main/spec/goondan.md)
+- [모델 어댑터 규격](https://github.com/goondan/goondan/blob/main/spec/model-adapters.md)
+
+## 라이선스
+
+Apache-2.0

goondan-0.1.0/README.md

@@ -0,0 +1,69 @@
+# goondan
+
+Goondan은 에이전트 구성과 연결을 YAML로 선언하고, TypeScript와 Python 호스트가 같은 구성을 같은 의미로 실행하는 런타임입니다. 이 패키지는 그 Python 호스트입니다.
+
+실행 의미는 [`spec/goondan.md`](https://github.com/goondan/goondan/blob/main/spec/goondan.md)가 규범으로 정하고, 두 호스트가 같은 기대 결과로 통과해야 하는 공통 실행 사례로 검증합니다.
+
+## 설치
+
+```bash
+pip install goondan
+```
+
+공식 Anthropic·OpenAI 어댑터를 함께 쓰려면 `models` 추가 의존을 설치합니다.
+
+```bash
+pip install "goondan[models]"
+```
+
+## 사용
+
+YAML에는 에이전트와 연결, 그리고 모델·도구·함수·확장의 **이름**만 선언합니다. 이름에 해당하는 구현은 호스트가 주입합니다.
+
+```yaml
+# goondan.yaml
+name: hello
+agents:
+  assistant:
+    model: main
+    systemMessage: 질문에 짧게 답합니다.
+routes: [assistant]
+```
+
+```python
+import asyncio
+from goondan import create_goondan, load_config
+from goondan.models import anthropic_model
+
+
+async def main():
+    goondan = create_goondan(
+        config=load_config("."),
+        models={"main": anthropic_model(model="claude-sonnet-5")},
+    )
+    try:
+        run = await goondan.run("Goondan을 설명해 주세요.", session_id="example")
+        result = await run.result
+        print(result["output"])
+    finally:
+        await goondan.close()
+
+
+asyncio.run(main())
+```
+
+`run`은 입력이 세션 저널에 기록되면 실행 핸들을 돌려줍니다. 핸들의 `session_id`, `turn_id`, `input_id`로 진행을 추적하고, 결과가 필요할 때 `result`를 기다립니다.
+
+## 범위
+
+런타임의 책임은 모델 루프, route 실행, 입력 대기열, 저널, 승인 작업과 취소입니다. 도구는 호스트 프로세스 안에서 실행되는 함수이며, 런타임은 샌드박스, 자격 증명 관리, 비용 통제와 관측 백엔드를 제공하지 않습니다. 격리가 필요하면 호스트가 도구 구현 바깥에 연결합니다.
+
+## 문서
+
+- [저장소와 README](https://github.com/goondan/goondan#readme)
+- [실행 규격](https://github.com/goondan/goondan/blob/main/spec/goondan.md)
+- [모델 어댑터 규격](https://github.com/goondan/goondan/blob/main/spec/model-adapters.md)
+
+## 라이선스
+
+Apache-2.0

goondan-0.1.0/goondan/__init__.py

@@ -0,0 +1,36 @@
+from .config import load_config, validate_config
+from .runtime import Goondan, create_goondan
+from .fold import FOLD_VERSION, FoldError, UnsupportedJournalVersionError, fold
+from .store import (
+    InMemoryStore,
+    Store,
+    StoreConflictError,
+    StoreError,
+    StoreInputError,
+)
+from .types import (
+    Extension,
+    ExtensionDefinition,
+    GoondanAbortError,
+    GoondanConfig,
+    GoondanConfigError,
+    GoondanError,
+    GoondanExecutionError,
+    HookContext,
+    ModelContext,
+    NoLog,
+    RunHandle,
+    RunResult,
+    Tool,
+    define_extension,
+    define_tool,
+)
+
+__all__ = [
+    "Extension", "ExtensionDefinition", "HookContext", "ModelContext", "NoLog", "RunHandle", "RunResult",
+    "InMemoryStore", "Store", "StoreConflictError", "StoreError", "StoreInputError",
+    "FOLD_VERSION", "FoldError", "UnsupportedJournalVersionError", "fold",
+    "GoondanAbortError", "GoondanConfig", "GoondanConfigError", "GoondanError",
+    "GoondanExecutionError", "Goondan", "Tool",
+    "create_goondan", "define_extension", "define_tool", "load_config", "validate_config",
+]

goondan-0.1.0/goondan/_json.py

@@ -0,0 +1,88 @@
+"""§JSON 텍스트: the one JSON text serializer the whole package uses.
+
+`JSON 텍스트` is what `JSON.stringify` writes in the TypeScript host, so the number
+spelling follows the ECMAScript `Number::toString` algorithm rather than Python's `repr`,
+and strings are written without ASCII escaping. The runtime, the template `json` filter
+and the model adapters all serialize through this module, so the package cannot
+contradict itself about the text a model receives.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from decimal import Decimal
+from typing import Any, Mapping
+
+from .types import GoondanError
+
+
+def _positional(raw: str) -> str:
+    """The exponent spelling `repr` produced, written out in positional notation.
+
+    Only a fractional tail loses its trailing zeros: the zeros of an integer part carry
+    the magnitude, so `1e16` is `10000000000000000` and never `1`.
+    """
+    text = format(Decimal(raw), "f")
+    return text.rstrip("0").rstrip(".") if "." in text else text
+
+
+def number_text(value: int | float) -> str:
+    """§JSON 텍스트: the `Number::toString` spelling of one finite JSON number."""
+    if isinstance(value, bool):
+        raise GoondanError("a boolean is not a JSON number")
+    if isinstance(value, int):
+        return str(value)
+    if not math.isfinite(value):
+        raise GoondanError("JSON numbers must be finite")
+    # `JSON.stringify(-0)` is `0`, so the sign of a zero is never written.
+    if value == 0:
+        return "0"
+    absolute = abs(value)
+    raw = repr(value).lower()
+    if 1e-6 <= absolute < 1e21:
+        # ECMAScript writes this range without an exponent; Python's `repr` may not.
+        if "e" in raw:
+            return _positional(raw)
+        return raw[:-2] if raw.endswith(".0") else raw
+    if "e" not in raw:
+        return raw
+    mantissa, exponent = raw.split("e")
+    if "." in mantissa:
+        mantissa = mantissa.rstrip("0").rstrip(".")
+    power = int(exponent)
+    return f"{mantissa}e{'+' if power >= 0 else '-'}{abs(power)}"
+
+
+def _text(value: str) -> str:
+    return json.dumps(value, ensure_ascii=False)
+
+
+def _write(value: Any, indent: int, level: int) -> str:
+    if value is None: return "null"
+    if value is True: return "true"
+    if value is False: return "false"
+    if isinstance(value, (int, float)): return number_text(value)
+    if isinstance(value, str): return _text(value)
+    compact = indent == 0
+    if isinstance(value, list):
+        if not value: return "[]"
+        if compact: return "[" + ",".join(_write(item, 0, 0) for item in value) + "]"
+        inner = ",\n".join("  " * (level + 1) + _write(item, indent, level + 1) for item in value)
+        return "[\n" + inner + "\n" + "  " * level + "]"
+    if isinstance(value, Mapping):
+        if not value: return "{}"
+        if compact: return "{" + ",".join(f"{_text(str(key))}:{_write(item, 0, 0)}" for key, item in value.items()) + "}"
+        inner = ",\n".join("  " * (level + 1) + f"{_text(str(key))}: {_write(item, indent, level + 1)}" for key, item in value.items())
+        return "{\n" + inner + "\n" + "  " * level + "}"
+    raise GoondanError(f"value is not JSON: {type(value).__name__}")
+
+
+def json_text(value: Any) -> str:
+    """§JSON 텍스트: the compact text, with no spaces between members and no ASCII escaping."""
+    return _write(value, 0, 0)
+
+
+def json_pretty_text(value: Any) -> str:
+    """The indented form the `json` filter without an argument produces: two spaces per level."""
+    return _write(value, 2, 0)