@dog_world/dak 0.1.0 → 0.1.1

package/dist/src/paths.js

@@ -1,147 +0,0 @@
-/** 路径工具函数 */
-import { existsSync } from 'node:fs';
-import { realpath } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-/**
- * 将路径中的 ~ 展开为用户主目录。
- * @param input 输入路径
- * @param homeDir 用户主目录绝对路径
- * @returns 展开后的绝对路径
- */
-export function expandHome(input, homeDir) {
-    if (input === '~')
-        return homeDir;
-    if (input.startsWith('~/'))
-        return homeDir + input.slice(1);
-    return input;
-}
-/**
- * 将输入路径解析为绝对路径。
- * 支持 ~ 展开、相对路径拼接、自动 normalize。
- * @param input 输入路径（支持 ~ 前缀或相对路径）
- * @param baseDir 相对路径的基准目录
- * @param homeDir 用于 ~ 展开的主目录
- * @returns 解析后的绝对路径
- */
-export function toAbsolutePath(input, baseDir, homeDir) {
-    const expanded = expandHome(input, homeDir);
-    if (expanded.startsWith('/')) {
-        return resolve(expanded);
-    }
-    return resolve(baseDir, expanded);
-}
-/**
- * 判断名称是否为隐藏项（以 . 开头）。
- * @param name 文件/目录名称
- * @returns 是否隐藏
- */
-export function isHiddenItem(name) {
-    const base = dirname(name) === '.' ? name : name.split('/').pop() ?? name;
-    return base.startsWith('.');
-}
-/**
- * 校验资源项名称是否合法。
- * @param name 资源项名称
- * @throws 名称非法时抛出错误
- */
-export function assertSafeItemName(name) {
-    const base = dirname(name) === '.' ? name : name.split('/').pop() ?? name;
-    // 先检查 . 和 ..（它们是合法 hidden item，但应报 "Invalid"）
-    if (name === '.' || name === '..') {
-        throw new Error('Invalid resource item name');
-    }
-    if (isHiddenItem(base)) {
-        throw new Error('Hidden resource items are ignored');
-    }
-    if (name.includes('/') || name.includes('\\') || name.includes('.')) {
-        throw new Error('Invalid resource item name');
-    }
-    if (name === '..') {
-        throw new Error('Invalid resource item name');
-    }
-}
-/**
- * 判断 child 路径是否在 parent 路径内部（严格前缀匹配，防止边界欺骗）。
- * @param child 子路径
- * @param parent 父路径
- * @returns 是否在内部
- */
-export function isPathInside(child, parent) {
-    const normalizedChild = resolve(child);
-    let normalizedParent = resolve(parent);
-    if (!normalizedParent.endsWith('/')) {
-        normalizedParent += '/';
-    }
-    // 子路径在父目录内（严格前缀）
-    if (normalizedChild.startsWith(normalizedParent))
-        return true;
-    // 子路径等于父目录本身
-    if (normalizedChild === parent || normalizedChild + '/' === normalizedParent)
-        return true;
-    return false;
-}
-/**
- * 获取路径的可比较真实路径。
- * 尝试 fs.realpath，失败时 fallback 到 path.resolve。
- * @param input 输入路径
- * @returns 绝对路径
- */
-export async function realComparablePath(input) {
-    try {
-        return await realpath(input);
-    }
-    catch {
-        return resolve(input);
-    }
-}
-/**
- * 解析 symlink 的实际目标路径。
- * @param linkPath 链接文件的实际路径
- * @param rawTarget 链接原始 target（相对或绝对）
- * @returns 解析后的绝对目标路径
- */
-export async function resolveLinkTarget(linkPath, rawTarget) {
-    if (rawTarget.startsWith('/')) {
-        return resolve(rawTarget);
-    }
-    const realParent = await realParentJoined(dirname(linkPath));
-    const resolved = join(realParent, rawTarget);
-    return resolve(resolved);
-}
-/**
- * 获取路径的"真实父目录 + 剩余相对部分"拼接结果。
- * 向上逐级查找最近存在的目录取 realpath，再拼接剩余部分。
- * @param path 目标路径
- * @returns 拼接后的绝对路径
- */
-export async function realParentJoined(path) {
-    const dir = dirname(path);
-    const basename = path.split('/').pop() ?? '';
-    // 向上逐级查找最近存在的目录
-    let current = dir;
-    const segments = [];
-    let foundExisting = null;
-    let remainingSegments = [];
-    while (current !== segments.join('/')) {
-        if (existsSync(current)) {
-            foundExisting = current;
-            // 计算还需要拼接的部分
-            const dirSegments = dir.split('/').filter(Boolean);
-            const foundSegments = foundExisting.split('/').filter(Boolean);
-            remainingSegments = dirSegments.slice(foundSegments.length);
-            remainingSegments.push(basename);
-            break;
-        }
-        segments.unshift(current.split('/').pop() ?? '');
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    if (foundExisting) {
-        const realAncestor = await realpath(foundExisting);
-        const remaining = remainingSegments.join('/');
-        return join(realAncestor, remaining);
-    }
-    return resolve(path);
-}

package/dist/src/resources.js

@@ -1,86 +0,0 @@
-/** 资源扫描与格式化 */
-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

@@ -1,83 +0,0 @@
-/** 状态读写 */
-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

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

package/dist/tests/cli.test.js

@@ -1,38 +0,0 @@
-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

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