ff-lntools 0.1.0__tar.gz

ff_lntools-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 gatesplan
+
+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.

ff_lntools-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: ff-lntools
+Version: 0.1.0
+Summary: ln-structure checker, blast radius, doc generator and Claude Code hooks
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# ff-lntools
+
+ln-structure 프로젝트용 정적 검사, 영향 범위, 문서 생성 도구와 Claude Code 훅.
+표준 라이브러리만 사용. Python 3.10+.
+
+ln-structure 규칙: `src/lntools/protocol/for-agent-codingprotocol-ln-structure.md`
+
+## 설치
+
+```
+pip install git+https://github.com/gatesplan/ff-lntools
+```
+
+프로젝트가 쓰는 Python 환경마다 설치한다. 훅이 `python -m lntools` 로 호출하기 때문이다.
+
+## 프로젝트 세팅
+
+```
+lnt init --skill    # 1회. ~/.claude/skills/init-protocol 스킬 설치
+cd my-project
+lnt init            # .claude/ 에 프로토콜 문서 복사, CLAUDE.md 생성, 훅 병합
+```
+
+Claude Code 에서는 `/init-protocol` 이 같은 일을 한다. 코딩 프로토콜 문서의 원본은 이 저장소의
+`src/lntools/protocol/` 이다.
+
+## 명령
+
+```
+lnt init [--skill]          # 프로젝트에 코딩 프로토콜 설치
+lnt check [--file PATH]     # C1 방향, C2 표면, C3 층 일치, C4 순환. 위반 시 exit 1
+lnt blast MODULE [-d N]     # MODULE 변경 시 영향받는 상위 모듈. 인터페이스 상속 경유 포함
+lnt map                     # 모듈 목록, 층, 의존
+lnt doc                     # for-agent-layerinfo.md, for-agent-layerinfo-lN.md 생성
+lnt doc --check             # 생성 결과와 파일 비교. 다르면 exit 1
+lnt doc --stamp MODULE      # for-agent-moduleinfo.md 의 sources hash 갱신
+lnt move MODULE lK          # 모듈을 lK 로 이동. 패키지/tests 의 import 재작성, tests 미러 이동,
+                            # 두 층의 __init__ 을 지연 re-export 로 재생성, 문서 재생성
+lnt hook post-edit          # Claude Code PostToolUse 훅 진입 (stdin JSON)
+lnt hook session-start      # Claude Code SessionStart 훅 진입
+```
+
+`--root` 로 프로젝트 안의 아무 경로를 주면 `src/<pkg>/lN` 을 찾아 올라간다. 기본은 현재 디렉토리.
+
+## 검사 규칙
+
+| 코드 | 내용 |
+|---|---|
+| C1 | import 대상 층이 자기 층보다 낮아야 한다. 같은 층도 위반. `TYPE_CHECKING` 안의 import 도 포함 |
+| C2 | `pkg.lN.module` 표면까지만 import. 모듈 안의 파일이나 중첩 모듈 내부로 진입 금지 |
+| C3 | 선언 층 == 계산 층 (의존 최고 층 + 1, 의존 없으면 0, 외부 패키지 의존이 있으면 최소 1) |
+| C4 | 모듈 간 runtime import 순환 금지. 모듈 내부 파일 간 순환은 규칙 밖 |
+
+## Claude Code 훅
+
+`.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [{
+      "matcher": "startup|resume|clear|compact",
+      "hooks": [{"type": "command", "command": "python -m lntools hook session-start"}]
+    }],
+    "PostToolUse": [{
+      "matcher": "Edit|Write|MultiEdit",
+      "hooks": [{"type": "command", "command": "python -m lntools hook post-edit", "timeout": 30}]
+    }]
+  }
+}
+```
+
+- session-start: `src/<pkg>/for-agent-layerinfo.md` 를 세션 컨텍스트에 주입
+- post-edit: 편집한 파일이 `src/**/*.py` 이면 그 모듈을 검사.
+  위반은 exit 2 + stderr 로 에이전트에게 오류로 전달되고, 위반이 없으면 영향 범위와
+  문서 stale 여부가 additionalContext 로 전달된다
+
+## 문서
+
+- `for-agent-layerinfo.md` (패키지 루트, 중첩 모듈 루트): 층별 모듈 목록. 마커 사이는 생성, 한 줄 설명과 마커 밖은 보존
+- `for-agent-layerinfo-lN.md` (각 층): 공개 클래스 메서드 시그니처. 마커 사이는 생성
+- `for-agent-moduleinfo.md` (각 모듈): 사람이 쓴다. `sources` 헤더의 hash 로 stale 판정만 한다

ff_lntools-0.1.0/README.md

@@ -0,0 +1,82 @@
+# ff-lntools
+
+ln-structure 프로젝트용 정적 검사, 영향 범위, 문서 생성 도구와 Claude Code 훅.
+표준 라이브러리만 사용. Python 3.10+.
+
+ln-structure 규칙: `src/lntools/protocol/for-agent-codingprotocol-ln-structure.md`
+
+## 설치
+
+```
+pip install git+https://github.com/gatesplan/ff-lntools
+```
+
+프로젝트가 쓰는 Python 환경마다 설치한다. 훅이 `python -m lntools` 로 호출하기 때문이다.
+
+## 프로젝트 세팅
+
+```
+lnt init --skill    # 1회. ~/.claude/skills/init-protocol 스킬 설치
+cd my-project
+lnt init            # .claude/ 에 프로토콜 문서 복사, CLAUDE.md 생성, 훅 병합
+```
+
+Claude Code 에서는 `/init-protocol` 이 같은 일을 한다. 코딩 프로토콜 문서의 원본은 이 저장소의
+`src/lntools/protocol/` 이다.
+
+## 명령
+
+```
+lnt init [--skill]          # 프로젝트에 코딩 프로토콜 설치
+lnt check [--file PATH]     # C1 방향, C2 표면, C3 층 일치, C4 순환. 위반 시 exit 1
+lnt blast MODULE [-d N]     # MODULE 변경 시 영향받는 상위 모듈. 인터페이스 상속 경유 포함
+lnt map                     # 모듈 목록, 층, 의존
+lnt doc                     # for-agent-layerinfo.md, for-agent-layerinfo-lN.md 생성
+lnt doc --check             # 생성 결과와 파일 비교. 다르면 exit 1
+lnt doc --stamp MODULE      # for-agent-moduleinfo.md 의 sources hash 갱신
+lnt move MODULE lK          # 모듈을 lK 로 이동. 패키지/tests 의 import 재작성, tests 미러 이동,
+                            # 두 층의 __init__ 을 지연 re-export 로 재생성, 문서 재생성
+lnt hook post-edit          # Claude Code PostToolUse 훅 진입 (stdin JSON)
+lnt hook session-start      # Claude Code SessionStart 훅 진입
+```
+
+`--root` 로 프로젝트 안의 아무 경로를 주면 `src/<pkg>/lN` 을 찾아 올라간다. 기본은 현재 디렉토리.
+
+## 검사 규칙
+
+| 코드 | 내용 |
+|---|---|
+| C1 | import 대상 층이 자기 층보다 낮아야 한다. 같은 층도 위반. `TYPE_CHECKING` 안의 import 도 포함 |
+| C2 | `pkg.lN.module` 표면까지만 import. 모듈 안의 파일이나 중첩 모듈 내부로 진입 금지 |
+| C3 | 선언 층 == 계산 층 (의존 최고 층 + 1, 의존 없으면 0, 외부 패키지 의존이 있으면 최소 1) |
+| C4 | 모듈 간 runtime import 순환 금지. 모듈 내부 파일 간 순환은 규칙 밖 |
+
+## Claude Code 훅
+
+`.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [{
+      "matcher": "startup|resume|clear|compact",
+      "hooks": [{"type": "command", "command": "python -m lntools hook session-start"}]
+    }],
+    "PostToolUse": [{
+      "matcher": "Edit|Write|MultiEdit",
+      "hooks": [{"type": "command", "command": "python -m lntools hook post-edit", "timeout": 30}]
+    }]
+  }
+}
+```
+
+- session-start: `src/<pkg>/for-agent-layerinfo.md` 를 세션 컨텍스트에 주입
+- post-edit: 편집한 파일이 `src/**/*.py` 이면 그 모듈을 검사.
+  위반은 exit 2 + stderr 로 에이전트에게 오류로 전달되고, 위반이 없으면 영향 범위와
+  문서 stale 여부가 additionalContext 로 전달된다
+
+## 문서
+
+- `for-agent-layerinfo.md` (패키지 루트, 중첩 모듈 루트): 층별 모듈 목록. 마커 사이는 생성, 한 줄 설명과 마커 밖은 보존
+- `for-agent-layerinfo-lN.md` (각 층): 공개 클래스 메서드 시그니처. 마커 사이는 생성
+- `for-agent-moduleinfo.md` (각 모듈): 사람이 쓴다. `sources` 헤더의 hash 로 stale 판정만 한다

ff_lntools-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ff-lntools"
+version = "0.1.0"
+description = "ln-structure checker, blast radius, doc generator and Claude Code hooks"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+
+[project.scripts]
+lnt = "lntools.l4.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+lntools = ["**/*.md", "protocol/*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

ff_lntools-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ff_lntools-0.1.0/src/ff_lntools.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: ff-lntools
+Version: 0.1.0
+Summary: ln-structure checker, blast radius, doc generator and Claude Code hooks
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# ff-lntools
+
+ln-structure 프로젝트용 정적 검사, 영향 범위, 문서 생성 도구와 Claude Code 훅.
+표준 라이브러리만 사용. Python 3.10+.
+
+ln-structure 규칙: `src/lntools/protocol/for-agent-codingprotocol-ln-structure.md`
+
+## 설치
+
+```
+pip install git+https://github.com/gatesplan/ff-lntools
+```
+
+프로젝트가 쓰는 Python 환경마다 설치한다. 훅이 `python -m lntools` 로 호출하기 때문이다.
+
+## 프로젝트 세팅
+
+```
+lnt init --skill    # 1회. ~/.claude/skills/init-protocol 스킬 설치
+cd my-project
+lnt init            # .claude/ 에 프로토콜 문서 복사, CLAUDE.md 생성, 훅 병합
+```
+
+Claude Code 에서는 `/init-protocol` 이 같은 일을 한다. 코딩 프로토콜 문서의 원본은 이 저장소의
+`src/lntools/protocol/` 이다.
+
+## 명령
+
+```
+lnt init [--skill]          # 프로젝트에 코딩 프로토콜 설치
+lnt check [--file PATH]     # C1 방향, C2 표면, C3 층 일치, C4 순환. 위반 시 exit 1
+lnt blast MODULE [-d N]     # MODULE 변경 시 영향받는 상위 모듈. 인터페이스 상속 경유 포함
+lnt map                     # 모듈 목록, 층, 의존
+lnt doc                     # for-agent-layerinfo.md, for-agent-layerinfo-lN.md 생성
+lnt doc --check             # 생성 결과와 파일 비교. 다르면 exit 1
+lnt doc --stamp MODULE      # for-agent-moduleinfo.md 의 sources hash 갱신
+lnt move MODULE lK          # 모듈을 lK 로 이동. 패키지/tests 의 import 재작성, tests 미러 이동,
+                            # 두 층의 __init__ 을 지연 re-export 로 재생성, 문서 재생성
+lnt hook post-edit          # Claude Code PostToolUse 훅 진입 (stdin JSON)
+lnt hook session-start      # Claude Code SessionStart 훅 진입
+```
+
+`--root` 로 프로젝트 안의 아무 경로를 주면 `src/<pkg>/lN` 을 찾아 올라간다. 기본은 현재 디렉토리.
+
+## 검사 규칙
+
+| 코드 | 내용 |
+|---|---|
+| C1 | import 대상 층이 자기 층보다 낮아야 한다. 같은 층도 위반. `TYPE_CHECKING` 안의 import 도 포함 |
+| C2 | `pkg.lN.module` 표면까지만 import. 모듈 안의 파일이나 중첩 모듈 내부로 진입 금지 |
+| C3 | 선언 층 == 계산 층 (의존 최고 층 + 1, 의존 없으면 0, 외부 패키지 의존이 있으면 최소 1) |
+| C4 | 모듈 간 runtime import 순환 금지. 모듈 내부 파일 간 순환은 규칙 밖 |
+
+## Claude Code 훅
+
+`.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [{
+      "matcher": "startup|resume|clear|compact",
+      "hooks": [{"type": "command", "command": "python -m lntools hook session-start"}]
+    }],
+    "PostToolUse": [{
+      "matcher": "Edit|Write|MultiEdit",
+      "hooks": [{"type": "command", "command": "python -m lntools hook post-edit", "timeout": 30}]
+    }]
+  }
+}
+```
+
+- session-start: `src/<pkg>/for-agent-layerinfo.md` 를 세션 컨텍스트에 주입
+- post-edit: 편집한 파일이 `src/**/*.py` 이면 그 모듈을 검사.
+  위반은 exit 2 + stderr 로 에이전트에게 오류로 전달되고, 위반이 없으면 영향 범위와
+  문서 stale 여부가 additionalContext 로 전달된다
+
+## 문서
+
+- `for-agent-layerinfo.md` (패키지 루트, 중첩 모듈 루트): 층별 모듈 목록. 마커 사이는 생성, 한 줄 설명과 마커 밖은 보존
+- `for-agent-layerinfo-lN.md` (각 층): 공개 클래스 메서드 시그니처. 마커 사이는 생성
+- `for-agent-moduleinfo.md` (각 모듈): 사람이 쓴다. `sources` 헤더의 hash 로 stale 판정만 한다

ff_lntools-0.1.0/src/ff_lntools.egg-info/SOURCES.txt

@@ -0,0 +1,62 @@
+LICENSE
+README.md
+pyproject.toml
+src/ff_lntools.egg-info/PKG-INFO
+src/ff_lntools.egg-info/SOURCES.txt
+src/ff_lntools.egg-info/dependency_links.txt
+src/ff_lntools.egg-info/entry_points.txt
+src/ff_lntools.egg-info/requires.txt
+src/ff_lntools.egg-info/top_level.txt
+src/lntools/__init__.py
+src/lntools/__main__.py
+src/lntools/for-agent-layerinfo.md
+src/lntools/l0/__init__.py
+src/lntools/l0/for-agent-layerinfo-l0.md
+src/lntools/l0/edge/__init__.py
+src/lntools/l0/edge/edge.py
+src/lntools/l0/initializer/__init__.py
+src/lntools/l0/initializer/initializer.py
+src/lntools/l0/module_ref/__init__.py
+src/lntools/l0/module_ref/module_ref.py
+src/lntools/l0/project_layout/__init__.py
+src/lntools/l0/project_layout/project_layout.py
+src/lntools/l0/raw_import/__init__.py
+src/lntools/l0/raw_import/raw_import.py
+src/lntools/l0/signature_extractor/__init__.py
+src/lntools/l0/signature_extractor/signature_extractor.py
+src/lntools/l0/violation/__init__.py
+src/lntools/l0/violation/violation.py
+src/lntools/l1/__init__.py
+src/lntools/l1/for-agent-layerinfo-l1.md
+src/lntools/l1/graph/__init__.py
+src/lntools/l1/graph/graph.py
+src/lntools/l1/layer_init_writer/__init__.py
+src/lntools/l1/layer_init_writer/layer_init_writer.py
+src/lntools/l1/scanner/__init__.py
+src/lntools/l1/scanner/scanner.py
+src/lntools/l2/__init__.py
+src/lntools/l2/for-agent-layerinfo-l2.md
+src/lntools/l2/blaster/__init__.py
+src/lntools/l2/blaster/blaster.py
+src/lntools/l2/checker/__init__.py
+src/lntools/l2/checker/checker.py
+src/lntools/l2/doc_generator/__init__.py
+src/lntools/l2/doc_generator/doc_generator.py
+src/lntools/l3/__init__.py
+src/lntools/l3/for-agent-layerinfo-l3.md
+src/lntools/l3/hook_runner/__init__.py
+src/lntools/l3/hook_runner/hook_runner.py
+src/lntools/l3/mover/__init__.py
+src/lntools/l3/mover/mover.py
+src/lntools/l4/__init__.py
+src/lntools/l4/for-agent-layerinfo-l4.md
+src/lntools/l4/cli/__init__.py
+src/lntools/l4/cli/cli.py
+src/lntools/protocol/CLAUDE-template.md
+src/lntools/protocol/SKILL-template.md
+src/lntools/protocol/for-agent-codingprotocol-ln-structure.md
+src/lntools/protocol/for-agent-codingprotocol-python.md
+src/lntools/protocol/for-agent-layerinfo-ln-template.md
+src/lntools/protocol/for-agent-layerinfo-template.md
+src/lntools/protocol/for-agent-moduleinfo-template.md
+src/lntools/protocol/settings-hooks-template.json

ff_lntools-0.1.0/src/ff_lntools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ff_lntools-0.1.0/src/ff_lntools.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lnt = lntools.l4.cli:main

ff_lntools-0.1.0/src/ff_lntools.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=8

ff_lntools-0.1.0/src/ff_lntools.egg-info/top_level.txt

@@ -0,0 +1 @@
+lntools

ff_lntools-0.1.0/src/lntools/__init__.py

@@ -0,0 +1,3 @@
+from .l4.cli import main
+
+__all__ = ["main"]

ff_lntools-0.1.0/src/lntools/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .l4.cli import main
+
+sys.exit(main())

ff_lntools-0.1.0/src/lntools/for-agent-layerinfo.md

@@ -0,0 +1,33 @@
+# for-agent-layerinfo.md
+
+<!-- lnt:generated:start -->
+## l0
+- edge: 모듈 간 의존 간선. kind runtime/type_only/inherits, 표면 초과 경로 extra
+- initializer: lnt init. 프로토콜 문서 복사, CLAUDE.md, 훅 병합, 스킬 설치
+- module_ref: ln 모듈 하나. 이름, 스코프, 선언 층, 파일 목록, 외부 의존 여부
+- project_layout: 프로젝트 루트와 src/<pkg> 탐색. LAYER_RE
+- raw_import: 해석 전 import 문 하나. target, names, kind, external
+- signature_extractor: 모듈 __init__ 공개 이름과 클래스 메서드 시그니처를 ast 로 추출
+- violation: 규칙 위반 C1~C4 레코드와 포맷
+
+## l1
+- graph: 모듈 그래프. 계산 층, 역의존, 인터페이스 경유 blast, 순환 탐지
+- layer_init_writer: 층 __init__.py 를 PEP 562 지연 re-export 형태로 생성
+- scanner: src/<pkg> 를 훑어 모듈과 간선 생성. 상대/절대/층 단위 import 해석, TYPE_CHECKING 구분
+
+## l2
+- blaster: blast 결과 텍스트 보고서
+- checker: C1 방향, C2 표면, C3 층 일치, C4 순환 검사
+- doc_generator: layerinfo/layerinfo-ln 생성과 검사, moduleinfo sources hash stamp/stale
+
+## l3
+- hook_runner: Claude Code 훅 진입. stdin JSON 해석, exit 2 / additionalContext 채널 선택
+- mover: lnt move. 모듈 층 이동, import 재작성, tests 미러, 층 __init__ 와 문서 재생성
+
+## l4
+- cli: lnt 명령줄. check, blast, map, doc, hook
+<!-- lnt:generated:end -->
+
+## Notes
+
+의존은 항상 아래로만. l4 cli 가 진입점이며 모든 하위를 조립한다.

ff_lntools-0.1.0/src/lntools/l0/__init__.py

@@ -0,0 +1,22 @@
+import importlib
+
+# 공개 이름 -> 모듈 폴더명. 지연 로드
+_EXPORTS = {
+    "Edge": "edge",
+    "Initializer": "initializer",
+    "LAYER_RE": "project_layout",
+    "PROTOCOL_FILES": "initializer",
+    "ModuleRef": "module_ref",
+    "ProjectLayout": "project_layout",
+    "RawImport": "raw_import",
+    "SignatureExtractor": "signature_extractor",
+    "Violation": "violation",
+}
+__all__ = list(_EXPORTS)
+
+
+def __getattr__(name: str):
+    if name in _EXPORTS:
+        mod = importlib.import_module(f".{_EXPORTS[name]}", __name__)
+        return getattr(mod, name)
+    raise AttributeError(name)

ff_lntools-0.1.0/src/lntools/l0/edge/__init__.py

@@ -0,0 +1,3 @@
+from .edge import Edge
+
+__all__ = ["Edge"]

ff_lntools-0.1.0/src/lntools/l0/edge/edge.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+# 모듈 간 의존 간선. import 문 하나가 간선 하나
+@dataclass
+class Edge:
+    src: str              # 출발 모듈 이름
+    dst: str | None       # 도착 모듈 이름. 층 단위 import에서 이름을 못 풀면 None
+    dst_layer: int        # 도착 층 번호
+    kind: str             # runtime | type_only | inherits
+    file: Path            # import 문이 있는 파일
+    line: int
+    target: str           # import 문에 쓰인 점 경로 (패키지명 제외)
+    extra: str = ""       # 도착 모듈 표면을 지나 들어간 나머지 경로. 비어있지 않으면 표면 위반
+
+    @property
+    def counts_for_layer(self) -> bool:
+        # 층 계산에 포함되는 간선. 상속 간선은 이미 runtime 간선이 따로 있으므로 제외
+        return self.kind in ("runtime", "type_only")

ff_lntools-0.1.0/src/lntools/l0/for-agent-layerinfo-l0.md

@@ -0,0 +1,40 @@
+# l0
+
+<!-- lnt:generated:start -->
+## edge
+Edge.counts_for_layer() -> bool  # edge.py
+
+## initializer
+Initializer.__init__(project_root: Path, home: Path | None=None)  # initializer.py
+Initializer.run() -> list[str]  # initializer.py
+Initializer.merge_hooks() -> str  # initializer.py
+Initializer.install_skill() -> Path  # initializer.py
+PROTOCOL_FILES  # 정의를 찾지 못함
+
+## module_ref
+ModuleRef.basename() -> str  # module_ref.py
+ModuleRef.layer_name() -> str  # module_ref.py
+ModuleRef.contains(other: str) -> bool  # module_ref.py
+
+## project_layout
+ProjectLayout.__init__(project_root: Path, package_root: Path)  # project_layout.py
+ProjectLayout.package_name() -> str  # project_layout.py
+ProjectLayout.src_dir() -> Path  # project_layout.py
+ProjectLayout.has_layers(d: Path) -> bool  # project_layout.py
+ProjectLayout.find(start: Path) -> 'ProjectLayout | None'  # project_layout.py
+ProjectLayout.relative(path: Path) -> str  # project_layout.py
+LAYER_RE  # 정의를 찾지 못함
+
+## raw_import
+RawImport  # raw_import.py (공개 메서드 없음)
+
+## signature_extractor
+SignatureExtractor.exports_of(module_dir: Path) -> list[str]  # signature_extractor.py
+SignatureExtractor.extract(module_dir: Path, exported: list[str]) -> list[str]  # signature_extractor.py
+
+## violation
+Violation.format(base: Path | None=None) -> str  # violation.py
+<!-- lnt:generated:end -->
+
+## Notes
+

ff_lntools-0.1.0/src/lntools/l0/initializer/__init__.py

@@ -0,0 +1,3 @@
+from .initializer import Initializer, PROTOCOL_FILES
+
+__all__ = ["Initializer", "PROTOCOL_FILES"]

ff_lntools-0.1.0/src/lntools/l0/initializer/initializer.py

@@ -0,0 +1,63 @@
+import json
+from importlib import resources
+from pathlib import Path
+
+PROTOCOL_FILES = [
+    "for-agent-codingprotocol-ln-structure.md",
+    "for-agent-codingprotocol-python.md",
+    "for-agent-layerinfo-template.md",
+    "for-agent-layerinfo-ln-template.md",
+    "for-agent-moduleinfo-template.md",
+]
+
+
+# 프로젝트에 코딩 프로토콜을 설치한다. 문서 복사, CLAUDE.md, 훅 병합, 스킬 설치
+class Initializer:
+    def __init__(self, project_root: Path, home: Path | None = None):
+        self.project_root = project_root
+        self.home = home if home is not None else Path.home()
+        self.claude_dir = project_root / ".claude"
+
+    @staticmethod
+    def _protocol(name: str) -> str:
+        return (resources.files("lntools") / "protocol" / name).read_text(encoding="utf-8")
+
+    # 반환: 한 일의 설명 줄 목록
+    def run(self) -> list[str]:
+        done: list[str] = []
+        self.claude_dir.mkdir(parents=True, exist_ok=True)
+        for name in PROTOCOL_FILES:
+            (self.claude_dir / name).write_text(self._protocol(name), encoding="utf-8")
+            done.append(f".claude/{name}")
+        claude_md = self.project_root / "CLAUDE.md"
+        if claude_md.is_file():
+            done.append("CLAUDE.md 이미 존재 (건너뜀)")
+        else:
+            claude_md.write_text(self._protocol("CLAUDE-template.md"), encoding="utf-8")
+            done.append("CLAUDE.md 생성")
+        done.append(self.merge_hooks())
+        return done
+
+    # settings.json 의 hooks 에 템플릿 훅을 합친다. 같은 command 가 이미 있으면 건너뛴다
+    def merge_hooks(self) -> str:
+        tpl = json.loads(self._protocol("settings-hooks-template.json"))
+        dst = self.claude_dir / "settings.json"
+        cur = json.loads(dst.read_text(encoding="utf-8")) if dst.is_file() else {}
+        hooks = cur.setdefault("hooks", {})
+        added = 0
+        for event, groups in tpl["hooks"].items():
+            existing = hooks.setdefault(event, [])
+            have = {h.get("command") for g in existing for h in g.get("hooks", [])}
+            for g in groups:
+                if not any(h.get("command") in have for h in g["hooks"]):
+                    existing.append(g)
+                    added += 1
+        dst.write_text(json.dumps(cur, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        return f".claude/settings.json 훅 {added}개 추가" if added else ".claude/settings.json 훅 이미 있음"
+
+    # ~/.claude/skills/init-protocol/SKILL.md 설치
+    def install_skill(self) -> Path:
+        p = self.home / ".claude" / "skills" / "init-protocol" / "SKILL.md"
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(self._protocol("SKILL-template.md"), encoding="utf-8")
+        return p

ff_lntools-0.1.0/src/lntools/l0/module_ref/__init__.py

@@ -0,0 +1,3 @@
+from .module_ref import ModuleRef
+
+__all__ = ["ModuleRef"]

ff_lntools-0.1.0/src/lntools/l0/module_ref/module_ref.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+# ln-structure 모듈 하나. 이름은 패키지 루트 기준 점 경로 (예: l1.order, l3.portfolio.l1.store)
+@dataclass
+class ModuleRef:
+    name: str
+    scope: str            # 소속 스코프. 루트는 "", 중첩 모듈 내부는 감싸는 모듈 이름
+    layer: int            # 선언 층 (디렉토리 번호)
+    path: Path            # 모듈 디렉토리
+    files: list[Path] = field(default_factory=list)   # 모듈에 속한 모든 .py (중첩 내부 포함)
+    has_external: bool = False                         # 표준 라이브러리 외 패키지 import 여부
+    is_nested: bool = False                            # 내부에 lN 디렉토리를 가지는지
+
+    @property
+    def basename(self) -> str:
+        return self.name.rsplit(".", 1)[-1]
+
+    @property
+    def layer_name(self) -> str:
+        # 소속 층의 이름. 예: l1, l3.portfolio.l1
+        return self.name.rsplit(".", 1)[0]
+
+    def contains(self, other: str) -> bool:
+        return other.startswith(self.name + ".")

ff_lntools-0.1.0/src/lntools/l0/project_layout/__init__.py

@@ -0,0 +1,3 @@
+from .project_layout import ProjectLayout, LAYER_RE
+
+__all__ = ["ProjectLayout", "LAYER_RE"]