specthread 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +139 -0
- package/dist/bin/check.d.ts +1 -0
- package/dist/bin/check.js +67 -0
- package/dist/bin/cli.d.ts +2 -0
- package/dist/bin/cli.js +26 -0
- package/dist/bin/generate.d.ts +1 -0
- package/dist/bin/generate.js +55 -0
- package/dist/checks/changelog.d.ts +8 -0
- package/dist/checks/changelog.js +30 -0
- package/dist/checks/headings.d.ts +3 -0
- package/dist/checks/headings.js +54 -0
- package/dist/checks/links.d.ts +8 -0
- package/dist/checks/links.js +66 -0
- package/dist/checks/markers.d.ts +2 -0
- package/dist/checks/markers.js +60 -0
- package/dist/checks/pending.d.ts +2 -0
- package/dist/checks/pending.js +200 -0
- package/dist/checks/references.d.ts +2 -0
- package/dist/checks/references.js +41 -0
- package/dist/checks/sections.d.ts +3 -0
- package/dist/checks/sections.js +137 -0
- package/dist/checks/style.d.ts +10 -0
- package/dist/checks/style.js +61 -0
- package/dist/checks/timestamps.d.ts +2 -0
- package/dist/checks/timestamps.js +58 -0
- package/dist/checks/toc.d.ts +2 -0
- package/dist/checks/toc.js +41 -0
- package/dist/commands/init.d.ts +1 -0
- package/dist/commands/init.js +115 -0
- package/dist/config-loader.d.ts +2 -0
- package/dist/config-loader.js +106 -0
- package/dist/config.schema.d.ts +96 -0
- package/dist/config.schema.js +27 -0
- package/dist/constants/docs.d.ts +15 -0
- package/dist/constants/docs.js +16 -0
- package/dist/constants/patterns.d.ts +24 -0
- package/dist/constants/patterns.js +24 -0
- package/dist/constants/rules.d.ts +101 -0
- package/dist/constants/rules.js +97 -0
- package/dist/gen/pending-section.d.ts +19 -0
- package/dist/gen/pending-section.js +102 -0
- package/dist/gen/references.d.ts +13 -0
- package/dist/gen/references.js +144 -0
- package/dist/gen/summary.d.ts +27 -0
- package/dist/gen/summary.js +125 -0
- package/dist/gen/toc.d.ts +25 -0
- package/dist/gen/toc.js +66 -0
- package/dist/types.d.ts +125 -0
- package/dist/types.js +1 -0
- package/dist/utils/anchor.d.ts +20 -0
- package/dist/utils/anchor.js +24 -0
- package/dist/utils/ignore.d.ts +11 -0
- package/dist/utils/ignore.js +20 -0
- package/dist/utils/parse.d.ts +50 -0
- package/dist/utils/parse.js +272 -0
- package/dist/utils/report.d.ts +17 -0
- package/dist/utils/report.js +38 -0
- package/dist/utils/resolve.d.ts +21 -0
- package/dist/utils/resolve.js +157 -0
- package/dist/utils/scan.d.ts +11 -0
- package/dist/utils/scan.js +111 -0
- package/dist/utils/scope.d.ts +51 -0
- package/dist/utils/scope.js +55 -0
- package/package.json +29 -0
- package/scaffold/AGENTS.md +67 -0
- package/scaffold/CLAUDE.md +1 -0
- package/scaffold/claude/skills/check.md +43 -0
- package/scaffold/claude/skills/gen.md +41 -0
- package/scaffold/claude/skills/plan-close.md +57 -0
- package/scaffold/claude/skills/plan-open.md +50 -0
- package/scaffold/claude/skills/plan-run.md +51 -0
- package/scaffold/config.jsonc +71 -0
- package/scaffold/pending.md +34 -0
- package/scaffold/project.md +47 -0
- package/scaffold/rules.md +421 -0
- package/scaffold/templates/plan.md +159 -0
- package/scaffold/templates/spec.md +96 -0
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 미확정 사항 절 생성 - 관리 문서 항목의 백링크를 문서 기준으로 뒤집는다.
|
|
3
|
+
*
|
|
4
|
+
* 각 관리 문서 항목의 `참조:` 줄이 어느 문서를 가리키는지 이미 안다. 그것을 대상
|
|
5
|
+
* 문서 기준으로 재정렬하면 그 문서의 미확정 목록이 나온다 (`docs/system/rules.md` §4).
|
|
6
|
+
* 목차·참조 절과 같은 방식이다 - 정본은 관리 문서이고 여기는 생성 뷰다.
|
|
7
|
+
*
|
|
8
|
+
* **이미 절을 가진 문서만 채운다.** 참조는 _이 항목이 이 문서와 관련 있다_ 는
|
|
9
|
+
* 인용이지 _이 문서가 이 미확정을 소유한다_ 는 선언이 아니다. `STATUS.md` 처럼
|
|
10
|
+
* 배경으로 인용될 뿐인 문서에 절을 새로 만들면 소유하지 않는 것을 소유한 듯 보인다.
|
|
11
|
+
*
|
|
12
|
+
* **소비자가 둘이다.** `bin/generate.ts` 가 파일에 쓰고, `checks/pending.ts` 가 같은
|
|
13
|
+
* 함수를 불러 지금 내용과 비교한다.
|
|
14
|
+
*/
|
|
15
|
+
import { dirname, join, normalize, relative } from 'node:path';
|
|
16
|
+
const ITEM_HEADING = /^###\s+`\[([a-z]+::[a-z0-9][a-z0-9-]*)\]`\s*(.*)$/;
|
|
17
|
+
const REF_LINK = /\]\(([^)\s]+)\)/g;
|
|
18
|
+
/** 관리 문서를 훑어 항목마다 (제목·앵커) 와 `참조:` 가 가리키는 대상 파일 집합을 뽑는다 */
|
|
19
|
+
const parseItems = (pending) => {
|
|
20
|
+
const out = [];
|
|
21
|
+
let current = null;
|
|
22
|
+
let inChangeLog = false;
|
|
23
|
+
pending.lines.forEach((raw, i) => {
|
|
24
|
+
if (/^## 변경 이력/.test(raw))
|
|
25
|
+
inChangeLog = true;
|
|
26
|
+
if (inChangeLog)
|
|
27
|
+
return;
|
|
28
|
+
const h = ITEM_HEADING.exec(raw);
|
|
29
|
+
if (h !== null) {
|
|
30
|
+
const heading = pending.headings.find((x) => x.line === i + 1);
|
|
31
|
+
current = {
|
|
32
|
+
item: { slug: h[1], title: h[2].trim(), anchor: heading?.anchor ?? '' },
|
|
33
|
+
targets: new Set(),
|
|
34
|
+
};
|
|
35
|
+
out.push(current);
|
|
36
|
+
return;
|
|
37
|
+
}
|
|
38
|
+
if (current === null || !raw.startsWith('참조:'))
|
|
39
|
+
return;
|
|
40
|
+
for (const m of raw.matchAll(REF_LINK)) {
|
|
41
|
+
const path = m[1].split('#')[0];
|
|
42
|
+
current.targets.add(normalize(join(dirname(pending.path), path)));
|
|
43
|
+
}
|
|
44
|
+
});
|
|
45
|
+
return out;
|
|
46
|
+
};
|
|
47
|
+
/** 대상 문서 경로 → 그 문서를 가리키는 항목 목록 (slug 순) */
|
|
48
|
+
export const invertByTarget = (pending) => {
|
|
49
|
+
const byTarget = new Map();
|
|
50
|
+
for (const { item, targets } of parseItems(pending)) {
|
|
51
|
+
for (const target of targets) {
|
|
52
|
+
const list = byTarget.get(target) ?? [];
|
|
53
|
+
list.push(item);
|
|
54
|
+
byTarget.set(target, list);
|
|
55
|
+
}
|
|
56
|
+
}
|
|
57
|
+
for (const list of byTarget.values())
|
|
58
|
+
list.sort((a, b) => a.slug.localeCompare(b.slug));
|
|
59
|
+
return byTarget;
|
|
60
|
+
};
|
|
61
|
+
/**
|
|
62
|
+
* 미확정 사항 절 본문. 절 자체가 없는 문서는 빈 배열 - 새로 만들지 않는다.
|
|
63
|
+
*
|
|
64
|
+
* 절은 있는데 가리키는 항목이 0 인 경우도 있다 (전부 해소됐거나 애초에 없음). 그때도
|
|
65
|
+
* _해당 없음_ 을 명시해 빈 채로 방치하지 않는다 - 빈 결과와 stale 결과를 구분 못 하면
|
|
66
|
+
* 검사가 항상 통과해 버린다.
|
|
67
|
+
*/
|
|
68
|
+
export const pendingSectionBlock = (file, byTarget, index) => {
|
|
69
|
+
if (file.pendingSection === null)
|
|
70
|
+
return [];
|
|
71
|
+
if (file.path.startsWith(index.config.work))
|
|
72
|
+
return [];
|
|
73
|
+
const items = byTarget.get(file.path) ?? [];
|
|
74
|
+
const rel = relative(dirname(file.path), index.config.pending);
|
|
75
|
+
const link = rel.startsWith('.') ? rel : `./${rel}`;
|
|
76
|
+
if (items.length === 0) {
|
|
77
|
+
return ['', `해당 없음 - 이 문서를 가리키는 미확정 항목이 없다 ([\`pending.md\`](${link})).`, ''];
|
|
78
|
+
}
|
|
79
|
+
return [
|
|
80
|
+
'',
|
|
81
|
+
`> **정본은 [\`pending.md\`](${link}) 다.** 이 절은 그 항목을 이 문서 기준으로 되짚은 생성 뷰다.`,
|
|
82
|
+
'',
|
|
83
|
+
...items.map((it) => `- [\`${it.slug}\`](${link}#${it.anchor}) ${it.title}`),
|
|
84
|
+
'',
|
|
85
|
+
];
|
|
86
|
+
};
|
|
87
|
+
/** 미확정 사항 절을 채운 문서 줄 목록. 바꿀 것이 없으면 null */
|
|
88
|
+
export const applyPendingSection = (file, lines, index) => {
|
|
89
|
+
if (file.path === index.config.pending)
|
|
90
|
+
return null;
|
|
91
|
+
const pending = index.files.get(index.config.pending);
|
|
92
|
+
if (pending === undefined)
|
|
93
|
+
return null;
|
|
94
|
+
const block = pendingSectionBlock(file, invertByTarget(pending), index);
|
|
95
|
+
if (block.length === 0 || file.pendingSection === null)
|
|
96
|
+
return null;
|
|
97
|
+
const { start, end } = file.pendingSection;
|
|
98
|
+
const current = lines.slice(start - 1, end);
|
|
99
|
+
if (current.join('\n') === block.join('\n'))
|
|
100
|
+
return null;
|
|
101
|
+
return [...lines.slice(0, start - 1), ...block, ...lines.slice(end)];
|
|
102
|
+
};
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
import type { SpecthreadConfig } from "../config.schema.ts";
|
|
2
|
+
import type { DocIndex, IndexedFile } from "../types.ts";
|
|
3
|
+
/**
|
|
4
|
+
* 참조 절 본문. `## 참조` 헤딩과 다음 절 사이에 놓일 모양 그대로.
|
|
5
|
+
*
|
|
6
|
+
* 앞뒤 빈 줄을 포함한다 - 헤딩 줄은 색인 범위 밖이므로 생성기가 건드리지 않는다.
|
|
7
|
+
* 수집된 대상이 없으면 빈 배열이다.
|
|
8
|
+
*/
|
|
9
|
+
export declare const referenceBlock: (file: IndexedFile, config: SpecthreadConfig) => string[];
|
|
10
|
+
/**
|
|
11
|
+
* 참조 절을 채우거나 새로 넣은 문서 줄 목록. 바꿀 것이 없으면 null.
|
|
12
|
+
*/
|
|
13
|
+
export declare const applyReferences: (file: IndexedFile, lines: string[], index: DocIndex) => string[] | null;
|
|
@@ -0,0 +1,144 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 참조 절 생성 - 본문 링크를 대상별로 모아 문서 하단 `## 참조` 절을 채운다.
|
|
3
|
+
*
|
|
4
|
+
* 참조 절은 **이 문서를 이해하려면 읽어야 하는 대상 목록** 이고, 대상의 어느 절을
|
|
5
|
+
* 읽어야 하는지는 본문 인라인 링크가 갖는다 (`docs/system/rules.md` §3-3). 그래서
|
|
6
|
+
* 라벨의 `§` 표기와 앵커는 떼고 파일만 남긴다 - 같은 대상을 한 줄로 합칠 때 서로
|
|
7
|
+
* 다른 앵커 중 하나를 고를 근거도 없다.
|
|
8
|
+
*
|
|
9
|
+
* 줄 끝 `- §N` 은 방향이 반대다. **이 문서의 어느 절에서 가리켰는지** 를 적는
|
|
10
|
+
* 역링크라서, 라벨 안 `§` 와 뜻이 겹치지 않는다.
|
|
11
|
+
*
|
|
12
|
+
* **소비자가 둘이다.** `bin/generate.ts` 가 파일에 쓰고, `checks/references.ts` 가 같은 함수를
|
|
13
|
+
* 불러 지금 내용과 비교한다. 검사기가 생성기를 부르는 것이 거꾸로 보이지만,
|
|
14
|
+
* _무엇이 옳은 내용인가_ 를 한곳에서만 정의하려면 이 방향이 맞다.
|
|
15
|
+
*/
|
|
16
|
+
import { basename, dirname, join, normalize } from "node:path";
|
|
17
|
+
import { wantsRefSection } from "../utils/scope.js";
|
|
18
|
+
/** 코드·데이터 대상인지. 나머지 (`.md` · 디렉터리) 는 문서 쪽으로 간다 */
|
|
19
|
+
const isCode = (path) => /\.(ts|tsx|json)$/.test(path);
|
|
20
|
+
/**
|
|
21
|
+
* 링크 대상의 리포 루트 기준 위치. 같은 파일 이름이 겹칠 때 라벨로 쓴다.
|
|
22
|
+
*
|
|
23
|
+
* 앞머리만 떼면 구분이 사라진다 - `client/README.md` 안에서 `../CLAUDE.md` 와
|
|
24
|
+
* `./CLAUDE.md` 는 서로 다른 파일인데 둘 다 `CLAUDE.md` 가 된다.
|
|
25
|
+
*/
|
|
26
|
+
const repoPath = (from, target) => normalize(join(dirname(from), target));
|
|
27
|
+
/**
|
|
28
|
+
* 표시 이름의 기본값.
|
|
29
|
+
*
|
|
30
|
+
* 디렉터리 대상은 끝 `/` 를 남긴다. 확장자가 없어서 떼면 파일인지 폴더인지 안 보인다.
|
|
31
|
+
*/
|
|
32
|
+
const shortName = (path) => path.endsWith("/") ? `${basename(path)}/` : basename(path) || path;
|
|
33
|
+
/**
|
|
34
|
+
* 본문 링크를 대상별로 묶는다.
|
|
35
|
+
*
|
|
36
|
+
* 꼬리 절 안의 링크는 넣지 않는다 - 생성 결과가 자기를 먹고 매 실행마다 자란다.
|
|
37
|
+
* 앵커 전용 링크 (`(#...)`) 도 대상이 없으므로 빠진다.
|
|
38
|
+
*
|
|
39
|
+
* 순서는 본문 첫 등장 순이다. 목록을 본문과 나란히 놓고 대조할 수 있다.
|
|
40
|
+
*/
|
|
41
|
+
const collect = (file) => {
|
|
42
|
+
const byPath = new Map();
|
|
43
|
+
const order = [];
|
|
44
|
+
for (const link of file.links) {
|
|
45
|
+
const path = link.target;
|
|
46
|
+
if (link.inTail || path === null)
|
|
47
|
+
continue;
|
|
48
|
+
let target = byPath.get(path);
|
|
49
|
+
if (target === undefined) {
|
|
50
|
+
target = { path, sections: [] };
|
|
51
|
+
byPath.set(path, target);
|
|
52
|
+
order.push(target);
|
|
53
|
+
}
|
|
54
|
+
// 번호 없는 헤딩 아래의 링크는 귀속 절이 없다. 그 경우 접미사를 통째로 생략한다
|
|
55
|
+
if (link.section !== null && !target.sections.includes(link.section)) {
|
|
56
|
+
target.sections.push(link.section);
|
|
57
|
+
}
|
|
58
|
+
}
|
|
59
|
+
return order;
|
|
60
|
+
};
|
|
61
|
+
/**
|
|
62
|
+
* 대상별 표시 이름.
|
|
63
|
+
*
|
|
64
|
+
* 기본은 파일 이름이고, 한 문서 안에서 같은 이름이 둘 이상 나오면 리포 안 위치를
|
|
65
|
+
* 알 만큼 앞을 붙인다 - `CLAUDE.md` 는 루트와 client 두 곳에 있다.
|
|
66
|
+
*/
|
|
67
|
+
const labels = (from, targets) => {
|
|
68
|
+
const seen = new Map();
|
|
69
|
+
for (const t of targets) {
|
|
70
|
+
const name = shortName(t.path);
|
|
71
|
+
seen.set(name, (seen.get(name) ?? 0) + 1);
|
|
72
|
+
}
|
|
73
|
+
const out = new Map();
|
|
74
|
+
for (const t of targets) {
|
|
75
|
+
const name = shortName(t.path);
|
|
76
|
+
out.set(t.path, (seen.get(name) ?? 0) > 1 ? repoPath(from, t.path) : name);
|
|
77
|
+
}
|
|
78
|
+
return out;
|
|
79
|
+
};
|
|
80
|
+
/** 항목 한 줄 */
|
|
81
|
+
const line = (target, label) => {
|
|
82
|
+
const sections = target.sections.map((s) => `§${s}`).join(", ");
|
|
83
|
+
return `- [\`${label}\`](${target.path})${sections === "" ? "" : ` - ${sections}`}`;
|
|
84
|
+
};
|
|
85
|
+
/**
|
|
86
|
+
* 참조 절 본문. `## 참조` 헤딩과 다음 절 사이에 놓일 모양 그대로.
|
|
87
|
+
*
|
|
88
|
+
* 앞뒤 빈 줄을 포함한다 - 헤딩 줄은 색인 범위 밖이므로 생성기가 건드리지 않는다.
|
|
89
|
+
* 수집된 대상이 없으면 빈 배열이다.
|
|
90
|
+
*/
|
|
91
|
+
export const referenceBlock = (file, config) => {
|
|
92
|
+
if (!wantsRefSection(file, config))
|
|
93
|
+
return [];
|
|
94
|
+
const targets = collect(file);
|
|
95
|
+
if (targets.length === 0)
|
|
96
|
+
return [];
|
|
97
|
+
const label = labels(file.path, targets);
|
|
98
|
+
const render = (list) => list.map((t) => line(t, label.get(t.path) ?? t.path));
|
|
99
|
+
const docs = targets.filter((t) => !isCode(t.path));
|
|
100
|
+
const code = targets.filter((t) => isCode(t.path));
|
|
101
|
+
const out = [""];
|
|
102
|
+
// 비는 갈래는 제목도 내지 않는다. 빈 제목만 남으면 아직 안 채운 것처럼 읽힌다
|
|
103
|
+
if (docs.length > 0)
|
|
104
|
+
out.push("### 문서", "", ...render(docs), "");
|
|
105
|
+
if (code.length > 0)
|
|
106
|
+
out.push("### 코드·데이터", "", ...render(code), "");
|
|
107
|
+
return out;
|
|
108
|
+
};
|
|
109
|
+
/**
|
|
110
|
+
* 참조 절을 새로 넣은 줄 목록.
|
|
111
|
+
*
|
|
112
|
+
* 꼬리 절 순서가 참조 → 미확정 사항 → 변경 이력 이므로 (`docs/system/rules.md`
|
|
113
|
+
* 규칙 8) 뒤 두 개 중 먼저 오는 것 앞에 놓는다. 꼬리 절이 하나도 없으면 파일 끝에
|
|
114
|
+
* 붙이고, 이때만 앞에 빈 줄을 하나 둔다 - 다른 자리는 앞 절이 이미 빈 줄로 끝난다.
|
|
115
|
+
*/
|
|
116
|
+
const insert = (file, lines, block) => {
|
|
117
|
+
const nextTail = file.headings.find((h) => h.level === 2 && h.tail);
|
|
118
|
+
if (nextTail !== undefined) {
|
|
119
|
+
const at = nextTail.line - 1;
|
|
120
|
+
return [...lines.slice(0, at), "## 참조", ...block, ...lines.slice(at)];
|
|
121
|
+
}
|
|
122
|
+
// 파일 끝 빈 줄은 버린다. 블록이 빈 줄로 끝나므로 줄바꿈은 그쪽이 갖는다
|
|
123
|
+
let end = lines.length;
|
|
124
|
+
while (end > 0 && lines[end - 1].trim() === "")
|
|
125
|
+
end--;
|
|
126
|
+
return [...lines.slice(0, end), "", "## 참조", ...block];
|
|
127
|
+
};
|
|
128
|
+
/**
|
|
129
|
+
* 참조 절을 채우거나 새로 넣은 문서 줄 목록. 바꿀 것이 없으면 null.
|
|
130
|
+
*/
|
|
131
|
+
export const applyReferences = (file, lines, index) => {
|
|
132
|
+
const block = referenceBlock(file, index.config);
|
|
133
|
+
// 본문 링크가 없으면 참조 절을 둘 이유가 없다
|
|
134
|
+
if (block.length === 0)
|
|
135
|
+
return null;
|
|
136
|
+
if (file.refSection === null)
|
|
137
|
+
return insert(file, lines, block);
|
|
138
|
+
const { start, end } = file.refSection;
|
|
139
|
+
const current = lines.slice(start - 1, end);
|
|
140
|
+
// 이미 맞으면 건드리지 않는다. 생성기를 두 번 돌려도 결과가 같아야 한다
|
|
141
|
+
if (current.join("\n") === block.join("\n"))
|
|
142
|
+
return null;
|
|
143
|
+
return [...lines.slice(0, start - 1), ...block, ...lines.slice(end)];
|
|
144
|
+
};
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
import type { DocIndex, IndexedFile } from '../types.ts';
|
|
2
|
+
/** 관리 문서인지. 표는 그 한 파일에만 붙는다 */
|
|
3
|
+
export declare const isPendingDoc: (file: IndexedFile, index: DocIndex) => boolean;
|
|
4
|
+
/** 표 한 행이 되는 항목 하나 */
|
|
5
|
+
export interface SummaryRow {
|
|
6
|
+
slug: string;
|
|
7
|
+
title: string;
|
|
8
|
+
anchor: string;
|
|
9
|
+
/** 해결 예정 라벨. 정하지 않았으면 null */
|
|
10
|
+
timepoint: string | null;
|
|
11
|
+
/** 마커가 걸린 곳 수 */
|
|
12
|
+
sites: number;
|
|
13
|
+
}
|
|
14
|
+
/** 표 블록. 절 헤딩과 첫 항목 사이에 놓일 모양 그대로 (앞뒤 빈 줄 포함) */
|
|
15
|
+
export declare const summaryTable: (list: SummaryRow[]) => string[];
|
|
16
|
+
/** 절마다 기대되는 표 블록. 항목이 있는 절만 나온다 */
|
|
17
|
+
export declare const summaryBlocks: (lines: string[], index: DocIndex) => {
|
|
18
|
+
blockStart: number;
|
|
19
|
+
blockEnd: number;
|
|
20
|
+
block: string[];
|
|
21
|
+
}[];
|
|
22
|
+
/**
|
|
23
|
+
* 요약 표를 채운 줄 목록. 바꿀 것이 없으면 null.
|
|
24
|
+
*
|
|
25
|
+
* 절이 여럿이라 **아래 절부터** 갈아끼운다. 위를 먼저 고치면 아래 절의 줄 번호가 밀린다.
|
|
26
|
+
*/
|
|
27
|
+
export declare const applySummary: (file: IndexedFile, lines: string[], index: DocIndex) => string[] | null;
|
|
@@ -0,0 +1,125 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 관리 문서 절 머리 요약 표 생성 - 항목 헤딩을 모아 절 첫머리를 채운다.
|
|
3
|
+
*
|
|
4
|
+
* 항목이 100 개를 넘으면 문서를 위에서 아래로 읽어 파악하는 것이 불가능하다. 그런데
|
|
5
|
+
* 목차 블록은 헤딩 문자열만 담을 수 있어서 (`gen/toc.ts`) 제목을 두 번 읽게 만드는 것
|
|
6
|
+
* 말고는 하는 일이 없다. 표는 열을 갖는다 - 처리 시점이 빈 항목과 어디에도 안 걸린
|
|
7
|
+
* 항목이 훑는 것만으로 드러난다.
|
|
8
|
+
*
|
|
9
|
+
* 셋 다 손으로 셀 수 없는 값이라 표가 정본을 갖지 않는다. `걸린 곳` 은 리포 전체의
|
|
10
|
+
* 마커를 세야 나오고, 나머지 둘은 항목 본문이 갖는다.
|
|
11
|
+
*
|
|
12
|
+
* **소비자가 둘이다.** `bin/generate.ts` 가 파일에 쓰고, `checks/pending.ts` 가 같은
|
|
13
|
+
* 함수를 불러 지금 내용과 비교한다.
|
|
14
|
+
*/
|
|
15
|
+
import { TIMEPOINT } from '../constants/patterns.js';
|
|
16
|
+
import { slugify } from '../utils/anchor.js';
|
|
17
|
+
/** 관리 문서인지. 표는 그 한 파일에만 붙는다 */
|
|
18
|
+
export const isPendingDoc = (file, index) => file.path === index.config.pending;
|
|
19
|
+
/** 항목 헤딩. id 와 제목을 함께 캡처한다 */
|
|
20
|
+
const ITEM_HEADING = /^###\s+`\[([a-z]+::[a-z0-9][a-z0-9-]*)\]`\s*(.*)$/;
|
|
21
|
+
/** 항목 첫 본문 줄의 시점 표기 */
|
|
22
|
+
const TIMEPOINT_LINE = new RegExp(`^${TIMEPOINT.source}$`);
|
|
23
|
+
const sections = (lines) => {
|
|
24
|
+
const out = [];
|
|
25
|
+
let cur = null;
|
|
26
|
+
lines.forEach((line, i) => {
|
|
27
|
+
if (/^##\s+\d/.test(line)) {
|
|
28
|
+
cur = { heading: i + 1, blockStart: i + 2, blockEnd: i + 1, items: [] };
|
|
29
|
+
out.push(cur);
|
|
30
|
+
return;
|
|
31
|
+
}
|
|
32
|
+
if (/^##\s/.test(line)) {
|
|
33
|
+
cur = null;
|
|
34
|
+
return;
|
|
35
|
+
}
|
|
36
|
+
if (cur === null)
|
|
37
|
+
return;
|
|
38
|
+
if (ITEM_HEADING.test(line)) {
|
|
39
|
+
cur.items.push(i + 1);
|
|
40
|
+
return;
|
|
41
|
+
}
|
|
42
|
+
// 첫 항목 앞까지만 표 자리다. 항목이 나온 뒤의 줄은 본문이다
|
|
43
|
+
if (cur.items.length === 0)
|
|
44
|
+
cur.blockEnd = i + 1;
|
|
45
|
+
});
|
|
46
|
+
return out.filter((s) => s.items.length > 0);
|
|
47
|
+
};
|
|
48
|
+
/** slug 별 마커 위치 수. 초안 문서는 세지 않는다 - 흡수되면 사라진다 */
|
|
49
|
+
const markerSites = (index) => {
|
|
50
|
+
const out = new Map();
|
|
51
|
+
for (const file of index.files.values()) {
|
|
52
|
+
if (file.path.startsWith(index.config.work))
|
|
53
|
+
continue;
|
|
54
|
+
for (const marker of file.markers) {
|
|
55
|
+
if (marker.legacy || marker.slug === '')
|
|
56
|
+
continue;
|
|
57
|
+
const id = `${marker.kind}::${marker.slug}`;
|
|
58
|
+
out.set(id, (out.get(id) ?? 0) + 1);
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
return out;
|
|
62
|
+
};
|
|
63
|
+
/** 절 안 항목을 표 행으로. 시점은 항목 첫 본문 줄에서 읽는다 */
|
|
64
|
+
const rows = (lines, itemLines, sites) => itemLines.map((at) => {
|
|
65
|
+
const m = ITEM_HEADING.exec(lines[at - 1]);
|
|
66
|
+
if (m === null)
|
|
67
|
+
throw new Error(`항목 헤딩이 아니다 - ${at}`);
|
|
68
|
+
// 헤딩 다음 첫 내용 줄이 시점이다. 없으면 검사기가 따로 지적한다
|
|
69
|
+
let timepoint = null;
|
|
70
|
+
for (let i = at; i < lines.length; i++) {
|
|
71
|
+
const line = lines[i].trim();
|
|
72
|
+
if (line === '')
|
|
73
|
+
continue;
|
|
74
|
+
const stamp = TIMEPOINT_LINE.exec(line);
|
|
75
|
+
timepoint = stamp?.[2]?.trim() ?? null;
|
|
76
|
+
break;
|
|
77
|
+
}
|
|
78
|
+
const slug = m[1];
|
|
79
|
+
return {
|
|
80
|
+
slug,
|
|
81
|
+
title: m[2].trim(),
|
|
82
|
+
anchor: slugify(lines[at - 1].replace(/^###\s+/, '')),
|
|
83
|
+
timepoint,
|
|
84
|
+
sites: sites.get(slug) ?? 0,
|
|
85
|
+
};
|
|
86
|
+
});
|
|
87
|
+
/** 표 블록. 절 헤딩과 첫 항목 사이에 놓일 모양 그대로 (앞뒤 빈 줄 포함) */
|
|
88
|
+
export const summaryTable = (list) => [
|
|
89
|
+
'',
|
|
90
|
+
'| id | 항목 | 해결 예정 | 걸린 곳 |',
|
|
91
|
+
'|----|-----|--------|-------|',
|
|
92
|
+
...list.map((r) => `| [\`${r.slug}\`](#${r.anchor}) | ${r.title} | ${r.timepoint ?? ''} | ${r.sites === 0 ? '' : r.sites} |`),
|
|
93
|
+
'',
|
|
94
|
+
];
|
|
95
|
+
/** 절마다 기대되는 표 블록. 항목이 있는 절만 나온다 */
|
|
96
|
+
export const summaryBlocks = (lines, index) => {
|
|
97
|
+
const sites = markerSites(index);
|
|
98
|
+
return sections(lines).map((s) => ({
|
|
99
|
+
blockStart: s.blockStart,
|
|
100
|
+
blockEnd: s.blockEnd,
|
|
101
|
+
block: summaryTable(rows(lines, s.items, sites)),
|
|
102
|
+
}));
|
|
103
|
+
};
|
|
104
|
+
/**
|
|
105
|
+
* 요약 표를 채운 줄 목록. 바꿀 것이 없으면 null.
|
|
106
|
+
*
|
|
107
|
+
* 절이 여럿이라 **아래 절부터** 갈아끼운다. 위를 먼저 고치면 아래 절의 줄 번호가 밀린다.
|
|
108
|
+
*/
|
|
109
|
+
export const applySummary = (file, lines, index) => {
|
|
110
|
+
if (!isPendingDoc(file, index))
|
|
111
|
+
return null;
|
|
112
|
+
const blocks = summaryBlocks(lines, index);
|
|
113
|
+
if (blocks.length === 0)
|
|
114
|
+
return null;
|
|
115
|
+
let next = lines;
|
|
116
|
+
let changed = false;
|
|
117
|
+
for (const { blockStart, blockEnd, block } of [...blocks].reverse()) {
|
|
118
|
+
const current = next.slice(blockStart - 1, blockEnd);
|
|
119
|
+
if (current.join('\n') === block.join('\n'))
|
|
120
|
+
continue;
|
|
121
|
+
next = [...next.slice(0, blockStart - 1), ...block, ...next.slice(blockEnd)];
|
|
122
|
+
changed = true;
|
|
123
|
+
}
|
|
124
|
+
return changed ? next : null;
|
|
125
|
+
};
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
import type { Heading, IndexedFile } from "../types.ts";
|
|
2
|
+
/**
|
|
3
|
+
* 목차 줄 목록. 목차를 둘 이유가 없으면 빈 배열.
|
|
4
|
+
*
|
|
5
|
+
* `##` 만 넣는다. `###` 까지 넣으면 목차가 본문보다 긴 문서가 나온다.
|
|
6
|
+
* 꼬리 절도 넣는다 - 참조·미확정 사항·변경 이력이 어디 있는지 알아야 한다.
|
|
7
|
+
*/
|
|
8
|
+
export declare const tocLines: (headings: Heading[]) => string[];
|
|
9
|
+
/** 목차 블록 전체. 제목 다음에 놓일 모양 그대로 */
|
|
10
|
+
export declare const tocBlock: (headings: Heading[]) => string[];
|
|
11
|
+
/**
|
|
12
|
+
* 목차를 넣거나 갈아끼운 문서 줄 목록. 바꿀 것이 없으면 null.
|
|
13
|
+
*
|
|
14
|
+
* 이미 있으면 그 블록만 갈아끼우고, 없으면 제목 다음 빈 줄 뒤에 넣는다.
|
|
15
|
+
* 제목이 없거나 둘 이상인 문서는 건드리지 않는다 - 어디에 넣을지 정할 근거가 없다.
|
|
16
|
+
* 검사기가 `heading/multiple-title` 로 따로 지적한다.
|
|
17
|
+
*
|
|
18
|
+
* 고칠 줄 목록을 따로 받는다. 한 파일에 생성기를 둘 이상 걸 때 앞 생성기의 결과
|
|
19
|
+
* 위에 이어 쓰기 위함이다. 색인의 줄 번호가 그대로 유효하려면 **문서 아래쪽을
|
|
20
|
+
* 고치는 생성기부터** 돌려야 한다.
|
|
21
|
+
*
|
|
22
|
+
* 헤딩은 색인이 아니라 넘겨받은 줄에서 다시 읽는다. 앞 생성기가 절을 새로 끼워
|
|
23
|
+
* 넣었으면 그 절이 목차에 실려야 한다.
|
|
24
|
+
*/
|
|
25
|
+
export declare const applyToc: (file: IndexedFile, lines: string[]) => string[] | null;
|
package/dist/gen/toc.js
ADDED
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 목차 생성 - `##` 헤딩을 모아 제목 아래 블록을 채운다.
|
|
3
|
+
*
|
|
4
|
+
* 목차는 같은 정보가 두 곳에 생기는 대표 사례라 손으로 관리하면 반드시 어긋난다
|
|
5
|
+
* (`docs/system/rules.md` §2-2). 여기서 만드는 문자열이 검사기의 기대값도 된다.
|
|
6
|
+
*
|
|
7
|
+
* **소비자가 둘이다.** `bin/generate.ts` 가 파일에 쓰고, `checks/toc.ts` 가 같은 함수를
|
|
8
|
+
* 불러 지금 내용과 비교한다. 검사기가 생성기를 부르는 것이 거꾸로 보이지만,
|
|
9
|
+
* _무엇이 옳은 내용인가_ 를 한곳에서만 정의하려면 이 방향이 맞다.
|
|
10
|
+
*/
|
|
11
|
+
import { slugify } from "../utils/anchor.js";
|
|
12
|
+
import { parseHeadings } from "../utils/parse.js";
|
|
13
|
+
import { singleTitle } from "../utils/scope.js";
|
|
14
|
+
/**
|
|
15
|
+
* 목차 줄 목록. 목차를 둘 이유가 없으면 빈 배열.
|
|
16
|
+
*
|
|
17
|
+
* `##` 만 넣는다. `###` 까지 넣으면 목차가 본문보다 긴 문서가 나온다.
|
|
18
|
+
* 꼬리 절도 넣는다 - 참조·미확정 사항·변경 이력이 어디 있는지 알아야 한다.
|
|
19
|
+
*/
|
|
20
|
+
export const tocLines = (headings) => headings
|
|
21
|
+
.filter((h) => h.level === 2)
|
|
22
|
+
.map((h) => `- [${h.raw}](#${slugify(h.raw)})`);
|
|
23
|
+
/** 목차 블록 전체. 제목 다음에 놓일 모양 그대로 */
|
|
24
|
+
export const tocBlock = (headings) => {
|
|
25
|
+
const lines = tocLines(headings);
|
|
26
|
+
return lines.length === 0 ? [] : ["**목차**", "", ...lines];
|
|
27
|
+
};
|
|
28
|
+
/**
|
|
29
|
+
* 목차를 넣거나 갈아끼운 문서 줄 목록. 바꿀 것이 없으면 null.
|
|
30
|
+
*
|
|
31
|
+
* 이미 있으면 그 블록만 갈아끼우고, 없으면 제목 다음 빈 줄 뒤에 넣는다.
|
|
32
|
+
* 제목이 없거나 둘 이상인 문서는 건드리지 않는다 - 어디에 넣을지 정할 근거가 없다.
|
|
33
|
+
* 검사기가 `heading/multiple-title` 로 따로 지적한다.
|
|
34
|
+
*
|
|
35
|
+
* 고칠 줄 목록을 따로 받는다. 한 파일에 생성기를 둘 이상 걸 때 앞 생성기의 결과
|
|
36
|
+
* 위에 이어 쓰기 위함이다. 색인의 줄 번호가 그대로 유효하려면 **문서 아래쪽을
|
|
37
|
+
* 고치는 생성기부터** 돌려야 한다.
|
|
38
|
+
*
|
|
39
|
+
* 헤딩은 색인이 아니라 넘겨받은 줄에서 다시 읽는다. 앞 생성기가 절을 새로 끼워
|
|
40
|
+
* 넣었으면 그 절이 목차에 실려야 한다.
|
|
41
|
+
*/
|
|
42
|
+
export const applyToc = (file, lines) => {
|
|
43
|
+
const block = tocBlock(parseHeadings(lines));
|
|
44
|
+
// `##` 절이 없으면 목차를 둘 이유가 없다
|
|
45
|
+
if (block.length === 0)
|
|
46
|
+
return null;
|
|
47
|
+
const title = singleTitle(file);
|
|
48
|
+
if (title === null)
|
|
49
|
+
return null;
|
|
50
|
+
if (file.tocBlock !== null) {
|
|
51
|
+
const { start, end } = file.tocBlock;
|
|
52
|
+
const current = lines.slice(start - 1, end);
|
|
53
|
+
// 이미 맞으면 건드리지 않는다. 생성기를 두 번 돌려도 결과가 같아야 한다
|
|
54
|
+
if (current.join("\n") === block.join("\n")) {
|
|
55
|
+
return null;
|
|
56
|
+
}
|
|
57
|
+
return [...lines.slice(0, start - 1), ...block, ...lines.slice(end)];
|
|
58
|
+
}
|
|
59
|
+
// 제목 줄은 색인에서 꺼낸다. 본문을 다시 훑으면 펜스 안 `# ` 를 제목으로 볼 수 있다
|
|
60
|
+
return [
|
|
61
|
+
...lines.slice(0, title.line),
|
|
62
|
+
"",
|
|
63
|
+
...block,
|
|
64
|
+
...lines.slice(title.line),
|
|
65
|
+
];
|
|
66
|
+
};
|
package/dist/types.d.ts
ADDED
|
@@ -0,0 +1,125 @@
|
|
|
1
|
+
import type { RuleId } from './constants/rules.ts';
|
|
2
|
+
import type { SpecthreadConfig } from './config.schema.ts';
|
|
3
|
+
/** 색인 자료 구조. 검사기와 생성기가 공유한다. */
|
|
4
|
+
/**
|
|
5
|
+
* 앵커가 붙은 링크의 라벨 구간과 그 링크 대상.
|
|
6
|
+
*
|
|
7
|
+
* 라벨 안에 놓인 `§N` 은 라벨 글자가 아니라 **링크 대상 경로** 로 풀어야 한다.
|
|
8
|
+
* `` [`CLAUDE.md` §1](../../CLAUDE.md#1-절대-원칙) `` 에서 라벨만 보면 루트와 client
|
|
9
|
+
* 중 어느 `CLAUDE.md` 인지 알 수 없지만 대상 경로는 알려준다.
|
|
10
|
+
*/
|
|
11
|
+
export interface AnchorLabelSpan {
|
|
12
|
+
start: number;
|
|
13
|
+
end: number;
|
|
14
|
+
target: string;
|
|
15
|
+
}
|
|
16
|
+
/** 1-indexed, 양끝 포함 */
|
|
17
|
+
export interface Range {
|
|
18
|
+
start: number;
|
|
19
|
+
end: number;
|
|
20
|
+
}
|
|
21
|
+
/** 절 하나. 번호가 있는 것만 `§` 로 가리킬 수 있다 */
|
|
22
|
+
export interface Heading {
|
|
23
|
+
level: number;
|
|
24
|
+
/** 앞머리 번호. `6` / `6-1`. 번호 없는 헤딩은 null */
|
|
25
|
+
num: string | null;
|
|
26
|
+
/** 번호를 뗀 제목 */
|
|
27
|
+
title: string;
|
|
28
|
+
/** 번호를 포함한 원문 */
|
|
29
|
+
raw: string;
|
|
30
|
+
anchor: string;
|
|
31
|
+
line: number;
|
|
32
|
+
/** 꼬리 절 (참조 / 미확정 사항 / 변경 이력) 인지 */
|
|
33
|
+
tail: boolean;
|
|
34
|
+
}
|
|
35
|
+
/** 마크다운 링크 하나. 절 귀속 정보가 있어야 참조 절을 생성할 수 있다 */
|
|
36
|
+
export interface Link {
|
|
37
|
+
label: string;
|
|
38
|
+
/** 링크 대상 경로. 앵커 전용 링크는 null */
|
|
39
|
+
target: string | null;
|
|
40
|
+
anchor: string | null;
|
|
41
|
+
line: number;
|
|
42
|
+
/** 이 링크가 놓인 절의 번호. 참조 절 생성에 쓴다 */
|
|
43
|
+
section: string | null;
|
|
44
|
+
/** 꼬리 절 안의 링크인지. 참조 절 생성에서 제외한다 */
|
|
45
|
+
inTail: boolean;
|
|
46
|
+
}
|
|
47
|
+
/** `§N` 참조 하나. 해소 결과와 사유를 함께 담아 지적 메시지를 만든다 */
|
|
48
|
+
export interface SectionRef {
|
|
49
|
+
/** 가리키는 절 번호 */
|
|
50
|
+
num: string;
|
|
51
|
+
/** 해소된 대상 문서의 리포 상대 경로. 미해소는 null */
|
|
52
|
+
targetFile: string | null;
|
|
53
|
+
/** 원문에 적힌 문서명. 자기 참조는 null */
|
|
54
|
+
rawTarget: string | null;
|
|
55
|
+
/** 미해소 사유 */
|
|
56
|
+
reason: "resolved" | "no-doc-name" | "unknown-doc" | "ambiguous-doc";
|
|
57
|
+
/**
|
|
58
|
+
* 앵커 링크 안에 놓인 참조인지.
|
|
59
|
+
*
|
|
60
|
+
* 다른 문서의 절은 앵커 링크로 가리켜야 한다 (`docs/system/rules.md` §3-5).
|
|
61
|
+
* 링크 없이 `§N` 만 적은 것을 가려내는 데 쓴다.
|
|
62
|
+
*/
|
|
63
|
+
linked: boolean;
|
|
64
|
+
line: number;
|
|
65
|
+
}
|
|
66
|
+
/** 미결 마커 하나. 새 형식과 구 형식을 갈라 담아 재편 진척을 센다 */
|
|
67
|
+
export interface Marker {
|
|
68
|
+
kind: string;
|
|
69
|
+
slug: string;
|
|
70
|
+
line: number;
|
|
71
|
+
/** 구 `TEMP_*` 형식인지. 재편에서 치환 대상 */
|
|
72
|
+
legacy: boolean;
|
|
73
|
+
}
|
|
74
|
+
/** 큐 항목 또는 문서 미확정 사항 절 항목 */
|
|
75
|
+
export interface PendingItem {
|
|
76
|
+
kind: string;
|
|
77
|
+
slug: string;
|
|
78
|
+
line: number;
|
|
79
|
+
}
|
|
80
|
+
/** 파일 종류. 뽑을 재료와 참조 해소 규칙이 달라진다 */
|
|
81
|
+
export type FileKind = "md" | "code" | "json";
|
|
82
|
+
/** 색인된 파일 하나. 검사기와 생성기가 이 모양만 보고 일한다 */
|
|
83
|
+
export interface IndexedFile {
|
|
84
|
+
/** 리포 루트 기준 상대 경로 */
|
|
85
|
+
path: string;
|
|
86
|
+
kind: FileKind;
|
|
87
|
+
/**
|
|
88
|
+
* 파일 전문. 검사기와 생성기가 다시 읽지 않게 색인이 들고 있는다.
|
|
89
|
+
*
|
|
90
|
+
* 각자 읽으면 같은 파일을 세 번 읽고, 서로 다른 내용을 볼 여지가 남는다.
|
|
91
|
+
*/
|
|
92
|
+
lines: string[];
|
|
93
|
+
headings: Heading[];
|
|
94
|
+
links: Link[];
|
|
95
|
+
sectionRefs: SectionRef[];
|
|
96
|
+
markers: Marker[];
|
|
97
|
+
pendingItems: PendingItem[];
|
|
98
|
+
/** 목차 블록 위치. 생성기가 덮어쓴다 */
|
|
99
|
+
tocBlock: Range | null;
|
|
100
|
+
/** 하단 참조 절 본문 범위. 헤딩 줄은 뺀다 - 생성기가 절 제목을 지우면 안 된다 */
|
|
101
|
+
refSection: Range | null;
|
|
102
|
+
/** 미확정 사항 절 본문 범위. 헤딩 줄은 뺀다. 없는 문서도 많다 - 그 절 자체가 선택이다 */
|
|
103
|
+
pendingSection: Range | null;
|
|
104
|
+
/** 변경 이력 절 본문 범위. 이 안의 참조는 과거 상태를 적은 것이라 검사에서 뺀다 */
|
|
105
|
+
changeLogRange: Range | null;
|
|
106
|
+
/** 변경 이력 절의 날짜. 정렬 검사에 쓴다 */
|
|
107
|
+
changeLogDates: string[];
|
|
108
|
+
/** `@specthread-ignore` 로 억제된 줄 번호 (1-indexed) */
|
|
109
|
+
ignored: Set<number>;
|
|
110
|
+
}
|
|
111
|
+
/** 색인 전체 */
|
|
112
|
+
export interface DocIndex {
|
|
113
|
+
files: Map<string, IndexedFile>;
|
|
114
|
+
/** 문서 basename·stem → 경로 목록. § 참조 해소에 쓴다 */
|
|
115
|
+
docsByName: Map<string, string[]>;
|
|
116
|
+
/** 로드된 설정. 검사기·생성기가 규약 경로 등에 접근할 때 쓴다 */
|
|
117
|
+
config: SpecthreadConfig;
|
|
118
|
+
}
|
|
119
|
+
/** 지적 하나. `rule` 로 집계하고 `file`·`line` 으로 자리를 가리킨다 */
|
|
120
|
+
export interface Finding {
|
|
121
|
+
file: string;
|
|
122
|
+
line: number;
|
|
123
|
+
rule: RuleId;
|
|
124
|
+
message: string;
|
|
125
|
+
}
|
package/dist/types.js
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export {};
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 헤딩 텍스트 → GitHub 앵커 변환.
|
|
3
|
+
*
|
|
4
|
+
* 목차 생성기와 링크 검사가 같은 규칙을 써야 하므로 한 곳에 둔다.
|
|
5
|
+
* 규칙: 소문자화 → 영숫자·하이픈·밑줄·공백·CJK 외 제거 → 공백을 하이픈으로.
|
|
6
|
+
*
|
|
7
|
+
* **공백은 하나씩 바꾼다.** 여러 개를 하나로 합치지 않는다. `항목 · 형식` 처럼
|
|
8
|
+
* 지워지는 구두점 양옆에 공백이 있으면 그 자리에 공백 둘이 남아 하이픈 둘이 된다.
|
|
9
|
+
* 하이픈 자신은 허용 문자라 지워지지 않는다 - `항목 - 형식` 은 하이픈 셋이 된다.
|
|
10
|
+
*/
|
|
11
|
+
export declare const slugify: (text: string) => string;
|
|
12
|
+
/**
|
|
13
|
+
* 헤딩 원문에서 앞머리 번호를 떼어낸다. `6-1. 기본 데미지` → `6-1` + `기본 데미지`
|
|
14
|
+
*
|
|
15
|
+
* 중간 자리에 문자가 오는 `1-B-1` 도 받는다 - `CLAUDE.md` §7 이 정한 형태다.
|
|
16
|
+
*/
|
|
17
|
+
export declare const splitHeadingNum: (raw: string) => {
|
|
18
|
+
num: string | null;
|
|
19
|
+
title: string;
|
|
20
|
+
};
|