Skip to content

hany202507/finance-ai-skills / skills/분개테스트

분개테스트

Verified

회사 분개장 엑셀 전부를 엔진이 판독해 감사 분개 테스트(JET, 한공회 3600-JET) 조서를 엑셀로 만든다. 완전성(받은 파일별 줄 수 · 기간 · 잘림 · 빠진 달, 차대 일치 · 손익계정 분개장 순액 = 시산표), 시험 스물여섯 가지의 건수 · 금액 · 결과 목록, 먼저 볼 전표(고위험 전부 · 점수 상위), 회계사 검토 칸을 낸다. 시험은 주말 · 공휴일, 기말 후 취소 · 역분개, 결산일 근처 큰 금액, 드문 계정 조합, 끝자리 0 반복, 적요 없음, 수기 조정, 전표 형식 이상, 전표번호 중복 · 순서 역전, 한 번만 나온 거래처의 큰 금액, 결산일 근처 이익을 늘린 전표, 중복 의심, 대표 · 주주 · 임원 관련 계정, 자본 계정, 적요 주의 낱말, 계정별로 평소보다 큰 금액, 결산일 근처 가계정 정리, 추정 계정의 기말 조정 · 환입, 현금 · 채권 · 채무 없이 이익을 늘린 전표, 드물게 쓰는 계정, 결산일 근처 매출의 기말 후 회수 없음, 승인 한도 바로 아래 금액(한도를 넣었을 때), 그리고 작성자 · 승인자 · 입력일시 열이 있을 때 자기 승인, 드물게 분개한 작성자, 결산 후 입력, 업무 시간이 아닌 입력이다. 첫 자리 분포(벤포드) · 월별 매출 · 전표번호 연속성 분석 시트와 여러 시험에 걸린 전표 시트도 낸다. 더존 · 위하고 등 여러 꼴의 분개장(한 줄에 계정 하나인 꼴, 한 행에 차변 계정 · 대변 계정이 함께 있는 꼴)을 읽는다. "JET", "분개 테스트", "분개장 전수", "3600-JET", "기말 후 취소 전표", "역분개", "주말 전표", "수기 전표", "이상 분개", "경영진 무시 위험", "저널 엔트리 테스트", "자기 승인 전표", "결산 후 입력", "전표번호 누락", "중복 전표", "벤포드", "가지급금 전표"가 언급되면 트리거.

FileKindSize
README.mdmarkdown3.4 KB
SKILL.mdskill md13.9 KB
examples/모의자료/분개장_2025.xlsxbinary109.0 KB
examples/모의자료/분개장_2026_기말후.xlsxbinary23.5 KB
examples/모의자료/재무제표_시산표.xlsxbinary5.9 KB
references/시험해보기.mdmarkdown1.6 KB
requirements.txtmanifest89 B
scripts/audit/__init__.pyscript273 B
scripts/audit/analysis/__init__.pyscript159 B
scripts/audit/analysis/defs.pyscript7.4 KB
scripts/audit/analysis/pdfread.pyscript18.7 KB
scripts/audit/assign.pyscript12.6 KB
scripts/audit/checklists.pyscript35.4 KB
scripts/audit/dart.pyscript22.3 KB
scripts/audit/director.pyscript62.0 KB
scripts/audit/errors.pyscript503 B
scripts/audit/figures.pyscript35.4 KB
scripts/audit/folder.pyscript27.1 KB
scripts/audit/index.pyscript28.9 KB
scripts/audit/ocr.pyscript13.2 KB
scripts/audit/params.pyscript15.3 KB
scripts/audit/prior.pyscript29.8 KB
scripts/audit/priorwp.pyscript33.6 KB
scripts/audit/reader.pyscript94.6 KB
scripts/audit/records.pyscript21.9 KB
scripts/audit/shareholders.pyscript19.9 KB
scripts/audit/start.pyscript81.8 KB
scripts/audit/style.pyscript7.8 KB
scripts/audit/workpapers/__init__.pyscript159 B
scripts/audit/workpapers/common.pyscript32.9 KB
scripts/audit/workpapers/jet.pyscript98.3 KB
scripts/audit/wp.pyscript34.5 KB
scripts/definitions/accounts.yamlconfig19.4 KB
scripts/definitions/folder_standard.yamlconfig15.1 KB
scripts/definitions/index_schema.jsonconfig19.1 KB
scripts/definitions/index_schema_analysis.jsonconfig15.2 KB
scripts/definitions/index_schema_apply.jsonconfig4.2 KB
scripts/definitions/index_schema_assign.jsonconfig977 B
scripts/definitions/index_schema_close.jsonconfig2.7 KB
scripts/definitions/index_schema_prior.jsonconfig5.1 KB
scripts/definitions/index_schema_report.jsonconfig4.1 KB
scripts/definitions/index_schema_start.jsonconfig8.8 KB
scripts/definitions/index_schema_workpapers.jsonconfig6.1 KB
scripts/definitions/jet.yamlconfig24.3 KB
scripts/definitions/received_links.yamlconfig2.0 KB
scripts/definitions/workpapers.yamlconfig20.4 KB
scripts/run.pyscript5.8 KB
tests/make_entry_columns.pyscript5.1 KB
tests/test_jet.pyscript17.3 KB

scripts/audit/wp.py

View on GitHub
"""조서 엑셀 공통: 모양 · 기입란 등록 · 되읽기 · 검사 · 저장 위치 (R3~R5 공통, 2026-10-05).

조서마다 생성기는 단계 모듈(analysis · workpapers · report · close)에 두고, 이 모듈만으로 책을 만든다.
엔진이 채운 칸과 회계사 기입란(노란 칸)을 나누고, 기입란은 숨김 시트 `_기입란` 에 적어 둔다.
회계사가 채워 다시 저장한 파일을 되읽을 때는 이 목록에 있는 셀만 읽는다(다른 셀은 보지 않는다).

  b = Book(d, "2120A", standard="감사기준서 520")      감사 폴더 d 의 감사건 · 회사제시 판에서 머리를 채운다
  ws, row = b.sheet("분석", widths=[...])
  b.put(ws, row, 1, 1234, fmt=WON)
  b.ask(ws, row, 5, "차이 설명", rule="required")         기입란 등록
  row = b.conclusion(ws, row, 6)                           결론 칸(기입란, required)
  path = b.save()                                          표준 폴더에 <번호>_<이름>[_v판].xlsx 로 저장
  readback(path) -> [{sheet, ref, label, rule, value}]
  check(path) -> list[str]                                 비어 있는 required, 규칙 위반, 엔진 검산(`_검산` 시트) 실패
  mark_checked(d, no, problems)                            조서목록 상태를 검사 통과 · 작성중 으로 바꾼다

규칙: required(비우면 안 됨) · number(숫자) · yesno(예/아니오) · date(날짜) · optional(되읽기만)
검산: b.verify(label, formula_or_value, expected) 는 `_검산` 시트에 엔진 기대값과 셀 수식을 함께 둔다.
엑셀이 계산하지 않은 파일(openpyxl 저장 직후)은 수식 값을 모르므로, 엔진이 쓴 기대값과 비교한다.
"""
from __future__ import annotations

import functools
import json
import re
from datetime import date, datetime
from pathlib import Path

from copy import copy

from openpyxl import Workbook, load_workbook
from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
from openpyxl.utils import get_column_letter

from . import folder, style

# 서식은 audit/style.py 한 곳에서 정한다(2026-11-03). 여기 이름은 예전 부르는 곳을 위해 남긴다
NAVY, INK, MUTED, RED, GREEN = style.NAVY, style.INK, style.MUTED, style.RED, style.GREEN
FILL_H, FILL_IN, FILL_SUB, FILL_FLAG, FILL_AI = style.FILL_HEAD, style.FILL_IN, style.FILL_SUB, style.FILL_FLAG, style.FILL_AI
THIN, BOX = style.THIN, style.BOX
FONT = style.FONT
WON, PCT = style.WON, style.PCT
font = style.font
INPUT_SHEET, CHECK_SHEET, META_SHEET = "_기입란", "_검산", "_조서"
# AI 작성 칸(2026-11-03). 확인 전 AI 칸은 연보라로 칠하고, 저장할 때 보이는 「AI 작성」 시트와 숨김 「_AI」 에 모은다
AI_SHEET, AI_META, AI_LABEL = "AI 작성", "_AI", "AI 확인: "
AI_HEAD = ["시트", "칸", "AI 가 쓴 것", "근거", "확인(O · X)"]
# 엔진이 확인 전 AI 판독을 글에 옮길 때 붙이는 표시. 이 표시가 든 글 칸은 Book.text 가 AI 칸으로 칠한다
AI_MARKS = ("(AI, 확인 전)", "(AI 판독, 확인 전)", "AI 짝(확인 전)", "AI 판독, 확인 전")
RULES = ("required", "number", "yesno", "date", "optional")
# 조서 상태 칸(2026-10-26, 감사 프로젝트관리 설계 4절). 첫 머리 시트(4000 은 표지)에 한 번 둔다. 담당 · 인차지가 고치고
# 감시 · 보드가 읽는다. 엔진이 조서를 다시 만들 때 사람이 적은 값을 옮겨 싣는다(Book.save).
DOC_STATUSES = ("초안", "작성중", "제출", "검토완료")
APPLIES_VALUES = ("해당", "해당 없음")
L_STATUS, L_APPLIES, L_REASON = "조서 상태", "조서 해당 여부", "해당 없음 사유"
STATE_LABELS = {L_STATUS: "status", L_APPLIES: "applies", L_REASON: "reason"}
SHEET_NAME_MAX = 31
SHEET_NAME_BAD = "/\\?*[]:"
NUMBERED = re.compile(r"^\.\d{2,} ")          # 번호가 붙은 절차 시트 이름 「.01 거래처별」
# 수식 안의 시트 참조: 문자열 상수 · 따옴표 붙은 이름 · 따옴표 없는 이름. 문자열 상수는 건드리지 않으려고 함께 잡는다
_SHEET_REF = re.compile(r'''"(?:[^"]|"")*"|'((?:[^']|'')+)'!|(?<![\w.'])([A-Za-z_가-힣][\w.]*)!''')


def base_name(sheet: str) -> str:
    """번호를 뗀 시트 이름. 「.01 거래처별」 → 「거래처별」. 번호가 없으면 그대로."""
    return NUMBERED.sub("", str(sheet))


def find_sheet(names, base: str) -> str | None:
    """시트 이름 목록(또는 워크북)에서 기본 이름이 base 인 시트의 실제 이름. 번호가 붙었든 아니든 찾는다."""
    names = getattr(names, "sheetnames", names)
    return next((n for n in names if n == base or base_name(n) == base), None)


def sheet_ref(name: str) -> str:
    """수식에 쓰는 시트 참조. 언제나 따옴표를 붙인다. 「'.01 거래처별'!」"""
    return "'" + name.replace("'", "''") + "'!"


def rename_in_formula(formula, old: str, new: str):
    """수식 안의 시트 참조 「'옛이름'!」 · 「옛이름!」 을 새 이름으로 바꾼다. 수식이 아니면(= 로 시작하지 않으면) 그대로."""
    if not isinstance(formula, str) or not formula.startswith("="):
        return formula

    def repl(m):
        quoted, bare = m.group(1), m.group(2)
        if (quoted is not None and quoted.replace("''", "'") == old) or (bare is not None and bare == old):
            return sheet_ref(new)
        return m.group(0)

    return _SHEET_REF.sub(repl, formula)


def _case(d: Path) -> dict:
    p = Path(d) / "_색인" / "감사건.json"
    return json.loads(p.read_text(encoding="utf-8")) if p.exists() else {}


def path_for(d: Path, no: str, ext: str = ".xlsx", version: str | None = None) -> Path:
    """표준 폴더와 이름 규칙대로 조서 경로를 정한다. 판은 회사제시 숫자가 들어가는 조서에만 붙인다."""
    std = folder.load_standard()
    sub = folder._wp_folder_map(std).get(no) or ("4000 계정별" if folder._is_area(no) else None)
    if sub is None:
        raise ValueError(f"표준에 없는 조서번호입니다: {no}")
    name = (std.get("workpaper_names") or {}).get(no, "")
    stem = f"{no}_{name}" if name else no
    uses = {str(x) for x in std.get("uses_company_figures", [])}
    if no in uses or (folder._is_area(no) and "4000" in uses):
        ver = version or _case(d).get("company_version")
        if ver:
            stem += f"_{ver if ver.startswith('v') else 'v' + ver}"
    return Path(d) / sub / f"{stem}{ext}"


class Book:
    def __init__(self, d: Path, no: str, title: str | None = None, standard: str = "", preparer: str | None = None):
        self.d, self.no = Path(d), no
        std = folder.load_standard()
        self.title = title or (std.get("workpaper_names") or {}).get(no, no)
        self.standard = standard
        case = _case(d)
        comp = case.get("company") or {}
        self.company = comp.get("name") if isinstance(comp, dict) else str(comp or "")
        self.fy_end = case.get("fiscal_year_end") or ""
        self.version = case.get("company_version")
        self.preparer = preparer or f"엔진 초안 {date.today().isoformat()}"
        # 소규모 감사 건의 필수 조서면 그 근거(한공회 소규모 일반조서목록, 2026-10-26). 머리에 「필수」 로 보인다
        req, basis = folder.required_of(no, case) if folder.is_small(case) else (False, None)
        self.required = basis if req else None
        self.wb = Workbook()
        self.wb.remove(self.wb.active)
        self.inputs: list[tuple] = []     # (sheet, ref, label, rule)
        self.checks: list[tuple] = []     # (label, formula, expected)
        self.state_placed = False
        self.state_inputs: list[tuple] = []   # 조서 상태 칸(sheet, ref, label, rule). 저장 때 `_기입란` 에 붙는다
        self.state_sheet: str | None = None   # 상태 칸을 둘 시트를 정한 책(4000 은 「표지」). None 이면 첫 머리 시트
        self.ai_cells: list[tuple] = []       # AI 작성 칸 (sheet, ref, what, basis, confirmed). 저장 때 「AI 작성」 · 「_AI」 시트(2026-11-03)
        self.summary_at: tuple | None = None  # 「AI 작성 칸 n개 · 엔진 검산 k줄」 을 적을 (시트, 행). 처음 legend 를 둔 시트
        # 엔진이 제안 값을 미리 넣는 기입란 이름(2026-11-03, 4000 표지 성격 · 시기). 다시 만들 때 감사인이 고친 값이 엔진 값보다 앞선다(common.save)
        self.prefill_labels: set = set()
        # 기입란 AI 초안(2026-11-05, audit/drafts.py). 시트마다 초안을 적을 열. draft_column 으로 정한 시트에서만 ask 가 초안을 옆에 둔다
        self.draft_cols: dict[str, int] = {}
        self._drafts: dict | None = None
        self._draft_at: list[tuple] = []      # (시트, -, 초안 칸, 기입란 이름)

    # ---------------------------------------------------------- 모양
    def sheet(self, name: str, widths: list[int], head: bool = True):
        """시트를 만들고 머리(조서번호 · 회사명 · 결산일 · 작성자 · 검토자)를 적는다. (시트, 다음 행).
        head=False 이면 열 너비만 잡고 1행부터 비워 둔다(4000 표지처럼 머리 배치가 다른 시트)."""
        ws = self.wb.create_sheet(name[:SHEET_NAME_MAX])
        for i, w in enumerate(widths, 1):
            ws.column_dimensions[get_column_letter(i)].width = w
        if not head:
            return ws, 1
        ws["A1"] = f"{self.no}  {self.title}"
        ws["A1"].font = font(size=14, bold=True, color=NAVY)
        ws["A2"] = " · ".join(x for x in (self.standard, f"회사제시 {self.version}" if self.version else "") if x)
        ws["A2"].font = font(size=9, color=MUTED)
        for r, (a, b, c) in enumerate([("회사명", self.company, "작성자"), ("결산일", self.fy_end, "검토자")], 3):
            ws.cell(r, 1, a).font = font(color=MUTED)
            ws.cell(r, 2, b).font = font(bold=True)
            ws.cell(r, 4, c).font = font(color=MUTED)
            if c == "작성자":
                ws.cell(r, 5, self.preparer).font = font()
            else:
                self.ask(ws, r, 5, "검토자", rule="optional")
        if self.state_sheet is None:
            self.status_block(ws, 3, 7)
        self.legend(ws, 5)
        self.required_mark(ws, 3, 9)
        return ws, 7

    def legend(self, ws, row: int) -> None:
        """row 에 칸의 뜻(범례). 저장할 때 같은 칸 맨 앞에 「AI 작성 칸 n개 · 엔진 검산 k줄」 을 붙인다. 책마다 처음 부른 시트 한 곳이다.
        다음 줄(6행)은 조서마다 안내 문장을 쓰는 자리라 비워 둔다(2026-11-03, 6행에 쓰던 첫 판이 2120A · 3800 안내를 덮었다)."""
        ws.cell(row, 1, style.LEGEND).font = font(size=9, color=MUTED, italic=True)
        if self.summary_at is None:
            self.summary_at = (ws.title, row)

    def text(self, ws, row: int, col: int, value, what: str, basis: str = "", **k):
        """글 칸. 확인 전 AI 판독 표시(AI_MARKS)가 들어 있으면 AI 칸(ai), 아니면 보통 칸(put). 엔진 글과 AI 판독이 한 칸에 섞일 때 쓴다."""
        if isinstance(value, str) and any(m in value for m in AI_MARKS):
            k.pop("flag", None)
            k.pop("color", None)
            k.pop("bold", None)
            return self.ai(ws, row, col, value, what=what, basis=basis, wrap=k.pop("wrap", True), fmt=k.pop("fmt", None))
        return self.put(ws, row, col, value, **k)

    def ai(self, ws, row: int, col: int, value, what: str, basis: str = "", confirmed: bool = False, wrap: bool = True, fmt=None):
        """AI 가 쓴 칸(판독 · 사유 · 제안 · 판정 글). 확인 전이면 연보라 · 왼쪽 보라 선으로 칠하고 「AI 작성」 시트에 모은다.
        확인 끝(confirmed)이면 보통 칸으로 두고 숨김 「_AI」 에만 남긴다. 숫자는 엔진만 만든다(AI 칸은 글이다)."""
        c = self.put(ws, row, col, value, fmt=fmt, wrap=wrap)
        if not confirmed:
            c.fill = FILL_AI
            c.border = style.AI_BOX
            c.font = font(color=style.AI_INK)
        self.ai_cells.append((ws.title, c.coordinate, str(what), str(basis or ""), bool(confirmed)))
        return c

    def status_block(self, ws, row: int, col: int) -> None:
        """조서 상태 · 해당 여부 · 해당 없음 사유 칸(두 줄). 책마다 처음 부를 때 한 번만 둔다.
        row 줄: 상태(초안 · 작성중 · 제출 · 검토완료), row+1 줄: 해당 여부와 해당 없음 사유.
        노란 기입란이지만 조서 기입란 목록(self.inputs)과 따로 둔다(self.state_inputs). 저장할 때 `_기입란` 끝에 붙는다."""
        if self.state_placed:
            return
        from openpyxl.worksheet.datavalidation import DataValidation
        self.state_placed = True

        def cell(r, c, label, value=None):
            x = self.put(ws, r, c, value, wrap=False)
            x.fill = FILL_IN
            self.state_inputs.append((ws.title, x.coordinate, label, "optional"))
            return x

        ws.cell(row, col, L_STATUS).font = font(color=MUTED)
        st = cell(row, col + 1, L_STATUS)          # 비워 둔다. 빈 칸은 초안으로 읽는다(엔진은 기입란을 미리 채우지 않는다)
        ws.cell(row + 1, col, L_APPLIES).font = font(color=MUTED)
        ap = cell(row + 1, col + 1, L_APPLIES)     # 빈 칸은 해당으로 읽는다
        ws.cell(row + 1, col + 2, L_REASON).font = font(color=MUTED)
        cell(row + 1, col + 3, L_REASON)
        for x, vals in ((st, DOC_STATUSES), (ap, APPLIES_VALUES)):
            dv = DataValidation(type="list", formula1='"' + ",".join(vals) + '"', allow_blank=True)
            ws.add_data_validation(dv)
            dv.add(x.coordinate)

    def required_mark(self, ws, row: int, col: int) -> None:
        """소규모 필수 조서 표시: (row, col) 에 「필수」, 오른쪽 칸에 근거(아래 줄은 상태 칸의 해당 없음 사유가 쓴다). 소규모가 아니거나 필수가 아니면 쓰지 않는다."""
        if not self.required:
            return
        c = ws.cell(row, col, "필수")
        c.font = font(bold=True, color=NAVY)
        c.border = BOX
        c.alignment = Alignment(horizontal="center")
        ws.cell(row, col + 1, f"소규모기업 필수 조서({self.required})").font = font(size=9, color=MUTED)

    def section(self, ws, row: int, text: str) -> int:
        ws.cell(row, 1, text).font = font(size=11, bold=True, color=NAVY)
        return row + 1

    def head(self, ws, row: int, heads: list[str], col: int = 1) -> int:
        for i, h in enumerate(heads):
            c = ws.cell(row, col + i, h)
            c.font = font(bold=True, color="FFFFFF")
            c.fill = FILL_H
            c.alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
            c.border = BOX
        ws.row_dimensions[row].height = 30
        return row + 1

    def put(self, ws, row: int, col: int, value, fmt=None, bold=False, wrap=False, flag=False, color=None):
        c = ws.cell(row, col, value)
        # 서식이 없는 새 칸이면 같은 인자로 먼저 만든 칸의 서식을 그대로 복사한다(2026-11-09: 결과 목록 수만 줄에서 칸마다 서식
        # 객체를 새로 만들고 해시하느라 조서 쓰기가 실행 시간의 절반을 넘던 것). 이미 서식이 있는 칸은 예전대로 하나씩 붙인다
        key = (bold, color or INK, fmt, flag, wrap)
        cache = self.__dict__.setdefault("_put_styles", {})
        if not c.has_style and key in cache:
            c._style = copy(cache[key])
            return c
        fresh = not c.has_style
        c.font = font(bold=bold, color=color or INK)
        c.border = BOX
        if fmt:
            c.number_format = fmt
        if flag:
            c.fill = FILL_FLAG
        c.alignment = Alignment(vertical="top", wrap_text=wrap, horizontal="right" if fmt and not wrap else None)
        if fresh:
            cache[key] = copy(c._style)
        return c

    def draft_column(self, ws, col: int, width: int = 44) -> None:
        """이 시트의 기입란 AI 초안을 col 열에 둔다(audit/drafts.py). 초안이 하나라도 있을 때만 열 너비를 잡는다."""
        self.draft_cols[ws.title] = col
        if self.drafts():
            ws.column_dimensions[get_column_letter(col)].width = width

    def drafts(self) -> dict:
        if self._drafts is None:
            from . import drafts

            self._drafts = drafts.for_wp(self.d, self.no)
        return self._drafts

    def _draft_beside(self, ws, row: int, col: int, label: str, value) -> None:
        if ws.title not in self.draft_cols or (value is not None and str(value).strip()):
            return
        x = self.drafts().get(label)
        if not x:
            return
        from . import drafts

        c = self.ai(ws, row, col, x["text"], what=f"기입란 초안: {label[:40]}", basis=drafts.basis_text(x.get("basis")))
        self._draft_at.append((ws.title, "", c.coordinate, label))
        # 초안 글이 다 보이게 줄 높이를 늘린다(열 너비 44 에 한글 약 26자)
        need = 15 * min(12, len(str(x["text"])) // 26 + 1)
        cur = ws.row_dimensions[row].height or 15
        if need > cur:
            ws.row_dimensions[row].height = need

    def _drop_filled_drafts(self) -> None:
        """기입란이 (옮겨 적은 값으로) 채워졌으면 그 옆 초안을 지운다. 점검표는 앞 판 값을 ask 뒤에 옮겨 적기 때문이다."""
        refs = {(s, lab): ref for s, ref, lab, _ in self.inputs}
        for sheet, _, ai_ref, label in self._draft_at:
            in_ref = refs.get((sheet, label))
            if in_ref is None:
                continue
            v = self.wb[sheet][in_ref].value
            if v is not None and str(v).strip():
                cell = self.wb[sheet][ai_ref]
                cell.value = None
                cell.fill, cell.border = PatternFill(fill_type=None), Border()
                self.ai_cells = [x for x in self.ai_cells if not (x[0] == sheet and x[1] == ai_ref)]

    def ask(self, ws, row: int, col: int, label: str, rule: str = "required", value=None, fmt=None, wrap=True):
        """회계사 기입란. 노란 칸으로 칠하고 `_기입란` 에 등록한다. 그 기입란에 AI 초안이 있고 비어 있으면 초안 열에 연보라로 둔다."""
        if rule not in RULES:
            raise ValueError(f"기입란 규칙이 아닙니다: {rule}")
        c = self.put(ws, row, col, value, fmt=fmt, wrap=wrap)
        c.fill = FILL_IN
        self.inputs.append((ws.title, c.coordinate, label, rule))
        if label != getattr(self, "_concluding", None) and ws.title in self.draft_cols:
            self._draft_beside(ws, row, self.draft_cols[ws.title], label, value)
        return c

    def conclusion(self, ws, row: int, ncols: int, label: str = "감사 결론") -> int:
        row = self.section(ws, row + 1, label)
        ws.merge_cells(start_row=row, start_column=1, end_row=row + 2, end_column=ncols)
        self._concluding = label            # 결론 초안은 옆이 아니라 아래 줄에 둔다
        c0 = self.ask(ws, row, 1, label, rule="required")
        self._concluding = None
        for r in range(row, row + 3):
            for c in range(1, ncols + 1):
                ws.cell(r, c).fill = FILL_IN
                ws.cell(r, c).border = BOX
        x = self.drafts().get(label) if ws.title in self.draft_cols and c0.value in (None, "") else None
        if x:                       # 결론 초안은 결론 칸 아래 줄에 둔다(2026-11-05)
            from . import drafts

            ws.merge_cells(start_row=row + 3, start_column=1, end_row=row + 3, end_column=ncols)
            ws.row_dimensions[row + 3].height = 15 * max(2, min(8, len(x["text"]) // 90 + 1))
            c = self.ai(ws, row + 3, 1, f"AI 초안(확인 전): {x['text']}", what=f"기입란 초안: {label}", basis=drafts.basis_text(x.get("basis")))
            self._draft_at.append((ws.title, "", c.coordinate, label))
            return row + 5
        return row + 4

    def verify(self, label: str, formula: str, expected) -> None:
        """엔진 검산 한 줄. formula 는 엑셀 수식(예: "=SUM('Lead'!C8:C20)"), expected 는 엔진이 계산한 값."""
        self.checks.append((label, formula, expected))

    # ---------------------------------------------------------- 시트 이름 · 순서
    def rename_sheet(self, old: str, new: str) -> None:
        """시트 이름을 바꾸고, 수식(= 로 시작하는 문자열 칸) 안의 「'옛이름'!」 · 「옛이름!」, 기입란 목록, 검산 수식의 시트 이름을 함께 바꾼다.
        4000 조서가 절차 시트에 번호를 붙일 때 쓴다(생성기는 번호 없는 이름으로 수식을 쓴다)."""
        if old not in self.wb.sheetnames:
            raise KeyError(f"없는 시트입니다: {old}")
        if old == new:
            return
        bad = [ch for ch in SHEET_NAME_BAD if ch in new]
        if not new or len(new) > SHEET_NAME_MAX or bad or new.startswith("'") or new.endswith("'"):
            raise ValueError(f"시트 이름으로 쓸 수 없습니다(31자 이하, {' '.join(SHEET_NAME_BAD)} 금지): {new}")
        if new in self.wb.sheetnames:
            raise ValueError(f"같은 이름의 시트가 이미 있습니다: {new}")
        self.wb[old].title = new
        for ws in self.wb.worksheets:
            for row in ws.iter_rows():
                for c in row:
                    if isinstance(c.value, str) and c.value.startswith("="):
                        c.value = rename_in_formula(c.value, old, new)
        self.inputs = [(new if sh == old else sh, ref, label, rule) for sh, ref, label, rule in self.inputs]
        self.state_inputs = [(new if sh == old else sh, ref, label, rule) for sh, ref, label, rule in self.state_inputs]
        self.ai_cells = [(new if sh == old else sh, ref, what, basis, ok) for sh, ref, what, basis, ok in self.ai_cells]
        if self.summary_at and self.summary_at[0] == old:
            self.summary_at = (new, self.summary_at[1])
        self.checks = [(label, rename_in_formula(formula, old, new), expected) for label, formula, expected in self.checks]

    def order(self, names: list[str]) -> None:
        """시트 순서를 names 대로 놓는다. names 에 없는 시트는 그 뒤에 지금 순서대로 둔다. 없는 이름은 건너뛴다."""
        want = [n for n in names if n in self.wb.sheetnames]
        rest = [n for n in self.wb.sheetnames if n not in want]
        for i, n in enumerate(want + rest):
            ws = self.wb[n]
            self.wb.move_sheet(ws, offset=i - self.wb.index(ws))

    # ---------------------------------------------------------- 저장
    def carry_state(self, path: Path) -> dict:
        """앞 파일(같은 경로, 없으면 같은 폴더의 같은 조서번호 다른 판 가운데 최근)의 조서 상태 칸 값을 새 책에 옮긴다.
        사람이 「제출」 · 「해당 없음」 으로 고친 것을 엔진이 다시 만들어도 지우지 않는다. 옮긴 값 {label: value}."""
        olds = [path] if path.is_file() else []
        if not olds and path.parent.is_dir():
            olds = sorted((p for p in path.parent.glob(f"{self.no}_*.xlsx") if not p.name.startswith("~$")),
                          key=lambda p: p.stat().st_mtime, reverse=True)[:1]
        if not olds:
            return {}
        try:
            got = doc_state(olds[0]) or {}
        except Exception:      # 열려 있거나 동기화 중인 앞 파일. 새 값(초안)으로 둔다
            return {}
        moved = {}
        for sheet, ref, label, _ in self.state_inputs:
            key = STATE_LABELS.get(label)
            if key and got.get(key) not in (None, ""):
                self.wb[sheet][ref].value = got[key]
                moved[label] = got[key]
        return moved

    def _ai_sheets(self, path: Path) -> int:
        """확인 전 AI 칸을 보이는 「AI 작성」 시트에, 전부를 숨김 「_AI」 에 적는다. 확인(O · X) 칸은 기입란(되읽기만)이고
        앞 파일의 같은 이름 값을 옮긴다. 머리 요약 줄도 여기서 쓴다. 확인 전 AI 칸 수."""
        todo = [x for x in self.ai_cells if not x[4]]
        if todo:
            from openpyxl.worksheet.datavalidation import DataValidation
            ws = self.wb.create_sheet(AI_SHEET)
            for i, w in enumerate([18, 10, 60, 40, 12], 1):
                ws.column_dimensions[get_column_letter(i)].width = w
            ws["A1"] = f"{self.no}  {self.title}: AI 작성 칸"
            ws["A1"].font = font(size=style.SIZE_TITLE, bold=True, color=NAVY)
            ws["A2"] = "AI 가 쓴 글(판독 · 사유 · 제안 · 판정)입니다. 숫자는 엔진이 만들었습니다. 칸을 누르면 그 칸으로 갑니다. 읽고 확인 칸에 O · X 를 적어 주십시오"
            ws["A2"].font = font(size=9, color=MUTED, italic=True)
            row = self.head(ws, 4, AI_HEAD)
            dv = DataValidation(type="list", formula1='"O,X"', allow_blank=True)
            ws.add_data_validation(dv)
            old = {}
            if path.is_file():
                try:
                    old = {x["label"]: x["value"] for x in readback(path)
                           if str(x["label"] or "").startswith(AI_LABEL) and not _blank(x["value"])}
                except Exception:          # 열려 있거나 동기화 중인 앞 파일
                    old = {}
            used: set = set()
            for sheet, ref, what, basis, _ in todo:
                self.put(ws, row, 1, sheet)
                link = self.put(ws, row, 2, ref)
                style.link(link, f"{sheet_ref(sheet)}{ref}")
                self.put(ws, row, 3, what, wrap=True)
                self.put(ws, row, 4, basis or None, wrap=True)
                label, n = f"{AI_LABEL}{sheet} {what}"[:200], 2
                while label in used:
                    label, n = f"{AI_LABEL}{sheet} {what} ({n})"[:200], n + 1
                used.add(label)
                c = self.ask(ws, row, 5, label, rule="optional", value=old.get(label), wrap=False)
                dv.add(c.coordinate)
                row += 1
            ws.freeze_panes = "A5"
        if self.summary_at and self.summary_at[0] in self.wb.sheetnames:
            sh, r = self.summary_at
            text = (f"AI 작성 칸 {len(todo)}개(「{AI_SHEET}」 시트에서 확인) · 엔진 검산 {len(self.checks)}줄" if todo
                    else f"AI 작성 칸 없음 · 엔진 검산 {len(self.checks)}줄")
            c = self.wb[sh].cell(r, 1)
            if c.value not in (None, "") and c.value != style.LEGEND:      # 범례가 아닌 글이 있으면 덮지 않는다
                return len(todo)
            c.value = text + (". " + style.LEGEND if c.value == style.LEGEND else "")
            c.font = font(size=9, bold=True, color=style.AI_INK if todo else MUTED)
            if todo:
                style.link(c, f"{sheet_ref(AI_SHEET)}A1")
                c.font = font(size=9, bold=True, color=style.AI_INK, underline="single")
        return len(todo)

    def save(self, path: Path | None = None) -> Path:
        path = Path(path) if path else path_for(self.d, self.no)
        path.parent.mkdir(parents=True, exist_ok=True)
        if self.state_placed:
            self.carry_state(path)
        self._drop_filled_drafts()
        self._ai_sheets(path)
        ws = self.wb.create_sheet(INPUT_SHEET)
        ws.append(["시트", "셀", "항목", "규칙"])
        for row in self.inputs + [x for x in self.state_inputs if x[0] in self.wb.sheetnames]:
            ws.append(list(row))
        ws.sheet_state = "hidden"
        ws = self.wb.create_sheet(CHECK_SHEET)
        ws.append(["검산", "수식", "엔진 기대값"])
        for label, formula, expected in self.checks:
            ws.append([label, formula, expected])
        ws.sheet_state = "hidden"
        ws = self.wb.create_sheet(META_SHEET)
        for k, v in (("조서번호", self.no), ("이름", self.title), ("회사제시 판", self.version or ""),
                     ("만든 시각", datetime.now().strftime("%Y-%m-%d %H:%M")), ("만든 것", "audit 엔진")):
            ws.append([k, v])
        ws.sheet_state = "hidden"
        if self.ai_cells:                                   # AI 칸이 있는 책만 숨김 「_AI」(확인 끝 칸 포함 전부)를 맨 뒤에 둔다
            meta = self.wb.create_sheet(AI_META)
            meta.append(["시트", "칸", "AI 가 쓴 것", "근거", "확인"])
            for sheet, ref, what, basis, ok in self.ai_cells:
                meta.append([sheet, ref, what, basis, "확인 끝" if ok else "확인 전"])
            meta.sheet_state = "hidden"
        drop_empty_validations(self.wb)
        style.finish(self.wb)
        self.wb.save(path)
        return path


def drop_empty_validations(wb) -> int:
    """칸이 하나도 없는 데이터 검증을 시트에서 뺀다. 빈 dataValidations 요소가 있으면 엑셀이 책을 열지 못한다."""
    n = 0
    for ws in wb.worksheets:
        dvs = ws.data_validations
        keep = [dv for dv in dvs.dataValidation if dv.sqref and str(dv.sqref).strip()]
        n += len(dvs.dataValidation) - len(keep)
        dvs.dataValidation = keep
    return n


# ---------------------------------------------------------------- 되읽기 · 검사
def readback(path: Path) -> list[dict]:
    wb = load_workbook(path, data_only=True)
    if INPUT_SHEET not in wb.sheetnames:
        return []
    out = []
    for sheet, ref, label, rule in wb[INPUT_SHEET].iter_rows(min_row=2, values_only=True):
        if not sheet:
            continue
        v = wb[sheet][ref].value if sheet in wb.sheetnames else None
        out.append({"sheet": sheet, "ref": ref, "label": label, "rule": rule, "value": v})
    return out


def _blank(v) -> bool:
    return v is None or (isinstance(v, str) and not v.strip())


def doc_meta(path: Path) -> dict:
    """조서 엑셀을 한 번 열어 {"made_at", "state"} 를 읽는다. state 는 {"status", "applies", "reason"} 이고
    상태 칸이 없는 예전 조서 · 엔진이 만들지 않은 파일이면 None. 감시가 조서마다 부르므로 읽기 전용으로 연다."""
    wb = load_workbook(path, read_only=True, data_only=True)
    try:
        out: dict = {"made_at": None, "state": None}
        names = wb.sheetnames
        if META_SHEET in names:
            for r in wb[META_SHEET].iter_rows(max_row=20, values_only=True):
                if r and str(r[0] or "").strip() == "만든 시각":
                    out["made_at"] = str(r[1] or "") or None
        if INPUT_SHEET in names:
            where = {}
            for r in wb[INPUT_SHEET].iter_rows(min_row=2, values_only=True):
                if r and len(r) >= 3 and r[2] in STATE_LABELS and r[0] in names:
                    where[STATE_LABELS[r[2]]] = (r[0], r[1])
            if where:
                st = {}
                for key, (sheet, ref) in where.items():
                    v = wb[sheet][ref].value
                    st[key] = v.strip() if isinstance(v, str) else v
                out["state"] = {k: st.get(k) for k in ("status", "applies", "reason")}
        return out
    finally:
        wb.close()


def doc_state(path: Path) -> dict | None:
    """조서 상태 칸 {"status", "applies", "reason"}. 칸이 없으면 None."""
    return doc_meta(path)["state"]


def check(path: Path) -> list[str]:
    """기입란 규칙과 엔진 검산을 본다. 문제가 없으면 빈 목록."""
    probs = []
    for x in readback(path):
        v, rule, where = x["value"], x["rule"], f"{x['sheet']}!{x['ref']} {x['label']}"
        if rule == "optional":
            continue
        if _blank(v):
            probs.append(f"비어 있음: {where}")
        elif rule == "number" and not isinstance(v, (int, float)):
            probs.append(f"숫자가 아님: {where} = {v}")
        elif rule == "yesno" and str(v).strip() not in ("예", "아니오", "해당 없음"):
            probs.append(f"예 · 아니오 · 해당 없음 중 하나여야 함: {where} = {v}")
        elif rule == "date" and not isinstance(v, (date, datetime)):
            probs.append(f"날짜가 아님: {where} = {v}")
    wb = load_workbook(path, data_only=True)
    if CHECK_SHEET in wb.sheetnames:
        wbf = load_workbook(path, data_only=False)
        for i, (label, formula, expected) in enumerate(wb[CHECK_SHEET].iter_rows(min_row=2, values_only=True), 2):
            if not label:
                continue
            got = wb[CHECK_SHEET].cell(i, 2).value
            if isinstance(wbf[CHECK_SHEET].cell(i, 2).value, str) and got is None:
                continue        # 엑셀이 아직 계산하지 않은 수식. 엔진 기대값은 생성 때 맞춰 두었다
            if isinstance(expected, (int, float)) and isinstance(got, (int, float)) and abs(got - expected) > 0.5:
                probs.append(f"검산 불일치: {label} 엑셀 {got:,.0f} · 엔진 {expected:,.0f}")
    return probs


DOC_MARKS = ("【기입", "[기입란")       # 워드 · HTML 초안의 기입란 표시(보고 단계 · 시작 자료 두 꼴)


def doc_marks(path: Path) -> int:
    """워드(.docx) · HTML 초안에 남은 기입란 수."""
    path = Path(path)
    if path.suffix.lower() == ".docx":
        from docx import Document

        doc = Document(str(path))
        texts = [p.text for p in doc.paragraphs]
        texts += [c.text for tb in doc.tables for row in tb.rows for c in row.cells]
    else:
        texts = [path.read_text(encoding="utf-8")]
    return sum(s.count(m) for s in texts for m in DOC_MARKS)


def check_doc(path: Path) -> list[str]:
    n = doc_marks(path)
    return [f"기입란 {n}칸 남음: {Path(path).name}"] if n else []


def mark_checked(d: Path, no: str, problems: list[str], now: str | None = None) -> str:
    """검사 결과로 조서목록 상태를 바꾼다. 문제가 없으면 검사 통과, 있으면 작성중."""
    d = Path(d)
    p = d / "_색인" / "조서목록.json"
    wps = json.loads(p.read_text(encoding="utf-8"))
    w = next((x for x in wps.get("workpapers", []) if x.get("no") == no), None)
    if w is None:
        raise KeyError(f"조서목록에 없는 조서입니다: {no}")
    if problems:
        w["status"] = "작성중"
        w["status_basis"] = f"검사 {len(problems)}건 남음: " + "; ".join(problems[:3])
    elif w.get("status") != "검토 끝":       # 검토가 끝난 조서는 다시 검사해도 내리지 않는다
        w["status"] = "검사 통과"
        w["status_basis"] = "검사 통과(기입란 · 검산)"
    if not problems:
        w["needs_recheck"] = False
    # 검사한 그 파일의 해시를 적는다. 그래야 다음 scan 이 '검사 뒤 바뀐 파일'로 보지 않는다
    if w.get("file") and (d / w["file"]).exists():
        w["sha256"] = folder._sha(d / w["file"])
    folder._write(p, wps)
    folder.validate_index(d)
    return w["status"]
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 196kUpdated Claude CodeCodexVerifiedInstall