@dog_world/dak 0.1.0

package/dist/src/resources.js

@@ -0,0 +1,86 @@
+/** 资源扫描与格式化 */
+import { readdir, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { RESOURCE_TYPES } from './types.js';
+import { assertSafeItemName, isHiddenItem } from './paths.js';
+/**
+ * 确保 store 目录和三类资源目录存在。
+ */
+export async function ensureStoreLayout(storePath, _config) {
+    await mkdir(storePath, { recursive: true });
+    for (const type of RESOURCE_TYPES) {
+        await mkdir(join(storePath, type), { recursive: true });
+    }
+}
+/**
+ * 扫描 store 中的资源目录（一级子项）。
+ */
+export async function scanResources(storePath, _config) {
+    const result = {
+        skills: [],
+        hooks: [],
+        agents: [],
+    };
+    for (const type of RESOURCE_TYPES) {
+        const dir = join(storePath, type);
+        if (!existsSync(dir))
+            continue;
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            const items = [];
+            for (const entry of entries) {
+                const name = entry.name;
+                if (isHiddenItem(name))
+                    continue;
+                try {
+                    assertSafeItemName(name);
+                }
+                catch {
+                    continue;
+                }
+                const fullPath = join(dir, name);
+                let kind;
+                if (entry.isSymbolicLink())
+                    kind = 'symlink';
+                else if (entry.isDirectory())
+                    kind = 'directory';
+                else
+                    kind = 'file';
+                items.push({ name, kind, path: fullPath });
+            }
+            items.sort((a, b) => a.name.localeCompare(b.name));
+            result[type] = items;
+        }
+        catch {
+            // ignore unreadable dir
+        }
+    }
+    return result;
+}
+/**
+ * 格式化资源列表输出（供 `dak list` 使用）。
+ * 输出稳定，支持 snapshot 测试。
+ */
+export function formatResourceList(resources) {
+    const lines = [];
+    const labels = {
+        skills: 'Skills:',
+        hooks: 'Hooks:',
+        agents: 'Agents:',
+    };
+    for (const type of RESOURCE_TYPES) {
+        lines.push(labels[type]);
+        const items = resources[type];
+        if (items.length === 0) {
+            lines.push('  (empty)');
+        }
+        else {
+            for (const item of items) {
+                const kind = item.kind === 'directory' ? ' [dir]' : item.kind === 'symlink' ? ' [link]' : '';
+                lines.push(`  ${item.name}${kind}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}

package/dist/src/state.js

@@ -0,0 +1,83 @@
+/** 状态读写 */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { STATE_FILE } from './constants.js';
+/** 空状态 */
+const EMPTY_STATE = { version: 1, targets: {} };
+/**
+ * 读取状态文件，不存在时返回空状态。
+ */
+export async function readState(storePath) {
+    const statePath = join(storePath, STATE_FILE);
+    if (!existsSync(statePath))
+        return EMPTY_STATE;
+    const raw = await readFile(statePath, 'utf-8');
+    const state = JSON.parse(raw);
+    if (state.version !== 1) {
+        throw new Error(`unsupported state version: ${state.version}`);
+    }
+    return state;
+}
+/**
+ * 写入状态文件。
+ */
+export async function writeState(storePath, state) {
+    const statePath = join(storePath, STATE_FILE);
+    await mkdir(storePath, { recursive: true });
+    await writeFile(statePath, JSON.stringify(state, null, 2), 'utf-8');
+}
+/**
+ * 确保状态文件存在（不存在则创建空状态）。
+ */
+export async function writeStateIfMissing(storePath) {
+    const statePath = join(storePath, STATE_FILE);
+    if (existsSync(statePath))
+        return;
+    await writeState(storePath, EMPTY_STATE);
+}
+/**
+ * 确保目标 state 存在（skills/hooks/agents 三个 map）。
+ */
+export function ensureTargetState(state, targetName) {
+    if (!state.targets[targetName]) {
+        state.targets[targetName] = {
+            skills: {},
+            hooks: {},
+            agents: {},
+        };
+    }
+    return state;
+}
+/**
+ * 替换某个 target/resource 的所有 records。
+ */
+export function replaceTargetResourceState(state, targetName, resourceType, records) {
+    ensureTargetState(state, targetName);
+    state.targets[targetName][resourceType] = records;
+    return state;
+}
+/**
+ * 新增或更新单条 record。
+ */
+export function upsertLinkRecord(state, targetName, resourceType, itemName, record) {
+    ensureTargetState(state, targetName);
+    state.targets[targetName][resourceType][itemName] = record;
+    return state;
+}
+/**
+ * 删除单条 record，返回是否删除成功（存在才删）。
+ */
+export function removeLinkRecord(state, targetName, resourceType, itemName) {
+    if (state.targets[targetName]?.[resourceType]) {
+        delete state.targets[targetName][resourceType][itemName];
+    }
+    return state;
+}
+/**
+ * 从 state 中移除整个 target 的 state。
+ */
+export function removeTargetState(state, targetName) {
+    delete state.targets[targetName];
+    return state;
+}

package/dist/src/types.js

@@ -0,0 +1,5 @@
+/** dak 核心类型定义 */
+/** 支持管理的资源类型 */
+export const RESOURCE_TYPES = ['skills', 'hooks', 'agents'];
+/** 冲突处理策略 */
+export const CONFLICT_POLICIES = ['skip', 'backup', 'overwrite'];

package/dist/state.js

@@ -0,0 +1,99 @@
+/** 状态读写 */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { STATE_FILE } from './constants.js';
+import { declaredResourceTypes } from './config.js';
+/** 空状态 */
+const EMPTY_STATE = { version: 1, targets: {} };
+/**
+ * 读取状态文件，不存在时返回空状态。
+ */
+export async function readState(storePath) {
+    const statePath = join(storePath, STATE_FILE);
+    if (!existsSync(statePath))
+        return EMPTY_STATE;
+    const raw = await readFile(statePath, 'utf-8');
+    const state = JSON.parse(raw);
+    if (state.version !== 1) {
+        throw new Error(`unsupported state version: ${state.version}`);
+    }
+    return state;
+}
+/**
+ * 写入状态文件。
+ */
+export async function writeState(storePath, state) {
+    const statePath = join(storePath, STATE_FILE);
+    await mkdir(storePath, { recursive: true });
+    await writeFile(statePath, JSON.stringify(state, null, 2), 'utf-8');
+}
+/**
+ * 确保状态文件存在（不存在则创建空状态）。
+ */
+export async function writeStateIfMissing(storePath) {
+    const statePath = join(storePath, STATE_FILE);
+    if (existsSync(statePath))
+        return;
+    await writeState(storePath, EMPTY_STATE);
+}
+/**
+ * 确保目标 state 存在，并补齐声明的各资源类型 map。
+ * 旧 state 缺失新声明的类型时补空 map；不删除已有 key。
+ */
+export function ensureTargetState(state, targetName, config) {
+    if (!state.targets[targetName]) {
+        state.targets[targetName] = {};
+    }
+    const targetState = state.targets[targetName];
+    for (const type of declaredResourceTypes(config)) {
+        if (!targetState[type]) {
+            targetState[type] = {};
+        }
+    }
+    return state;
+}
+/**
+ * 确保 target 容器与指定资源类型的 map 存在（惰性创建）。
+ */
+function ensureResourceMap(state, targetName, resourceType) {
+    if (!state.targets[targetName]) {
+        state.targets[targetName] = {};
+    }
+    if (!state.targets[targetName][resourceType]) {
+        state.targets[targetName][resourceType] = {};
+    }
+    return state;
+}
+/**
+ * 替换某个 target/resource 的所有 records。
+ */
+export function replaceTargetResourceState(state, targetName, resourceType, records) {
+    ensureResourceMap(state, targetName, resourceType);
+    state.targets[targetName][resourceType] = records;
+    return state;
+}
+/**
+ * 新增或更新单条 record。
+ */
+export function upsertLinkRecord(state, targetName, resourceType, itemName, record) {
+    ensureResourceMap(state, targetName, resourceType);
+    state.targets[targetName][resourceType][itemName] = record;
+    return state;
+}
+/**
+ * 删除单条 record，返回是否删除成功（存在才删）。
+ */
+export function removeLinkRecord(state, targetName, resourceType, itemName) {
+    if (state.targets[targetName]?.[resourceType]) {
+        delete state.targets[targetName][resourceType][itemName];
+    }
+    return state;
+}
+/**
+ * 从 state 中移除整个 target 的 state。
+ */
+export function removeTargetState(state, targetName) {
+    delete state.targets[targetName];
+    return state;
+}

package/dist/tests/cli.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { parseArgv, main } from '../src/cli.js';
+describe('parseArgv', () => {
+    it('link codex --store /tmp/store --on-conflict backup', () => {
+        const result = parseArgv(['link', 'codex', '--store', '/tmp/store', '--on-conflict', 'backup']);
+        expect(result.command).toBe('link');
+        expect(result.target).toBe('codex');
+        expect(result.store).toBe('/tmp/store');
+        expect(result.onConflict).toBe('backup');
+    });
+    it('非法 conflict policy 报错', () => {
+        expect(() => parseArgv(['link', 'codex', '--on-conflict', 'invalid']))
+            .toThrow('Invalid conflict policy');
+    });
+    it('status 无 target', () => {
+        const result = parseArgv(['status', '--store', '/tmp/store']);
+        expect(result.command).toBe('status');
+        expect(result.target).toBeUndefined();
+    });
+    it('link 缺 target 报错', () => {
+        expect(() => parseArgv(['link']))
+            .toThrow('target is required');
+    });
+    it('unlink 缺 target 报错', () => {
+        expect(() => parseArgv(['unlink']))
+            .toThrow('target is required');
+    });
+});
+describe('main', () => {
+    it('未知命令报错', async () => {
+        const code = await main(['unknown']);
+        expect(code).toBe(1);
+    });
+    it('link 缺 target 返回 1', async () => {
+        const code = await main(['link']);
+        expect(code).toBe(1);
+    });
+});

package/dist/tests/commands.test.js

@@ -0,0 +1,218 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { runInit, runList, runLink, runStatus, runUpdate, runUnlink, } from '../src/commands.js';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+const TMP_PREFIX = 'dak-cmd-';
+const FIXED_NOW = new Date('2025-06-28T10:00:00.000Z');
+function makeStore(tmp) {
+    const store = join(tmp, 'store');
+    mkdirSync(store, { recursive: true });
+    return store;
+}
+function makeTarget(tmp, name) {
+    const target = join(tmp, name);
+    mkdirSync(target, { recursive: true });
+    return target;
+}
+function makeHome(tmp) {
+    const home = join(tmp, 'home');
+    mkdirSync(join(home, '.codex'), { recursive: true });
+    mkdirSync(join(home, '.claude'), { recursive: true });
+    return home;
+}
+describe('runInit', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
+    });
+    afterEach(() => {
+        rmSync(tmp, { recursive: true });
+    });
+    it('创建 store/config/state/resource dirs', async () => {
+        const storePath = join(tmp, 'init-store');
+        const output = await runInit({ store: storePath, homeDir: '/tmp/home' });
+        expect(output).toContain('Initialized');
+        // config 存在
+        const config = JSON.parse(readFileSync(join(storePath, 'dak.config.json'), 'utf-8'));
+        expect(config.store).toBe(storePath);
+        // state 存在
+        const state = JSON.parse(readFileSync(join(storePath, '.dak-state.json'), 'utf-8'));
+        expect(state.version).toBe(1);
+        // resource dirs 存在
+        for (const type of ['skills', 'hooks', 'agents']) {
+            expect(require('node:fs').existsSync(join(storePath, type))).toBe(true);
+        }
+    });
+});
+describe('runList', () => {
+    let tmp;
+    let store;
+    let home;
+    beforeEach(async () => {
+        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
+        store = makeStore(tmp);
+        home = makeHome(tmp);
+        await runInit({ store, homeDir: home });
+        mkdirSync(join(store, 'skills'), { recursive: true });
+        mkdirSync(join(store, 'skills', 'my-skill'));
+        mkdirSync(join(store, 'hooks'), { recursive: true });
+        mkdirSync(join(store, 'hooks', 'my-hook'));
+        mkdirSync(join(store, 'agents'), { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(tmp, { recursive: true });
+    });
+    it('输出三类资源', async () => {
+        const output = await runList({ store, homeDir: home });
+        expect(output).toContain('Skills:');
+        expect(output).toContain('Hooks:');
+        expect(output).toContain('Agents:');
+        expect(output).toContain('my-skill');
+        expect(output).toContain('my-hook');
+    });
+});
+describe('runLink', () => {
+    let tmp;
+    let store;
+    let home;
+    let codex;
+    beforeEach(async () => {
+        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
+        store = makeStore(tmp);
+        home = makeHome(tmp);
+        codex = join(home, '.codex'); // 使用 home 下的 .codex
+        mkdirSync(join(codex, 'skills'), { recursive: true });
+        mkdirSync(join(codex, 'agents'), { recursive: true });
+        // 初始化 config（使用真实存在的 homeDir）
+        await runInit({ store, homeDir: home });
+        // 写入 store 资源
+        writeFileSync(join(store, 'skills', 'foo'), 'x');
+        mkdirSync(join(store, 'hooks', 'my-hook'));
+        writeFileSync(join(store, 'agents', 'bar'), 'x');
+    });
+    afterEach(() => {
+        rmSync(tmp, { recursive: true });
+    });
+    it('runLink(codex) 为三类资源创建 symlink 并写 state', async () => {
+        const output = await runLink('codex', { store, homeDir: home, now: FIXED_NOW });
+        expect(output).toContain('created');
+        // symlink 已创建
+        expect(readFileSync(join(codex, 'skills', 'foo'), 'utf-8')).toBe('x');
+        expect(readFileSync(join(codex, 'agents', 'bar'), 'utf-8')).toBe('x');
+        // state 存在
+        const state = JSON.parse(readFileSync(join(store, '.dak-state.json'), 'utf-8'));
+        expect(state.targets['codex'].skills['foo']).toBeDefined();
+    });
+    it('runLink(all) 支持配置里的所有 targets', async () => {
+        const claude = join(home, '.claude');
+        mkdirSync(join(claude, 'skills'), { recursive: true });
+        mkdirSync(join(claude, 'agents'), { recursive: true });
+        const output = await runLink('all', { store, homeDir: home, now: FIXED_NOW });
+        expect(output).toContain('created');
+        expect(readFileSync(join(claude, 'skills', 'foo'), 'utf-8')).toBe('x');
+    });
+});
+describe('runUpdate', () => {
+    let tmp;
+    let store;
+    let home;
+    let codex;
+    beforeEach(async () => {
+        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
+        store = makeStore(tmp);
+        home = makeHome(tmp);
+        codex = join(home, '.codex');
+        mkdirSync(join(codex, 'skills'), { recursive: true });
+        await runInit({ store, homeDir: home });
+        // 初始资源
+        writeFileSync(join(store, 'skills', 'foo'), 'x');
+    });
+    afterEach(() => {
+        rmSync(tmp, { recursive: true });
+    });
+    it('store 新增 item 后补 symlink', async () => {
+        await runLink('codex', { store, homeDir: '/home/test', now: FIXED_NOW });
+        // store 新增 bar
+        writeFileSync(join(store, 'skills', 'bar'), 'y');
+        const output = await runUpdate({ store, homeDir: '/home/test', now: FIXED_NOW });
+        expect(output).toContain('created');
+        expect(readFileSync(join(codex, 'skills', 'bar'), 'utf-8')).toBe('y');
+    });
+    it('store 删除 item 后安全删除旧 symlink', async () => {
+        await runLink('codex', { store, homeDir: home, now: FIXED_NOW });
+        // 删除 store 中的 foo
+        rmSync(join(store, 'skills', 'foo'));
+        const output = await runUpdate({ store, homeDir: home, now: FIXED_NOW });
+        expect(output).toContain('deleted');
+        // target symlink 已删除，读取应抛错
+        expect(() => readFileSync(join(codex, 'skills', 'foo'))).toThrow();
+    });
+    it('只 link 过 codex 时不得刷新 claude-code', async () => {
+        const claude = join(home, '.claude');
+        mkdirSync(join(claude, 'skills'), { recursive: true });
+        // 只 link codex
+        await runLink('codex', { store, homeDir: home, now: FIXED_NOW });
+        // update 应只更新 codex
+        const output = await runUpdate({ store, homeDir: home, now: FIXED_NOW });
+        expect(output).not.toContain('claude-code');
+    });
+});
+describe('runStatus', () => {
+    let tmp;
+    let store;
+    let home;
+    let codex;
+    beforeEach(async () => {
+        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
+        store = makeStore(tmp);
+        home = makeHome(tmp);
+        codex = join(home, '.codex');
+        mkdirSync(join(codex, 'skills'), { recursive: true });
+        await runInit({ store, homeDir: home });
+        writeFileSync(join(store, 'skills', 'foo'), 'x');
+        writeFileSync(join(store, 'skills', 'stale-item'), 'x');
+    });
+    afterEach(() => {
+        rmSync(tmp, { recursive: true });
+    });
+    it('输出 linked/missing/stale', async () => {
+        // link foo
+        await runLink('codex', { store, homeDir: home, now: FIXED_NOW });
+        // 创建 missing item（store 中存在但未 link）
+        mkdirSync(join(store, 'skills', 'missing-item'));
+        // stale：store 已删但 state 有记录
+        rmSync(join(store, 'skills', 'stale-item'));
+        const output = await runStatus({ store, homeDir: home });
+        expect(output).toContain('linked');
+        expect(output).toContain('missing');
+        expect(output).toContain('stale');
+    });
+});
+describe('runUnlink', () => {
+    let tmp;
+    let store;
+    let home;
+    let codex;
+    beforeEach(async () => {
+        tmp = mkdtempSync(join(tmpdir(), TMP_PREFIX));
+        store = makeStore(tmp);
+        home = makeHome(tmp);
+        codex = join(home, '.codex');
+        mkdirSync(join(codex, 'skills'), { recursive: true });
+        await runInit({ store, homeDir: home });
+        writeFileSync(join(store, 'skills', 'foo'), 'x');
+    });
+    afterEach(() => {
+        rmSync(tmp, { recursive: true });
+    });
+    it('只删除 dak 管理的 symlink，不删除 store 资源', async () => {
+        await runLink('codex', { store, homeDir: home, now: FIXED_NOW });
+        const output = await runUnlink('codex', { store, homeDir: home, now: FIXED_NOW });
+        expect(output).toContain('deleted');
+        // store 源文件仍在
+        expect(readFileSync(join(store, 'skills', 'foo'), 'utf-8')).toBe('x');
+        // target 已删除
+        expect(() => readFileSync(join(codex, 'skills', 'foo'))).toThrow();
+    });
+});

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

@@ -0,0 +1,146 @@
+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);
+    });
+});