@dog_world/dak 0.1.0

package/dist/tests/e2e.test.js

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

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

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

package/dist/types.js

@@ -0,0 +1,5 @@
+/** dak 核心类型定义 */
+/** 默认资源类型；自定义类型在 config.resourceTypes 中声明 */
+export const DEFAULT_RESOURCE_TYPES = ['skills', 'hooks', 'agents'];
+/** 冲突处理策略 */
+export const CONFLICT_POLICIES = ['skip', 'backup', 'overwrite'];

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@dog_world/dak",
+  "version": "0.1.0",
+  "description": "Dog Agents Kit - agent skills CLI",
+  "type": "module",
+  "bin": {
+    "dak": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "type-check": "tsc --noEmit --project tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "agent-skills",
+    "skills",
+    "ai-agents",
+    "claude-code",
+    "codex"
+  ],
+  "license": "MIT",
+  "author": "dog_world",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zzy1099207684/dog-agents-kit.git"
+  },
+  "homepage": "https://github.com/zzy1099207684/dog-agents-kit#readme",
+  "bugs": {
+    "url": "https://github.com/zzy1099207684/dog-agents-kit/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5",
+    "vitest": "^2"
+  }
+}