@cheongfish/bouncer 0.0.0-stage → 0.1.13

package/dist/guards.js

@@ -0,0 +1,82 @@
+'use strict';
+// 판별 helper 단일 정의. 이 모듈은 import가 없어야 한다 — cli 모듈이 로드될 때
+// symbol-index·intent-* 같은 무거운 모듈이 미리 올라오지 않는 lazy-load 경계를
+// 공용 helper가 깨뜨리면 안 된다.
+/**
+ * 값이 배열이 아닌 일반 객체(null 제외)인지 좁힌다.
+ *
+ * @param {unknown} value - 검사할 값
+ * @returns {boolean} 배열·null·원시값이면 false
+ */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * catch 변수에서 `message`를 읽는다.
+ * 예전 error.message 접근과 같다. extra null 가드를 두면 throw null이
+ * TypeError 대신 빈 메시지(또는 undefined)가 되어 종료 코드·unavailable reason
+ * 경로가 바뀌므로 의도적으로 가드를 두지 않는다.
+ *
+ * @param {unknown} error - catch로 잡은 값
+ * @returns {string} error.message. null/undefined면 TypeError가 난다
+ */
+function catchMessage(error) {
+    return error.message;
+}
+/**
+ * catch 변수에서 메시지를 읽고, 없으면 String(error)로 폴백한다.
+ * 예전 `e && e.message ? e.message : String(e)` 와 같다. extra null 가드를
+ * 넣으면 throw null이 TypeError 대신 'null' 문자열이 된다.
+ *
+ * @param {unknown} error - catch로 잡은 값
+ * @returns {string} 비어 있지 않은 message 문자열, 아니면 String(error)
+ */
+function catchMessageOrString(error) {
+    const message = error && error.message;
+    return message ? String(message) : String(error);
+}
+/**
+ * 오류가 지정한 fs `code`를 가졌는지 본다.
+ * catch 변수는 strict에서 unknown이라 code를 읽기 전에 객체인지 좁힌다.
+ * 그러지 않으면 권한 오류와 파일 부재를 같은 분기로 합치게 된다.
+ *
+ * @param {unknown} error - catch로 잡은 값
+ * @param {string} code - 비교할 errno 코드(예: 'ENOENT')
+ * @returns {boolean} code가 일치하면 true
+ */
+function isFsCode(error, code) {
+    return typeof error === 'object'
+        && error !== null
+        && 'code' in error
+        && error.code === code;
+}
+/**
+ * 파일 부재(ENOENT) 오류인지 본다.
+ *
+ * @param {unknown} error - catch로 잡은 값
+ * @returns {boolean} ENOENT면 true
+ */
+function isEnoentError(error) {
+    return isFsCode(error, 'ENOENT');
+}
+/**
+ * 순회 중 건너뛰어도 안전한 fs 오류인지 본다(부재·권한·루프·비디렉터리).
+ *
+ * @param {unknown} error - catch로 잡은 값
+ * @returns {boolean} 건너뛸 수 있는 코드면 true
+ */
+function isSkippableFsError(error) {
+    return isFsCode(error, 'ENOENT')
+        || isFsCode(error, 'EACCES')
+        || isFsCode(error, 'EPERM')
+        || isFsCode(error, 'ELOOP')
+        || isFsCode(error, 'ENOTDIR');
+}
+module.exports = {
+    isRecord,
+    catchMessage,
+    catchMessageOrString,
+    isEnoentError,
+    isFsCode,
+    isSkippableFsError,
+};

package/dist/import-git.js

@@ -0,0 +1,78 @@
+'use strict';
+const contextIds = require("./context-ids");
+const { parseContextPath } = contextIds;
+const LOG_FORMAT = '%H%x1f%s%x1f%aI%x1f%an';
+/**
+ * epic 디렉터리 이름에서 번호 형식의 세 자리 id를 꺼낸다. slug 형식 이름과 해석 불가 이름은 번호가 없다.
+ * 세그먼트 해석은 context-ids 한 곳에 맡긴다.
+ *
+ * @param {string} dirName - `epics/` 바로 아래 디렉터리 이름
+ * @returns {string | null} 번호 형식이면 세 자리 id, 아니면 null
+ */
+function numericEpicIdOf(dirName) {
+    const ids = parseContextPath(`epics/${dirName}`);
+    return ids !== null && ids.format === 'numeric' ? ids.epicKey : null;
+}
+/** 제목에서 ASCII 슬러그를 뽑고, 한글·기호만 남으면 축약 sha로 떨어뜨린다. */
+function slugFromSubject(subject, sha) {
+    const slug = String(subject || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return slug || sha.slice(0, 7);
+}
+function parseLogOutput(text) {
+    const out = [];
+    for (const line of String(text || '').split('\n')) {
+        if (!line.trim())
+            continue;
+        const parts = line.split('\x1f');
+        if (parts.length < 4)
+            continue;
+        const [sha, subject, date, author] = parts;
+        if (!sha)
+            continue;
+        out.push({
+            sha,
+            subject: subject || '',
+            date: date || '',
+            author: author || '',
+        });
+    }
+    return out;
+}
+function gitLogArgs(kind, since) {
+    const args = kind === 'merges'
+        ? ['log', '--merges', '--reverse', `--format=${LOG_FORMAT}`]
+        : ['log', '--reverse', `--format=${LOG_FORMAT}`];
+    // --since <ref> 는 날짜 해석이 아니라 <ref>..HEAD 범위다.
+    if (typeof since === 'string' && since)
+        args.push(`${since}..HEAD`);
+    return args;
+}
+function listChangedFiles(execFileSync, repoRoot, source, sha) {
+    // merge 커밋은 부모가 둘이라 `git show --name-only <sha>`가 결합 diff를
+    // 내지 않고 파일 목록이 비어 버린다. 첫 부모(^1, 병합 대상 브랜치)와의
+    // diff 로만 이번 머지가 가져온 경로가 보인다. 일반 커밋은 부모가 하나라
+    // show 한 번으로 그 커밋이 건드린 파일을 얻는다.
+    const args = source === 'merges'
+        ? ['diff', '--name-only', `${sha}^1`, sha]
+        : ['show', '--name-only', '--format=', sha];
+    const out = execFileSync('git', args, {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return String(out || '')
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean);
+}
+module.exports = {
+    LOG_FORMAT,
+    numericEpicIdOf,
+    slugFromSubject,
+    parseLogOutput,
+    gitLogArgs,
+    listChangedFiles,
+};

package/dist/import-history.js

@@ -0,0 +1,392 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync: realExecFileSync } = require('node:child_process');
+const layout = require("./layout");
+const { CONTEXT_ROOT } = layout;
+const paths = require("./paths");
+const { isNumericContextId } = paths;
+const epicIndex = require("./epic-index");
+const { listEpicDirNames, ensureEpicIndexEntry } = epicIndex;
+const contextIds = require("./context-ids");
+const { parseContextPath, validateSlug, SLUG_MAX } = contextIds;
+const epicRegistry = require("./epic-registry");
+const { readEpicRegistry } = epicRegistry;
+const runtimeState = require("./runtime-state");
+const { readRuntimeCurrent, isWorktreeDirty } = runtimeState;
+const time = require("./time");
+const { nowIsoKst } = time;
+const importGit = require("./import-git");
+const { numericEpicIdOf, slugFromSubject, parseLogOutput, gitLogArgs, listChangedFiles, } = importGit;
+const importRender = require("./import-render");
+const { renderEpicBody, renderBlueprintBody, writeImportDoc, } = importRender;
+const preCommitHook = require("./pre-commit-hook");
+const { internalCommitEnv } = preCommitHook;
+// 계획·거절·적용 + 공개 배럴. git 파싱과 문서 렌더는 형제가 담당한다.
+// CLI 는 이 파일의 planImport / applyImport 만 본다.
+const DEFAULT_LIMIT = 200;
+const DEFAULT_EPIC_NAME = 'imported-history';
+function emptyPlan(partial) {
+    return {
+        ok: false,
+        fellBack: false,
+        total: 0,
+        entries: [],
+        refusals: [],
+        ...partial,
+    };
+}
+/**
+ * 사용 중인 epic 번호 중 가장 작은 빈 세 자리를 고른다.
+ * 연속이면 max+1, 구멍이 있으면 그 구멍 — "다음 빈"이 둘 다 커버된다.
+ */
+function nextEpicId(repoRoot) {
+    const used = new Set();
+    // slug 형식 epic은 번호가 없어 번호 공간을 쓰지 않는다.
+    for (const name of listEpicDirNames(repoRoot)) {
+        const id = numericEpicIdOf(name);
+        if (id !== null)
+            used.add(Number(id));
+    }
+    for (let n = 1; n <= 999; n += 1) {
+        if (!used.has(n))
+            return String(n).padStart(3, '0');
+    }
+    // 이론상만 도달 — 세 자리 공간이 가득 찬 상태.
+    throw new Error('no free epic id in 001..999');
+}
+/**
+ * 커밋 제목 slug 목록을 slug 형식 blueprint 디렉터리 이름으로 바꾼다. 번호 형식은 번호 접두가 이름을 구분했지만
+ * slug 형식은 이름 자체가 식별자라, 40자 제한·숫자만/숫자 접두 금지(번호 세그먼트와 구분 불가)를 맞추고
+ * 같은 이름이 겹치면 `-2`, `-3`을 붙여 유일하게 만든다. 입력 순서(오래된 커밋 먼저)를 유지한다.
+ *
+ * @param {string[]} slugs - slugFromSubject 결과(소문자 영숫자와 `-`)
+ * @returns {string[]} 입력과 같은 길이의 유효하고 서로 다른 slug
+ */
+function toBlueprintSlugs(slugs) {
+    const used = new Set();
+    const clip = (value, max) => value.slice(0, max).replace(/-+$/, '');
+    return slugs.map((raw) => {
+        let base = clip(raw, SLUG_MAX);
+        // 숫자만이거나 `ddd-`로 시작하면 번호 세그먼트와 구분되지 않는다. 접두 `bp-`로 피한다.
+        if (validateSlug(base) !== null)
+            base = clip(`bp-${base}`, SLUG_MAX);
+        if (validateSlug(base) !== null)
+            base = 'bp';
+        let candidate = base;
+        for (let n = 2; used.has(candidate); n += 1) {
+            const suffix = `-${n}`;
+            candidate = `${clip(base, SLUG_MAX - suffix.length)}${suffix}`;
+        }
+        used.add(candidate);
+        return candidate;
+    });
+}
+function collectRefusals({ repoRoot, epicDir, execFileSync, }) {
+    const refusals = [];
+    // 거절은 전부 첫 write 앞에 모은다. apply 중간에 멈추면 epic 디렉터리만
+    // 생기고 context/index.md 행이 없는 반쪽이 남고, 그 상태는 저장소 전체
+    // validate 를 S13 으로 깨뜨린다. 여기서 ok 를 뒤집지 않는 이유: 거절은
+    // apply 입구에서 refusals 배열로 처리하고, plan 자체는 후보 목록을 돌려준다.
+    if (isWorktreeDirty(repoRoot, execFileSync)) {
+        refusals.push({
+            code: 'IMPORT_WORKTREE_DIRTY',
+            message: 'worktree has uncommitted changes; commit or stash before apply',
+        });
+    }
+    const current = readRuntimeCurrent({
+        repoRoot,
+        deps: { execFileSync },
+    });
+    if (current) {
+        refusals.push({
+            code: 'IMPORT_POINTER_ACTIVE',
+            message: `active pointer exists at blueprint ${current.blueprint}`,
+        });
+    }
+    if (fs.existsSync(path.join(repoRoot, epicDir))) {
+        refusals.push({
+            code: 'IMPORT_EPIC_DIR_EXISTS',
+            message: `epic directory already exists: ${epicDir}`,
+        });
+    }
+    const indexRel = `${CONTEXT_ROOT}/index.md`;
+    if (!fs.existsSync(path.join(repoRoot, indexRel))) {
+        refusals.push({
+            code: 'IMPORT_CONTEXT_INDEX_MISSING',
+            message: `missing ${indexRel}; run bouncer init before import`,
+        });
+    }
+    return refusals;
+}
+function planImport({ repoRoot, source, since, limit, epicId, epicName, deps, }) {
+    const d = deps || {};
+    const execFileSync = d.execFileSync || realExecFileSync;
+    const resolvedLimit = typeof limit === 'number' && Number.isFinite(limit)
+        ? limit
+        : DEFAULT_LIMIT;
+    const resolvedName = typeof epicName === 'string' && epicName
+        ? epicName
+        : DEFAULT_EPIC_NAME;
+    // source 미지정 = 자동(머지 우선). 명시값만 merges|commits 화이트리스트.
+    const sourceSpecified = source !== undefined && source !== null && source !== '';
+    if (sourceSpecified && source !== 'merges' && source !== 'commits') {
+        const id = typeof epicId === 'string' && epicId ? epicId : '000';
+        return emptyPlan({
+            ok: false,
+            source: 'merges',
+            epicId: id,
+            epicName: resolvedName,
+            epicDir: `${CONTEXT_ROOT}/epics/${id}-${resolvedName}`,
+            limit: resolvedLimit,
+            error: {
+                code: 'IMPORT_SOURCE_INVALID',
+                message: `source must be merges or commits, got ${JSON.stringify(source)}`,
+            },
+        });
+    }
+    // 새 epic의 형식: 번호를 명시하면 번호 형식, 아니면 등록부 버전이 정한다(v2면 slug epic, 그 밖에는 기존
+    // 번호 배정). 경로가 아직 없는 새 epic에만 등록부 버전을 쓴다 — 이미 있는 epic의 형식은 경로가 정한다.
+    const explicitId = typeof epicId === 'string' && epicId !== '';
+    const registryRead = explicitId ? null : readEpicRegistry(repoRoot);
+    const slugEpic = registryRead !== null && registryRead.status === 'ok' && registryRead.registry.version === 2;
+    if (slugEpic) {
+        const violation = validateSlug(resolvedName);
+        if (violation !== null) {
+            return emptyPlan({
+                ok: false,
+                source: (sourceSpecified ? source : 'merges'),
+                epicId: resolvedName,
+                epicName: resolvedName,
+                epicDir: `${CONTEXT_ROOT}/epics/${resolvedName}`,
+                limit: resolvedLimit,
+                error: {
+                    code: 'IMPORT_EPIC_NAME_INVALID',
+                    message: `epicName must be a valid slug for a v2 registry: ${violation}`,
+                },
+            });
+        }
+    }
+    let resolvedEpicId;
+    if (slugEpic) {
+        resolvedEpicId = resolvedName;
+    }
+    else if (typeof epicId === 'string' && epicId) {
+        if (!isNumericContextId(epicId)) {
+            return emptyPlan({
+                ok: false,
+                source: (sourceSpecified ? source : 'merges'),
+                epicId,
+                epicName: resolvedName,
+                epicDir: `${CONTEXT_ROOT}/epics/${epicId}-${resolvedName}`,
+                limit: resolvedLimit,
+                error: {
+                    code: 'IMPORT_EPIC_ID_INVALID',
+                    message: `epicId must be a zero-padded three-digit id (\\d{3}), got ${JSON.stringify(epicId)}`,
+                },
+            });
+        }
+        resolvedEpicId = epicId;
+    }
+    else {
+        resolvedEpicId = nextEpicId(repoRoot);
+    }
+    const epicDir = slugEpic
+        ? `${CONTEXT_ROOT}/epics/${resolvedName}`
+        : `${CONTEXT_ROOT}/epics/${resolvedEpicId}-${resolvedName}`;
+    const baseFields = {
+        epicId: resolvedEpicId,
+        epicName: resolvedName,
+        epicDir,
+        limit: resolvedLimit,
+    };
+    let resolvedSource;
+    let fellBack = false;
+    let raw;
+    if (sourceSpecified && source === 'commits') {
+        resolvedSource = 'commits';
+        raw = parseLogOutput(execFileSync('git', gitLogArgs('commits', since), {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }));
+    }
+    else if (sourceSpecified && source === 'merges') {
+        // 명시 merges 는 0건이어도 일반 커밋으로 폴백하지 않는다.
+        resolvedSource = 'merges';
+        raw = parseLogOutput(execFileSync('git', gitLogArgs('merges', since), {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }));
+    }
+    else {
+        const merges = parseLogOutput(execFileSync('git', gitLogArgs('merges', since), {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }));
+        if (merges.length > 0) {
+            resolvedSource = 'merges';
+            raw = merges;
+        }
+        else {
+            resolvedSource = 'commits';
+            fellBack = true;
+            raw = parseLogOutput(execFileSync('git', gitLogArgs('commits', since), {
+                cwd: repoRoot,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            }));
+        }
+    }
+    const total = raw.length;
+    const refusals = collectRefusals({ repoRoot, epicDir, execFileSync });
+    // 상한 초과는 앞에서 잘라 일부만 돌리지 않는다 — 전체 개수와 상한을 보고 중단.
+    if (total > resolvedLimit) {
+        return {
+            ok: false,
+            source: resolvedSource,
+            fellBack,
+            ...baseFields,
+            total,
+            entries: [],
+            refusals,
+            error: {
+                code: 'IMPORT_LIMIT_EXCEEDED',
+                message: `import candidate count ${total} exceeds limit ${resolvedLimit}`,
+            },
+        };
+    }
+    const subjectSlugs = raw.map((c) => slugFromSubject(c.subject, c.sha));
+    // slug epic은 순서가 번호가 아니라 apply가 쓰는 order(목록 위치)이고 이름이 곧 식별자다.
+    const blueprintSlugs = slugEpic ? toBlueprintSlugs(subjectSlugs) : null;
+    const entries = raw.map((c, i) => {
+        const slug = blueprintSlugs ? blueprintSlugs[i] : subjectSlugs[i];
+        const blueprintId = blueprintSlugs ? slug : String(i + 1).padStart(3, '0');
+        return {
+            sha: c.sha,
+            subject: c.subject,
+            date: c.date,
+            author: c.author,
+            files: listChangedFiles(execFileSync, repoRoot, resolvedSource, c.sha),
+            blueprintId,
+            slug,
+            blueprintDir: blueprintSlugs ? slug : `${blueprintId}-${slug}`,
+        };
+    });
+    return {
+        ok: true,
+        source: resolvedSource,
+        fellBack,
+        ...baseFields,
+        total,
+        entries,
+        refusals,
+    };
+}
+function failResult(error) {
+    return { ok: false, created: [], committed: false, error };
+}
+/**
+ * 계획 → imported 문서 트리 → 단일 커밋.
+ * 차단 판정은 전부 첫 파일 쓰기 전 — 부분 생성은 S13으로 저장소 전체를 깨뜨린다.
+ */
+function applyImport({ repoRoot, plan, message, deps, }) {
+    const d = deps || {};
+    const execFileSync = d.execFileSync || realExecFileSync;
+    if (!plan || plan.ok === false) {
+        return failResult(plan && plan.error
+            ? plan.error
+            : { code: 'IMPORT_PLAN_INVALID', message: 'import plan is not ok' });
+    }
+    if (Array.isArray(plan.refusals) && plan.refusals.length > 0) {
+        const first = plan.refusals[0];
+        return failResult({ code: first.code, message: first.message });
+    }
+    const trimmed = typeof message === 'string' ? message.trim() : '';
+    if (!trimmed) {
+        return failResult({
+            code: 'IMPORT_MESSAGE_REQUIRED',
+            message: 'commit message is required to apply import',
+        });
+    }
+    if (!Array.isArray(plan.entries) || plan.entries.length === 0) {
+        return { ok: true, created: [], committed: false };
+    }
+    const timestamp = nowIsoKst();
+    // 쓸 형식은 계획의 epicDir 경로로 읽는다. 계획은 dry-run 출력이라 사람이 거치는 값이고, 같은 경로가
+    // 곧 디스크에 쓰일 위치이므로 경로와 문서 안 식별자가 어긋나지 않게 경로를 정본으로 삼는다.
+    const epicPath = parseContextPath(plan.epicDir);
+    const slugEpic = epicPath !== null && epicPath.format === 'slug';
+    const epicKey = epicPath !== null ? epicPath.epicKey : plan.epicId;
+    const epicRel = `${plan.epicDir}/index.md`;
+    const epicDescription = `Imported history (${plan.source})`;
+    const created = [];
+    // 렌더 → 쓰기 → 목록 등록 → 스테이징 → 커밋. 중간에 멈추면 안 되므로
+    // 거절은 위에서 전부 끝냈다.
+    created.push(writeImportDoc(repoRoot, epicRel, {
+        type: 'bouncer.epic',
+        title: slugEpic ? plan.epicName : `${plan.epicId} ${plan.epicName}`,
+        description: epicDescription,
+        resource: epicRel,
+        tags: ['bouncer', 'epic'],
+        timestamp,
+        bouncer: {
+            id: epicKey,
+            epic_id: epicKey,
+            status: 'imported',
+        },
+    }, renderEpicBody(plan)));
+    plan.entries.forEach((entry, index) => {
+        const bpRel = `${plan.epicDir}/blueprints/${entry.blueprintDir}/index.md`;
+        created.push(writeImportDoc(repoRoot, bpRel, {
+            type: 'bouncer.blueprint',
+            title: slugEpic ? entry.slug : `${entry.blueprintId} ${entry.slug}`,
+            description: entry.subject || `Imported ${entry.sha.slice(0, 7)}`,
+            resource: bpRel,
+            tags: ['bouncer', 'blueprint'],
+            timestamp,
+            bouncer: {
+                id: entry.blueprintId,
+                epic_id: epicKey,
+                blueprint_id: entry.blueprintId,
+                status: 'imported',
+                // slug 형식은 디렉터리에 번호가 없다. 계획 순서(오래된 커밋 먼저)를 1부터 order로 남긴다.
+                ...(slugEpic ? { order: index + 1 } : {}),
+            },
+        }, renderBlueprintBody(plan, entry)));
+    });
+    const indexRel = ensureEpicIndexEntry({
+        repoRoot,
+        epicId: slugEpic ? undefined : plan.epicId,
+        name: plan.epicName,
+        description: epicDescription,
+    });
+    if (indexRel)
+        created.push(indexRel);
+    // 생성한 경로만 스테이징 — git add -A 는 쓰지 않는다.
+    execFileSync('git', ['add', '--', ...created], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    // 커밋 메시지는 --message 인자 그대로. .gitmessage/문서 필드에서 조립하지 않는다.
+    // 내부 커밋이라 hook의 commit-guard만 건너뛴다. 사용자 hook은 그대로 돈다.
+    execFileSync('git', ['commit', '-m', message], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: internalCommitEnv(),
+    });
+    return {
+        ok: true,
+        created,
+        committed: true,
+        message: message,
+    };
+}
+module.exports = {
+    planImport,
+    applyImport,
+};

package/dist/import-render.js

@@ -0,0 +1,59 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const render = require("./render");
+const { renderDoc } = render;
+// 문서 본문 조립과 디스크 쓰기. 계획·거절 판정은 여기 두지 않는다 —
+// 렌더가 거절을 알면 쓰기 직전에만 막히고, 그 앞의 부분 생성을 막지 못한다.
+// import-history 를 require 하지 않는다(render → plan 순환 금지).
+/** 임포트 epic 본문. Success criteria 헤딩은 context digest 화이트리스트라 넣지 않는다. */
+function renderEpicBody(plan) {
+    const lines = [
+        `# ${plan.epicId} ${plan.epicName}`,
+        '',
+        '## Intent',
+        `- Imported from git ${plan.source}${plan.fellBack ? ' (fell back from merges)' : ''}.`,
+        `- ${plan.entries.length} blueprint(s) transcribed from history.`,
+        '',
+        '## Blueprints',
+    ];
+    for (const e of plan.entries) {
+        const title = e.subject || e.slug;
+        lines.push(`* [${e.blueprintId} ${e.slug}](blueprints/${e.blueprintDir}/index.md) - ${title}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function renderBlueprintBody(plan, entry) {
+    const changeLines = entry.files.length
+        ? entry.files.map((f) => `- ${f}`)
+        : ['- (no files)'];
+    return [
+        `# ${entry.blueprintId} ${entry.slug}`,
+        '',
+        `Epic: [${plan.epicId}](../../index.md)`,
+        '',
+        '## Source',
+        `- sha: \`${entry.sha}\``,
+        `- date: ${entry.date}`,
+        `- author: ${entry.author}`,
+        '',
+        '## Message',
+        entry.subject || '(empty)',
+        '',
+        '## Changes',
+        ...changeLines,
+        '',
+    ].join('\n');
+}
+function writeImportDoc(repoRoot, rel, data, body) {
+    const abs = path.join(repoRoot, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, renderDoc(data, body));
+    return rel;
+}
+module.exports = {
+    renderEpicBody,
+    renderBlueprintBody,
+    writeImportDoc,
+};

package/dist/import-types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });