@chrono-meta/fh-gate 3.4.0 → 3.5.0

package/plugins/fh-preprep/skills/preprep/oox.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+"""oox — 세 레인(geometry · attr_consistency · screen_parity)이 공유하는 OOXML 독자.
+
+🟥 왜 있나 (2026-09-11, codex cross-family R1~R6 — 여섯 라운드 연속): 각 레인이 정규식으로 XML 을 읽었고
+   매 라운드 같은 부류가 S/A 를 냈다 — 속성 순서(`<a:off y= x=>`·`<p:sldId r:id= id=>`·`<p:sldSz cy= cx=>`),
+   접두 변이(`<q:sldId xmlns:q=…>`), 여는 태그의 속성(`<p:sp useBgFill>`), 엔티티(`&amp;` vs `&#38;`),
+   중첩 그룹의 변환(flip·이동)이 자식에 안 붙음. 「조이지 말고 줄여라」— 정규식을 지우고 **트리로 읽는다**.
+   태그는 지역명(local-name)으로 맞춘다: 실물의 `p:`/`a:` 도, 레인 픽스처의 가짜 접두(`xmlns:p="p"`)도 같이 읽힌다.
+   그룹은 grpSpPr/xfrm(off·ext·chOff·chExt·flipH/V) 을 **재귀로 합성**해 자식 좌표를 절대 EMU 로 낸다.
+
+이 파일은 정규식을 «안» 쓴다(접두 결박 한 줄 제외). 도형의 «무엇»(이름·좌표·flip·문단·런·선)만 낸다 —
+판정은 각 레인의 몫이다.
+"""
+import re, zipfile, xml.etree.ElementTree as ET
+
+_PREFIX_RE = re.compile(r'\b(p|a|r):')
+
+
+def parse_xml(s):
+    """XML 문자열 → 루트. 레인 픽스처처럼 접두가 «선언 없이» 쓰인 문서도 읽는다(루트에 임시 결박)."""
+    if isinstance(s, bytes):
+        s = s.decode('utf-8', 'replace')
+    _NSMAP.clear(); _NSMAP.update({p_: u for p_, u in re.findall(r'xmlns:([\w.-]+)\s*=\s*["\']([^"\']*)["\']', s)})
+    m = None
+    for m_ in re.finditer(r'<!--.*?-->|<\?.*?\?>|<!\[CDATA\[.*?\]\]>|<([A-Za-z_][\w.-]*:)?[A-Za-z_][\w.-]*\b[^>]*>', s, re.S):   # R8 B10: 주석·PI 안의 태그는 루트가 아니다
+        if not m_.group(0).startswith(('<!--', '<?', '<![CDATA[')):
+            m = m_
+            break
+    if m:
+        head = m.group(0)
+        need = [p for p in ('p', 'a', 'r') if not re.search(r'xmlns:%s\s*=' % p, head) and re.search(r'\b%s:' % p, s)]   # R7 B8: `xmlns:p = "…"` 도 선언이다
+        if need:
+            inj = ''.join(' xmlns:%s="urn:fh-unbound-%s"' % (p, p) for p in need)
+            s = s[:m.start()] + head[:-1].rstrip('/') + inj + ('/>' if head.endswith('/>') else '>') + s[m.end():]
+    return ET.fromstring(s)
+
+
+def local(tag):
+    return tag.rsplit('}', 1)[-1] if '}' in tag else tag.split(':', 1)[-1]
+
+
+def attr(el, name):
+    """지역명으로 속성 찾기 — `r:id` 든 `{ns}id` 든."""
+    for k, v in el.attrib.items():
+        if local(k) == name:
+            return v
+    return None
+
+
+def children(el, name):
+    return [c for c in el if local(c.tag) == name]
+
+
+def child(el, name):
+    cs = children(el, name)
+    return cs[0] if cs else None
+
+
+def find_desc(el, name):
+    for d in el.iter():
+        if d is not el and local(d.tag) == name:
+            return d
+    return None
+
+
+# ── 발표 순서 ─────────────────────────────────────────────────────────────
+
+def slide_order(z):
+    """[슬라이드 파일 번호 …] 발표 순서. 못 푸는 r:id 는 KeyError 로 올라간다(조용히 안 빠진다)."""
+    rels = {}
+    for rel in parse_xml(z.read('ppt/_rels/presentation.xml.rels')).iter():
+        if local(rel.tag) != 'Relationship':
+            continue
+        tgt = attr(rel, 'Target') or ''
+        if tgt.startswith('/'):                                        # R8 B7: OPC 절대 Target
+            tgt = tgt[len('/ppt/'):] if tgt.startswith('/ppt/') else tgt.lstrip('/')
+        m = re.fullmatch(r'slides/slide(\d+)\.xml', tgt)
+        if m and attr(rel, 'Id'):
+            rels[attr(rel, 'Id')] = int(m.group(1))
+    pres = parse_xml(z.read('ppt/presentation.xml'))
+    lst = find_desc(pres, 'sldIdLst')
+    out = []
+    for sid in (list(lst) if lst is not None else []):
+        if local(sid.tag) != 'sldId':
+            continue
+        rid = attr(sid, 'id') if attr(sid, 'id') and not str(attr(sid, 'id')).isdigit() else None
+        # r:id 와 id 가 둘 다 «id» 지역명이다 — 숫자가 아닌 쪽이 관계 id
+        for k, v in sid.attrib.items():
+            if local(k) == 'id' and not str(v).isdigit():
+                rid = v
+        out.append(rels[rid])
+    return out
+
+
+def slide_size(z):
+    """(cx, cy) EMU. 없으면 None."""
+    pres = parse_xml(z.read('ppt/presentation.xml'))
+    sz = find_desc(pres, 'sldSz')
+    if sz is None or attr(sz, 'cx') is None or attr(sz, 'cy') is None:
+        return None
+    return int(attr(sz, 'cx')), int(attr(sz, 'cy'))
+
+
+# ── 변환 합성 ─────────────────────────────────────────────────────────────
+
+class _T:
+    """그룹 변환의 «사슬». 자식 좌표 → (chOff 빼고 × scale) → 이 그룹 자신의 flip 으로 상자 안에서 반사 → off 더해
+    부모 좌표 → 부모에게 같은 절차. 반사를 **각 단계에서** 하므로 바깥 그룹의 flip 이 안쪽 그룹의 내부 배치까지 거울로
+    옮긴다(R7 A4 — 초판은 표식만 XOR 하고 자리를 안 옮겨 «이동» 이 사라졌다).
+    회전(rot)은 합성하지 않는다 — 사슬 어딘가에 rot 가 있으면 `rot_unmeasured` 로 이름을 남긴다(잔여)."""
+    __slots__ = ('parent', 'ox', 'oy', 'sx', 'sy', 'chx', 'chy', 'gcx', 'gcy', 'own', 'flips', 'rot_unmeasured', 'geo_unmeasured')
+
+    def __init__(self):
+        self.parent = None
+        self.ox = self.oy = 0; self.sx = self.sy = 1.0; self.chx = self.chy = 0; self.gcx = self.gcy = 0
+        self.own = set(); self.flips = set(); self.rot_unmeasured = False; self.geo_unmeasured = False
+
+    def _apply_f(self, x, y, cx, cy):
+        if self.parent is None:
+            return (x, y, cx, cy)
+        lx, ly = (x - self.chx) * self.sx, (y - self.chy) * self.sy
+        w, h = cx * self.sx, cy * self.sy
+        if 'H' in self.own:
+            lx = self.gcx - lx - w
+        if 'V' in self.own:
+            ly = self.gcy - ly - h
+        return self.parent._apply_f(self.ox + lx, self.oy + ly, w, h)
+
+    def apply(self, x, y, cx, cy):
+        return tuple(int(round(v)) for v in self._apply_f(x, y, cx, cy))
+
+    def then(self, xfrm):
+        """이 변환 «안» 의 그룹 xfrm 을 합성한 새 변환."""
+        t = _T()
+        t.parent = self
+        off, ext, choff, chext = (child(xfrm, n) for n in ('off', 'ext', 'chOff', 'chExt'))
+        gx, gy = (int(attr(off, 'x') or 0), int(attr(off, 'y') or 0)) if off is not None else (0, 0)
+        gcx, gcy = (int(attr(ext, 'cx') or 0), int(attr(ext, 'cy') or 0)) if ext is not None else (0, 0)
+        cx0, cy0 = (int(attr(choff, 'x') or 0), int(attr(choff, 'y') or 0)) if choff is not None else (gx, gy)
+        ccx, ccy = (int(attr(chext, 'cx') or 0), int(attr(chext, 'cy') or 0)) if chext is not None else (gcx, gcy)
+        t.ox, t.oy = gx, gy                        # 부모 좌표계 값 그대로 — 부모 변환은 사슬이 통과시킨다
+        t.sx = (gcx / ccx) if ccx else 1.0
+        t.sy = (gcy / ccy) if ccy else 1.0
+        t.chx, t.chy = cx0, cy0
+        t.gcx, t.gcy = gcx, gcy                    # 이 그룹 상자(부모 좌표계 크기) — 자식 반사의 기준
+        for k in ('H', 'V'):
+            if attr(xfrm, 'flip' + k) in ('1', 'true'):
+                t.own.add(k)
+        t.flips = set(self.flips) ^ t.own
+        t.rot_unmeasured = self.rot_unmeasured or attr(xfrm, 'rot') not in (None, '0')
+        # R8 B11: ext 또는 chExt 가 0/부재인 그룹은 배율이 정의되지 않는다 — «안 움직였다» 로 접지 말고 이름으로 남긴다
+        t.geo_unmeasured = self.geo_unmeasured or not (gcx and gcy and ccx and ccy)
+        return t
+
+
+def _xfrm_of(el):
+    """도형 요소의 xfrm — spPr/grpSpPr/graphicFrame 의 p:xfrm 중 첫 것."""
+    for d in el.iter():
+        if d is not el and local(d.tag) == 'xfrm':
+            return d
+    return None
+
+
+def _text_of(el):
+    return ''.join(el.itertext())
+
+
+# mc:AlternateContent — «우리가 읽는» 네임스페이스. Choice 의 Requires 접두가 전부 여기 결박돼 있으면 그 Choice 를 고르고,
+# 하나라도 모르는 네임스페이스면 Fallback 을 고른다(OOXML Part 3 §8.3.4.2.1 — 이해 못 하는 Choice 는 건너뛴다). R9 A7a.
+KNOWN_NS = {
+    'http://schemas.openxmlformats.org/presentationml/2006/main',
+    'http://schemas.openxmlformats.org/drawingml/2006/main',
+    'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+    'http://schemas.openxmlformats.org/markup-compatibility/2006',
+    'http://schemas.microsoft.com/office/powerpoint/2010/main',
+    'http://schemas.microsoft.com/office/powerpoint/2012/main',
+    'http://schemas.microsoft.com/office/drawing/2010/main',
+    'http://schemas.microsoft.com/office/drawing/2014/main',
+}
+_NSMAP = {}          # 마지막으로 parse_xml 한 문서의 접두 → URI (Requires 판정용)
+
+
+def select_alternate(el):
+    """mc:AlternateContent 원소 → 걸을 자식(Choice 또는 Fallback) 또는 None.
+    빈 Choice 라도 «이해하는» Requires 면 그 Choice(=아무것도 안 그림)다 — Element 진리값(길이)으로 고르지 않는다(R8 B6)."""
+    for c in el:
+        if local(c.tag) != 'Choice':
+            continue
+        req = (attr(c, 'Requires') or '').split()
+        # 접두 p·a·r·mc 는 이 독자가 «이름으로» 읽는 것이라 URI 가 무엇이든 이해한다(레인 픽스처는 가짜 URI 를 쓴다)
+        if all(p_ in ('p', 'a', 'r', 'mc') or _NSMAP.get(p_) in KNOWN_NS for p_ in req):
+            return c
+        # 모르는 네임스페이스를 요구하는 Choice 는 건너뛴다 → 다음 Choice / Fallback
+    return child(el, 'Fallback')
+
+
+def _iter_selected(el):
+    """el 의 자손을 문서 순서로 — 단 AlternateContent 는 «선택된 분기» 만 들어간다(R9 A8: 양쪽 문단을 다 세던 구멍)."""
+    for c in el:
+        if local(c.tag) == 'AlternateContent':
+            alt = select_alternate(c)
+            if alt is not None:
+                yield from _iter_selected(alt)
+            continue
+        yield c
+        yield from _iter_selected(c)
+
+
+def _paras(el):
+    """[{'algn': str|None, 'runs': [(text, sz_pt|None)]}] — 문단 단위, endParaRPr 제외, fld 포함."""
+    out = []
+    for p in _iter_selected(el):
+        if local(p.tag) != 'p':
+            continue
+        ppr = child(p, 'pPr')
+        algn = attr(ppr, 'algn') if ppr is not None else None
+        runs = []
+        for r in p:
+            if local(r.tag) in ('r', 'fld'):
+                rpr = child(r, 'rPr')
+                sz = int(attr(rpr, 'sz')) / 100 if (rpr is not None and attr(rpr, 'sz')) else None
+                t = ''.join(x.text or '' for x in r.iter() if local(x.tag) == 't')
+                runs.append((t, sz))
+            elif local(r.tag) == 'br':
+                runs.append(('\n', None))
+        out.append({'algn': algn, 'runs': runs})
+    return out
+
+
+def walk_slide(z, sn):
+    """한 슬라이드의 «화면에 놓이는» 도형 전부(그룹은 풀어서, 좌표는 절대 EMU 로 합성).
+    반환: [{'name','kind','x','y','cx','cy','flip','paras','ln_w','dash','in_group'} …] 문서 순서."""
+    root = parse_xml(z.read('ppt/slides/slide%d.xml' % sn))
+    tree = find_desc(root, 'spTree')
+    if tree is None:
+        return []
+    out = []
+    _walk(tree, _T(), out, False)
+    return out
+
+
+def _walk(container, T, out, in_group):
+    for el in container:
+        kind = local(el.tag)
+        if kind == 'AlternateContent':                       # R7 A5 · R8 B6 · R9 A7a: 선택 규칙은 select_alternate 한 곳
+            alt = select_alternate(el)
+            if alt is not None:
+                _walk(alt, T, out, in_group)
+            continue
+        if kind == 'grpSp':
+            gpr = child(el, 'grpSpPr')
+            xf = child(gpr, 'xfrm') if gpr is not None else None
+            _walk(el, T.then(xf) if xf is not None else T, out, True)
+            continue
+        if kind not in ('sp', 'cxnSp', 'pic', 'graphicFrame'):
+            continue
+        nv = None
+        for d in el:
+            if local(d.tag).startswith('nv') and local(d.tag).endswith('Pr'):
+                nv = d
+        cnv = child(nv, 'cNvPr') if nv is not None else None
+        name = attr(cnv, 'name') if cnv is not None else None
+        xf = _xfrm_of(el)
+        geo = None
+        if xf is not None:
+            off, ext = child(xf, 'off'), child(xf, 'ext')
+            if off is not None and ext is not None and all(attr(off, k) is not None for k in ('x', 'y')) and all(attr(ext, k) is not None for k in ('cx', 'cy')):
+                geo = T.apply(int(attr(off, 'x')), int(attr(off, 'y')), int(attr(ext, 'cx')), int(attr(ext, 'cy')))
+        flips = set(T.flips)
+        if xf is not None:
+            for k in ('H', 'V'):
+                if attr(xf, 'flip' + k) in ('1', 'true'):
+                    flips ^= {k}
+        ln = None
+        spr = child(el, 'spPr')
+        if spr is not None:
+            ln = child(spr, 'ln')
+        ln_w = int(attr(ln, 'w')) if (ln is not None and attr(ln, 'w')) else None
+        dash_el = child(ln, 'prstDash') if ln is not None else None
+        dash = attr(dash_el, 'val') if dash_el is not None else None
+        # 문단: txBody 의 것 + 표(graphicFrame) 셀의 것
+        paras = []
+        tx = child(el, 'txBody')
+        if tx is not None:
+            paras = _paras(tx)
+        elif kind == 'graphicFrame':
+            paras = _paras(el)
+        out.append(dict(name=name, kind=kind, x=geo[0] if geo else None, y=geo[1] if geo else None,
+                        cx=geo[2] if geo else None, cy=geo[3] if geo else None,
+                        flip=''.join(k for k in ('H', 'V') if k in flips), paras=paras,
+                        ln_w=ln_w, dash=dash, in_group=in_group, rot_unmeasured=T.rot_unmeasured, geo_unmeasured=T.geo_unmeasured))
+
+
+def para_texts(paras):
+    """문단 텍스트 목록(런 '' 로 이어붙임, 공백 정규화, 빈 문단 제외)."""
+    res = []
+    for p in paras:
+        t = re.sub(r'\s+', ' ', ''.join(t for t, _ in p['runs'])).strip()
+        if t:
+            res.append(t)
+    return res
+
+
+def shape_text(paras):
+    return ' '.join(para_texts(paras))

package/plugins/{fh-commons → fh-preprep}/skills/preprep/preprep.py

@@ -776,8 +776,9 @@ def main():
     #    [[feedback_rule_misdescribes_its_own_machine]] · [[feedback_instrument_vs_target_and_budget]]
     _lanes = sorted(n[5:] for n in globals() if n.startswith('lane_') and callable(globals()[n]))
     _mods = sorted(m for m in ('lane_promise', 'lane_adjacent_dup', 'lane_progression',
-                                'lane_slide_relations', 'lane_geometry', 'lane_diagram', 'lane_slide_refs',
-                                'lane_font')
+                                'lane_slide_relations', 'lane_geometry', 'lane_attr_consistency',
+                                'lane_screen_parity',
+                                'lane_diagram', 'lane_slide_refs', 'lane_font')
                    if os.path.exists(os.path.join(HERE, m + '.py')))
     # 🟥 2026-09-04 신설 — `--lane R1,R2,...` 로 **새 모듈 레인(R1-R5·P1/P3)만** 골라 끈다/켠다.
     #    L1~L11 은 아직 이 필터를 안 탄다(usage 줄의 --lane 은 그쪽엔 미배선인 채 남아 있다 —
@@ -793,7 +794,30 @@ def main():
     print(f"   레인 {len(_mods)}(모듈): {' · '.join(m[5:] for m in _mods) if _mods else '🟥 없음 — 갈라진 사본일 수 있다'}")
     cfg_path = sys.argv[1] if len(sys.argv) > 1 and not sys.argv[1].startswith('--') \
                else os.path.join(HERE, 'surfaces.yaml')
-    cfg = load(cfg_path)
+    # 🟥 2026-09-13 — 설정을 못 읽는 것은 «발견» 이 아니라 «판정불가» 다.
+    #    종전엔 `load()` 가 그대로 터져 트레이스백 + rc=1 이었고, 이 파일의 선언(SKILL.md:164
+    #    「0 통과 · 1 발견 · 2 판정불가(계기오류/미측정)」)에서 **1 은 「발견 있음」**이다.
+    #    즉 「아무것도 못 쟀다」가 「뭔가 찾았다」와 **같은 종료코드**로 나갔다 — 부르는 쪽이
+    #    둘을 못 가른다. 이 저장소가 이름으로 관리하는 「미측정을 0(또는 남의 값)으로 렌더」의
+    #    한 얼굴이다. 그래서 여기서 잡아 **2** 로 확정한다(설정이 없으면 레인은 한 줄도 안 돌았다).
+    try:
+        cfg = load(cfg_path)
+    except FileNotFoundError:
+        print(f"\n{ANSI_BAD} 설정을 못 찾았다: {cfg_path}")
+        print(f"   이 디렉터리에 surfaces.example.yaml 이 있다 — 복사해서 surfaces.yaml 로 쓰거나,")
+        print(f"   설정 경로를 첫 인자로 줘라:  python3 preprep.py <설정.yaml>")
+        print(f"   ⚠️ 이것은 «발견 0» 이 아니라 «한 줄도 안 쟀다» 다 (exit 2 = 판정불가).")
+        return 2
+    except Exception as e:
+        print(f"\n{ANSI_BAD} 설정을 읽을 수 없다: {cfg_path}\n   {type(e).__name__}: {e}")
+        print(f"   ⚠️ «발견 0» 이 아니라 «한 줄도 안 쟀다» 다 (exit 2 = 판정불가).")
+        return 2
+    if not isinstance(cfg, dict) or 'root' not in cfg or 'surfaces' not in cfg:
+        # 파싱은 됐는데 계약이 아니다 — 빈 파일(`yaml.safe_load` → None)이 여기로 온다.
+        # 이것도 「돌았는데 발견 0」이 아니라 「돌 수 없었다」다.
+        print(f"\n{ANSI_BAD} 설정에 필수 키가 없다: {cfg_path} (root · surfaces)")
+        print(f"   ⚠️ «발견 0» 이 아니라 «한 줄도 안 쟀다» 다 (exit 2 = 판정불가).")
+        return 2
     root = os.path.expanduser(cfg['root'])
     surf = {s['id']: s for s in cfg['surfaces']}
 
@@ -899,6 +923,21 @@ def main():
         except Exception as _e:
             notes.append('P1/P3 geometry : 계기 미실행 — NOT_WIRED (%s: %s) (0 아님)'
                          % (type(_e).__name__, _e))
+    try:
+        import lane_screen_parity
+        _f14, _n14 = lane_screen_parity.scan(cfg, root)
+        notes += _n14   # advisory 고정 — L8·L11 관례
+    except Exception as _e:
+        notes.append('L14 screen-parity : 계기 미실행 — NOT_WIRED (%s: %s) (0 아님)'
+                     % (type(_e).__name__, _e))
+    if _lane_on('P4', 'P'):
+        try:
+            import lane_attr_consistency
+            _f4, _n4 = lane_attr_consistency.scan(cfg, root)
+            notes += _n4   # advisory 고정 — 같은 관례
+        except Exception as _e:
+            notes.append('P4 attr-consistency : 계기 미실행 — NOT_WIRED (%s: %s) (0 아님)'
+                         % (type(_e).__name__, _e))
 
     for n in notes: print(f"   · {n}")
     use = [f for f in findings if f[1] != 'mention']
@@ -922,4 +961,13 @@ def main():
 #    못 쓴다(레인 하나만 부르려 해도 전체가 돌고 종료한다). 배포본이 된 뒤에 드러난 결함이다:
 #    스킬 문서가 «레인을 골라 부를 수 있다»는 인상을 주는데 실제로는 CLI 한 형태뿐이었다.
 if __name__ == '__main__':
-    sys.exit(main())
+    # ── 사용 원장 (2026-09-13) — 🟥 **옵트인**이다. `FH_USAGE_LEDGER` 가 없으면 완전 무동작이고
+    #    배포본에서 아무것도 안 남긴다(동의 없는 계측 금지 · 부재 ≠ 승인).
+    #    🟥 **판정을 안 바꾼다**: `observe` 는 `main()` 의 반환값을 그대로 통과시키고, 원장 쓰기가
+    #    실패해도 예외를 여기로 올리지 않는다. 관측이 대상을 바꾸면 그 숫자는 의미가 없다.
+    #    모듈이 없어도(부분 설치) 종전과 같이 돈다 — 그게 이 try 의 유일한 목적이다.
+    try:
+        from usage_ledger import observe as _observe
+    except Exception:
+        _observe = None
+    sys.exit(_observe('preprep', 'cli', main) if _observe else main())