test(server): 添加 routes 模块单元测试

- agents.test.ts: Agent presets CRUD API (18 tests)
- tools.test.ts: Tool registration & execution (10 tests)
- files.test.ts: File browser API with path security (24 tests)
- commands.test.ts: Slash commands CRUD & execution (20 tests)
- hooks.test.ts: Hooks configuration management (20 tests)

覆盖率从 29.59% 提升到 60.35%，共 287 个测试

packages/server/tests/unit/routes/agents.test.ts

@@ -0,0 +1,338 @@
+/**
+ * Agents Route 测试
+ *
+ * 测试 Agent 预设管理 REST API 端点
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Hono } from 'hono';
+
+// Create mock agent module
+const mockAgentRegistry = vi.hoisted(() => ({
+  init: vi.fn().mockResolvedValue(undefined),
+  get: vi.fn(),
+  list: vi.fn(),
+}));
+
+const mockPresetAgents = vi.hoisted(() => ({
+  general: {
+    description: 'General purpose agent',
+    mode: 'subagent' as const,
+    model: { model: 'claude-3-5-sonnet' },
+  },
+  explore: {
+    description: 'Code exploration agent',
+    mode: 'subagent' as const,
+  },
+}));
+
+const mockAgentModule = vi.hoisted(() => ({
+  agentRegistry: mockAgentRegistry,
+  loadAgentConfig: vi.fn(),
+  saveAgentConfig: vi.fn(),
+  presetAgents: mockPresetAgents,
+  isPresetAgent: vi.fn((name: string) => name in mockPresetAgents),
+}));
+
+// Track if module should be available
+let moduleAvailable = true;
+
+vi.mock('@ai-assistant/core', () => {
+  if (!moduleAvailable) {
+    throw new Error('Module not found');
+  }
+  return mockAgentModule;
+});
+
+vi.mock('../../../src/routes/config.js', () => ({
+  getConfig: vi.fn(() => ({ workdir: '/test/workdir' })),
+}));
+
+import { agentsRouter } from '../../../src/routes/agents.js';
+
+// Create test app
+const app = new Hono();
+app.route('/agents', agentsRouter);
+
+describe('Agents Route', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    moduleAvailable = true;
+    mockAgentModule.loadAgentConfig.mockResolvedValue(null);
+    mockAgentModule.saveAgentConfig.mockResolvedValue(undefined);
+  });
+
+  describe('GET /agents - 获取所有 Agent 列表', () => {
+    it('返回 Agent 列表', async () => {
+      mockAgentRegistry.list.mockReturnValue([
+        { name: 'general', description: 'General purpose agent', mode: 'subagent' },
+        { name: 'explore', description: 'Code exploration agent', mode: 'subagent' },
+      ]);
+
+      const res = await app.request('/agents');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data).toHaveLength(2);
+      expect(json.data[0].name).toBe('general');
+    });
+
+    it('返回空列表', async () => {
+      mockAgentRegistry.list.mockReturnValue([]);
+
+      const res = await app.request('/agents');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data).toEqual([]);
+    });
+
+    it('包含 isPreset 和 isCustomized 标记', async () => {
+      mockAgentRegistry.list.mockReturnValue([
+        { name: 'general', description: 'General purpose agent', mode: 'subagent' },
+      ]);
+      mockAgentModule.loadAgentConfig.mockResolvedValue({
+        agents: { general: { model: { model: 'custom-model' } } },
+      });
+
+      const res = await app.request('/agents');
+      const json = await res.json();
+
+      expect(json.data[0].isPreset).toBe(true);
+      expect(json.data[0].isCustomized).toBe(true);
+    });
+  });
+
+  describe('GET /agents/presets - 获取预设 Agent 列表', () => {
+    it('返回预设列表', async () => {
+      const res = await app.request('/agents/presets');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data).toHaveLength(2);
+      expect(json.data.some((a: { name: string }) => a.name === 'general')).toBe(true);
+      expect(json.data.some((a: { name: string }) => a.name === 'explore')).toBe(true);
+    });
+
+    it('预设都标记为 isPreset: true', async () => {
+      const res = await app.request('/agents/presets');
+      const json = await res.json();
+
+      expect(json.data.every((a: { isPreset: boolean }) => a.isPreset === true)).toBe(true);
+    });
+  });
+
+  describe('GET /agents/defaults - 获取全局默认配置', () => {
+    it('返回默认配置', async () => {
+      mockAgentModule.loadAgentConfig.mockResolvedValue({
+        defaults: {
+          maxSteps: 10,
+          model: { model: 'claude-3-5-sonnet' },
+        },
+      });
+
+      const res = await app.request('/agents/defaults');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.maxSteps).toBe(10);
+    });
+
+    it('无配置时返回空对象', async () => {
+      mockAgentModule.loadAgentConfig.mockResolvedValue(null);
+
+      const res = await app.request('/agents/defaults');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data).toEqual({});
+    });
+  });
+
+  describe('PUT /agents/defaults - 更新全局默认配置', () => {
+    it('更新成功', async () => {
+      const res = await app.request('/agents/defaults', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ maxSteps: 20 }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(mockAgentModule.saveAgentConfig).toHaveBeenCalled();
+    });
+  });
+
+  describe('GET /agents/:name - 获取单个 Agent 详情', () => {
+    it('返回 Agent 详情', async () => {
+      mockAgentRegistry.get.mockReturnValue({
+        name: 'general',
+        description: 'General purpose agent',
+        mode: 'subagent',
+      });
+
+      const res = await app.request('/agents/general');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.name).toBe('general');
+      expect(json.data.isPreset).toBe(true);
+    });
+
+    it('Agent 不存在返回 404', async () => {
+      mockAgentRegistry.get.mockReturnValue(undefined);
+
+      const res = await app.request('/agents/non-existent');
+      const json = await res.json();
+
+      expect(res.status).toBe(404);
+      expect(json.success).toBe(false);
+      expect(json.error).toContain('not found');
+    });
+  });
+
+  describe('POST /agents - 创建新 Agent', () => {
+    it('创建成功', async () => {
+      mockAgentRegistry.get.mockReturnValue({
+        name: 'my-agent',
+        description: 'My custom agent',
+        mode: 'subagent',
+      });
+
+      const res = await app.request('/agents', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name: 'my-agent',
+          description: 'My custom agent',
+          mode: 'subagent',
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(mockAgentModule.saveAgentConfig).toHaveBeenCalled();
+    });
+
+    it('缺少名称返回 400', async () => {
+      const res = await app.request('/agents', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ description: 'No name agent' }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+      expect(json.error).toContain('name is required');
+    });
+
+    it('名称与预设冲突返回 400', async () => {
+      const res = await app.request('/agents', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name: 'general',
+          description: 'Trying to create preset',
+          mode: 'subagent',
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.error).toContain('preset name');
+    });
+
+    it('Agent 已存在返回 409', async () => {
+      mockAgentModule.loadAgentConfig.mockResolvedValue({
+        agents: { 'my-agent': { description: 'Existing' } },
+      });
+
+      const res = await app.request('/agents', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name: 'my-agent',
+          description: 'Duplicate',
+          mode: 'subagent',
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(409);
+      expect(json.error).toContain('already exists');
+    });
+  });
+
+  describe('PUT /agents/:name - 更新 Agent', () => {
+    it('更新成功', async () => {
+      mockAgentRegistry.get.mockReturnValue({
+        name: 'general',
+        description: 'Updated description',
+        mode: 'subagent',
+      });
+
+      const res = await app.request('/agents/general', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          description: 'Updated description',
+          mode: 'subagent',
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.isCustomized).toBe(true);
+    });
+  });
+
+  describe('DELETE /agents/:name - 删除 Agent', () => {
+    it('删除自定义 Agent 成功', async () => {
+      mockAgentModule.loadAgentConfig.mockResolvedValue({
+        agents: { 'my-agent': { description: 'Custom agent' } },
+      });
+
+      const res = await app.request('/agents/my-agent', {
+        method: 'DELETE',
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(mockAgentModule.saveAgentConfig).toHaveBeenCalled();
+    });
+
+    it('删除预设 Agent 返回 400', async () => {
+      mockAgentModule.loadAgentConfig.mockResolvedValue({ agents: {} });
+
+      const res = await app.request('/agents/general', {
+        method: 'DELETE',
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.error).toContain('Cannot delete preset');
+    });
+
+    it('Agent 不存在返回 404', async () => {
+      mockAgentModule.loadAgentConfig.mockResolvedValue({ agents: {} });
+      mockAgentModule.isPresetAgent.mockReturnValue(false);
+
+      const res = await app.request('/agents/non-existent', {
+        method: 'DELETE',
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(404);
+      expect(json.error).toContain('not found');
+    });
+  });
+});

packages/server/tests/unit/routes/commands.test.ts

@@ -0,0 +1,412 @@
+/**
+ * Commands Route 测试
+ *
+ * 测试斜杠命令管理 REST API 端点
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Hono } from 'hono';
+
+// Create mock command module
+const mockCommandRegistry = vi.hoisted(() => ({
+  initialize: vi.fn().mockResolvedValue(undefined),
+  reload: vi.fn().mockResolvedValue(undefined),
+  get: vi.fn(),
+  getAll: vi.fn(),
+  list: vi.fn(),
+  search: vi.fn(),
+  getStats: vi.fn(),
+}));
+
+const mockCommandExecutor = vi.hoisted(() => ({
+  execute: vi.fn(),
+}));
+
+const mockCommandManager = vi.hoisted(() => ({
+  create: vi.fn(),
+  update: vi.fn(),
+  delete: vi.fn(),
+  getContent: vi.fn(),
+}));
+
+const mockCommandModule = vi.hoisted(() => ({
+  getCommandRegistry: vi.fn(() => mockCommandRegistry),
+  createCommandExecutor: vi.fn(() => mockCommandExecutor),
+  createCommandManager: vi.fn(() => mockCommandManager),
+}));
+
+// Track if module should be available
+let moduleAvailable = true;
+
+vi.mock('@ai-assistant/core', () => {
+  if (!moduleAvailable) {
+    throw new Error('Module not found');
+  }
+  return mockCommandModule;
+});
+
+vi.mock('../../../src/routes/config.js', () => ({
+  getConfig: vi.fn(() => ({ workdir: '/test/workdir' })),
+}));
+
+import { commandsRouter } from '../../../src/routes/commands.js';
+
+// Create test app
+const app = new Hono();
+app.route('/commands', commandsRouter);
+
+describe('Commands Route', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    moduleAvailable = true;
+    mockCommandRegistry.list.mockReturnValue([]);
+    mockCommandRegistry.getStats.mockReturnValue({ total: 0, bySource: {} });
+  });
+
+  describe('GET /commands - 列出所有命令', () => {
+    it('返回命令列表', async () => {
+      mockCommandRegistry.list.mockReturnValue([
+        { name: 'test', description: 'Test command', source: 'builtin' },
+        { name: 'deploy', description: 'Deploy command', source: 'project' },
+      ]);
+      mockCommandRegistry.getStats.mockReturnValue({
+        total: 2,
+        bySource: { builtin: 1, project: 1 },
+      });
+
+      const res = await app.request('/commands');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.commands).toHaveLength(2);
+      expect(json.data.stats.total).toBe(2);
+    });
+
+    it('返回空列表', async () => {
+      const res = await app.request('/commands');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data.commands).toEqual([]);
+    });
+  });
+
+  describe('POST /commands/search - 搜索命令', () => {
+    it('搜索返回结果', async () => {
+      mockCommandRegistry.search.mockReturnValue([
+        {
+          command: { name: 'test', description: 'Test', source: 'builtin', template: 'echo test' },
+          score: 0.9,
+        },
+      ]);
+
+      const res = await app.request('/commands/search', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query: 'test', limit: 10 }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data).toHaveLength(1);
+      expect(json.data[0].score).toBe(0.9);
+    });
+
+    it('缺少查询参数返回 400', async () => {
+      const res = await app.request('/commands/search', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+    });
+  });
+
+  describe('POST /commands/reload - 重新加载命令', () => {
+    it('重新加载成功', async () => {
+      mockCommandRegistry.getStats.mockReturnValue({
+        total: 5,
+        bySource: { builtin: 3, project: 2 },
+      });
+
+      const res = await app.request('/commands/reload', { method: 'POST' });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.message).toBe('Commands reloaded');
+      expect(mockCommandRegistry.reload).toHaveBeenCalled();
+    });
+  });
+
+  describe('GET /commands/:name - 获取命令详情', () => {
+    it('返回命令详情', async () => {
+      mockCommandRegistry.get.mockReturnValue({
+        name: 'test',
+        description: 'Test command',
+        template: 'echo test',
+        source: 'builtin',
+      });
+
+      const res = await app.request('/commands/test');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.name).toBe('test');
+      expect(json.data.hasTemplate).toBe(true);
+    });
+
+    it('命令不存在返回 404', async () => {
+      mockCommandRegistry.get.mockReturnValue(undefined);
+
+      const res = await app.request('/commands/non-existent');
+      const json = await res.json();
+
+      expect(res.status).toBe(404);
+      expect(json.success).toBe(false);
+      expect(json.error).toContain('not found');
+    });
+
+    it('支持包含斜杠的命令名', async () => {
+      mockCommandRegistry.get.mockReturnValue({
+        name: 'deploy/staging',
+        description: 'Deploy to staging',
+        template: 'deploy staging',
+        source: 'project',
+      });
+
+      const res = await app.request('/commands/deploy/staging');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data.name).toBe('deploy/staging');
+    });
+  });
+
+  describe('POST /commands/:name/execute - 执行命令', () => {
+    it('执行成功', async () => {
+      mockCommandRegistry.get.mockReturnValue({
+        name: 'test',
+        template: 'echo {{args}}',
+        source: 'builtin',
+      });
+      mockCommandExecutor.execute.mockResolvedValue({
+        success: true,
+        prompt: 'echo hello',
+      });
+
+      const res = await app.request('/commands/test/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ arguments: 'hello' }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.prompt).toBe('echo hello');
+    });
+
+    it('执行失败返回 400', async () => {
+      mockCommandExecutor.execute.mockResolvedValue({
+        success: false,
+        error: 'Command not found',
+      });
+
+      const res = await app.request('/commands/test/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+    });
+
+    it('无请求体时默认空参数', async () => {
+      mockCommandExecutor.execute.mockResolvedValue({
+        success: true,
+        prompt: 'test',
+      });
+
+      const res = await app.request('/commands/test/execute', {
+        method: 'POST',
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(mockCommandExecutor.execute).toHaveBeenCalled();
+    });
+  });
+
+  describe('POST /commands - 创建命令', () => {
+    it('创建成功', async () => {
+      mockCommandManager.create.mockResolvedValue({
+        success: true,
+        path: '/test/.claude/commands/my-command.md',
+      });
+
+      const res = await app.request('/commands', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name: 'my-command',
+          description: 'My command',
+          template: 'echo hello',
+          scope: 'project',
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.name).toBe('my-command');
+    });
+
+    it('缺少必需字段返回 400', async () => {
+      const res = await app.request('/commands', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'test' }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+    });
+
+    it('创建失败返回错误', async () => {
+      mockCommandManager.create.mockResolvedValue({
+        success: false,
+        error: 'Command already exists',
+      });
+
+      const res = await app.request('/commands', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name: 'existing',
+          template: 'echo test',
+          scope: 'project',
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.error).toContain('already exists');
+    });
+  });
+
+  describe('GET /commands/:name/content - 获取命令完整内容', () => {
+    // Note: Due to Hono route matching, /:name{.+} matches before /:name{.+}/content
+    // So /test/content is interpreted as getting command "test/content" via the detail route
+    // This is a known issue in the source code - the /content endpoint is shadowed
+
+    it('路由被 /:name{.+} 遮蔽，实际请求 test/content 作为命令名', async () => {
+      // The request goes to GET /:name{.+} with name="test/content"
+      // Not to GET /:name{.+}/content
+      mockCommandRegistry.get.mockReturnValue({
+        name: 'test/content',
+        description: 'A command with /content in name',
+        template: 'echo test',
+        source: 'project',
+      });
+
+      const res = await app.request('/commands/test/content');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      // The detail route returns hasTemplate, not template
+      expect(json.data.hasTemplate).toBe(true);
+      expect(json.data.template).toBeUndefined();
+    });
+
+    it('当命令不存在时返回 404', async () => {
+      // This also goes through GET /:name{.+} with name="non-existent/content"
+      mockCommandRegistry.get.mockReturnValue(undefined);
+
+      const res = await app.request('/commands/non-existent/content');
+      const json = await res.json();
+
+      expect(res.status).toBe(404);
+      expect(json.success).toBe(false);
+      expect(json.error).toContain('non-existent/content');
+    });
+  });
+
+  describe('PUT /commands/:name - 更新命令', () => {
+    it('更新成功', async () => {
+      mockCommandManager.update.mockResolvedValue({
+        success: true,
+        path: '/test/.claude/commands/test.md',
+      });
+
+      const res = await app.request('/commands/test', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ template: 'echo updated' }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+
+    it('更新失败返回 400', async () => {
+      mockCommandManager.update.mockResolvedValue({
+        success: false,
+        error: 'Cannot update builtin command',
+      });
+
+      const res = await app.request('/commands/builtin-cmd', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ template: 'new template' }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+    });
+  });
+
+  describe('DELETE /commands/:name - 删除命令', () => {
+    it('删除成功', async () => {
+      mockCommandManager.delete.mockResolvedValue({
+        success: true,
+        path: '/test/.claude/commands/test.md',
+      });
+
+      const res = await app.request('/commands/test', {
+        method: 'DELETE',
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+
+    it('删除失败返回 400', async () => {
+      mockCommandManager.delete.mockResolvedValue({
+        success: false,
+        error: 'Cannot delete builtin command',
+      });
+
+      const res = await app.request('/commands/builtin-cmd', {
+        method: 'DELETE',
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+    });
+  });
+});

packages/server/tests/unit/routes/files.test.ts

@@ -0,0 +1,263 @@
+/**
+ * Files Route 测试
+ *
+ * 测试文件浏览器 REST API 端点
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { Hono } from 'hono';
+import {
+  filesRouter,
+  setWorkingDirectory,
+  getWorkingDirectory,
+} from '../../../src/routes/files.js';
+import { join } from 'node:path';
+
+// Create test app
+const app = new Hono();
+app.route('/files', filesRouter);
+
+// Save original working directory
+const originalWorkdir = process.cwd();
+
+describe('Files Route', () => {
+  beforeEach(() => {
+    // Reset to current working directory
+    setWorkingDirectory(originalWorkdir);
+  });
+
+  afterEach(() => {
+    // Restore original working directory
+    setWorkingDirectory(originalWorkdir);
+  });
+
+  describe('setWorkingDirectory / getWorkingDirectory', () => {
+    it('设置工作目录', () => {
+      setWorkingDirectory('/tmp');
+      expect(getWorkingDirectory()).toBe('/tmp');
+    });
+
+    it('获取当前工作目录', () => {
+      expect(getWorkingDirectory()).toBeDefined();
+      expect(typeof getWorkingDirectory()).toBe('string');
+    });
+  });
+
+  describe('GET /files - 获取工作目录信息', () => {
+    it('返回工作目录信息', async () => {
+      const res = await app.request('/files');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.workingDirectory).toBeDefined();
+      expect(json.data.separator).toBe('/');
+    });
+  });
+
+  describe('GET /files/list - 列出目录内容', () => {
+    it('列出当前目录', async () => {
+      const res = await app.request('/files/list');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(Array.isArray(json.data.files)).toBe(true);
+    });
+
+    it('列出指定目录', async () => {
+      const res = await app.request('/files/list?path=.');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.path).toBe('.');
+    });
+
+    it('包含隐藏文件', async () => {
+      const res = await app.request('/files/list?path=.&hidden=true');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+
+    it('路径在工作目录外返回 403', async () => {
+      const res = await app.request('/files/list?path=../../../../../../etc');
+      const json = await res.json();
+
+      expect(res.status).toBe(403);
+      expect(json.success).toBe(false);
+      expect(json.error).toContain('Access denied');
+    });
+
+    it('非目录返回 400', async () => {
+      // package.json 是一个文件，不是目录
+      const res = await app.request('/files/list?path=package.json');
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+      expect(json.error).toContain('Not a directory');
+    });
+
+    it('文件信息包含正确字段', async () => {
+      const res = await app.request('/files/list?path=.');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      if (json.data.files.length > 0) {
+        const file = json.data.files[0];
+        expect(file).toHaveProperty('name');
+        expect(file).toHaveProperty('path');
+        expect(file).toHaveProperty('type');
+        expect(file).toHaveProperty('size');
+        expect(file).toHaveProperty('modified');
+      }
+    });
+  });
+
+  describe('GET /files/read - 读取文件内容', () => {
+    it('缺少路径参数返回 400', async () => {
+      const res = await app.request('/files/read');
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+      expect(json.error).toContain('Path is required');
+    });
+
+    it('读取文本文件', async () => {
+      const res = await app.request('/files/read?path=package.json');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.encoding).toBe('utf-8');
+      expect(json.data.content).toContain('"name"');
+    });
+
+    it('路径在工作目录外返回 403', async () => {
+      const res = await app.request('/files/read?path=../../../../../../etc/passwd');
+      const json = await res.json();
+
+      expect(res.status).toBe(403);
+      expect(json.success).toBe(false);
+    });
+
+    it('读取目录返回 400', async () => {
+      const res = await app.request('/files/read?path=src');
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.error).toContain('Cannot read directory');
+    });
+
+    it('返回文件元信息', async () => {
+      const res = await app.request('/files/read?path=package.json');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data).toHaveProperty('path');
+      expect(json.data).toHaveProperty('name');
+      expect(json.data).toHaveProperty('type');
+      expect(json.data).toHaveProperty('size');
+      expect(json.data).toHaveProperty('modified');
+    });
+  });
+
+  describe('GET /files/stat - 获取文件信息', () => {
+    it('缺少路径参数返回 400', async () => {
+      const res = await app.request('/files/stat');
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+      expect(json.error).toContain('Path is required');
+    });
+
+    it('获取文件信息', async () => {
+      const res = await app.request('/files/stat?path=package.json');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.type).toBe('file');
+      expect(json.data.name).toBe('package.json');
+    });
+
+    it('获取目录信息', async () => {
+      const res = await app.request('/files/stat?path=src');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.type).toBe('directory');
+    });
+
+    it('路径在工作目录外返回 403', async () => {
+      const res = await app.request('/files/stat?path=../../../../../../etc/passwd');
+      const json = await res.json();
+
+      expect(res.status).toBe(403);
+      expect(json.success).toBe(false);
+    });
+
+    it('文件不存在返回 500', async () => {
+      const res = await app.request('/files/stat?path=non-existent-file-12345.txt');
+      const json = await res.json();
+
+      expect(res.status).toBe(500);
+      expect(json.success).toBe(false);
+    });
+  });
+
+  describe('GET /files/tree - 获取目录树', () => {
+    it('获取目录树', async () => {
+      const res = await app.request('/files/tree?path=.&depth=1');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.path).toBe('.');
+      expect(Array.isArray(json.data.tree)).toBe(true);
+    });
+
+    it('限制深度', async () => {
+      const res = await app.request('/files/tree?path=.&depth=2');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+
+    it('显示隐藏文件', async () => {
+      const res = await app.request('/files/tree?path=.&depth=1&hidden=true');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+
+    it('路径在工作目录外返回 403', async () => {
+      const res = await app.request('/files/tree?path=../../../../../../etc');
+      const json = await res.json();
+
+      expect(res.status).toBe(403);
+      expect(json.success).toBe(false);
+    });
+
+    it('树节点包含正确字段', async () => {
+      const res = await app.request('/files/tree?path=.&depth=1');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      if (json.data.tree.length > 0) {
+        const node = json.data.tree[0];
+        expect(node).toHaveProperty('name');
+        expect(node).toHaveProperty('path');
+        expect(node).toHaveProperty('type');
+      }
+    });
+  });
+});

packages/server/tests/unit/routes/hooks.test.ts

@@ -0,0 +1,323 @@
+/**
+ * Hooks Route 测试
+ *
+ * 测试 Hooks 配置管理 REST API 端点
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Hono } from 'hono';
+
+// Create mock hooks module
+const mockHooksModule = vi.hoisted(() => ({
+  loadProjectConfig: vi.fn(),
+  loadHookConfig: vi.fn(),
+  getConfigFilePath: vi.fn(),
+  createDefaultConfig: vi.fn(),
+}));
+
+// Track if module should be available
+let moduleAvailable = true;
+
+vi.mock('@ai-assistant/core', () => {
+  if (!moduleAvailable) {
+    throw new Error('Module not found');
+  }
+  return mockHooksModule;
+});
+
+vi.mock('../../../src/routes/config.js', () => ({
+  getConfig: vi.fn(() => ({ workdir: '/test/workdir' })),
+}));
+
+// Mock fs/promises
+vi.mock('fs/promises', () => ({
+  readFile: vi.fn().mockResolvedValue('{}'),
+  writeFile: vi.fn().mockResolvedValue(undefined),
+}));
+
+import { hooksRouter } from '../../../src/routes/hooks.js';
+
+// Create test app
+const app = new Hono();
+app.route('/hooks', hooksRouter);
+
+describe('Hooks Route', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    moduleAvailable = true;
+    mockHooksModule.loadHookConfig.mockResolvedValue(null);
+    mockHooksModule.getConfigFilePath.mockResolvedValue('/test/workdir/.ai-assistant.json');
+  });
+
+  describe('GET /hooks/config - 获取完整钩子配置', () => {
+    it('返回钩子配置', async () => {
+      mockHooksModule.loadHookConfig.mockResolvedValue({
+        file_edited: { '*.ts': [{ command: ['npx', 'prettier', '--write'] }] },
+        session_completed: [],
+      });
+
+      const res = await app.request('/hooks/config');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.file_edited).toBeDefined();
+    });
+
+    it('无配置时返回默认空对象', async () => {
+      mockHooksModule.loadHookConfig.mockResolvedValue(null);
+
+      const res = await app.request('/hooks/config');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data.file_edited).toEqual({});
+      expect(json.data.session_completed).toEqual([]);
+    });
+  });
+
+  describe('PUT /hooks/config - 更新完整钩子配置', () => {
+    it('更新成功', async () => {
+      const res = await app.request('/hooks/config', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          file_edited: { '*.ts': [{ command: ['echo', 'edited'] }] },
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+  });
+
+  describe('GET /hooks/file-edited - 获取 file_edited 钩子', () => {
+    it('返回 file_edited 配置', async () => {
+      mockHooksModule.loadHookConfig.mockResolvedValue({
+        file_edited: { '*.ts': [{ command: ['npx', 'prettier', '--write'] }] },
+      });
+
+      const res = await app.request('/hooks/file-edited');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data['*.ts']).toBeDefined();
+    });
+
+    it('无配置时返回空对象', async () => {
+      const res = await app.request('/hooks/file-edited');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data).toEqual({});
+    });
+  });
+
+  describe('PUT /hooks/file-edited - 更新 file_edited 钩子', () => {
+    it('更新成功', async () => {
+      const res = await app.request('/hooks/file-edited', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          '*.ts': [{ command: ['npx', 'eslint', '--fix'] }],
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+  });
+
+  describe('GET /hooks/file-created - 获取 file_created 钩子', () => {
+    it('返回 file_created 配置', async () => {
+      mockHooksModule.loadHookConfig.mockResolvedValue({
+        file_created: { '*.tsx': [{ command: ['echo', 'new file'] }] },
+      });
+
+      const res = await app.request('/hooks/file-created');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+
+    it('无配置时返回空对象', async () => {
+      const res = await app.request('/hooks/file-created');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data).toEqual({});
+    });
+  });
+
+  describe('PUT /hooks/file-created - 更新 file_created 钩子', () => {
+    it('更新成功', async () => {
+      const res = await app.request('/hooks/file-created', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          '*.tsx': [{ command: ['echo', 'created'] }],
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+  });
+
+  describe('GET /hooks/file-deleted - 获取 file_deleted 钩子', () => {
+    it('返回 file_deleted 配置', async () => {
+      mockHooksModule.loadHookConfig.mockResolvedValue({
+        file_deleted: { '*.log': [{ command: ['echo', 'deleted'] }] },
+      });
+
+      const res = await app.request('/hooks/file-deleted');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+
+    it('无配置时返回空对象', async () => {
+      const res = await app.request('/hooks/file-deleted');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data).toEqual({});
+    });
+  });
+
+  describe('PUT /hooks/file-deleted - 更新 file_deleted 钩子', () => {
+    it('更新成功', async () => {
+      const res = await app.request('/hooks/file-deleted', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          '*.tmp': [{ command: ['echo', 'cleaned'] }],
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+  });
+
+  describe('GET /hooks/session-completed - 获取 session_completed 钩子', () => {
+    it('返回 session_completed 配置', async () => {
+      mockHooksModule.loadHookConfig.mockResolvedValue({
+        session_completed: [{ command: ['echo', 'session done'] }],
+      });
+
+      const res = await app.request('/hooks/session-completed');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data).toHaveLength(1);
+    });
+
+    it('无配置时返回空数组', async () => {
+      const res = await app.request('/hooks/session-completed');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data).toEqual([]);
+    });
+  });
+
+  describe('PUT /hooks/session-completed - 更新 session_completed 钩子', () => {
+    it('更新成功', async () => {
+      const res = await app.request('/hooks/session-completed', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify([{ command: ['echo', 'completed'] }]),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+  });
+
+  describe('POST /hooks/test - 测试执行钩子命令', () => {
+    it('执行简单命令', async () => {
+      const res = await app.request('/hooks/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          command: ['echo', 'test'],
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data).toHaveProperty('exitCode');
+      expect(json.data).toHaveProperty('duration');
+    });
+
+    it('无效命令配置返回 400', async () => {
+      const res = await app.request('/hooks/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          command: [],
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+      expect(json.error).toContain('Invalid command configuration');
+    });
+
+    it('命令非数组返回 400', async () => {
+      const res = await app.request('/hooks/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          command: 'echo test',
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(400);
+      expect(json.success).toBe(false);
+    });
+
+    it('支持超时配置', async () => {
+      const res = await app.request('/hooks/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          command: ['echo', 'quick'],
+          timeout: 5000,
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+
+    it('支持环境变量', async () => {
+      const res = await app.request('/hooks/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          command: ['echo', '$TEST_VAR'],
+          environment: { TEST_VAR: 'hello' },
+        }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+    });
+  });
+});

packages/server/tests/unit/routes/tools.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Tools Route 测试
+ *
+ * 测试工具管理 REST API 端点
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Hono } from 'hono';
+import { toolsRouter, registerTool, getRegisteredTools } from '../../../src/routes/tools.js';
+
+// Create test app
+const app = new Hono();
+app.route('/tools', toolsRouter);
+
+describe('Tools Route', () => {
+  beforeEach(() => {
+    // Clear any previously registered tools
+    // Note: Since the toolRegistry is a module-level Map, we test what's already registered
+    vi.clearAllMocks();
+  });
+
+  describe('registerTool / getRegisteredTools - 工具注册', () => {
+    it('注册工具', () => {
+      registerTool({
+        name: 'test-tool',
+        description: 'A test tool',
+        parameters: {},
+      });
+
+      const tools = getRegisteredTools();
+      expect(tools.some((t) => t.name === 'test-tool')).toBe(true);
+    });
+
+    it('获取所有已注册工具', () => {
+      const tools = getRegisteredTools();
+      expect(Array.isArray(tools)).toBe(true);
+    });
+  });
+
+  describe('GET /tools - 列出所有工具', () => {
+    it('返回工具列表', async () => {
+      // Register a tool first
+      registerTool({
+        name: 'list-test-tool',
+        description: 'Tool for list test',
+        parameters: {},
+      });
+
+      const res = await app.request('/tools');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(Array.isArray(json.data)).toBe(true);
+    });
+
+    it('返回数组类型数据', async () => {
+      const res = await app.request('/tools');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(Array.isArray(json.data)).toBe(true);
+    });
+  });
+
+  describe('GET /tools/:name - 获取单个工具', () => {
+    it('返回存在的工具', async () => {
+      registerTool({
+        name: 'get-test-tool',
+        description: 'Tool for get test',
+        parameters: { path: { type: 'string' } },
+      });
+
+      const res = await app.request('/tools/get-test-tool');
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.name).toBe('get-test-tool');
+      expect(json.data.description).toBe('Tool for get test');
+    });
+
+    it('工具不存在返回 404', async () => {
+      const res = await app.request('/tools/non-existent-tool-12345');
+      const json = await res.json();
+
+      expect(res.status).toBe(404);
+      expect(json.success).toBe(false);
+      expect(json.error).toBe('Tool not found');
+    });
+  });
+
+  describe('POST /tools/:name/execute - 执行工具', () => {
+    it('执行存在的工具（占位实现）', async () => {
+      registerTool({
+        name: 'execute-test-tool',
+        description: 'Tool for execute test',
+        parameters: {},
+      });
+
+      const res = await app.request('/tools/execute-test-tool/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ params: { test: 'value' } }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.success).toBe(true);
+      expect(json.data.tool).toBe('execute-test-tool');
+      expect(json.data.params).toEqual({ test: 'value' });
+    });
+
+    it('工具不存在返回 404', async () => {
+      const res = await app.request('/tools/non-existent-tool-67890/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ params: {} }),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(404);
+      expect(json.success).toBe(false);
+      expect(json.error).toBe('Tool not found');
+    });
+
+    it('无 params 时使用空对象', async () => {
+      registerTool({
+        name: 'no-params-tool',
+        description: 'Tool without params',
+        parameters: {},
+      });
+
+      const res = await app.request('/tools/no-params-tool/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(json.data.params).toEqual({});
+    });
+
+    it('无效 JSON 返回 500', async () => {
+      registerTool({
+        name: 'json-error-tool',
+        description: 'Tool for JSON error test',
+        parameters: {},
+      });
+
+      const res = await app.request('/tools/json-error-tool/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: 'invalid json',
+      });
+      const json = await res.json();
+
+      expect(res.status).toBe(500);
+      expect(json.success).toBe(false);
+    });
+  });
+});