svharness 0.8.0

package/dist/utils/baseline-copy.js

@@ -0,0 +1,591 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXT_BLACKLIST = exports.DIR_BLACKLIST = void 0;
+exports.copyBaseline = copyBaseline;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:stream/promises");
+const node_fs_1 = require("node:fs");
+const tar = __importStar(require("tar"));
+const baseline_defaults_1 = require("./baseline-defaults");
+// Re-exported for any legacy import sites.
+exports.DIR_BLACKLIST = baseline_defaults_1.DEFAULT_DIR_BLACKLIST;
+exports.EXT_BLACKLIST = baseline_defaults_1.DEFAULT_EXT_BLACKLIST;
+async function copyBaseline(input) {
+    const log = input.onLog ?? (() => { });
+    await fs_extra_1.default.emptyDir(input.destDir);
+    if (input.mode === 'git') {
+        return copyFromGit(input, log);
+    }
+    return copyFromLocal(input, log);
+}
+async function copyFromLocal(input, log) {
+    const src = input.source;
+    if (!fs_extra_1.default.existsSync(src)) {
+        throw new Error(`baseline 本地路径不存在: ${src}`);
+    }
+    if (!fs_extra_1.default.statSync(src).isDirectory()) {
+        throw new Error(`baseline 本地路径不是目录: ${src}`);
+    }
+    log(`基线模式: local · 源: ${src}`);
+    // Prefer `git ls-files` when the source is a git working tree. This respects
+    // .gitignore, skips every untracked cache/artifact (e.g. Android build
+    // outputs, IDE caches, 9000+ untracked drawable pngs) and finishes in a
+    // fraction of the time a full walk would take on Windows.
+    if (isGitWorkingTree(src)) {
+        try {
+            log('  检测到 .git · 走 git ls-files（仅拷贝已追踪文件）');
+            const stats = await copyFromLocalGitTracked(src, input.destDir, input.maxSizeKB, log);
+            return { mode: 'local', source: src, stats };
+        }
+        catch (err) {
+            log(`  git ls-files 失败，回退到全量 walk：${err.message}`);
+        }
+    }
+    log('  执行目录 walk（黑名单过滤 + 扩展名过滤 + 单文件大小上限）');
+    const stats = await walkAndCopy(src, input.destDir, input.maxSizeKB, log);
+    return { mode: 'local', source: src, stats };
+}
+function isGitWorkingTree(dir) {
+    // `.git` is normally a directory, but for submodules/worktrees it can be a
+    // regular file that contains a `gitdir:` pointer — both count as "git here".
+    try {
+        return fs_extra_1.default.existsSync(node_path_1.default.join(dir, '.git'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Copy only git-tracked files from a local working tree. Path-based blacklists
+ * and the extension blacklist still apply as a safety net against checked-in
+ * binaries.
+ */
+async function copyFromLocalGitTracked(srcRoot, destRoot, maxSizeKB, log) {
+    ensureGitAvailable();
+    const maxBytes = Math.max(1, maxSizeKB) * 1024;
+    const stats = { files: 0, sizeKB: 0, skipped: 0 };
+    let totalBytes = 0;
+    const res = (0, node_child_process_1.spawnSync)('git', ['-C', srcRoot, 'ls-files', '-z'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        encoding: 'buffer',
+        maxBuffer: 256 * 1024 * 1024,
+    });
+    if (res.status !== 0) {
+        const stderr = (res.stderr?.toString('utf8') || '').trim();
+        throw new Error(`git ls-files 失败 (exit=${res.status}): ${stderr || '未知错误'}`);
+    }
+    const raw = res.stdout ?? Buffer.alloc(0);
+    const relPaths = raw
+        .toString('utf8')
+        .split('\0')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    log(`  git ls-files 命中 ${relPaths.length} 个已追踪文件`);
+    await fs_extra_1.default.ensureDir(destRoot);
+    const progress = createProgress(log, relPaths.length, 'local-git');
+    const ensuredDirs = new Set();
+    ensuredDirs.add(node_path_1.default.resolve(destRoot));
+    for (const relPosix of relPaths) {
+        progress.tick();
+        if ((0, baseline_defaults_1.anySegmentBlacklisted)(relPosix)) {
+            stats.skipped++;
+            continue;
+        }
+        const ext = node_path_1.default.extname(relPosix).toLowerCase();
+        if ((0, baseline_defaults_1.isBlacklistedExt)(ext)) {
+            stats.skipped++;
+            continue;
+        }
+        const absSrc = node_path_1.default.join(srcRoot, relPosix);
+        let size = 0;
+        try {
+            const st = fs_extra_1.default.statSync(absSrc);
+            if (!st.isFile()) {
+                stats.skipped++;
+                continue;
+            }
+            size = st.size;
+        }
+        catch {
+            stats.skipped++;
+            continue;
+        }
+        if (size > maxBytes) {
+            stats.skipped++;
+            continue;
+        }
+        const absDest = node_path_1.default.join(destRoot, relPosix);
+        const parent = node_path_1.default.dirname(absDest);
+        if (!ensuredDirs.has(parent)) {
+            await fs_extra_1.default.ensureDir(parent);
+            ensuredDirs.add(parent);
+        }
+        await fs_extra_1.default.copyFile(absSrc, absDest);
+        stats.files++;
+        totalBytes += size;
+    }
+    progress.finish(stats.files, stats.skipped);
+    stats.sizeKB = Math.round(totalBytes / 1024);
+    return stats;
+}
+/**
+ * Git mode: prefer tarball over HTTPS (fast, CDN-backed, no .git metadata).
+ * Fall back to `git clone --depth 1 --no-checkout --filter=...` when the
+ * host is unknown or tarball download fails (private repos, self-hosted, etc).
+ */
+async function copyFromGit(input, log) {
+    const branch = input.branch;
+    log(`基线模式: git · 源: ${input.source}${branch ? ` · 分支: ${branch}` : ''}`);
+    const tarballUrl = resolveTarballUrl(input.source, branch);
+    if (tarballUrl) {
+        try {
+            log(`  尝试 tarball 直下: ${tarballUrl}`);
+            return await copyViaTarball(input, tarballUrl, log);
+        }
+        catch (err) {
+            log(`  tarball 下载失败，回退到 git clone：${err.message}`);
+        }
+    }
+    else {
+        log('  未识别为已知托管服务，直接走 git clone');
+    }
+    return copyViaGitClone(input, log);
+}
+/**
+ * Parse common git URL shapes into (host, owner, repo):
+ *   - git@github.com:owner/repo.git
+ *   - https://github.com/owner/repo(.git)?
+ *   - ssh://git@github.com/owner/repo.git
+ * Only recognized, well-known public hosting providers are returned.
+ */
+function parseRepoUrl(url) {
+    const stripGit = (s) => s.replace(/\.git$/i, '');
+    // SSH style: git@host:owner/repo(.git)
+    const sshMatch = /^git@([^:]+):([^/]+)\/(.+?)(?:\.git)?$/i.exec(url);
+    if (sshMatch) {
+        const host = hostKind(sshMatch[1]);
+        if (host)
+            return { host, owner: sshMatch[2], repo: stripGit(sshMatch[3]) };
+    }
+    // ssh://git@host/owner/repo(.git)
+    const sshSchemeMatch = /^ssh:\/\/[^@]+@([^/]+)\/([^/]+)\/(.+?)(?:\.git)?$/i.exec(url);
+    if (sshSchemeMatch) {
+        const host = hostKind(sshSchemeMatch[1]);
+        if (host)
+            return { host, owner: sshSchemeMatch[2], repo: stripGit(sshSchemeMatch[3]) };
+    }
+    // https://host/owner/repo(.git)(/...)?
+    const httpsMatch = /^https?:\/\/([^/]+)\/([^/]+)\/([^/?#]+?)(?:\.git)?(?:[/?#].*)?$/i.exec(url);
+    if (httpsMatch) {
+        const host = hostKind(httpsMatch[1]);
+        if (host)
+            return { host, owner: httpsMatch[2], repo: stripGit(httpsMatch[3]) };
+    }
+    return undefined;
+}
+function hostKind(host) {
+    const h = host.toLowerCase();
+    if (h === 'github.com' || h.endsWith('.github.com'))
+        return 'github';
+    if (h === 'gitee.com' || h.endsWith('.gitee.com'))
+        return 'gitee';
+    if (h === 'gitlab.com' || h.endsWith('.gitlab.com'))
+        return 'gitlab';
+    if (h === 'bitbucket.org' || h.endsWith('.bitbucket.org'))
+        return 'bitbucket';
+    return undefined;
+}
+/**
+ * Build a tarball download URL for the given repo + branch.
+ * Branch defaults to 'HEAD' (GitHub/GitLab) when not provided.
+ */
+function resolveTarballUrl(source, branch) {
+    const parsed = parseRepoUrl(source);
+    if (!parsed)
+        return undefined;
+    const { host, owner, repo } = parsed;
+    const ref = branch && branch.trim() ? branch.trim() : 'HEAD';
+    switch (host) {
+        case 'github':
+            // codeload serves gzipped tarballs directly from CDN
+            return ref === 'HEAD'
+                ? `https://codeload.github.com/${owner}/${repo}/tar.gz/HEAD`
+                : `https://codeload.github.com/${owner}/${repo}/tar.gz/refs/heads/${encodeURIComponent(ref)}`;
+        case 'gitee':
+            return `https://gitee.com/${owner}/${repo}/repository/archive/${encodeURIComponent(ref)}.tar.gz`;
+        case 'gitlab':
+            return `https://gitlab.com/${owner}/${repo}/-/archive/${encodeURIComponent(ref)}/${repo}-${encodeURIComponent(ref)}.tar.gz`;
+        case 'bitbucket':
+            return `https://bitbucket.org/${owner}/${repo}/get/${encodeURIComponent(ref)}.tar.gz`;
+    }
+}
+async function copyViaTarball(input, tarballUrl, log) {
+    const tmpRoot = fs_extra_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'svhb-tarball-'));
+    const extractDir = node_path_1.default.join(tmpRoot, 'extracted');
+    await fs_extra_1.default.ensureDir(extractDir);
+    const tarFile = node_path_1.default.join(tmpRoot, 'archive.tar.gz');
+    try {
+        log(`  下载到: ${tarFile}`);
+        await downloadToFile(tarballUrl, tarFile, log);
+        log('  解压 tarball（strip 顶层目录）');
+        // `strip: 1` removes the single top-level directory that all git-host
+        // tarballs wrap their content in (e.g. "repo-branch/").
+        await tar.x({ file: tarFile, cwd: extractDir, strip: 1 });
+        log('  按规则过滤拷贝到 baseline/code/');
+        const stats = await walkAndCopy(extractDir, input.destDir, input.maxSizeKB, log);
+        return {
+            mode: 'git',
+            source: input.source,
+            branch: input.branch,
+            stats,
+        };
+    }
+    finally {
+        try {
+            fs_extra_1.default.removeSync(tmpRoot);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+}
+/**
+ * HTTPS GET with redirect follow-through. Streams the response body straight
+ * to disk so we never hold the whole archive in memory.
+ */
+async function downloadToFile(url, filePath, log, redirectsLeft = 5) {
+    const parsed = new URL(url);
+    const client = parsed.protocol === 'http:' ? node_http_1.default : node_https_1.default;
+    await new Promise((resolve, reject) => {
+        const req = client.get(url, {
+            headers: {
+                'User-Agent': 'svharnessbuild',
+                Accept: 'application/gzip, application/octet-stream, */*',
+            },
+        }, (res) => {
+            const status = res.statusCode ?? 0;
+            // follow redirects
+            if (status >= 300 && status < 400 && res.headers.location) {
+                res.resume();
+                if (redirectsLeft <= 0) {
+                    reject(new Error(`tarball 重定向次数超限: ${url}`));
+                    return;
+                }
+                const next = new URL(res.headers.location, url).toString();
+                downloadToFile(next, filePath, log, redirectsLeft - 1).then(resolve, reject);
+                return;
+            }
+            if (status !== 200) {
+                res.resume();
+                reject(new Error(`tarball HTTP ${status} · ${url}`));
+                return;
+            }
+            const total = Number(res.headers['content-length'] ?? 0);
+            let received = 0;
+            let lastPct = -1;
+            res.on('data', (chunk) => {
+                received += chunk.length;
+                if (total > 0) {
+                    const pct = Math.floor((received / total) * 100);
+                    if (pct >= lastPct + 10) {
+                        log(`  下载进度: ${pct}% (${mib(received)} / ${mib(total)})`);
+                        lastPct = pct;
+                    }
+                }
+            });
+            (0, promises_1.pipeline)(res, (0, node_fs_1.createWriteStream)(filePath)).then(resolve, reject);
+        });
+        req.on('error', reject);
+        req.setTimeout(60_000, () => {
+            req.destroy(new Error('tarball 下载超时（60s 无数据）'));
+        });
+    });
+}
+function mib(bytes) {
+    return `${(bytes / 1024 / 1024).toFixed(1)} MiB`;
+}
+// ---------------------------------------------------------------------------
+// Git clone fallback path
+// ---------------------------------------------------------------------------
+async function copyViaGitClone(input, log) {
+    ensureGitAvailable();
+    const tmpRoot = fs_extra_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'svhb-baseline-'));
+    log(`  浅克隆到临时目录: ${tmpRoot}`);
+    try {
+        // Partial clone + no-checkout: don't materialize working tree, so oversize
+        // blobs (skipped by --filter) never trigger lazy fetch.
+        const blobLimit = `${Math.max(1, input.maxSizeKB)}k`;
+        const cloneArgs = [
+            'clone',
+            '--depth', '1',
+            '--single-branch',
+            '--no-tags',
+            '--no-checkout',
+            '--shallow-submodules',
+            `--filter=blob:limit=${blobLimit}`,
+            '--progress',
+        ];
+        if (input.branch) {
+            cloneArgs.push('-b', input.branch);
+        }
+        cloneArgs.push(input.source, tmpRoot);
+        const cloneEnv = {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: '0',
+            GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? 'ssh -o StrictHostKeyChecking=accept-new',
+        };
+        const cloneRes = (0, node_child_process_1.spawnSync)('git', cloneArgs, {
+            stdio: 'inherit',
+            env: cloneEnv,
+        });
+        if (cloneRes.error) {
+            throw new Error(`git clone 启动失败: ${cloneRes.error.message}`);
+        }
+        if (cloneRes.status !== 0) {
+            throw new Error(`git clone 失败 (exit=${cloneRes.status}). ` +
+                '请检查：网络连通性、SSH 密钥是否就绪、分支名是否存在、仓库是否可访问。');
+        }
+        const commit = resolveGitHead(tmpRoot);
+        if (commit)
+            log(`  HEAD commit: ${commit}`);
+        const stats = await copyFromGitTree(tmpRoot, input.destDir, input.maxSizeKB, log);
+        return {
+            mode: 'git',
+            source: input.source,
+            branch: input.branch,
+            commit,
+            stats,
+        };
+    }
+    finally {
+        try {
+            fs_extra_1.default.removeSync(tmpRoot);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+}
+function ensureGitAvailable() {
+    const res = (0, node_child_process_1.spawnSync)('git', ['--version'], { stdio: 'ignore' });
+    if (res.status !== 0) {
+        throw new Error('未检测到 git 命令，请先安装 git 并确保其在 PATH 中');
+    }
+}
+function resolveGitHead(repoDir) {
+    const res = (0, node_child_process_1.spawnSync)('git', ['-C', repoDir, 'rev-parse', 'HEAD'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        encoding: 'utf8',
+    });
+    if (res.status !== 0)
+        return undefined;
+    return (res.stdout || '').trim() || undefined;
+}
+/**
+ * Walk srcRoot recursively and copy files to destRoot under the same relative
+ * path, subject to the directory/extension blacklist and size cap.
+ *
+ * Emits heartbeat logs via `createProgress` so the user can see forward motion
+ * even when most of the time is spent `stat`ing thousands of filtered files.
+ */
+async function walkAndCopy(srcRoot, destRoot, maxSizeKB, log) {
+    const maxBytes = Math.max(1, maxSizeKB) * 1024;
+    const stats = { files: 0, sizeKB: 0, skipped: 0 };
+    let totalBytes = 0;
+    await fs_extra_1.default.ensureDir(destRoot);
+    const progress = createProgress(log, -1, 'walk');
+    async function walk(relDir) {
+        const absDir = node_path_1.default.join(srcRoot, relDir);
+        let entries;
+        try {
+            entries = await fs_extra_1.default.readdir(absDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const name = entry.name;
+            const relPath = relDir ? node_path_1.default.join(relDir, name) : name;
+            const absPath = node_path_1.default.join(absDir, name);
+            if (entry.isDirectory()) {
+                if ((0, baseline_defaults_1.isBlacklistedDir)(name))
+                    continue;
+                await walk(relPath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            progress.tick();
+            const ext = node_path_1.default.extname(name).toLowerCase();
+            if ((0, baseline_defaults_1.isBlacklistedExt)(ext)) {
+                stats.skipped++;
+                continue;
+            }
+            let size = 0;
+            try {
+                size = (await fs_extra_1.default.stat(absPath)).size;
+            }
+            catch {
+                stats.skipped++;
+                continue;
+            }
+            if (size > maxBytes) {
+                stats.skipped++;
+                continue;
+            }
+            const destPath = node_path_1.default.join(destRoot, relPath);
+            await fs_extra_1.default.ensureDir(node_path_1.default.dirname(destPath));
+            await fs_extra_1.default.copyFile(absPath, destPath);
+            stats.files++;
+            totalBytes += size;
+        }
+    }
+    await walk('');
+    progress.finish(stats.files, stats.skipped);
+    stats.sizeKB = Math.round(totalBytes / 1024);
+    return stats;
+}
+/**
+ * Lightweight progress reporter.
+ *
+ * Emits a heartbeat every `intervalMs` milliseconds OR every `everyN`
+ * `tick()` calls, whichever comes first. `total < 0` means the total is
+ * unknown (common while walking) and the message omits the total.
+ */
+function createProgress(log, total, label, intervalMs = 1500, everyN = 500) {
+    let seen = 0;
+    let lastTs = Date.now();
+    return {
+        tick() {
+            seen++;
+            const now = Date.now();
+            if (seen % everyN === 0 || now - lastTs >= intervalMs) {
+                lastTs = now;
+                if (total > 0) {
+                    log(`  [${label}] 已处理 ${seen}/${total}`);
+                }
+                else {
+                    log(`  [${label}] 已扫描 ${seen} 个文件…`);
+                }
+            }
+        },
+        finish(files, skipped) {
+            log(`  [${label}] 完成：拷贝 ${files}，跳过 ${skipped}，共扫描 ${seen}`);
+        },
+    };
+}
+/**
+ * Read files directly from a git repo's object store via ls-tree + cat-file,
+ * bypassing the working tree so that blobs skipped by --filter are never
+ * lazy-fetched from the remote. Used only by the git-clone fallback path.
+ */
+async function copyFromGitTree(repoDir, destDir, maxSizeKB, log) {
+    const maxBytes = Math.max(1, maxSizeKB) * 1024;
+    const stats = { files: 0, sizeKB: 0, skipped: 0 };
+    let totalBytes = 0;
+    await fs_extra_1.default.ensureDir(destDir);
+    const ls = (0, node_child_process_1.spawnSync)('git', ['-C', repoDir, 'ls-tree', '-r', '-l', 'HEAD'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        encoding: 'utf8',
+        maxBuffer: 256 * 1024 * 1024,
+    });
+    if (ls.status !== 0) {
+        const stderr = (ls.stderr || '').trim();
+        throw new Error(`git ls-tree 失败 (exit=${ls.status}): ${stderr || '未知错误'}`);
+    }
+    const lines = (ls.stdout || '').split('\n');
+    const toExtract = [];
+    for (const line of lines) {
+        if (!line)
+            continue;
+        const tabIdx = line.indexOf('\t');
+        if (tabIdx < 0)
+            continue;
+        const metaPart = line.slice(0, tabIdx);
+        const relPath = line.slice(tabIdx + 1);
+        const meta = metaPart.trim().split(/\s+/);
+        if (meta.length < 4)
+            continue;
+        const [, type, sha, sizeStr] = meta;
+        if (type !== 'blob')
+            continue;
+        if ((0, baseline_defaults_1.anySegmentBlacklisted)(relPath)) {
+            stats.skipped++;
+            continue;
+        }
+        const basename = relPath.split('/').pop() ?? relPath;
+        const ext = node_path_1.default.extname(basename).toLowerCase();
+        if ((0, baseline_defaults_1.isBlacklistedExt)(ext)) {
+            stats.skipped++;
+            continue;
+        }
+        const size = Number.parseInt(sizeStr, 10);
+        if (!Number.isFinite(size) || size > maxBytes) {
+            stats.skipped++;
+            continue;
+        }
+        toExtract.push({ sha, size, relPath });
+    }
+    log(`  对象索引: 命中 ${toExtract.length} 个文件，跳过 ${stats.skipped} 个`);
+    const progress = createProgress(log, toExtract.length, 'git-tree');
+    for (const item of toExtract) {
+        progress.tick();
+        const cat = (0, node_child_process_1.spawnSync)('git', ['-C', repoDir, 'cat-file', '-p', item.sha], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            maxBuffer: maxBytes + 64 * 1024,
+        });
+        if (cat.status !== 0 || !cat.stdout) {
+            stats.skipped++;
+            continue;
+        }
+        const destPath = node_path_1.default.join(destDir, item.relPath);
+        await fs_extra_1.default.ensureDir(node_path_1.default.dirname(destPath));
+        await fs_extra_1.default.writeFile(destPath, cat.stdout);
+        stats.files++;
+        totalBytes += item.size;
+    }
+    progress.finish(stats.files, stats.skipped);
+    stats.sizeKB = Math.round(totalBytes / 1024);
+    return stats;
+}

package/dist/utils/baseline-defaults.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Baseline copy defaults.
+ *
+ * Centralises the "what to skip" rules used by baseline-copy.ts so that new
+ * host projects or new file types can be added in one place without touching
+ * the walking / cloning logic.
+ *
+ * Philosophy:
+ *   - Text / source files are ALWAYS preserved (they are the baseline).
+ *   - Binary / media / archive / IDE cache / generated-output files are the
+ *     only things we skip.
+ *   - Directory rules are strictly "name match" — they prune an entire subtree
+ *     and save us from walking millions of ignored files on Windows.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EXT_BLACKLIST = exports.DEFAULT_DIR_BLACKLIST_PATTERNS = exports.DEFAULT_DIR_BLACKLIST = void 0;
+exports.isBlacklistedDir = isBlacklistedDir;
+exports.anySegmentBlacklisted = anySegmentBlacklisted;
+exports.isBlacklistedExt = isBlacklistedExt;
+/**
+ * Directory names pruned entirely from baseline copy (case-insensitive).
+ */
+exports.DEFAULT_DIR_BLACKLIST = new Set([
+    // VCS metadata
+    '.git', '.hg', '.svn',
+    // Node
+    'node_modules',
+    // Build outputs
+    'build', '.gradle', 'dist', 'out', 'target',
+    // Android native build cache
+    '.cxx', '.externalNativeBuild',
+    // Web framework outputs
+    '.next', '.nuxt',
+    // IDE / editor state
+    '.idea', '.vscode', '.qoder', '.vhub',
+    // Python
+    '__pycache__', '.venv',
+    // Coverage & temp
+    'coverage', 'tmp', 'temp',
+    // svharnessbuild verification fixtures
+    '_tmp-verify', '_tmp-verify2',
+]);
+/**
+ * Regex directory rules (matched against directory basename, case-insensitive).
+ * Primarily used to prune previously generated harness artifacts such as
+ * `demo-harness/`, `.dsv-carsettings-harness/`, etc.
+ */
+exports.DEFAULT_DIR_BLACKLIST_PATTERNS = [
+    /-harness$/i,
+    /\.harness$/i,
+];
+/**
+ * File extensions to skip. Never contains text / source-code extensions.
+ * Keep in sync with the doc block of `copyBaseline`.
+ */
+exports.DEFAULT_EXT_BLACKLIST = new Set([
+    // Native binaries & object files
+    '.so', '.dll', '.exe', '.dylib', '.a', '.lib', '.o', '.obj', '.class',
+    // Packaged artifacts
+    '.apk', '.aar', '.jar', '.war', '.ear', '.ipa', '.app',
+    // Archives
+    '.zip', '.tar', '.gz', '.tgz', '.7z', '.rar', '.bz2', '.xz', '.iso', '.dmg',
+    // Video
+    '.mp4', '.mov', '.avi', '.mkv', '.webm', '.flv', '.wmv', '.m4v',
+    // Audio
+    '.mp3', '.wav', '.ogg', '.m4a', '.flac', '.aac',
+    // Images
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.bmp', '.svg',
+    '.tif', '.tiff', '.heic', '.avif',
+    // Fonts
+    '.ttf', '.otf', '.woff', '.woff2', '.eot',
+    // Docs / design binaries
+    '.pdf', '.psd', '.ai', '.sketch', '.fig', '.xd',
+    // Databases & binary dumps
+    '.db', '.sqlite', '.sqlite3', '.mdb', '.dat', '.bin',
+]);
+/**
+ * True if the given directory basename should be pruned from baseline copy.
+ */
+function isBlacklistedDir(name) {
+    const lower = name.toLowerCase();
+    if (exports.DEFAULT_DIR_BLACKLIST.has(lower))
+        return true;
+    return exports.DEFAULT_DIR_BLACKLIST_PATTERNS.some((re) => re.test(lower));
+}
+/**
+ * True if any segment of the given POSIX-style relative path is a blacklisted
+ * directory. Used when a file list is already flat (e.g. `git ls-files`).
+ */
+function anySegmentBlacklisted(relPosixPath) {
+    const segments = relPosixPath.split('/');
+    // Last segment is the file basename → exclude from dir check.
+    for (let i = 0; i < segments.length - 1; i++) {
+        if (isBlacklistedDir(segments[i]))
+            return true;
+    }
+    return false;
+}
+/**
+ * True if the given file extension (including leading dot, lowercase) is in
+ * the binary/media skip list.
+ */
+function isBlacklistedExt(extLower) {
+    return exports.DEFAULT_EXT_BLACKLIST.has(extLower);
+}