@cheongfish/bouncer 0.0.0-stage → 0.1.13

package/dist/frontmatter.js

@@ -0,0 +1,22 @@
+'use strict';
+const fs = require('node:fs');
+// 경로는 emit된 scripts/lib/ 기준(tsc는 require 문자열을 재작성하지 않음).
+const yaml = require('../vendor/js-yaml');
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+function parseFrontmatter(markdown) {
+    const match = FRONTMATTER_RE.exec(markdown);
+    if (!match) {
+        throw new Error('missing frontmatter block');
+    }
+    // yaml.load는 스칼라·배열·객체를 모두 돌려줄 수 있다. 객체로 좁히면
+    // 기존 `|| {}` 폴백(falsy만 빈 객체)과 달라져 게이트 입력이 바뀐다.
+    const loaded = yaml.load(match[1]);
+    const data = loaded || {};
+    return { data, body: match[2] };
+}
+function readDoc(absPath) {
+    const raw = fs.readFileSync(absPath, 'utf8');
+    const { data, body } = parseFrontmatter(raw);
+    return { data, body, path: absPath };
+}
+module.exports = { parseFrontmatter, readDoc };

package/dist/git-ops.js

@@ -0,0 +1,49 @@
+'use strict';
+const { execFileSync } = require('node:child_process');
+const preCommitHook = require("./pre-commit-hook");
+const { internalCommitEnv } = preCommitHook;
+function realGit(repoRoot) {
+    const run = (args) => execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8' });
+    const lines = (s) => s.split('\n').filter(Boolean);
+    return {
+        changedFiles: () => lines(run(['diff', '--name-only', 'HEAD'])),
+        untrackedFiles: () => lines(run(['ls-files', '--others', '--exclude-standard'])),
+        trackedFiles: () => lines(run(['ls-files', '--cached'])),
+        stage: (files) => { if (files.length)
+            run(['add', '--', ...files]); },
+        commit: (msg) => {
+            // remainder 커밋도 G17 이후라 hook이 인덱스를 다시 보면 순환 차단한다.
+            execFileSync('git', ['commit', '-m', msg], {
+                cwd: repoRoot,
+                encoding: 'utf8',
+                env: internalCommitEnv(),
+            });
+        },
+        headSha: () => run(['rev-parse', 'HEAD']).trim(),
+    };
+}
+/**
+ * checkout이 실제로 가리키는 local branch를 읽는다. detached HEAD·삭제된
+ * worktree·Git 조회 실패는 null로 보존한다. finalize는 provenance를 못 읽었다고
+ * 닫기를 거절하지 않으므로, 계산한 이름으로 빈 사실을 채우지 않는다.
+ *
+ * @param {string | null} worktreePath - branch를 확인할 checkout 경로
+ * @returns {string | null} 실제 branch 또는 확인 불가를 뜻하는 null
+ */
+function resolveCheckoutBranch(worktreePath) {
+    if (!worktreePath)
+        return null;
+    try {
+        const branch = String(execFileSync('git', ['symbolic-ref', '--quiet', '--short', 'HEAD'], {
+            cwd: worktreePath,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        })).trim();
+        return branch || null;
+    }
+    catch (_error) {
+        // detached HEAD와 접근 불가 checkout은 provenance에서 구별할 branch가 없다.
+        return null;
+    }
+}
+module.exports = { realGit, resolveCheckoutBranch };

package/dist/graph-exec.js

@@ -0,0 +1,179 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const graphify = require("./graphify");
+const { resolveGraphifyBin } = graphify;
+const posixPath = require("./posix-path");
+const { toPosix } = posixPath;
+// graphify 프로세스와 결과 경로 정규화. 해석기 PATH 탐색이
+// execFileSync('graphify', ['--version']) 를 돌리므로 realHasGraphify 도
+// 여기 둔다 — 이름은 판정처럼 보이지만 프로세스를 띄운다.
+// session-graph 를 require 하지 않는다(exec → plan 순환 금지).
+// PATH/`command -v` 폴백은 resolveGraphifyBin의 hasOnPath가 흡수한다.
+// 해석 실패는 새 상태가 아니라 기존 skip-no-graphify와 같다.
+function realHasGraphify(repoRoot) {
+    return resolveGraphifyBin({ repoRoot }).bin !== null;
+}
+// part cwd(보통 ".") 기준 원하는 outDir. graphify가 인정할 값이 필요하면
+// cwd에 대해 resolve — runGraphifyUpdate 참고. graphify join 규칙과 무관하게
+// cwd-relative 계약을 테스트할 수 있도록 순수 relative helper로 유지.
+function graphifyOutEnv(cwdAbs, outDirAbs) {
+    return path.relative(cwdAbs, outDirAbs).split(path.sep).join('/') || '.';
+}
+function partOutDir(outDir, dir) {
+    const slug = dir.replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'root';
+    return `${outDir}/parts/${slug}`;
+}
+function runGraphifyUpdate(repoRoot, dir, outDir, opts = null) {
+    // part outDir에 cwd를 격리해 graphify 고정
+    // `<cwd>/graphify-out/manifest.json`이 repo root가 아니라 part 아래에
+    // 생성되게 한다. scan target은 절대 경로 — cwd는 cache/output sandbox만.
+    // `--repo .`처럼 상대 경로가 오면 scan target도 상대가 된다. graphify는 part cwd에서 돌아
+    // 그 경로를 찾지 못하므로 먼저 절대 경로로 고정한다.
+    const rootAbs = path.resolve(repoRoot);
+    const partAbs = path.join(rootAbs, outDir);
+    const scanAbs = path.join(rootAbs, dir);
+    fs.mkdirSync(partAbs, { recursive: true });
+    const exec = ((opts && opts.exec) || execFileSync);
+    // 실행 대상은 해석기가 준 값만 — 여기 리터럴 'graphify'를 두지 않는다.
+    // 호출자(defaultExecGraphify)가 한 번 해석한 bin을 넘기는 것이 정상이며,
+    // 미주입 시에만 여기서 한 번 더 해석한다(단위 테스트·직접 호출용).
+    const bin = (opts && opts.bin) || resolveGraphifyBin({ repoRoot }).bin;
+    // graphify는 *상대* GRAPHIFY_OUT을 scan 디렉터리에 join한다. 절대 scan
+    // target이면 cwd-relative "."를 넘기면 source tree에 쓰게 되므로, graph.json이
+    // partAbs에 오도록 part cwd 기준으로 resolve.
+    const outEnv = path.resolve(partAbs, graphifyOutEnv(partAbs, partAbs));
+    // `update`는 AST-only 경로: `extract`와 달리 LLM key 불필요.
+    exec(bin, ['update', scanAbs], {
+        cwd: partAbs,
+        env: { ...process.env, GRAPHIFY_OUT: outEnv },
+        stdio: 'ignore',
+    });
+}
+// graphify는 scan한 디렉터리 기준 source_file을 기록하고 node id를 파생하므로,
+// `scripts`에서 만든 part는 `src/lib/render.ts`를 주장하고 다른 source dir 아래
+// 동일 경로명과 충돌할 수 있다. 소비 전에 둘 다 repo-relative/네임스페이스
+// 형태로 rewrite.
+function normalizeGraphPaths(repoRoot, partOut, dir) {
+    const graph = JSON.parse(fs.readFileSync(path.join(repoRoot, partOut, 'graph.json'), 'utf8'));
+    const idPrefix = `${dir.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '')}_`;
+    const prefixId = (id) => (typeof id === 'string' ? idPrefix + id : id);
+    const prefixFile = (f) => (typeof f === 'string' && f ? `${dir}/${f}` : f);
+    for (const node of graph.nodes || []) {
+        node.id = prefixId(node.id);
+        node.source_file = prefixFile(node.source_file);
+    }
+    for (const link of graph.links || []) {
+        link.source = prefixId(link.source);
+        link.target = prefixId(link.target);
+        link.source_file = prefixFile(link.source_file);
+    }
+    for (const hyperedge of graph.hyperedges || []) {
+        if (Array.isArray(hyperedge.nodes))
+            hyperedge.nodes = hyperedge.nodes.map(prefixId);
+        hyperedge.source_file = prefixFile(hyperedge.source_file);
+    }
+    const rel = `${partOut}/graph.normalized.json`;
+    fs.writeFileSync(path.join(repoRoot, rel), JSON.stringify(graph));
+    return rel;
+}
+/**
+ * source_file이 exclude prefix 아래인지 본다. `scripts/lib`가
+ * `scripts/liberator`를 삼키지 않도록 exact 또는 `prefix/`만 인정한다.
+ *
+ * @param {unknown} sourceFile - 노드/링크의 source_file
+ * @param {string[]} prefixes - 저장소 상대 제외 prefix
+ * @returns {boolean} 제외 대상이면 true
+ */
+function matchesExcludePrefix(sourceFile, prefixes) {
+    if (typeof sourceFile !== 'string' || !sourceFile)
+        return false;
+    const posix = toPosix(sourceFile);
+    return prefixes.some((raw) => {
+        const pref = toPosix(raw).replace(/\/+$/, '');
+        if (!pref)
+            return false;
+        return posix === pref || posix.startsWith(`${pref}/`);
+    });
+}
+/**
+ * 제외 prefix 아래 node와 그 id를 참조하는 link·hyperedge를 함께 제거한다.
+ * 빈 excludeDirs는 입력을 그대로 돌려 JavaScript를 생성물로 추측해
+ * 지우지 않는다(정본 JS 저장소 호환).
+ *
+ * @param {GraphJson} graph - 정규화·병합된 그래프
+ * @param {string[]} excludeDirs - 저장소 상대 prefix 목록
+ * @returns {GraphJson} 필터된 그래프(동일 객체를 변이)
+ */
+function applyExcludeDirs(graph, excludeDirs) {
+    if (!excludeDirs || excludeDirs.length === 0)
+        return graph;
+    const dropped = new Set();
+    graph.nodes = (graph.nodes || []).filter((node) => {
+        if (matchesExcludePrefix(node.source_file, excludeDirs)) {
+            dropped.add(node.id);
+            return false;
+        }
+        return true;
+    });
+    graph.links = (graph.links || []).filter((link) => (!dropped.has(link.source) && !dropped.has(link.target)));
+    graph.hyperedges = (graph.hyperedges || []).filter((hyperedge) => {
+        if (!Array.isArray(hyperedge.nodes))
+            return true;
+        return hyperedge.nodes.every((id) => !dropped.has(id));
+    });
+    return graph;
+}
+function writeFilteredGraph(targetAbs, excludeDirs) {
+    // exclude가 비면 파일을 다시 읽지 않는다 — merge/copy 결과를 그대로 둔다.
+    if (!excludeDirs || excludeDirs.length === 0)
+        return;
+    const graph = JSON.parse(fs.readFileSync(targetAbs, 'utf8'));
+    applyExcludeDirs(graph, excludeDirs);
+    fs.writeFileSync(targetAbs, JSON.stringify(graph));
+}
+// 각 dir은 parts/ 아래 graphify state를 유지해 incremental rebuild가 graphify가
+// 쓴 id를 본다; scope graph.json은 우리가 만든 파생 artifact.
+function defaultExecGraphify(repoRoot, graph, opts = null) {
+    // 루프마다 재해석하지 않음 — config/venv/PATH 판정을 한 번만 하고 part·merge에 공유.
+    // 단위 테스트는 bin·exec를 주입해 실제 graphify 없이 source exclude 경로를 검증한다.
+    const bin = (opts && opts.bin) || resolveGraphifyBin({ repoRoot }).bin;
+    // 소비 측 계약: scanDirs || dirs. source 는 scanDirs 없이 dirs 만 쓴다.
+    const scanDirs = graph.scanDirs || graph.dirs;
+    const parts = scanDirs.map((dir) => {
+        const partOut = partOutDir(graph.outDir, dir);
+        runGraphifyUpdate(repoRoot, dir, partOut, {
+            bin,
+            ...(opts && opts.exec ? { exec: opts.exec } : {}),
+        });
+        return normalizeGraphPaths(repoRoot, partOut, dir);
+    });
+    const target = path.join(repoRoot, graph.outDir, 'graph.json');
+    if (parts.length === 1) {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.copyFileSync(path.join(repoRoot, parts[0]), target);
+    }
+    else {
+        const exec = ((opts && opts.exec) || execFileSync);
+        exec(bin, ['merge-graphs', ...parts, '--out', `${graph.outDir}/graph.json`], {
+            cwd: repoRoot,
+            stdio: 'ignore',
+        });
+    }
+    // source 병합 결과에만 exclude를 적용. test는 역할이 달라
+    // 같은 prefix로 지우면 안 된다.
+    if (graph.name === 'source') {
+        writeFilteredGraph(target, graph.excludeDirs);
+    }
+}
+module.exports = {
+    realHasGraphify,
+    graphifyOutEnv,
+    partOutDir,
+    runGraphifyUpdate,
+    normalizeGraphPaths,
+    applyExcludeDirs,
+    writeFilteredGraph,
+    defaultExecGraphify,
+};

package/dist/graph-scope.js

@@ -0,0 +1,268 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const config = require("./config");
+const { readConfig } = config;
+const posixPath = require("./posix-path");
+const { toPosix } = posixPath;
+// 설정·디렉터리 존재·mtime 판정만. 프로세스를 띄우지 않고 graphify.ts 도
+// require 하지 않는다 — 그 모듈의 PATH 탐색이 execFileSync 를 돌리기 때문.
+// 신선도 계산이 graphify 설치 여부를 묻기 시작하면 테스트가 deps 없이
+// 안전한 함수와 아닌 함수를 구분하지 못한다.
+const DEFAULT_SOURCE_OUT = 'graphify-out/source';
+const DEFAULT_TEST_OUT = 'graphify-out/test';
+// freshness walk 전용 이름 기반 prune — config key 아님.
+// graphify-out 을 건너뛰는 이유 둘:
+// 1) 파생 트리는 freshness 입력이 아니다. 산출물 mtime 이 stale 을 만들면
+//    매 sync 가 자기 산출물을 보고 재빌드한다.
+// 2) 사용자가 source_dirs: ["."] 로 graphify-out 을 다시 넣으면
+//    build 가 graphify-out 아래에 쓰기 → mtime 갱신 → rebuild 무한 루프.
+const SCAN_EXCLUDED_DIRS = new Set(['graphify-out', 'node_modules', '.git', '.worktrees']);
+function configField(cfg, key) {
+    // cfg?.key 와 같다. `'key' in cfg`로 바꾸면 프로토타입 필드가 생기고
+    // null에서 단락되지 않을 수 있다.
+    return cfg && typeof cfg === 'object' ? cfg[key] : undefined;
+}
+/**
+ * 저장소 상대 디렉터리만 허용한다. 절대 경로·`..` 탈출은 거부해
+ * graphify 입력이 작업 트리 밖으로 새지 않게 한다.
+ *
+ * @param {unknown} value - 검사할 경로 후보
+ * @returns {boolean} 상대·비탈출 문자열이면 true
+ */
+function isSafeRepoRelativeDir(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return false;
+    const posix = toPosix(value);
+    // path.isAbsolute는 플랫폼 절대만 본다. POSIX 절대·드라이브 문자는
+    // Windows host에서도 명시적으로 막는다.
+    if (path.isAbsolute(value) || path.isAbsolute(posix))
+        return false;
+    if (posix.startsWith('/') || /^[A-Za-z]:/.test(posix))
+        return false;
+    if (posix.split('/').includes('..'))
+        return false;
+    return true;
+}
+/**
+ * graphify.test_dirs / exclude_dirs 공통 파서. 문자열 배열이 아니거나
+ * 안전하지 않은 항목이 있으면 값을 적용하지 않고 진단 사유만 남긴다.
+ *
+ * @param {unknown} raw - config 필드 원본
+ * @param {string} fieldName - 진단에 쓸 필드 이름
+ * @returns {DirListParse} 성공 시 dirs, 실패 시 reason
+ */
+function parseDirList(raw, fieldName) {
+    if (!Array.isArray(raw)) {
+        return { ok: false, reason: `${fieldName} must be a string array of repo-relative paths` };
+    }
+    if (!raw.every(isSafeRepoRelativeDir)) {
+        return {
+            ok: false,
+            reason: `${fieldName} entries must be repo-relative paths without '..' or absolute roots`,
+        };
+    }
+    return { ok: true, dirs: raw };
+}
+function graphifyObject(cfg) {
+    const graphify = configField(cfg, 'graphify');
+    if (!graphify || typeof graphify !== 'object' || Array.isArray(graphify))
+        return null;
+    return graphify;
+}
+/**
+ * 선택 필드 graphify.test_dirs를 읽는다. 키 부재는 present:false —
+ * resolveGraphScopes가 test 항목을 skip-unconfigured로 실을 때 쓴다.
+ * 잘못된 값은 적용하지 않고 skipReason만 돌려 호출자가 skips와
+ * skip-unconfigured reason에 같은 사유를 싣게 한다.
+ *
+ * @param {string} repoRoot - 저장소 루트
+ * @returns {OptionalDirList} 부재·유효 dirs·무효 skip
+ */
+function realTestDirs(repoRoot) {
+    const graphify = graphifyObject(readConfig(repoRoot));
+    if (!graphify || !Object.prototype.hasOwnProperty.call(graphify, 'test_dirs')) {
+        return { present: false };
+    }
+    const parsed = parseDirList(graphify.test_dirs, 'graphify.test_dirs');
+    if (!parsed.ok)
+        return { present: true, dirs: null, skipReason: parsed.reason };
+    return { present: true, dirs: parsed.dirs };
+}
+/**
+ * 선택 필드 graphify.exclude_dirs를 읽는다. 키 부재·빈 배열은 제외
+ * 없음을 뜻하며 JavaScript를 생성물로 추측해 지우지 않는다. 무효 값도
+ * 빈 제외로 수렴하고 skipReason만 남긴다.
+ *
+ * @param {string} repoRoot - 저장소 루트
+ * @returns {{ dirs: string[], skipReason?: string }} 적용할 prefix와 선택적 사유
+ */
+function realExcludeDirs(repoRoot) {
+    const graphify = graphifyObject(readConfig(repoRoot));
+    if (!graphify || !Object.prototype.hasOwnProperty.call(graphify, 'exclude_dirs')) {
+        return { dirs: [] };
+    }
+    const parsed = parseDirList(graphify.exclude_dirs, 'graphify.exclude_dirs');
+    if (!parsed.ok)
+        return { dirs: [], skipReason: parsed.reason };
+    return { dirs: parsed.dirs };
+}
+function realGraphifyEnabled(repoRoot) {
+    // ?? {}를 붙이지 않는다. 부재를 빈 객체와 같게 보면 enabled 판정이
+    // "키 없음"과 "파일 없음"을 구분하지 못하게 되고, 둘 다 false로 떨어져
+    // 겉보기엔 같아 보이지만 cfg?. 전제(null 유지)가 깨진다.
+    const cfg = readConfig(repoRoot);
+    const graphify = configField(cfg, 'graphify');
+    const enabled = graphify && typeof graphify === 'object'
+        ? graphify.enabled
+        : undefined;
+    return enabled === true;
+}
+function realSourceDirs(repoRoot) {
+    const cfg = readConfig(repoRoot);
+    const dirs = configField(cfg, 'source_dirs');
+    return Array.isArray(dirs) ? dirs : [];
+}
+function realExistingDirs(repoRoot, dirs) {
+    return dirs.filter((d) => fs.existsSync(path.join(repoRoot, d)));
+}
+function newestMtimeUnder(repoRoot, dir) {
+    const root = path.join(repoRoot, dir);
+    let newest = 0;
+    const walk = (abs) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(abs, { withFileTypes: true });
+        }
+        catch (_e) {
+            return;
+        }
+        for (const e of entries) {
+            const child = path.join(abs, e.name);
+            // exclude set 밖의 실제 디렉터리만 descend. symlink dir은
+            // 따라가지 않음 — 링크가 ancestor를 가리킬 때 cycle 방지.
+            if (e.isDirectory()) {
+                if (!e.isSymbolicLink() && !SCAN_EXCLUDED_DIRS.has(e.name))
+                    walk(child);
+                continue;
+            }
+            const m = fs.statSync(child).mtimeMs;
+            if (m > newest)
+                newest = m;
+        }
+    };
+    walk(root);
+    return newest;
+}
+/**
+ * dirs 는 보통 디렉터리 walk, watchFiles 는 config.json 같은 단일 파일 mtime.
+ * 디렉터리가 아닌 경로는 walk 하지 않고 statSync 로 직접 잰다.
+ * 파생 memory 파일·디렉터리는 freshness 입력이 아니다 — 소스 원본만 본다.
+ */
+function realNewestMtime(repoRoot, dirs, watchFiles) {
+    let newest = 0;
+    for (const d of dirs || []) {
+        const abs = path.join(repoRoot, d);
+        let st;
+        try {
+            st = fs.statSync(abs);
+        }
+        catch (_e) {
+            continue;
+        }
+        if (st.isDirectory()) {
+            newest = Math.max(newest, newestMtimeUnder(repoRoot, d));
+        }
+        else if (st.mtimeMs > newest) {
+            newest = st.mtimeMs;
+        }
+    }
+    const files = [...(watchFiles || [])];
+    for (const f of files) {
+        const abs = path.join(repoRoot, f);
+        let st;
+        try {
+            st = fs.statSync(abs);
+        }
+        catch (_e) {
+            continue;
+        }
+        if (st.isDirectory()) {
+            newest = Math.max(newest, st.mtimeMs, newestMtimeUnder(repoRoot, f));
+        }
+        else if (st.mtimeMs > newest) {
+            newest = st.mtimeMs;
+        }
+    }
+    return newest;
+}
+function realGraphMtime(repoRoot, outDir) {
+    const abs = path.join(repoRoot, outDir, 'graph.json');
+    return fs.existsSync(abs) ? fs.statSync(abs).mtimeMs : null;
+}
+/**
+ * source·test 두 scope 계획을 항상 만든다. testDirs가 null/undefined면
+ * 빌드 불가 test 항목을 남기고 unconfiguredReason을 싣는다(보고 길이 2 유지).
+ * 빈 배열은 필드 존재 → skip-no-dirs. excludeDirs는 source에만 실어 merge 뒤
+ * 필터가 소비한다 — 빈 목록이면 필터 no-op.
+ *
+ * @param {{
+ *   sourceDirs: string[],
+ *   testDirs?: string[] | null,
+ *   excludeDirs?: string[],
+ *   testUnconfiguredReason?: string
+ * }} args
+ * @returns {GraphScopePlan[]} 빌드·freshness 계획 목록(길이 2)
+ */
+function resolveGraphScopes({ sourceDirs, testDirs, excludeDirs, testUnconfiguredReason }) {
+    const source = {
+        name: 'source',
+        dirs: sourceDirs,
+        outDir: DEFAULT_SOURCE_OUT,
+        // exclude_dirs·test_dirs는 config에만 있다. source 입력 mtime만 보면
+        // exclude를 바꾼 뒤에도 skip-fresh로 남아 필터가 한 번도 안 돈다.
+        // config mtime을 freshness에 넣어 다음 sync가 rebuild·재필터하게 한다.
+        watchFiles: ['.bouncer/config.json'],
+    };
+    // 빈 배열도 "명시적 제외 없음"이라 키를 붙여도 no-op이지만, 호출자가
+    // 넘긴 목록만 실어 진단·테스트가 계획 객체를 읽을 수 있게 한다.
+    if (excludeDirs && excludeDirs.length > 0) {
+        source.excludeDirs = excludeDirs;
+    }
+    else if (excludeDirs) {
+        source.excludeDirs = [];
+    }
+    const scopes = [source];
+    // null/undefined = 미설정·무효 → skip-unconfigured 자리표시. 빈 배열은
+    // 필드 존재 → planOneGraph가 skip-no-dirs로 수렴한다(skip-unconfigured 아님).
+    if (testDirs != null) {
+        scopes.push({ name: 'test', dirs: testDirs, outDir: DEFAULT_TEST_OUT });
+    }
+    else {
+        scopes.push({
+            name: 'test',
+            dirs: [],
+            outDir: DEFAULT_TEST_OUT,
+            // 존재하지 않는 입력을 꾸며 싣지 않는다 — configured도 비운다.
+            unconfiguredReason: testUnconfiguredReason
+                || 'graphify.test_dirs is not configured',
+        });
+    }
+    return scopes;
+}
+module.exports = {
+    SCAN_EXCLUDED_DIRS,
+    DEFAULT_SOURCE_OUT,
+    DEFAULT_TEST_OUT,
+    realGraphifyEnabled,
+    realSourceDirs,
+    realTestDirs,
+    realExcludeDirs,
+    parseDirList,
+    isSafeRepoRelativeDir,
+    realExistingDirs,
+    newestMtimeUnder,
+    realNewestMtime,
+    realGraphMtime,
+    resolveGraphScopes,
+};