@playcraft/cli 0.0.48 → 0.0.51

package/dist/commands/tools-research.test.js

@@ -1,216 +0,0 @@
-/**
- * playcraft tools research / fetch-url 命令测试
- *
- * 覆盖：
- * - 正确路径：research 返回 answer + citations
- * - 正确路径：fetch-url 返回 answer + citations
- * - focus 参数透传
- * - query 参数透传
- * - 后端返回 4xx / 5xx 时抛出错误
- * - 鉴权头：sandbox JWT → X-Sandbox-Token；PAT → Authorization: Bearer
- * - citation 为空时不崩溃
- */
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi, } from 'vitest';
-import http from 'node:http';
-import { researchCommand, fetchUrlCommand } from './tools-research.js';
-// ─── Mock loadGlobalConfig ─────────────────────────────────────────────────────
-vi.mock('../config.js', () => ({
-    loadGlobalConfig: vi.fn(() => ({})),
-    saveGlobalConfig: vi.fn(),
-    loadConfig: vi.fn(),
-}));
-let server;
-let baseUrl;
-let lastRequest = null;
-let responseStatus = 200;
-let responseBody = {
-    answer: 'Test answer from Gemini',
-    citations: [],
-};
-beforeAll(async () => {
-    server = http.createServer((req, res) => {
-        let body = '';
-        req.on('data', (chunk) => { body += chunk.toString(); });
-        req.on('end', () => {
-            lastRequest = {
-                url: req.url ?? '',
-                method: req.method ?? '',
-                headers: req.headers,
-                body,
-            };
-            res.writeHead(responseStatus, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(responseBody));
-        });
-    });
-    await new Promise((resolve) => {
-        server.listen(0, '127.0.0.1', () => resolve());
-    });
-    const addr = server.address();
-    baseUrl = `http://127.0.0.1:${addr.port}`;
-});
-afterAll(async () => {
-    await new Promise((resolve) => server.close(() => resolve()));
-});
-beforeEach(() => {
-    lastRequest = null;
-    responseStatus = 200;
-    responseBody = { answer: 'Test answer', citations: [] };
-    delete process.env.PLAYCRAFT_API_URL;
-    delete process.env.PLAYCRAFT_SANDBOX_TOKEN;
-});
-afterEach(() => {
-    delete process.env.PLAYCRAFT_API_URL;
-    delete process.env.PLAYCRAFT_SANDBOX_TOKEN;
-});
-// ─── Helper ───────────────────────────────────────────────────────────────────
-/** 解析测试服务器收到的请求 body */
-function parseBody() {
-    return JSON.parse(lastRequest?.body ?? '{}');
-}
-// ─── researchCommand ──────────────────────────────────────────────────────────
-describe('researchCommand', () => {
-    it('发送 POST 到 /api/agent/tools/research', async () => {
-        const result = await researchCommand({
-            query: 'match-3 level design',
-            apiUrl: baseUrl,
-            token: 'test-sandbox-token',
-        });
-        expect(lastRequest?.url).toBe('/api/agent/tools/research');
-        expect(lastRequest?.method).toBe('POST');
-        expect(result.answer).toBe('Test answer');
-    });
-    it('将 query 和 focus 正确写入请求 body', async () => {
-        await researchCommand({
-            query: 'pixel art color palette',
-            focus: 'visual',
-            apiUrl: baseUrl,
-            token: 'test-sandbox-token',
-        });
-        const body = parseBody();
-        expect(body.query).toBe('pixel art color palette');
-        expect(body.focus).toBe('visual');
-    });
-    it('不传 focus 时 body 中 focus 为 undefined（不发送该字段）', async () => {
-        await researchCommand({
-            query: 'game mechanics',
-            apiUrl: baseUrl,
-            token: 'test-sandbox-token',
-        });
-        const body = parseBody();
-        expect(body.query).toBe('game mechanics');
-        expect(body.focus).toBeUndefined();
-    });
-    it('所有 focus 枚举值均可正常透传', async () => {
-        const focuses = ['gameplay', 'visual', 'audio', 'code', 'compliance'];
-        for (const focus of focuses) {
-            await researchCommand({ query: 'test', focus, apiUrl: baseUrl, token: 'tok' });
-            expect(parseBody().focus).toBe(focus);
-        }
-    });
-    it('返回包含 citations 的完整结果', async () => {
-        responseBody = {
-            answer: 'Answer with citations',
-            citations: [
-                { url: 'https://example.com/1', title: 'Source 1' },
-                { url: 'https://example.com/2', title: 'Source 2', excerpt: 'excerpt text' },
-            ],
-        };
-        const result = await researchCommand({
-            query: 'test query',
-            apiUrl: baseUrl,
-            token: 'test-token',
-        });
-        expect(result.answer).toBe('Answer with citations');
-        expect(result.citations).toHaveLength(2);
-        expect(result.citations[0].url).toBe('https://example.com/1');
-        expect(result.citations[1].excerpt).toBe('excerpt text');
-    });
-    it('citations 为空数组时不崩溃', async () => {
-        responseBody = { answer: 'No citations answer', citations: [] };
-        const result = await researchCommand({
-            query: 'test',
-            apiUrl: baseUrl,
-            token: 'test-token',
-        });
-        expect(result.citations).toEqual([]);
-    });
-    it('使用沙箱 JWT 时发送 X-Sandbox-Token 头', async () => {
-        await researchCommand({ query: 'test', apiUrl: baseUrl, token: 'sandbox-jwt-eyJ...' });
-        expect(lastRequest?.headers['x-sandbox-token']).toBe('sandbox-jwt-eyJ...');
-        expect(lastRequest?.headers['authorization']).toBeUndefined();
-    });
-    it('使用 PAT 时发送 Authorization: Bearer 头', async () => {
-        await researchCommand({ query: 'test', apiUrl: baseUrl, token: 'playcraft_pat_abc123' });
-        expect(lastRequest?.headers['authorization']).toBe('Bearer playcraft_pat_abc123');
-        expect(lastRequest?.headers['x-sandbox-token']).toBeUndefined();
-    });
-    it('后端返回 400 时抛出错误', async () => {
-        responseStatus = 400;
-        responseBody = { error: 'query is required' };
-        await expect(researchCommand({ query: 'test', apiUrl: baseUrl, token: 'tok' })).rejects.toThrow(/400/);
-    });
-    it('后端返回 500 时抛出错误', async () => {
-        responseStatus = 500;
-        responseBody = { error: 'Internal server error' };
-        await expect(researchCommand({ query: 'test', apiUrl: baseUrl, token: 'tok' })).rejects.toThrow(/500/);
-    });
-});
-// ─── fetchUrlCommand ──────────────────────────────────────────────────────────
-describe('fetchUrlCommand', () => {
-    it('发送 POST 到 /api/agent/tools/fetch-url', async () => {
-        const result = await fetchUrlCommand({
-            url: 'https://phaser.io/docs/3.60.0',
-            apiUrl: baseUrl,
-            token: 'test-token',
-        });
-        expect(lastRequest?.url).toBe('/api/agent/tools/fetch-url');
-        expect(lastRequest?.method).toBe('POST');
-        expect(result.answer).toBe('Test answer');
-    });
-    it('将 url 和 query 正确写入请求 body', async () => {
-        await fetchUrlCommand({
-            url: 'https://phaser.io/docs/3.60.0',
-            query: 'how does TileMap collision work',
-            apiUrl: baseUrl,
-            token: 'test-token',
-        });
-        const body = parseBody();
-        expect(body.url).toBe('https://phaser.io/docs/3.60.0');
-        expect(body.query).toBe('how does TileMap collision work');
-    });
-    it('不传 query 时请求 body 中 query 为 undefined', async () => {
-        await fetchUrlCommand({
-            url: 'https://example.com',
-            apiUrl: baseUrl,
-            token: 'tok',
-        });
-        const body = parseBody();
-        expect(body.url).toBe('https://example.com');
-        expect(body.query).toBeUndefined();
-    });
-    it('返回包含 citations 的完整结果', async () => {
-        responseBody = {
-            answer: 'Content from URL',
-            citations: [{ url: 'https://phaser.io/docs', title: 'Phaser Docs' }],
-        };
-        const result = await fetchUrlCommand({
-            url: 'https://phaser.io/docs',
-            apiUrl: baseUrl,
-            token: 'tok',
-        });
-        expect(result.answer).toBe('Content from URL');
-        expect(result.citations[0].title).toBe('Phaser Docs');
-    });
-    it('使用 PAT 时发送 Authorization: Bearer 头', async () => {
-        await fetchUrlCommand({
-            url: 'https://example.com',
-            apiUrl: baseUrl,
-            token: 'playcraft_pat_xyz',
-        });
-        expect(lastRequest?.headers['authorization']).toBe('Bearer playcraft_pat_xyz');
-    });
-    it('后端返回 400 时抛出错误', async () => {
-        responseStatus = 400;
-        await expect(fetchUrlCommand({ url: 'https://example.com', apiUrl: baseUrl, token: 'tok' })).rejects.toThrow(/400/);
-    });
-});

package/dist/prad/check.test.js

@@ -1,49 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-import { checkPradFile } from './check.js';
-import { explainPradPath, formatExplain } from './explain.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const mahjongSample = path.resolve(__dirname, '..', '..', '..', '..', 'docs', 'prad', 'samples', 'mahjong-gate4.atom-tree.json');
-describe('prad check', () => {
-    it('mahjong gate4 v0.2.1 passes with no E026 and draft warnings only', () => {
-        if (!fs.existsSync(mahjongSample))
-            return;
-        const result = checkPradFile(mahjongSample, { gate: 4 });
-        expect(result.errors).toEqual([]);
-        expect(result.warnings.some((w) => w.code === 'PRAD-W020')).toBe(true);
-        expect(result.warnings.some((w) => w.code === 'PRAD-E026')).toBe(false);
-        expect(result.errors.some((e) => e.code === 'PRAD-E026')).toBe(false);
-        expect(result.ok).toBe(true);
-    });
-    it('explain play_btn path', () => {
-        if (!fs.existsSync(mahjongSample))
-            return;
-        const doc = JSON.parse(fs.readFileSync(mahjongSample, 'utf-8'));
-        const result = explainPradPath(doc, 'scenes.entry.ui_layer.play_btn');
-        expect(result.found).toBe(true);
-        expect(result.slot?.spine).toBe('medium.hook.play');
-        expect(formatExplain(result)).toContain('medium.hook.play');
-    });
-    it('explain rule_engine itemSprites uses pick_and_match manifest', () => {
-        if (!fs.existsSync(mahjongSample))
-            return;
-        const doc = JSON.parse(fs.readFileSync(mahjongSample, 'utf-8'));
-        const result = explainPradPath(doc, 'scenes.gameplay.board_layer.rule_engine.props.itemSprites');
-        expect(result.found).toBe(true);
-        expect(result.bindAs).toBe('itemSprites');
-        expect(result.parentEffectiveAtom).toBe('pick_and_match_rules.aigameplay');
-        expect(result.manifestImportSlots).toContain('itemSprites');
-    });
-    it('explain hint_btn icon bindAs fingerTexture on tutorial_overlay', () => {
-        if (!fs.existsSync(mahjongSample))
-            return;
-        const doc = JSON.parse(fs.readFileSync(mahjongSample, 'utf-8'));
-        const result = explainPradPath(doc, 'scenes.gameplay.hud_layer.hint_btn.props.icon');
-        expect(result.found).toBe(true);
-        expect(result.bindAs).toBe('fingerTexture');
-        expect(result.parentEffectiveAtom).toBe('tutorial_overlay.aicomponent');
-        expect(result.manifestImportSlots).toContain('fingerTexture');
-    });
-});

package/dist/sync/sync-manager.test.js

@@ -1,80 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import { SyncManager } from './sync-manager.js';
-describe('SyncManager', () => {
-    let tmpDir;
-    let mockConnection;
-    beforeEach(async () => {
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'sync-manager-test-'));
-        mockConnection = {
-            request: vi.fn(),
-            isConnected: true,
-            connectionState: 'connected',
-        };
-    });
-    afterEach(async () => {
-        if (tmpDir) {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it('upload() reads file and calls cloud request', async () => {
-        const filePath = 'test.txt';
-        const fullPath = path.join(tmpDir, filePath);
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        await fs.writeFile(fullPath, 'hello', 'utf-8');
-        vi.mocked(mockConnection.request).mockResolvedValue({ success: true });
-        const manager = new SyncManager({
-            cloudConnection: mockConnection,
-            projectDir: tmpDir,
-        });
-        const result = await manager.upload(filePath);
-        expect(result.success).toBe(true);
-        expect(result.direction).toBe('up');
-        expect(mockConnection.request).toHaveBeenCalledWith('POST', '/api/sync/upload', expect.objectContaining({
-            path: filePath,
-            data: expect.any(String),
-            compressed: false,
-        }));
-    });
-    it('upload() returns error result when file missing', async () => {
-        const manager = new SyncManager({
-            cloudConnection: mockConnection,
-            projectDir: tmpDir,
-        });
-        const result = await manager.upload('nonexistent.txt');
-        expect(result.success).toBe(false);
-        expect(result.error).toBeDefined();
-        expect(mockConnection.request).not.toHaveBeenCalled();
-    });
-    it('download() calls cloud request and writes file', async () => {
-        const filePath = 'subdir/file.txt';
-        const content = Buffer.from('world').toString('base64');
-        vi.mocked(mockConnection.request).mockResolvedValue({ data: content });
-        const manager = new SyncManager({
-            cloudConnection: mockConnection,
-            projectDir: tmpDir,
-        });
-        const result = await manager.download(filePath);
-        expect(result.success).toBe(true);
-        expect(result.direction).toBe('down');
-        const fullPath = path.join(tmpDir, filePath);
-        const written = await fs.readFile(fullPath, 'utf-8');
-        expect(written).toBe('world');
-    });
-    it('getPendingUploads returns empty array', () => {
-        const manager = new SyncManager({
-            cloudConnection: mockConnection,
-            projectDir: tmpDir,
-        });
-        expect(manager.getPendingUploads()).toEqual([]);
-    });
-    it('getPendingDownloads returns empty array', () => {
-        const manager = new SyncManager({
-            cloudConnection: mockConnection,
-            projectDir: tmpDir,
-        });
-        expect(manager.getPendingDownloads()).toEqual([]);
-    });
-});