@dog_world/dak 0.1.0 → 0.1.1

package/dist/tests/config-state-resources.test.js

@@ -1,146 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { resolveStorePath, createDefaultConfig, writeConfigIfMissing, validateConfigStore, } from '../src/config.js';
-import { readState, writeState, } from '../src/state.js';
-import { scanResources, formatResourceList } from '../src/resources.js';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-const TMP_PREFIX = 'dak-config-';
-describe('resolveStorePath', () => {
-    it('默认 store 解析为 <home>/.dog-agents-kit', () => {
-        const result = resolveStorePath(undefined, '/home/test');
-        expect(result).toBe('/home/test/.dog-agents-kit');
-    });
-    it('--store ~/custom-store 展开 home', () => {
-        const result = resolveStorePath('~/custom-store', '/home/test');
-        expect(result).toBe('/home/test/custom-store');
-    });
-    it('绝对路径直接返回', () => {
-        const result = resolveStorePath('/abs/store', '/home/test');
-        expect(result).toBe('/abs/store');
-    });
-});
-describe('createDefaultConfig', () => {
-    it('写入绝对 store path', () => {
-        const config = createDefaultConfig('/abs/store', '/home/test');
-        expect(config.store).toBe('/abs/store');
-        expect(config.targets['codex'].path).toBe('/home/test/.codex');
-        expect(config.targets['claude-code'].path).toBe('/home/test/.claude');
-    });
-});
-describe('writeConfigIfMissing', () => {
-    let tmp;
-    beforeEach(() => {
-        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
-    });
-    afterEach(() => {
-        rmSync(tmp, { recursive: true });
-    });
-    it('store 不存在时创建 config', async () => {
-        const storePath = join(tmp, 'store');
-        const config = createDefaultConfig(storePath, '/home/test');
-        await writeConfigIfMissing(storePath, config);
-        const content = readFileSync(join(storePath, 'dak.config.json'), 'utf-8');
-        expect(JSON.parse(content).store).toBe(storePath);
-    });
-    it('已存在 dak.config.json 时不覆盖', async () => {
-        const storePath = join(tmp, 'store');
-        mkdirSync(storePath);
-        writeFileSync(join(storePath, 'dak.config.json'), '{"store":"custom"}');
-        const config = createDefaultConfig(storePath, '/home/test');
-        await writeConfigIfMissing(storePath, config);
-        const content = readFileSync(join(storePath, 'dak.config.json'), 'utf-8');
-        expect(JSON.parse(content).store).toBe('custom');
-    });
-});
-describe('validateConfigStore', () => {
-    it('config.store 和当前 store 不一致时报错', () => {
-        const config = { store: '/abs/store', targets: {} };
-        expect(() => validateConfigStore(config, '/other/store')).toThrow('config store mismatch');
-    });
-});
-describe('scanResources', () => {
-    let tmp;
-    beforeEach(() => {
-        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
-    });
-    afterEach(() => {
-        rmSync(tmp, { recursive: true });
-    });
-    it('只扫一级子项', async () => {
-        const storePath = join(tmp, 'store');
-        mkdirSync(join(storePath, 'skills', 'nested'), { recursive: true });
-        writeFileSync(join(storePath, 'skills', 'top-skill'), 'x');
-        writeFileSync(join(storePath, 'skills', 'nested', 'deep'), 'x');
-        const config = createDefaultConfig(storePath, '/home/test');
-        const resources = await scanResources(storePath, config);
-        // 一级子项应包含 top-skill（文件）和 nested（目录），但不含 nested/deep
-        const names = resources.skills.map(i => i.name).sort();
-        expect(names).toEqual(['nested', 'top-skill']);
-        expect(resources.skills.find(i => i.name === 'nested')?.kind).toBe('directory');
-    });
-    it('hidden item 跳过', async () => {
-        const storePath = join(tmp, 'store');
-        mkdirSync(join(storePath, 'skills'), { recursive: true });
-        writeFileSync(join(storePath, 'skills', '.hidden'), 'x');
-        writeFileSync(join(storePath, 'skills', 'visible'), 'x');
-        const config = createDefaultConfig(storePath, '/home/test');
-        const resources = await scanResources(storePath, config);
-        expect(resources.skills.map(i => i.name)).toEqual(['visible']);
-    });
-    it('文件、目录、symlink 都算 item', async () => {
-        const storePath = join(tmp, 'store');
-        mkdirSync(join(storePath, 'skills'), { recursive: true });
-        writeFileSync(join(storePath, 'skills', 'file-skill'), 'x');
-        mkdirSync(join(storePath, 'skills', 'dir-skill'));
-        const linkTarget = join(tmp, 'real-target');
-        writeFileSync(linkTarget, 'x');
-        // symlink via fs.symlinkSync
-        const { symlinkSync } = await import('node:fs');
-        symlinkSync(linkTarget, join(storePath, 'skills', 'link-skill'));
-        const config = createDefaultConfig(storePath, '/home/test');
-        const resources = await scanResources(storePath, config);
-        const names = resources.skills.map(i => i.name).sort();
-        expect(names).toEqual(['dir-skill', 'file-skill', 'link-skill']);
-    });
-    it('formatResourceList 输出固定标题行', async () => {
-        const resources = {
-            skills: [{ name: 'foo', kind: 'file', path: '/s/foo' }],
-            hooks: [],
-            agents: [],
-        };
-        const output = formatResourceList(resources);
-        expect(output).toContain('Skills:');
-        expect(output).toContain('Hooks:');
-        expect(output).toContain('Agents:');
-        expect(output).toContain('foo');
-    });
-});
-describe('readState / writeState', () => {
-    let tmp;
-    beforeEach(() => {
-        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
-    });
-    afterEach(() => {
-        rmSync(tmp, { recursive: true });
-    });
-    it('缺文件时返回空状态', async () => {
-        const state = await readState(join(tmp, 'no-store'));
-        expect(state.version).toBe(1);
-        expect(state.targets).toEqual({});
-    });
-    it('只接受 version: 1', async () => {
-        const storePath = join(tmp, 'store');
-        mkdirSync(storePath);
-        writeFileSync(join(storePath, '.dak-state.json'), '{"version":2,"targets":{}}');
-        await expect(readState(storePath)).rejects.toThrow('unsupported state version');
-    });
-    it('写状态后可读回', async () => {
-        const storePath = join(tmp, 'store');
-        mkdirSync(storePath);
-        const state = { version: 1, targets: {} };
-        await writeState(storePath, state);
-        const read = await readState(storePath);
-        expect(read).toEqual(state);
-    });
-});

package/dist/tests/e2e.test.js

@@ -1,74 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { execFileSync } from 'node:child_process';
-import { mkdirSync, rmSync, writeFileSync, readFileSync, mkdtempSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-const DAK_CLI = join(process.cwd(), 'dist', 'cli.js');
-const TMP_PREFIX = 'dak-e2e-';
-function tmpRoot() {
-    return mkdtempSync(join(tmpdir(), TMP_PREFIX));
-}
-describe('dak e2e', () => {
-    let root;
-    let home;
-    let store;
-    beforeAll(() => {
-        root = tmpRoot();
-        home = join(root, 'home');
-        store = join(root, 'dak-store');
-        mkdirSync(store, { recursive: true });
-    });
-    afterAll(() => {
-        rmSync(root, { recursive: true, force: true });
-    });
-    function exec(args) {
-        return execFileSync(process.execPath, [DAK_CLI, ...args], {
-            env: { ...process.env, HOME: home },
-            encoding: 'utf-8',
-        });
-    }
-    it('init --store', () => {
-        const out = exec(['init', '--store', store]);
-        expect(out).toContain('Initialized');
-        expect(exec(['list', '--store', store])).toContain('Skills:');
-    });
-    it('写入 skills/foo 后 link codex', () => {
-        writeFileSync(join(store, 'skills', 'foo'), 'hello');
-        const out = exec(['link', 'codex', '--store', store, '--on-conflict', 'skip']);
-        expect(out).toContain('created');
-        const linkPath = join(home, '.codex', 'skills', 'foo');
-        expect(execFileSync('readlink', [linkPath], { encoding: 'utf-8' }).trim()).toBe(join(store, 'skills', 'foo'));
-    });
-    it('删除 foo 新增 bar 后 update', () => {
-        rmSync(join(store, 'skills', 'foo'));
-        writeFileSync(join(store, 'skills', 'bar'), 'world');
-        const out = exec(['update', '--store', store]);
-        expect(out).toContain('deleted');
-        expect(out).toContain('created');
-        // bar 已链接
-        const linkPath = join(home, '.codex', 'skills', 'bar');
-        expect(readFileSync(linkPath, 'utf-8')).toBe('world');
-    });
-    it('unlink codex', () => {
-        const out = exec(['unlink', 'codex', '--store', store]);
-        expect(out).toContain('deleted');
-        // 源文件仍在
-        expect(readFileSync(join(store, 'skills', 'bar'), 'utf-8')).toBe('world');
-    });
-    it('--on-conflict backup', () => {
-        // 先创建真实文件
-        mkdirSync(join(home, '.codex', 'skills'), { recursive: true });
-        writeFileSync(join(home, '.codex', 'skills', 'foo'), 'real-file');
-        writeFileSync(join(store, 'skills', 'foo'), 'store-file');
-        const out = exec(['link', 'codex', '--store', store, '--on-conflict', 'backup']);
-        expect(out).toContain('backed-up');
-    });
-    it('非交互环境未传 --on-conflict 且目标已有真实文件，默认 skip', () => {
-        writeFileSync(join(home, '.codex', 'skills', 'baz'), 'existing');
-        writeFileSync(join(store, 'skills', 'baz'), 'new');
-        const out = exec(['link', 'codex', '--store', store]);
-        expect(out).toContain('conflict');
-        // 真实文件未被覆盖
-        expect(readFileSync(join(home, '.codex', 'skills', 'baz'), 'utf-8')).toBe('existing');
-    });
-});

package/dist/tests/linker.test.js

@@ -1,234 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { classifyTarget, linkItem, safeDeleteManagedLink } from '../src/linker.js';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, symlinkSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-const TMP_PREFIX = 'dak-linker-';
-function makeStore(tmp) {
-    const store = join(tmp, 'store');
-    mkdirSync(join(store, 'skills'), { recursive: true });
-    mkdirSync(join(store, 'hooks'), { recursive: true });
-    mkdirSync(join(store, 'agents'), { recursive: true });
-    return store;
-}
-function makeTarget(tmp, name) {
-    const target = join(tmp, name);
-    mkdirSync(target, { recursive: true });
-    return target;
-}
-describe('classifyTarget', () => {
-    let tmp;
-    beforeEach(() => {
-        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
-    });
-    afterEach(() => {
-        rmSync(tmp, { recursive: true });
-    });
-    it('missing 当 target 不存在', async () => {
-        const result = await classifyTarget(join(tmp, 'no-such-dir', 'item'), '/abs/source');
-        expect(result).toBe('missing');
-    });
-    it('linked 当 symlink 指向 expected source', async () => {
-        const source = join(tmp, 'store', 'skills', 'foo');
-        mkdirSync(join(tmp, 'store', 'skills'), { recursive: true });
-        writeFileSync(source, 'x');
-        const targetDir = join(tmp, 'codex', 'skills');
-        mkdirSync(targetDir, { recursive: true });
-        const targetPath = join(targetDir, 'foo');
-        symlinkSync(source, targetPath);
-        const result = await classifyTarget(targetPath, source);
-        expect(result).toBe('linked');
-    });
-    it('conflict 当 target 是真实文件', async () => {
-        const targetPath = join(tmp, 'real-file');
-        writeFileSync(targetPath, 'x');
-        const result = await classifyTarget(targetPath, '/abs/source');
-        expect(result).toBe('conflict');
-    });
-    it('broken 当 symlink 指向不存在目标', async () => {
-        const targetPath = join(tmp, 'broken-link');
-        symlinkSync('/no/such/target', targetPath);
-        const result = await classifyTarget(targetPath, '/abs/source');
-        expect(result).toBe('broken');
-    });
-});
-describe('linkItem', () => {
-    let tmp;
-    let store;
-    let targetRoot;
-    beforeEach(() => {
-        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
-        store = makeStore(tmp);
-        targetRoot = makeTarget(tmp, 'codex');
-        mkdirSync(join(targetRoot, 'skills'), { recursive: true });
-        writeFileSync(join(store, 'skills', 'foo'), 'x');
-    });
-    afterEach(() => {
-        rmSync(tmp, { recursive: true });
-    });
-    const now = new Date('2025-01-01T00:00:00.000Z');
-    it('missing 时创建 symlink', async () => {
-        const outcome = await linkItem({
-            sourcePath: join(store, 'skills', 'foo'),
-            targetPath: join(targetRoot, 'skills', 'foo'),
-            resourceType: 'skills',
-            itemName: 'foo',
-            storePath: store,
-            policy: 'skip',
-            now,
-        });
-        expect(outcome.status).toBe('created');
-        expect(readFileSync(join(targetRoot, 'skills', 'foo'), 'utf-8')).toBe('x');
-    });
-    it('linked 时直接返回', async () => {
-        const targetPath = join(targetRoot, 'skills', 'foo');
-        symlinkSync(join(store, 'skills', 'foo'), targetPath);
-        const outcome = await linkItem({
-            sourcePath: join(store, 'skills', 'foo'),
-            targetPath,
-            resourceType: 'skills',
-            itemName: 'foo',
-            storePath: store,
-            policy: 'skip',
-            now,
-        });
-        expect(outcome.status).toBe('linked');
-    });
-    it('conflict 时 skip 返回 conflict', async () => {
-        writeFileSync(join(targetRoot, 'skills', 'foo'), 'old');
-        const outcome = await linkItem({
-            sourcePath: join(store, 'skills', 'foo'),
-            targetPath: join(targetRoot, 'skills', 'foo'),
-            resourceType: 'skills',
-            itemName: 'foo',
-            storePath: store,
-            policy: 'skip',
-            now,
-        });
-        expect(outcome.status).toBe('conflict');
-        expect(readFileSync(join(targetRoot, 'skills', 'foo'), 'utf-8')).toBe('old');
-    });
-    it('backup 移动旧内容后创建 symlink', async () => {
-        writeFileSync(join(targetRoot, 'skills', 'foo'), 'old');
-        const outcome = await linkItem({
-            sourcePath: join(store, 'skills', 'foo'),
-            targetPath: join(targetRoot, 'skills', 'foo'),
-            resourceType: 'skills',
-            itemName: 'foo',
-            storePath: store,
-            policy: 'backup',
-            now,
-        });
-        expect(outcome.status).toBe('backed-up');
-        // symlink 已创建
-        const stat = await import('node:fs/promises').then(m => m.stat(join(targetRoot, 'skills', 'foo')));
-        expect(stat).toBeDefined();
-        // 备份存在
-        const ts = now.toISOString().replace(/[:.]/g, '-');
-        const backupPath = join(targetRoot, '.dak-backup', ts, 'skills', 'foo');
-        expect(readFileSync(backupPath, 'utf-8')).toBe('old');
-    });
-    it('overwrite 删除旧内容后创建 symlink', async () => {
-        writeFileSync(join(targetRoot, 'skills', 'foo'), 'old');
-        const outcome = await linkItem({
-            sourcePath: join(store, 'skills', 'foo'),
-            targetPath: join(targetRoot, 'skills', 'foo'),
-            resourceType: 'skills',
-            itemName: 'foo',
-            storePath: store,
-            policy: 'overwrite',
-            now,
-        });
-        expect(outcome.status).toBe('overwritten');
-        expect(readFileSync(join(targetRoot, 'skills', 'foo'), 'utf-8')).toBe('x');
-    });
-    it('broken symlink 视为 conflict；overwrite 可替换', async () => {
-        const targetPath = join(targetRoot, 'skills', 'foo');
-        symlinkSync('/no/target', targetPath);
-        const outcome = await linkItem({
-            sourcePath: join(store, 'skills', 'foo'),
-            targetPath,
-            resourceType: 'skills',
-            itemName: 'foo',
-            storePath: store,
-            policy: 'overwrite',
-            now,
-        });
-        expect(outcome.status).toBe('overwritten');
-        expect(readFileSync(targetPath, 'utf-8')).toBe('x');
-    });
-});
-describe('safeDeleteManagedLink', () => {
-    let tmp;
-    let store;
-    beforeEach(() => {
-        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
-        store = makeStore(tmp);
-    });
-    afterEach(() => {
-        rmSync(tmp, { recursive: true });
-    });
-    it('删除正确的 symlink 返回 deleted', async () => {
-        const source = join(store, 'skills', 'foo');
-        writeFileSync(source, 'x');
-        const targetDir = join(tmp, 'codex', 'skills');
-        mkdirSync(targetDir, { recursive: true });
-        const targetPath = join(targetDir, 'foo');
-        symlinkSync(source, targetPath);
-        const record = { source, target: targetPath, linkedAt: new Date().toISOString() };
-        const result = await safeDeleteManagedLink(record, store);
-        expect(result).toBe('deleted');
-    });
-    it('target 不存在返回 missing', async () => {
-        const record = {
-            source: join(store, 'skills', 'foo'),
-            target: join(tmp, 'codex', 'skills', 'foo'),
-            linkedAt: new Date().toISOString(),
-        };
-        const result = await safeDeleteManagedLink(record, store);
-        expect(result).toBe('missing');
-    });
-    it('真实文件不删除，返回 conflict', async () => {
-        const targetDir = join(tmp, 'codex', 'skills');
-        mkdirSync(targetDir, { recursive: true });
-        const targetPath = join(targetDir, 'foo');
-        writeFileSync(targetPath, 'x');
-        const record = {
-            source: join(store, 'skills', 'foo'),
-            target: targetPath,
-            linkedAt: new Date().toISOString(),
-        };
-        const result = await safeDeleteManagedLink(record, store);
-        expect(result).toBe('conflict');
-        expect(require('node:fs').existsSync(targetPath)).toBe(true);
-    });
-    it('指向其他 store 的 symlink 不删除，返回 conflict', async () => {
-        const otherStore = join(tmp, 'other-store');
-        mkdirSync(join(otherStore, 'skills'), { recursive: true });
-        const source = join(otherStore, 'skills', 'foo');
-        writeFileSync(source, 'x');
-        const targetDir = join(tmp, 'codex', 'skills');
-        mkdirSync(targetDir, { recursive: true });
-        const targetPath = join(targetDir, 'foo');
-        symlinkSync(source, targetPath);
-        const record = { source, target: targetPath, linkedAt: new Date().toISOString() };
-        const result = await safeDeleteManagedLink(record, store);
-        expect(result).toBe('conflict');
-    });
-    it('symlink 改指向同一 store 另一个 item，返回 conflict', async () => {
-        const source1 = join(store, 'skills', 'foo');
-        const source2 = join(store, 'skills', 'bar');
-        writeFileSync(source1, 'x');
-        writeFileSync(source2, 'x');
-        const targetDir = join(tmp, 'codex', 'skills');
-        mkdirSync(targetDir, { recursive: true });
-        const targetPath = join(targetDir, 'foo');
-        symlinkSync(source1, targetPath);
-        // 用户改成指向 bar
-        rmSync(targetPath);
-        symlinkSync(source2, targetPath);
-        const record = { source: source1, target: targetPath, linkedAt: new Date().toISOString() };
-        const result = await safeDeleteManagedLink(record, store);
-        expect(result).toBe('conflict');
-    });
-});

package/dist/tests/paths.test.js

@@ -1,120 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { expandHome, toAbsolutePath, isHiddenItem, assertSafeItemName, isPathInside, realComparablePath, resolveLinkTarget, realParentJoined, } from '../src/paths.js';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-describe('expandHome', () => {
-    it('展开 ~ 为指定 home', () => {
-        expect(expandHome('~/foo', '/home/test')).toBe('/home/test/foo');
-    });
-    it('~ 本身展开为 home', () => {
-        expect(expandHome('~', '/home/test')).toBe('/home/test');
-    });
-    it('非 ~ 路径原样返回', () => {
-        expect(expandHome('/abs/path', '/home/test')).toBe('/abs/path');
-    });
-});
-describe('toAbsolutePath', () => {
-    it('相对路径按 baseDir 解析', () => {
-        expect(toAbsolutePath('foo/bar', '/base', '/home')).toBe('/base/foo/bar');
-    });
-    it('~ 路径展开后解析', () => {
-        expect(toAbsolutePath('~/.config', '/base', '/home')).toBe('/home/.config');
-    });
-    it('绝对路径 resolve', () => {
-        expect(toAbsolutePath('/foo/../bar', '/base', '/home')).toBe('/bar');
-    });
-});
-describe('isHiddenItem', () => {
-    it('.hidden 返回 true', () => {
-        expect(isHiddenItem('.hidden')).toBe(true);
-    });
-    it('.foo 返回 true', () => {
-        expect(isHiddenItem('.foo')).toBe(true);
-    });
-    it('foo 返回 false', () => {
-        expect(isHiddenItem('foo')).toBe(false);
-    });
-});
-describe('assertSafeItemName', () => {
-    it('隐藏项抛出', () => {
-        expect(() => assertSafeItemName('.hidden')).toThrow('Hidden resource items are ignored');
-    });
-    it('斜杠抛出', () => {
-        expect(() => assertSafeItemName('group/foo')).toThrow('Invalid resource item name');
-    });
-    it('反斜杠抛出', () => {
-        expect(() => assertSafeItemName('group\\foo')).toThrow('Invalid resource item name');
-    });
-    it('. 单独抛出', () => {
-        expect(() => assertSafeItemName('.')).toThrow('Invalid resource item name');
-    });
-    it('.. 抛出', () => {
-        expect(() => assertSafeItemName('..')).toThrow('Invalid resource item name');
-    });
-    it('合法名称不抛', () => {
-        expect(() => assertSafeItemName('foo')).not.toThrow();
-    });
-});
-describe('isPathInside', () => {
-    it('/tmp/store 内路径返回 true', () => {
-        expect(isPathInside('/tmp/store/a', '/tmp/store')).toBe(true);
-    });
-    it('/tmp/store-other 不被 /tmp/store 骗过', () => {
-        expect(isPathInside('/tmp/store-other/a', '/tmp/store')).toBe(false);
-    });
-    it('/tmp/store 自身返回 true', () => {
-        expect(isPathInside('/tmp/store', '/tmp/store')).toBe(true);
-    });
-    it('/tmp/store 深层返回 true', () => {
-        expect(isPathInside('/tmp/store/a/b/c', '/tmp/store')).toBe(true);
-    });
-    it('/tmp/other 返回 false', () => {
-        expect(isPathInside('/tmp/other', '/tmp/store')).toBe(false);
-    });
-});
-describe('realComparablePath', () => {
-    it('真实路径文件返回 resolved path', async () => {
-        const tmp = mkdtempSync(join(tmpdir(), 'dak-paths-'));
-        const f = join(tmp, 'file.txt');
-        writeFileSync(f, 'x');
-        const result = await realComparablePath(f);
-        expect(result).toBe(f);
-        rmSync(tmp, { recursive: true });
-    });
-});
-describe('resolveLinkTarget', () => {
-    it('绝对 target 直接 resolve', async () => {
-        const result = await resolveLinkTarget('/tmp/link', '/abs/target');
-        expect(result).toBe('/abs/target');
-    });
-    it('相对 target 按 link parent 解析', async () => {
-        const tmp = mkdtempSync(join(tmpdir(), 'dak-paths-'));
-        const linkPath = join(tmp, 'sub', 'link');
-        const sourcePath = join(tmp, 'src');
-        mkdirSync(join(tmp, 'sub'), { recursive: true });
-        mkdirSync(sourcePath, { recursive: true });
-        writeFileSync(join(sourcePath, 'item'), 'x');
-        const result = await resolveLinkTarget(linkPath, '../src/item');
-        expect(result).toBe(join(sourcePath, 'item'));
-        rmSync(tmp, { recursive: true });
-    });
-});
-describe('realParentJoined', () => {
-    it('父目录存在时用真实路径拼接', async () => {
-        const tmp = mkdtempSync(join(tmpdir(), 'dak-paths-'));
-        const dir = join(tmp, 'real-dir');
-        mkdirSync(dir);
-        const result = await realParentJoined(join(dir, 'child'));
-        expect(result).toBe(join(dir, 'child'));
-        rmSync(tmp, { recursive: true });
-    });
-    it('父目录不存在时向上找祖先', async () => {
-        const tmp = mkdtempSync(join(tmpdir(), 'dak-paths-'));
-        const existing = join(tmp, 'existing');
-        mkdirSync(existing);
-        const result = await realParentJoined(join(existing, 'missing', 'child'));
-        expect(result).toBe(join(existing, 'missing', 'child'));
-        rmSync(tmp, { recursive: true });
-    });
-});