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/checklists.py

View on GitHub
"""한공회 점검표 조서(R5, 2026-10-05): 1300 독립성 · 3200 · 3300 · 3400 · 3500 · 3600 · 3700 · 8200 · 8600.
3500 에는 특수관계자 거래 · 잔액 시트(audit/relparty.py, 2026-10-16)가 붙는다.

문항은 한공회 감사조서서식 2026 원본에서 뽑은 tools/proto_data/kicpa_checklists_r5.json(없으면 kicpa_checklists.json)이다.
문항마다 예 · 아니오 · 해당 없음 기입란(rule yesno)과 근거 기입란을 둔다. 판단은 회계사 몫이라 엔진은 답을 넣지 않는다.
엔진이 색인에서 아는 사실(의사록 판독 사실, 3600-JET 조서 경로 등)은 표 위에 "엔진이 아는 사실" 로 적는다.

  load_items()                     조서번호 → {"title", "items": [[문항, 조서번호], ...]}
  classify(items, narrative)       문항마다 종류(head 제목 · item 확인 · fill 적어 넣기 · note 주석)를 정한다
  people(d, given)                 1300 감사반 인원. 명령줄 입력이 앞서고, 없으면 1000 감사계약/감사반인원.xlsx
  hints(d, no)                     엔진이 아는 사실 문장
  going_concern(d)                 3700 계속기업 재무적 사항(시산표 · 전기 재무제표 · 계정명세서 차입금 표)과 점검 항목의 「해당 후보」 표시
  make(d, no, ...)                 조서 하나를 만든다. refresh 면 앞선 파일의 기입란 값을 이어받는다
  people_template(d)               빈 감사반인원.xlsx 를 만든다(이미 있으면 두고 경로만 돌려준다)
  carry_inputs(book, old_path)     앞선 파일의 기입란 값을 (시트, 항목) 으로 맞춰 새 책에 옮긴다
"""
from __future__ import annotations

import json
import re
from pathlib import Path

from openpyxl import Workbook, load_workbook
from openpyxl.worksheet.datavalidation import DataValidation

from . import folder, params, wp
from . import style

ROOT = Path(__file__).resolve().parent.parent
DATA = ROOT / "tools" / "proto_data"
YESNO = '"예,아니오,해당 없음"'
EVAL = '"양호,미흡,해당 없음"'


def load_defs() -> dict:
    from . import params

    return params.overlay("close", folder.read_yaml(folder.DEFS / "close.yaml"))   # 2700B 값(2026-10-07)


def load_items() -> dict:
    out = {}
    for name in ("kicpa_checklists.json", "kicpa_checklists_r5.json"):   # 뒤 파일(원본 전체 문항)이 앞선다
        p = DATA / name
        if p.exists():
            out.update({k: v for k, v in json.loads(p.read_text(encoding="utf-8")).items() if not k.startswith("$")})
    return out


# ---------------------------------------------------------------- 문항 종류
_NOTE = re.compile(r"^(\(\*+\)|\*|※|\(주\d*\)|☞|◈|▣|■|□|●|◆|◎)")
_LEVELS = [
    (1, re.compile(r"^\d+\s*[.,](?!\d)|^\d+-\d+\.")),
    (2, re.compile(r"^(\(\d+\)|[⑴-⒇])")),
    (3, re.compile(r"^\d+\)")),
    (4, re.compile(r"^([①-⑳]|\([a-z]+\)|[a-z]\)|[ivx]+\)|[-∙•·])")),
]


def _level(text: str) -> int:
    for n, rx in _LEVELS:
        if rx.match(text):
            return n
    return 5


def classify(items: list, narrative: bool = False) -> list[dict]:
    """문항마다 kind 를 붙인다.

    head: 아래에 더 깊은 문항이 있는 제목(기입란 없음). note: 주석(기입란 없음).
    fill: 값을 적어 넣는 줄(끝이 ':' 이거나 '( )' 가 있음). item: 예 · 아니오 · 해당 없음으로 답하는 문항.
    narrative(3200): 제목 아래 설명 줄과 짝 없는 제목에 내용 기입란을 둔다. 첫 주석부터는 모두 주석.
    """
    rows = [{"text": str(t).strip(), "ref": str(r or "").strip()} for t, r in items if str(t).strip()]
    in_notes = False
    for x in rows:                      # 1) 주석: 3200 처럼 서술형이면 첫 주석부터 끝까지
        t = x["text"]
        x["level"] = _level(t)
        if in_notes or _NOTE.match(t) or (t.startswith("(") and t.endswith(")") and x["level"] == 5):
            x["kind"] = "note"
            in_notes = in_notes or narrative
    for i, x in enumerate(rows):        # 2) 제목 · 적어 넣기 · 확인 문항
        if x.get("kind") == "note":
            continue
        t = x["text"]
        nxt = None
        for y in rows[i + 1:]:
            if y.get("kind") == "note":
                if narrative:
                    break
                continue
            nxt = y
            break
        if ":" in t or "( )" in t:
            x["kind"] = "fill"
        elif nxt is not None and nxt["level"] > x["level"] and x["level"] < 5:
            x["kind"] = "head"
        elif narrative or t.endswith(":"):
            x["kind"] = "fill"
        else:
            x["kind"] = "item"
    return rows


# ---------------------------------------------------------------- 감사반 인원
def people_path(d: Path) -> Path:
    return Path(d) / load_defs()["independence"]["people_file"]


def people_template(d: Path) -> Path:
    p = people_path(d)
    if p.exists():
        return p
    p.parent.mkdir(parents=True, exist_ok=True)
    wb = Workbook()
    ws = wb.active
    ws.title = "감사반인원"
    ws.append(["성명", "역할", "등록번호"])
    ws.append([])
    ws["E1"] = "역할: " + " · ".join(load_defs()["independence"]["roles"]) + ". 감사반 소속 공인회계사 전원을 적어 주십시오(외감법 제9조 제3항)"
    for col, w in zip("ABCE", (14, 16, 14, 60)):
        ws.column_dimensions[col].width = w
    style.finish(wb)
    wb.save(p)
    return p


def people(d: Path, given: list[str] | None = None) -> tuple[list[dict], str]:
    """(인원 목록, 출처). given 은 '성명:역할[:등록번호]' 목록. 인원을 지어내지 않는다: 없으면 빈 목록."""
    if given:
        out = []
        for g in given:
            parts = [x.strip() for x in str(g).split(":")]
            if parts and parts[0]:
                out.append({"name": parts[0], "role": parts[1] if len(parts) > 1 else "", "reg": parts[2] if len(parts) > 2 else ""})
        return out, "명령줄 입력"
    p = people_path(d)
    if not p.exists():
        return [], ""
    wb = load_workbook(p, data_only=True, read_only=True)
    ws = wb.worksheets[0]
    rows = list(ws.iter_rows(values_only=True))
    wb.close()
    if not rows:
        return [], ""
    head = [str(v or "").strip() for v in rows[0]]
    col = {k: head.index(k) for k in ("성명", "역할", "등록번호") if k in head}
    if "성명" not in col:
        return [], ""
    out = []
    for r in rows[1:]:
        name = str(r[col["성명"]] or "").strip() if col["성명"] < len(r) else ""
        if not name:
            continue
        get = lambda k: str(r[col[k]] or "").strip() if k in col and col[k] < len(r) else ""   # noqa: E731
        out.append({"name": name, "role": get("역할"), "reg": get("등록번호")})
    return out, p.relative_to(d).as_posix()


# ---------------------------------------------------------------- 엔진이 아는 사실
def _read(d: Path, name: str, default):
    p = Path(d) / "_색인" / name
    return json.loads(p.read_text(encoding="utf-8")) if p.exists() else default


def _wp_file(d: Path, no: str) -> str | None:
    w = next((x for x in _read(d, "조서목록.json", {"workpapers": []})["workpapers"] if x["no"] == no), None)
    return w.get("file") if w else None


def hints(d: Path, no: str) -> list[str]:
    """색인에 있는 사실만 옮긴다. 숫자를 새로 만들지 않고, AI 판독 사실은 확인 전이라고 붙인다."""
    d = Path(d)
    docs = _read(d, "문서목록.json", {"files": []})["files"]
    case = _read(d, "감사건.json", {})
    out = []

    def facts_of(pred, limit=12):
        n = 0
        for f in docs:
            if not pred(f):
                continue
            for x in f.get("facts") or []:
                tag = "엔진 판독" if x.get("basis") == "엔진" else ("AI 판독, 회계사 확인 끝" if f.get("confirmed") else "AI 판독, 확인 전")
                page = f" {x['source_page']}" if x.get("source_page") else ""
                out.append(f"{x['text']} ({f['path']}{page}, {tag})")
                n += 1
                if n >= limit:
                    return

    if no == "3500":
        facts_of(lambda f: f.get("role") == "received" and "의사록" in (f.get("kind") or ""))
        perm = [f["path"] for f in docs if f.get("role") == "permanent" and f.get("kind") == "특수관계자목록"]
        out += [f"영구조서 특수관계자목록: {p}" for p in perm]
        if not perm:
            out.append("영구조서에 150 특수관계자목록이 없습니다")
    elif no == "3600":
        jet = _wp_file(d, "3600-JET")
        out.append(f"분개 테스트 조서: {jet}" if jet else "3600-JET 분개테스트 조서가 아직 없습니다")
        issues = [i for i in _read(d, "이슈.json", {"issues": []})["issues"] if i.get("status") == "열림"]
        out += [f"열린 이슈 {i['no']}: {i['title']} (발생 {i['origin_wp']})" for i in issues[:10]]
    elif no == "3300":
        for n in ("2120A", "8110A"):
            p = _wp_file(d, n)
            if p:
                out.append(f"분석적절차 조서: {p}")
        if (d / "_색인" / "분석.json").exists():
            out.append("분석 결과 색인: _색인/분석.json")
    elif no == "3400":
        areas = [w for w in _read(d, "조서목록.json", {"workpapers": []})["workpapers"] if folder._is_area(w["no"]) and w.get("file")]
        out += [f"계정별 조서: {w['file']}" for w in areas]
    elif no == "8200":
        fy = case.get("fiscal_year_end") or ""
        after = [f for f in docs if f.get("role") == "received" and f.get("period") and fy and str(f["period"]) > fy[:7]]
        out += [f"결산일 뒤 기간의 받은자료: {f['path']} ({f['kind']}, {f['period']})" for f in after]
        facts_of(lambda f: f in after)
    elif no == "8600":
        for n in ("8100A", "8820"):
            p = _wp_file(d, n)
            if p:
                out.append(f"관련 조서: {p}")
        opened = [i for i in _read(d, "이슈.json", {"issues": []})["issues"] if i.get("status") == "열림"]
        out.append(f"열린 이슈 {len(opened)}건(이슈.json)")
    elif no == "2110":
        out += _plan_facts(d, case)
        out += _materiality(d)
        issues = [i for i in _read(d, "이슈.json", {"issues": []})["issues"] if i.get("status") == "열림"]
        out += [f"열린 이슈 {i['no']}: {i['title']} → 대응 조서 {i.get('response_wp') or '미정'}" for i in issues[:15]]
        if not issues:
            out.append("열린 이슈가 없습니다(이슈.json)")
        ppl, src = people(d)
        out.append("감사반 인원: " + (", ".join(f"{p['name']}({p['role'] or '역할 미기재'})" for p in ppl) + f" [{src}]"
                                    if ppl else f"감사반 인원 목록이 없습니다({load_defs()['independence']['people_file']})"))
    elif no == "3700":
        out += [f"사실 {i}. {x['text']}" for i, x in enumerate(going_concern(d), 1)]
    elif no == "2301":
        ana = _read(d, "분석.json", None)
        if ana and ana.get("issues"):
            out += [f"분석 상위 {x['rank']}: {x['title']} (영역 {x.get('area') or '-'}, 이슈 {x['issue']})" for x in ana["issues"][:10]]
        else:
            out.append("_색인/분석.json 이 없거나 상위 이슈가 없습니다(분석적 검토 전)")
        p2302 = _wp_file(d, "2302")
        out.append(f"경영진주장 수준 위험 조서: {p2302}" if p2302 else "2302 조서가 아직 없습니다")
    elif no in SIZE_WPS:
        n = 0
        for f in docs:
            if f.get("role") != "received" or f.get("kind") not in SIZE_KINDS:
                continue
            for x in f.get("facts") or []:
                if x.get("basis") == "엔진" and any(k in x["text"] for k in SIZE_KEYS):
                    out.append(f"회사 규모: {x['text']} ({f['path']}, 엔진 판독)")
                    n += 1
        if not n:
            out.append("회사 규모(매출 · 인원)를 엔진이 읽은 받은자료가 없습니다")
        out.append("소규모 기업 간소화 대상인지는 회계사 판단입니다. 엔진은 정하지 않습니다")
    return out


# ---------------------------------------------------------------- 3700 계속기업 (2026-10-18)
def _won(x) -> str:
    return f"{int(round(x)):,}원"


def _prior_pl(pf: dict | None, stem: str):
    """전기 손익계산서의 영업 · 당기순 손익(손실은 음수). 「영업손실」 처럼 손실 이름 줄은 금액 부호와 관계없이 손실로 본다."""
    from . import reader

    for k, v in ((pf or {}).get("is") or {}).items():
        if not isinstance(v, (int, float)):
            continue
        n = reader._norm(k)
        if n in (f"{stem}이익", f"{stem}손익"):
            return v
        if n == f"{stem}손실":
            return -abs(v)
    return None


def _prior_bs(pf: dict | None, name: str):
    from . import reader

    for k, v in ((pf or {}).get("bs") or {}).items():
        if reader._norm(k) == name and isinstance(v, (int, float)):
            return v
    return None


def _pl_text(what: str, cur, prior) -> tuple[str, bool]:
    """(문장, 당기 손실인가). 금액은 시산표 · 전기 재무제표 값 그대로."""
    def one(label, v):
        return f"{what}{'손실' if v < 0 else '이익'} {_won(abs(v))}({label})"
    t = one("당기", cur)
    if prior is None:
        t += f". 전기 {what}손익은 전기 재무제표에서 찾지 못했습니다"
    else:
        t += ", " + one("전기", prior)
        if cur < 0 and prior < 0:
            t += f" (당기 · 전기 연속 {what}손실)"
    return t, cur < 0


def going_concern(d: Path) -> list[dict]:
    """3700 「엔진이 아는 사실」. [{key, text, candidate}]. key 는 close.yaml going_concern.links 의 사실 종류다.
    숫자는 회사제시 시산표(figures.current_tb) · 전기 재무제표(figures.prior) · 계정명세서 차입금 표(recalc.loans)에서만 온다.
    candidate 는 한공회 3700 점검 항목에 「해당 후보」 를 붙일지다. 해당 여부(예 · 아니오)와 계속기업 판단은 회계사 몫이다."""
    from datetime import date as _date

    from . import figures, reader
    from .workpapers import common, recalc

    d = Path(d)
    gc = load_defs().get("going_concern") or {}
    case = _read(d, "감사건.json", {})
    out: list[dict] = []

    def add(key: str, text: str, candidate: bool = False) -> None:
        out.append({"key": key, "text": text, "candidate": candidate})

    rows = [r for r in figures.current_tb(d) if not figures.is_group_row(r.get("name"))]
    pf = figures.prior(d)
    actual: dict = {}
    if not rows:
        add("tb", f"재무적 사항을 계산하지 못했습니다. {figures.tb_absent_reason(d)}")
    else:
        def grp(r) -> str | None:
            if r.get("fs_group"):
                return r["fs_group"]
            k = common.code3(r["code"])
            return next((g for g, (lo, hi) in figures.FS_RANGES.items() if k is not None and lo <= k <= hi), None)

        def tot(g: str) -> int:
            return sum(r["amount"] for r in rows if grp(r) == g)

        ver = next((r.get("version") for r in rows if r.get("version")), None)
        src = f"회사제시 시산표{' ' + ver if ver else ''}"
        ca, cl = tot("유동자산"), -tot("유동부채")
        assets, liab = ca + tot("비유동자산"), cl - tot("비유동부채")
        equity = assets - liab
        capital = -sum(r["amount"] for r in rows if grp(r) == "자본" and reader._norm(r["name"]).endswith("자본금"))
        t = f"당기말 자본총계 {_won(equity)} (자산총계 {_won(assets)} − 부채총계 {_won(liab)}, {src})"
        pe = _prior_bs(pf, "자본총계")
        if pe is not None:
            t += f". 전기말 자본총계 {_won(pe)} (전기 재무제표)"
        if equity < 0:
            add("capital_deficit", t + ". 자본총계가 음수다(완전자본잠식)", True)
        elif capital > 0 and equity < capital:
            add("capital_deficit", t + f". 자본금 {_won(capital)} 보다 작다(부분자본잠식, 자본잠식률 {(capital - equity) / capital:.1%})")
        else:
            add("capital_deficit", t)
        t = f"당기말 유동자산 {_won(ca)}, 유동부채 {_won(cl)} ({src}, 계정코드 범위 유동자산 101~175 · 유동부채 251~290)"
        if cl > ca:
            add("net_current_liabilities", t + f". 유동부채가 유동자산보다 많다(순유동부채 {_won(cl - ca)})", True)
        else:
            add("net_current_liabilities", t)
        # 영업손익은 매출액 · 매출원가 · 판매비와관리비 묶음과 제조 · 도급원가 계정(코드 501~800), 당기순손익은 손익 계정 전부
        op_groups = ("매출액", "매출원가", "판매비와관리비")
        pl_groups = op_groups + ("영업외수익", "영업외비용", "법인세비용")
        cost = lambda r: grp(r) is None and 501 <= (common.code3(r["code"]) or 0) <= 800      # noqa: E731
        op = -sum(r["amount"] for r in rows if grp(r) in op_groups or cost(r))
        ni = -sum(r["amount"] for r in rows if grp(r) in pl_groups or cost(r))
        t, loss = _pl_text("영업", op, _prior_pl(pf, "영업"))
        mfg = " · 제조 · 도급원가(코드 501~800)" if any(cost(r) and r["amount"] for r in rows) else ""
        add("operating_loss", t + f" ({src} 매출액 · 매출원가 · 판매비와관리비{mfg}, 전기 재무제표)", loss)
        actual = {"revenue": -tot("매출액"), "op": op}
        t, loss = _pl_text("당기순", ni, _prior_pl(pf, "당기순"))
        add("net_loss", t + f" ({src} 손익 계정, 전기 재무제표)", loss)
        short = [r for r in rows if grp(r) == "유동부채" and any(k in reader._norm(r["name"]) for k in ("단기차입금", "유동성장기"))]
        if short:
            v = -sum(r["amount"] for r in short)
            names = " · ".join(dict.fromkeys(r["name"] for r in short))
            add("borrowings_due", f"유동부채로 분류된 차입금({names}) 합계 {_won(v)} ({src})", v > 0)
        else:
            add("borrowings_due", f"시산표 유동부채에 단기차입금 · 유동성장기부채 계정이 없습니다 ({src})")
    try:
        ls = recalc.loans(d)
    except Exception:            # 계정명세서를 읽지 못하면 명세가 없는 것으로 본다
        ls = []
    fy = case.get("fiscal_year_end")
    if ls and fy:
        e = _date.fromisoformat(fy)
        try:
            limit = e.replace(year=e.year + 1)
        except ValueError:       # 2월 29일
            limit = _date(e.year + 1, 2, 28)
        due = [(x, reader._date(x.get("만기"))) for x in ls]
        hit = [x for x, m in due if m and m <= limit]
        unknown = sum(1 for _, m in due if m is None)
        t = (f"차입금 표(계정명세서 · 회사 차입금 리스트) {len(ls)}건 가운데 만기가 {limit.isoformat()} 까지인 차입 {len(hit)}건 "
             f"합계 {_won(sum(abs(x['잔액']) for x in hit))}")
        if unknown:
            t += f". 만기를 읽지 못한 차입 {unknown}건(만기 열이 없거나 날짜가 아님)"
        add("borrowings_due", t + ". 갱신 · 상환 가능성은 약정서 · 조회로 회계사가 본다", bool(hit))
    elif not ls:
        add("borrowings_due", "계정명세서 · 회사 차입금 리스트에 차입금 표가 없어 1년 안 만기 차입금 합계를 내지 못했습니다")
    keys = [str(k).lower() for k in gc.get("plan_keys") or []]
    docs = _read(d, "문서목록.json", {"files": []})["files"]
    plans = [f["path"] for f in docs if f.get("role") == "received" and any(k in Path(f["path"]).name.lower() for k in keys)]
    nxt = f"{int(fy[:4]) + 1}년 " if fy else "다음 해 "
    from . import folder as _folder, plans as _plans

    read_plans = [(p, _plans.read(d / p)) for p in plans]
    years = sorted({g["year"] for _, g in read_plans if g and g.get("year")})
    if years:                                  # 파일에서 읽은 계획 연도(중간감사는 결산 연도 계획이다, 2026-10-20)
        nxt = " · ".join(f"{y}년" for y in years) + " "
    if plans:
        add("plan", f"{nxt}사업계획 · 추정 자료로 보이는 받은자료 {len(plans)}개(파일 이름으로 찾음): " + ", ".join(plans[:5])
            + (f" 외 {len(plans) - 5}개" if len(plans) > 5 else "") + ". 내용과 기간은 회계사가 확인한다")
        # 사업계획 ↔ 실적(2026-10-20): 엑셀 계획을 읽어 같은 기간 합계(중간감사 · 예산) 또는 다음 해 연간 계획과 당기 실적을 견준다
        if actual and fy:
            start, end = _folder.fiscal_start(case), _date.fromisoformat(fy[:10])
            for p, got in read_plans:
                c = _plans.compare(got, start, end, actual) if got else None
                if c:
                    short = c["kind"] == "같은 기간" and any(ln["diff"] < 0 for ln in c["lines"])
                    add("plan_actual", _plans.text(c, _won) + ". 계획의 실현 가능성은 회계사가 본다", short)
    else:
        add("plan", f"받은자료에 {nxt}사업계획 · 추정재무제표 · 자금계획으로 보이는 파일이 없습니다(파일 이름으로 찾음)")
    return out


def going_concern_marks(rows: list[dict], facts: list[dict]) -> dict[int, str]:
    """점검 항목 줄 번호(rows 의 0부터) → 「해당 후보: 사실 1 · 2」 같은 표시. 답 칸은 비워 둔다."""
    links = (load_defs().get("going_concern") or {}).get("links") or {}
    out: dict[int, str] = {}
    for i, x in enumerate(rows):
        if x["kind"] != "item":
            continue
        cand, ref = [], []
        for n, f in enumerate(facts, 1):
            if any(k in x["text"] for k in links.get(f["key"], [])):
                (cand if f["candidate"] else ref).append(str(n))
        parts = ([f"해당 후보: 사실 {' · '.join(cand)}"] if cand else []) + ([f"참고: 사실 {' · '.join(ref)}"] if ref else [])
        if parts:
            out[i] = ". ".join(parts)
    return out


SIZE_WPS = ("2511", "2512", "2513", "2520", "2530", "2531", "2532", "2533")
SIZE_KINDS = ("회사제시 재무제표·시산표", "급여대장")
SIZE_KEYS = ("매출액", "자산총계", "인원")


def _won_s(v) -> str:
    return f"{int(round(v)):,}원" if isinstance(v, (int, float)) else "-"


def _plan_facts(d: Path, case: dict) -> list[str]:
    """2110 감사계획 수립에 쓰는 엔진 사실(2026-11-05): 회사 규모 · 초도감사 · 전기 원천 · 실행 조서와 생긴 까닭 · 분개장 대사.
    숫자는 분석.json · 조서목록.json 값 그대로다."""
    out = []
    ana = _read(d, "분석.json", None)
    if ana:
        b = {x["name"]: x for x in ana.get("materiality_bases") or []}
        size = " · ".join(f"{n} 당기 {_won_s(b[n]['cur'])}(전기 {_won_s(b[n]['prior'])})" for n in ("매출액", "법인세비용차감전순이익", "자산총계")
                          if n in b and b[n].get("cur") is not None)
        if size:
            out.append(f"회사 규모(회사제시): {size}")
        pr = ana.get("prior") or {}
        basis = ", ".join(f"{k} {v}개" for k, v in (pr.get("basis_counts") or {}).items())
        out.append(f"전기 자료: {pr.get('situation') or '-'}. 계정 단위 전기 잔액 원천 {basis or '없음'}")
        jr = ana.get("journal_recon") or {}
        if jr.get("status") == "ok":
            c = jr.get("counts") or {}
            out.append(f"분개장 대사(8100B): 맞음 {c.get('맞음', 0)} · 차이 {c.get('차이', 0)} · 기초 없음 {c.get('기초 없음', 0)}")
    if case.get("first_year") or folder_first_year(d):
        out.append("초도감사: 기초잔액 감사(감사기준서 510, 3800 조서)와 전임감사인 조서 열람 여부를 계획에 넣는다")
    wps = _read(d, "조서목록.json", {"workpapers": []})["workpapers"]
    areas = [w for w in wps if folder._is_area(w["no"]) and w.get("file")]
    if areas:
        out.append("실행 단계 계정별 조서 " + str(len(areas)) + "개: " + ", ".join(w["no"] for w in areas))
    return out


def folder_first_year(d: Path) -> bool:
    try:
        from . import methodology

        return bool(methodology.first_year(Path(d)))
    except Exception:  # noqa: BLE001  판정하지 못하면 표시만 빠진다
        return False


def _materiality(d: Path) -> list[str]:
    """2700A 중요성 기입란 가운데 회계사가 채운 값. 없으면 분석이 쓴 적용값(방법론 기본값이면 그 표시)을 옮긴다."""
    f = _wp_file(d, "2700A")
    if not f or not (Path(d) / f).exists() or not f.endswith(".xlsx"):
        return ["2700A 미입력(중요성 조서 없음)"]
    vals = [x for x in wp.readback(Path(d) / f) if not wp._blank(x["value"]) and x["label"] not in ("작성자", "검토자")]
    if not vals:
        ana = _read(d, "분석.json", None) or {}
        inp = ana.get("inputs") or {}
        got = [(n, inp.get(f"materiality.{k}") or {}) for n, k in (("재무제표 전체 중요성", "overall"), ("수행중요성", "performance"),
                                                                ("명백히 사소한 금액", "trivial"))]
        if not any(x.get("value") is not None for _, x in got):
            return ["2700A 미입력"]
        return ["2700A 기입란 미입력. 분석이 쓴 적용값: " + " · ".join(f"{n} {_won_s(x.get('value'))}" for n, x in got)
                + (" (방법론 기본값, 감사인 확인 전)" if any(x.get("default") for _, x in got) else "")]
    return [f"2700A {x['label']}: {x['value']:,}" if isinstance(x["value"], (int, float)) else f"2700A {x['label']}: {x['value']}"
            for x in vals[:8]]


# ---------------------------------------------------------------- 기입란 이어받기
def carry_inputs(book: wp.Book, old_path: Path) -> int:
    """앞선 파일에서 같은 (시트, 항목) 기입란에 적힌 값을 새 책에 옮긴다. 옮긴 칸 수."""
    if not Path(old_path).exists():
        return 0
    old = {(x["sheet"], x["label"]): x["value"] for x in wp.readback(old_path) if not wp._blank(x["value"])}
    n = 0
    for sheet, ref, label, _rule in book.inputs:
        v = old.get((sheet, label))
        if v is not None:
            book.wb[sheet][ref].value = v
            n += 1
    return n


def _yesno_validation(ws) -> DataValidation:
    dv = DataValidation(type="list", formula1=YESNO, allow_blank=True)
    ws.add_data_validation(dv)
    return dv


def preparer_input(b: wp.Book, ws) -> None:
    """머리 작성자 칸을 기입란으로 바꾼다(검사 통과 때 이 이름으로 작성 서명을 단다)."""
    note = b.preparer
    b.ask(ws, 3, 5, "작성자", rule="optional")
    ws.cell(3, 5).value = None          # ws.cell(.., value=None) 은 앞 값을 지우지 않는다
    ws.cell(3, 6, note).font = wp.font(size=9, color=wp.MUTED)


# ---------------------------------------------------------------- 조서 만들기
def _table(b: wp.Book, ws, row: int, rows: list[dict], no: str, key: str, dv, evaluate=None, marks: dict | None = None) -> int:
    """evaluate 가 있으면(통제 이해 2511~2513) 첫째 수준 고려요소마다 평가결과(양호 · 미흡 · 해당 없음) 기입란을 둔다.
    marks 가 있으면(3700) 여섯째 열에 엔진 사실과 이은 표시(해당 후보 · 참고)를 적는다. 기입란이 아니다."""
    third = "예 · 아니오 · 해당 없음" + (" / 평가결과" if evaluate else "")
    row = b.head(ws, row, ["항목", "조서번호", third, "근거 · 수행 결과", "수행자"] + (["엔진 표시(답은 회계사)"] if marks else []))
    if marks:
        ws.column_dimensions["F"].width = 30
    for i, x in enumerate(rows, 1):
        if marks and (i - 1) in marks:
            b.put(ws, row, 6, marks[i - 1], wrap=True, color=wp.RED)
        kind = x["kind"]
        b.put(ws, row, 1, x["text"], wrap=True, bold=(kind == "head"), color=wp.MUTED if kind == "note" else None)
        ws.row_dimensions[row].height = 15 * max(1, min(6, len(x["text"]) // 60 + 1))
        b.put(ws, row, 2, x["ref"] or None)
        lab = f"{key}{i}. {x['text'][:40]}"
        if kind == "head" and evaluate is not None and x["level"] == 1 and not any(w in x["text"][:12] for w in ("결론", "기타")):
            evaluate.add(b.ask(ws, row, 3, f"{lab} | 평가결과", rule="required").coordinate)
            b.ask(ws, row, 4, f"{lab} | 평가 근거", rule="optional")
        elif kind == "item":
            cell = b.ask(ws, row, 3, f"{lab} | 답", rule="yesno")
            dv.add(cell.coordinate)
            b.ask(ws, row, 4, f"{lab} | 근거", rule="optional")
            b.ask(ws, row, 5, f"{lab} | 수행자", rule="optional")
        elif kind == "fill":
            b.ask(ws, row, 4, f"{lab} | 내용", rule="required" if no == "3200" else "optional")
        row += 1
    return row


def _hint_block(b: wp.Book, ws, row: int, lines: list[str]) -> int:
    row = b.section(ws, row, "엔진이 아는 사실(색인에서 옮김. 판단은 회계사가 합니다)")
    if not lines:
        ws.cell(row, 1, "색인에 이 조서와 이어진 사실이 없습니다").font = wp.font(size=9, color=wp.MUTED)
        return row + 2
    for t in lines:
        c = ws.cell(row, 1, t)
        c.font = wp.font(size=9, color=wp.RED)
        row += 1
    return row + 1


def _independence(b: wp.Book, ws, row: int, ppl: list[dict], source: str, dv) -> int:
    ind = load_defs()["independence"]
    row = b.section(ws, row, "감사반 소속 공인회계사별 독립성 확인(외감법 제9조 제3항 · 공인회계사법 제21조)")
    ws.cell(row, 1, "답: 예(해당하지 않음을 확인) · 아니오(해당함, 근거 칸에 내용) · 해당 없음").font = wp.font(size=9, color=wp.MUTED)
    row += 1
    if not ppl:
        ws.cell(row, 1, f"감사반 인원 목록이 없습니다. {ind['people_file']} 에 성명 · 역할을 적고 "
                        "python -m audit close make <감사 폴더> 1300 --refresh 로 다시 만드십시오").font = wp.font(color=wp.RED, bold=True)
        b.ask(ws, row + 1, 1, "감사반 인원 목록", rule="required")
        return row + 3
    ws.cell(row, 1, f"인원 출처: {source}").font = wp.font(size=9, color=wp.MUTED)
    row += 1
    for k, p in enumerate(ppl, 1):
        head = f"{p['name']} ({p['role'] or '역할 미기재'}{', ' + p['reg'] if p.get('reg') else ''})"
        row = b.section(ws, row + 1, f"{k}. {head}")
        row = b.head(ws, row, ["확인 항목", "근거 조문", "예 · 아니오 · 해당 없음", "근거 · 내용", "확인일"])
        for j, it in enumerate(ind["items"], 1):
            b.put(ws, row, 1, it["text"], wrap=True)
            ws.row_dimensions[row].height = 30
            b.put(ws, row, 2, it["law"], wrap=True)
            lab = f"독립 {p['name']} {j}"
            dv.add(b.ask(ws, row, 3, f"{lab} | 답", rule="yesno").coordinate)
            b.ask(ws, row, 4, f"{lab} | 근거", rule="optional")
            b.ask(ws, row, 5, f"{lab} | 확인일", rule="optional", fmt="yyyy-mm-dd")
            row += 1
    return row + 1


def _register(b: wp.Book, ws, row: int, data: dict) -> int:
    """한공회 서식의 빈 기입 표. 템플릿 예시 행은 옮기지 않는다. 칸은 모두 선택 기입(줄 수가 회사마다 다르다)."""
    cols = data["columns"]
    row = b.section(ws, row + 1, data.get("table_title") or "기입 표(한공회 서식 열)")
    for j in range(len(cols)):
        letter = chr(ord("A") + j)
        cur = ws.column_dimensions[letter].width or 10
        ws.column_dimensions[letter].width = max(cur, 18)
    row = b.head(ws, row, cols)
    ws.row_dimensions[row - 1].height = 45
    for i in range(1, int(data.get("register_rows", 10)) + 1):
        for j, c in enumerate(cols, 1):
            b.ask(ws, row, j, f"표 {i}행 {c[:24]}", rule="optional")
        row += 1
    for t, _ in data.get("notes", []):
        ws.cell(row, 1, t).font = wp.font(size=9, color=wp.MUTED)
        row += 1
    return row + 1


@params.engaged
def make(d: Path, no: str, people_given: list[str] | None = None, refresh: bool = False) -> Path:
    d = Path(d)
    defs = load_defs()["checklists"]
    if no not in defs:
        raise ValueError(f"점검표 조서가 아닙니다: {no}")
    spec = defs[no]
    data = load_items().get(no)
    if data is None:
        raise ValueError(f"한공회 점검표 문항이 없습니다: {no}")
    path = wp.path_for(d, no)
    if path.exists() and not refresh:
        return path
    b = wp.Book(d, no, standard=spec["standard"] + " · 한공회 감사조서서식 2026 문항")
    ws, row = b.sheet(no, widths=[70, 14, 14, 40, 12])
    b.draft_column(ws, 6)               # 기입란 AI 초안 열(audit/drafts.py, 2026-11-05)
    preparer_input(b, ws)
    dv = _yesno_validation(ws)
    title = data["title"].split(" ", 1)[1].strip() if " " in data["title"] else data["title"]
    ws.cell(2, 1, f"{ws.cell(2, 1).value} · 원본 제목: {title}").font = wp.font(size=9, color=wp.MUTED)
    if spec.get("per_person"):
        ppl, source = people(d, people_given)
        row = _independence(b, ws, row, ppl, source, dv)
    else:
        row = _hint_block(b, ws, row, hints(d, no))
    layout = data.get("layout")
    if data["items"]:
        rows = classify(data["items"], narrative=bool(spec.get("narrative")))
        ev = None
        if layout == "control":
            ev = DataValidation(type="list", formula1=EVAL, allow_blank=True)
            ws.add_data_validation(ev)
        marks = going_concern_marks(rows, going_concern(d)) if no == "3700" else None
        row = b.section(ws, row, "한공회 점검 항목")
        row = _table(b, ws, row, rows, no, "", dv, evaluate=ev, marks=marks)
    if layout == "register":
        row = _register(b, ws, row, data)
    b.conclusion(ws, row, 5)
    ws.sheet_view.showGridLines = False
    if no == "3200":                    # 소송 조회 대장(R9 A7). 사건 줄은 회계사 기입
        from .workpapers import recalc

        recalc.litigation_sheet(b, d)
    if no == "8600":                    # 감사의견 선택 시트(2026-10-06). 8820 · DART 문형이 이 값을 따른다
        from .report import opinion

        opinion.add_sheet(b)
    if no == "3500":                    # 특수관계자 거래 · 잔액(2026-10-16). 목록은 영구조서 150, 거래는 분개장
        from . import relparty

        relparty.add_sheet(b, d)
    if no == "3300":                    # 3300A 실증적 분석절차 부속 시트(R9 B2). 기대치는 분석 결과를 쓴다
        from .analysis import substantive

        substantive.add_sheet(b)
    from . import priorwp

    priorwp.reference_sheet(b, d, no)   # 작년 같은 번호 조서에 회계사가 적은 내용(참고 시트, 2026-10-12)
    if refresh:
        carry_inputs(b, path)
    return b.save(path)


@params.engaged
def make_all(d: Path, nos: list[str] | None = None, people_given: list[str] | None = None, refresh: bool = False) -> list[Path]:
    targets = nos or list(load_defs()["checklists"])
    return [make(d, no, people_given, refresh) for no in targets]


def counts(path: Path) -> dict:
    """기입란 채움 현황: {yesno, yesno_filled, required, required_filled}."""
    out = {"yesno": 0, "yesno_filled": 0, "required": 0, "required_filled": 0}
    for x in wp.readback(path):
        if x["rule"] == "yesno":
            out["yesno"] += 1
            out["yesno_filled"] += 0 if wp._blank(x["value"]) else 1
        elif x["rule"] == "required":
            out["required"] += 1
            out["required_filled"] += 0 if wp._blank(x["value"]) else 1
    return out


__all__ = ["load_items", "classify", "people", "people_template", "hints", "going_concern", "make", "make_all", "carry_inputs",
           "preparer_input", "counts"]
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