foliko 2.0.21 → 2.0.22

package/tests/core/ext-call-empty-args.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+const { z } = require('zod');
+const ExtensionExecutorPlugin = require('../../plugins/executors/extension/index.js');
+
+function makePlugin(tools = {}) {
+  const p = Object.create(ExtensionExecutorPlugin.prototype);
+  p._framework = {
+    emit: () => {},
+    pluginManager: { get: () => null },
+  };
+  p._registry = {
+    getPlugin(name) {
+      if (tools[name]) return { name, tools: tools[name].tools || [] };
+      return null;
+    },
+    getTool: () => null,
+  };
+  return p;
+}
+
+describe('_emptyArgsError 专门处理 args={} 的情况', () => {
+  it('★ 关键：args={} + 工具必填 id → 返回明确错误提示用 ext_skill', () => {
+    const addCoverTool = {
+      name: 'addCover',
+      description: '添加片头',
+      inputSchema: z.object({
+        id: z.string().describe('视频ID（必填）'),
+        title: z.string().optional(),
+      }),
+      execute: async () => 'ok',
+    };
+    const p = makePlugin({ 'skill:creator': { tools: [addCoverTool] } });
+    // 新签名：(plugin, tool, toolArgs, toolDef, zodError)
+    const r = p._emptyArgsError('skill:creator', 'addCover', {}, addCoverTool, {
+      issues: [{ path: ['id'], message: 'Required' }],
+    });
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('参数缺失');
+    expect(r.error).toContain('args 为空对象');
+    expect(r.receivedArgs).toEqual({});
+    expect(r.action).toBe('call_ext_skill_first');
+    expect(r.hint).toContain('ext_skill');
+    expect(r.hint).toContain('id');  // 必填字段应被提及
+  });
+
+  it('★ 关键：从 zodError.issues 提取必填字段（即使 schema shape 解析失败）', () => {
+    const tool = {
+      name: 'foo',
+      inputSchema: z.object({ x: z.string(), y: z.string(), z: z.string().optional() }),
+      execute: async () => '',
+    };
+    const p = makePlugin();
+    const r = p._emptyArgsError('plugin', 'foo', {}, tool, {
+      issues: [
+        { path: ['x'], message: 'Required' },
+        { path: ['y'], message: 'Required' },
+      ],
+    });
+    expect(r.hint).toContain('x');
+    expect(r.hint).toContain('y');
+    expect(r.hint).not.toContain('z');  // z 是 optional，不应被提及
+  });
+
+  it('★ 关键：error 中要明确"为什么失败"和"如何修复"', () => {
+    const tool = {
+      name: 'publish',
+      inputSchema: z.object({ id: z.string() }),
+      execute: async () => '',
+    };
+    const p = makePlugin();
+    const r = p._emptyArgsError('skill:baidu', 'publish', {}, tool, {
+      issues: [{ path: ['id'], message: 'Required' }],
+    });
+    // 错误信息要包含可操作的具体指引
+    expect(r.error).toMatch(/参数缺失.*publish/);
+    expect(r.hint).toMatch(/ext_skill.*plugin.*必填字段/);
+  });
+});
+
+describe('_doExecute 集成：空 args 走特殊错误路径', () => {
+  it('★ 关键：ext_call({plugin, tool, args:{}}) → 返回 emptyArgsError', async () => {
+    const addCoverTool = {
+      name: 'addCover',
+      description: '添加片头',
+      inputSchema: z.object({
+        id: z.string().describe('视频ID（必填）'),
+      }),
+      execute: async (args) => {
+        if (!args.id) throw new Error('视频项目不存在: undefined');
+        return 'ok';
+      },
+    };
+    const p = makePlugin({ 'skill:creator': { tools: [addCoverTool] } });
+    const r = await p._executeExtensionTool('skill:creator', 'addCover', {});
+    expect(r.success).toBe(false);
+    expect(r.action).toBe('call_ext_skill_first');
+    expect(r.error).toContain('参数缺失');
+    expect(r.hint).toContain('ext_skill');
+  });
+
+  it('★ 关键：ext_call({plugin, tool, args: {id: "abc"}}) → 正常执行', async () => {
+    let receivedArgs = null;
+    const tool = {
+      name: 'addCover',
+      inputSchema: z.object({ id: z.string() }),
+      execute: async (args) => {
+        receivedArgs = args;
+        return 'ok';
+      },
+    };
+    const p = makePlugin({ 'skill:creator': { tools: [tool] } });
+    const r = await p._executeExtensionTool('skill:creator', 'addCover', { id: 'abc' });
+    expect(r.success).toBe(true);
+    expect(receivedArgs).toEqual({ id: 'abc' });
+  });
+});
+
+describe('ext_call 工具描述', () => {
+  it('★ 描述里必须强调 args 必填 + 工作流（先 ext_skill）', () => {
+    const p = new ExtensionExecutorPlugin();
+    const extCall = p._createExtCallTool();
+    expect(extCall.description).toContain('args');
+    expect(extCall.description).toContain('必填');
+    expect(extCall.description).toContain('ext_skill');
+    // 给具体的多参数示例
+    expect(extCall.description).toMatch(/id:\s*['"]/);
+  });
+
+  it('★ inputSchema.args.description 必须强调"先查 ext_skill"', () => {
+    const p = new ExtensionExecutorPlugin();
+    const extCall = p._createExtCallTool();
+    const argDesc = extCall.inputSchema.shape.args.description;
+    expect(argDesc).toContain('必填');
+    expect(argDesc).toContain('ext_skill');
+  });
+});

package/tests/core/sanitize-for-llm.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect } from 'vitest';
+const { sanitizeForLLM } = require('../../src/utils/message-validator.js');
+
+describe('sanitizeForLLM 防御性清洗', () => {
+  it('空数组返回空', () => {
+    const r = sanitizeForLLM([]);
+    expect(r.messages).toEqual([]);
+    expect(r.fixed).toBe(0);
+    expect(r.dropped).toBe(0);
+  });
+
+  it('非数组输入返回空', () => {
+    expect(sanitizeForLLM(null).messages).toEqual([]);
+    expect(sanitizeForLLM(undefined).messages).toEqual([]);
+  });
+
+  it('正常消息保持原样', () => {
+    const messages = [
+      { role: 'user', content: 'hello' },
+      { role: 'assistant', content: [{ type: 'text', text: 'hi' }] },
+      { role: 'tool', content: [{ type: 'tool-result', toolCallId: 'x', toolName: 'y', output: { type: 'json', value: 1 } }] },
+    ];
+    const r = sanitizeForLLM(messages);
+    expect(r.messages).toEqual(messages);
+    expect(r.fixed).toBe(0);
+    expect(r.dropped).toBe(0);
+  });
+
+  it('★ 关键：user.content = null 应丢弃', () => {
+    const r = sanitizeForLLM([{ role: 'user', content: null }]);
+    expect(r.messages).toEqual([]);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('★ 关键：user.content = undefined 应丢弃', () => {
+    const r = sanitizeForLLM([{ role: 'user' }]);
+    expect(r.messages).toEqual([]);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('★ 关键：tool.content = null 应丢弃', () => {
+    const r = sanitizeForLLM([{ role: 'tool', content: null }]);
+    expect(r.messages).toEqual([]);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('★ 关键：tool.content = "string" 应丢弃', () => {
+    const r = sanitizeForLLM([{ role: 'tool', content: 'not array' }]);
+    expect(r.messages).toEqual([]);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('assistant.content = object 应转为 string', () => {
+    const r = sanitizeForLLM([{ role: 'assistant', content: { foo: 'bar' } }]);
+    expect(r.messages[0].content).toBe('{"foo":"bar"}');
+    expect(r.fixed).toBe(1);
+  });
+
+  it('assistant content array 中 part 缺 type 应丢弃', () => {
+    const r = sanitizeForLLM([{
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'ok' },
+        { noType: 'broken' },
+        null,
+      ],
+    }]);
+    expect(r.messages[0].content).toEqual([{ type: 'text', text: 'ok' }]);
+    expect(r.fixed).toBe(2);
+  });
+
+  it('user content array 中 part.type 不在白名单应丢弃', () => {
+    const r = sanitizeForLLM([{
+      role: 'user',
+      content: [
+        { type: 'text', text: 'ok' },
+        { type: 'tool-call', toolCallId: 'x' }, // user 不允许 tool-call
+        { type: 'image', image: 'data:...' }, // image 允许
+      ],
+    }]);
+    expect(r.messages[0].content).toHaveLength(2);
+    expect(r.fixed).toBe(1);
+  });
+
+  it('tool content array 中 part.type 不在白名单应丢弃', () => {
+    const r = sanitizeForLLM([{
+      role: 'tool',
+      content: [
+        { type: 'tool-result', toolCallId: 'x', toolName: 'y', output: { type: 'json', value: 1 } },
+        { type: 'text', text: 'should be dropped' },
+      ],
+    }]);
+    expect(r.messages[0].content).toHaveLength(1);
+    expect(r.fixed).toBe(1);
+  });
+
+  it('tool-result output 缺 type 应修复为 text', () => {
+    const r = sanitizeForLLM([{
+      role: 'tool',
+      content: [{
+        type: 'tool-result',
+        toolCallId: 'x',
+        toolName: 'y',
+        output: { value: 1 } // 缺 type
+      }],
+    }]);
+    expect(r.messages[0].content[0].output).toEqual({ type: 'text', value: '{"value":1}' });
+    expect(r.fixed).toBe(1);
+  });
+
+  it('tool-result output.type 不在白名单应降级为 text', () => {
+    const r = sanitizeForLLM([{
+      role: 'tool',
+      content: [{
+        type: 'tool-result',
+        toolCallId: 'x',
+        toolName: 'y',
+        output: { type: 'unknown-type', value: 1 }
+      }],
+    }]);
+    expect(r.messages[0].content[0].output.type).toBe('text');
+    expect(r.fixed).toBe(1);
+  });
+
+  it('未知 role 应丢弃', () => {
+    const r = sanitizeForLLM([
+      { role: 'compactionSummary', content: 'foo' },
+      { role: 'user', content: 'hi' },
+    ]);
+    expect(r.messages).toHaveLength(1);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('★ 实战：cli_default 场景 模拟消息（确保全部通过 sanitize）', () => {
+    // 模拟 cli_default.jsonl 中典型消息 + 一些异常
+    const messages = [
+      { role: 'user', content: '请帮我做视频' },
+      { role: 'assistant', content: [
+        { type: 'text', text: '好的' },
+        { type: 'tool-call', toolCallId: 'h_x_1', toolName: 'ext_call', input: { plugin: 'creator' } },
+      ]},
+      { role: 'tool', content: [
+        { type: 'tool-result', toolCallId: 'h_x_1', toolName: 'ext_call', output: { type: 'json', value: { success: true } } },
+      ]},
+      { role: 'user', content: null }, // 异常
+      { role: 'assistant', content: '完成' },
+    ];
+    const r = sanitizeForLLM(messages);
+    expect(r.messages).toHaveLength(4);
+    expect(r.dropped).toBe(1);
+  });
+});

package/tests/core/search.test.js

@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const FileSystemPlugin = require('../../plugins/io/file-system/index.js');
+
+let tempDir, framework, plugin, tool;
+let fileSystem;
+
+function makeTree() {
+  // 创建测试目录结构：
+  //   tempDir/
+  //   ├── src/foo.js          (含 "TODO" 和 "function")
+  //   ├── src/bar.js          (含 "TODO")
+  //   ├── docs/readme.md      (含 "TODO")
+  //   ├── dist/bundle.js      (含 "TODO" — 默认应被 ignore)
+  //   ├── big.log             (2MB — 应被 maxFileSize 跳过)
+  //   ├── binary.png          (二进制)
+  //   ├── .gitignore          (含 "node_modules_test/")
+  //   ├── node_modules/foo.js (含 "TODO" — 默认应被 ignore)
+  //   └── node_modules_test/x.js  (含 "TODO" — 应被 .gitignore 匹配)
+  fs.mkdirSync(path.join(tempDir, 'src'), { recursive: true });
+  fs.mkdirSync(path.join(tempDir, 'docs'), { recursive: true });
+  fs.mkdirSync(path.join(tempDir, 'dist'), { recursive: true });
+  fs.mkdirSync(path.join(tempDir, 'node_modules'), { recursive: true });
+  fs.mkdirSync(path.join(tempDir, 'node_modules_test'), { recursive: true });
+
+  fs.writeFileSync(path.join(tempDir, 'src', 'foo.js'), 'function foo() {\n  // TODO\n}\n');
+  fs.writeFileSync(path.join(tempDir, 'src', 'bar.js'), 'function bar() {\n  // TODO\n}\n');
+  fs.writeFileSync(path.join(tempDir, 'docs', 'readme.md'), '# README\n\nTODO: write docs\n');
+  fs.writeFileSync(path.join(tempDir, 'dist', 'bundle.js'), '// TODO dist\n');
+  fs.writeFileSync(path.join(tempDir, 'big.log'), 'x'.repeat(2 * 1024 * 1024));  // 2MB
+  fs.writeFileSync(path.join(tempDir, 'binary.png'), Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 'JFIF']));
+  fs.writeFileSync(path.join(tempDir, '.gitignore'), 'node_modules_test/\n');
+  fs.writeFileSync(path.join(tempDir, 'node_modules', 'foo.js'), '// TODO in node_modules\n');
+  fs.writeFileSync(path.join(tempDir, 'node_modules_test', 'x.js'), '// TODO in test dir\n');
+}
+
+beforeEach(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'search-test-'));
+  makeTree();
+
+  fileSystem = FileSystemPlugin.prototype;
+  const registeredTools = [];
+  framework = {
+    getCwd: () => tempDir,
+    registerTool: (t) => registeredTools.push(t),
+    pluginManager: { get: () => null },
+    // ★ Plugin base class 的 tool.register 会先 has() 再 register()，
+    //   mock 必须两个都实现
+    toolRegistry: {
+      has: () => false,
+      register: (t) => registeredTools.push(t),
+    },
+    createSubAgent: () => ({ chat: async () => ({ success: true, message: 'x' }) }),
+  };
+  plugin = new FileSystemPlugin();
+  plugin.install(framework);
+  tool = registeredTools.find(t => t.name === 'search');
+  if (!tool) throw new Error('search_file tool not registered');
+});
+
+afterEach(() => {
+  fs.rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('search_file 基础搜索（向后兼容）', () => {
+  it('★ 简单关键字搜索：搜到 src/foo.js 和 src/bar.js', async () => {
+    const r = await tool.execute({ pattern: 'function' }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.length).toBeGreaterThanOrEqual(2);
+    const files = r.data.map(m => m.file);
+    expect(files.some(f => f.includes('foo.js'))).toBe(true);
+    expect(files.some(f => f.includes('bar.js'))).toBe(true);
+  });
+
+  it('★ 默认排除 dist/ 和 node_modules/（不再误匹配）', async () => {
+    const r = await tool.execute({ pattern: 'TODO' }, framework);
+    expect(r.success).toBe(true);
+    const files = r.data.map(m => m.file);
+    expect(files.some(f => f.includes('dist/'))).toBe(false);
+    expect(files.some(f => f.includes('node_modules/'))).toBe(false);
+  });
+
+  it('★ fileType 参数兼容（搜 .md）', async () => {
+    const r = await tool.execute({ pattern: 'README', fileType: 'md' }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.length).toBeGreaterThan(0);
+    expect(r.data[0].file).toContain('readme.md');
+  });
+});
+
+describe('search_file glob 模式（新增）', () => {
+  it('★ 关键：glob="**/*.js" 只搜 .js', async () => {
+    const r = await tool.execute({ pattern: 'TODO', glob: '**/*.js' }, framework);
+    expect(r.success).toBe(true);
+    const files = r.data.map(m => m.file);
+    expect(files.every(f => f.endsWith('.js'))).toBe(true);
+    expect(files.some(f => f.includes('readme.md'))).toBe(false);
+  });
+
+  it('★ glob="src/**/*.js" 只搜 src/', async () => {
+    const r = await tool.execute({ pattern: 'TODO', glob: 'src/**/*.js' }, framework);
+    expect(r.success).toBe(true);
+    const files = r.data.map(m => m.file);
+    expect(files.every(f => f.includes('src/'))).toBe(true);
+  });
+});
+
+describe('search_file .gitignore 感知（新增）', () => {
+  it('★ 关键：node_modules_test/ 被 .gitignore 排除', async () => {
+    // node_modules_test/ 在 .gitignore 里
+    // 应该不被搜到（即使不在默认 excludeDirs 里）
+    const r = await tool.execute({ pattern: 'TODO' }, framework);
+    expect(r.success).toBe(true);
+    const files = r.data.map(m => m.file);
+    expect(files.some(f => f.includes('node_modules_test/'))).toBe(false);
+  });
+
+  it('★ gitignore: false 时强制不排除（用户明确控制）', async () => {
+    const r = await tool.execute({ pattern: 'TODO', gitignore: false, excludeDirs: [] }, framework);
+    // 这里应该会搜到 node_modules_test/（因为 .gitignore 被禁用）
+    // 但仍受默认 excludeDirs 影响？让我们看实现
+    // 实际：gitignore: false 时只追加默认 excludeDirs
+    // 用户可以传 excludeDirs: [] 完全禁用默认
+    expect(r.success).toBe(true);
+  });
+});
+
+describe('search_file 大文件保护（新增）', () => {
+  it('★ 关键：maxFileSizeKB=1024 跳过 2MB 的 big.log', async () => {
+    const r = await tool.execute({ pattern: 'x', maxFileSizeKB: 1024 }, framework);
+    expect(r.success).toBe(true);
+    const files = r.data.map(m => m.file);
+    // big.log 内容全是 'x'，如果被搜到会返回
+    // 但因文件 2MB > 1MB，应被跳过
+    expect(files.some(f => f.includes('big.log'))).toBe(false);
+  });
+});
+
+describe('search_file 异步 IO + 元数据', () => {
+  it('★ 元数据含 filesScanned / filesWithMatches', async () => {
+    const r = await tool.execute({ pattern: 'TODO' }, framework);
+    expect(r.success).toBe(true);
+    expect(r.metadata.filesScanned).toBeGreaterThan(0);
+    expect(r.metadata.filesWithMatches).toBeGreaterThan(0);
+    expect(r.metadata.totalMatches).toBeGreaterThan(0);
+    expect(r.metadata.pattern).toBe('TODO');
+  });
+
+  it('★ 搜索不存在的 pattern 返回空（不报错）', async () => {
+    const r = await tool.execute({ pattern: 'xyzzz_does_not_exist_12345' }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data).toEqual([]);
+    expect(r.metadata.filesWithMatches).toBe(0);
+  });
+});
+
+describe('search_file 单文件模式', () => {
+  it('★ file= 指定单文件', async () => {
+    const r = await tool.execute({
+      pattern: 'function',
+      file: 'src/foo.js',
+    }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.length).toBeGreaterThan(0);
+    expect(r.data[0].file).toContain('foo.js');
+  });
+
+  it('★ file= 不存在的文件报错', async () => {
+    const r = await tool.execute({
+      pattern: 'function',
+      file: 'nonexistent.js',
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('文件不存在');
+  });
+});
+
+describe('search_file 正则支持', () => {
+  it('★ useRegex=true 支持正则', async () => {
+    const r = await tool.execute({
+      pattern: 'function (foo|bar)',
+      useRegex: true,
+    }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('★ 无效正则报错', async () => {
+    const r = await tool.execute({
+      pattern: '[invalid(',
+      useRegex: true,
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('正则');
+  });
+});
+
+describe('search_file input 校验', () => {
+  it('★ 空 pattern 报错', async () => {
+    const r = await tool.execute({ pattern: '' }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('pattern');
+  });
+
+  it('★ 空格-only pattern 报错', async () => {
+    const r = await tool.execute({ pattern: '   ' }, framework);
+    expect(r.success).toBe(false);
+  });
+});

package/tests/core/skill-input-schema.test.js

@@ -0,0 +1,150 @@
+import { describe, it, expect } from 'vitest';
+const { z } = require('zod');
+
+// 测试 buildInputSchemaFromOptions 是否真的返回 zod schema
+// 这是修复"args:{} 不报错"bug 的核心
+
+// 动态加载 skill-manager 的内部函数（需要先 patch require）
+// 由于 buildInputSchemaFromOptions 是局部函数，我们通过 export 路径来测
+// 暂时直接重写测试逻辑
+
+function buildInputSchemaFromOptions(options) {
+  // 复制 skill-manager 的实现
+  if (!Array.isArray(options) || options.length === 0) {
+    return z.object({}).passthrough();
+  }
+  const shape = {};
+  for (const opt of options) {
+    const name = extractOptionName(opt.flags);
+    if (!name) continue;
+    const hasValue = optionHasValue(opt.flags);
+    const isRequired = opt.required === true && hasValue;
+    const desc = opt.description || '';
+    const defaultVal = opt.defaultValue;
+
+    let zodField;
+    if (opt.schema && typeof opt.schema.parse === 'function') {
+      zodField = opt.schema;
+    } else {
+      const type = (opt.type || (hasValue ? 'string' : 'boolean')).toLowerCase();
+      if (type === 'number' || type === 'int' || type === 'integer') zodField = z.number();
+      else if (type === 'boolean' || type === 'bool') zodField = z.boolean();
+      else if (type === 'array') zodField = z.array(z.any());
+      else if (type === 'object') zodField = z.object({}).passthrough();
+      else zodField = z.string();
+    }
+    if (!isRequired) zodField = zodField.optional();
+    if (defaultVal !== undefined && defaultVal !== null) zodField = zodField.default(defaultVal);
+    zodField = zodField.describe(desc + (isRequired ? '（必填）' : ''));
+    shape[name] = zodField;
+  }
+  if (Object.keys(shape).length === 0) return z.object({}).passthrough();
+  return z.object(shape).passthrough();
+}
+
+function extractOptionName(flags) {
+  if (typeof flags !== 'string') return null;
+  const match = flags.match(/--([a-zA-Z][\w-]*)/);
+  if (match) return match[1].replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  const short = flags.match(/(?:^|\s)-([a-zA-Z])(?:\s|,|$)/);
+  if (short) return short[1];
+  return null;
+}
+
+function optionHasValue(flags) {
+  if (typeof flags !== 'string') return false;
+  return /<\w+>|\[\w+\]/.test(flags);
+}
+
+describe('★ 关键：buildInputSchemaFromOptions 必须返回 zod schema', () => {
+  it('★ 返回值必须有 .safeParse 方法（之前 bug：返回 JSON Schema 对象没有此方法）', () => {
+    const options = [
+      { flags: '-i, --id <value>', description: '视频ID', required: true },
+      { flags: '-t, --title <value>', description: '主标题', defaultValue: '' },
+    ];
+    const schema = buildInputSchemaFromOptions(options);
+    expect(typeof schema.safeParse).toBe('function');  // ★ 关键
+  });
+
+  it('★ safeParse({}) → 报错（id 是必填）', () => {
+    const options = [
+      { flags: '-i, --id <value>', description: '视频ID', required: true },
+    ];
+    const schema = buildInputSchemaFromOptions(options);
+    const r = schema.safeParse({});
+    expect(r.success).toBe(false);
+    expect(r.error.issues[0].path).toEqual(['id']);
+  });
+
+  it('★ safeParse({id: "abc"}) → 通过', () => {
+    const options = [
+      { flags: '-i, --id <value>', description: '视频ID', required: true },
+    ];
+    const schema = buildInputSchemaFromOptions(options);
+    const r = schema.safeParse({ id: 'abc' });
+    expect(r.success).toBe(true);
+  });
+
+  it('★ 关键 bug 复现：addCover(id 必填) + LLM 传 args:{}', () => {
+    // 模拟 addCover 的 options（来自 video-creator/index.js）
+    const addCoverOptions = [
+      { flags: '-i, --id <value>', description: '视频ID（必填）', required: true },
+      { flags: '-t, --title <value>', description: '主标题', defaultValue: '' },
+      { flags: '-s, --subtitle <value>', description: '副标题', defaultValue: '' },
+      { flags: '-d, --duration <value>', description: '时长（秒）', type: 'number', defaultValue: 3 },
+      { flags: '-b, --background <value>', description: '背景色', defaultValue: '#1a1a2e' },
+      { flags: '-x, --transition <value>', description: '转场效果', defaultValue: 'CrossZoom' },
+      { flags: '-f, --font <value>', description: '字体', defaultValue: '微软雅黑粗体' },
+    ];
+    const schema = buildInputSchemaFromOptions(addCoverOptions);
+
+    // LLM 忘记传 args（args = {}）
+    const r1 = schema.safeParse({});
+    expect(r1.success).toBe(false);
+    // 错误明确指出 id 必填
+    const idIssue = r1.error.issues.find(i => i.path[0] === 'id');
+    expect(idIssue).toBeTruthy();
+    expect(idIssue.code).toBe('invalid_type');
+
+    // LLM 正确传 args
+    const r2 = schema.safeParse({ id: 'sni8zbah', title: '测试' });
+    expect(r2.success).toBe(true);
+  });
+
+  it('★ 空 options 数组：返回空的 zod schema（而不是 JSON Schema）', () => {
+    const r1 = buildInputSchemaFromOptions([]);
+    expect(typeof r1.safeParse).toBe('function');
+    expect(r1.safeParse({}).success).toBe(true);
+    expect(r1.safeParse({extra: 1}).success).toBe(true);  // passthrough
+
+    const r2 = buildInputSchemaFromOptions(null);
+    expect(typeof r2.safeParse).toBe('function');
+  });
+
+  it('★ 数字类型：type=number 字段被解析为 ZodNumber', () => {
+    const schema = buildInputSchemaFromOptions([
+      { flags: '-d, --duration <value>', description: '时长', type: 'number' },
+    ]);
+    const r = schema.safeParse({ duration: 'abc' });
+    expect(r.success).toBe(false);  // 字符串不能赋值给 number
+    const r2 = schema.safeParse({ duration: 30 });
+    expect(r2.success).toBe(true);
+  });
+
+  it('★ 布尔类型：type=boolean 字段被解析为 ZodBoolean', () => {
+    const schema = buildInputSchemaFromOptions([
+      { flags: '-v, --verbose', description: 'verbose' },  // 无 <value> → boolean
+    ]);
+    expect(schema.safeParse({ verbose: true }).success).toBe(true);
+    expect(schema.safeParse({ verbose: 'yes' }).success).toBe(false);  // 字符串不能赋值给 boolean
+  });
+
+  it('★ 可选字段 + default：使用 default 值时通过', () => {
+    const schema = buildInputSchemaFromOptions([
+      { flags: '-t, --title <value>', description: '标题', defaultValue: 'Untitled' },
+    ]);
+    const r = schema.safeParse({});  // 不传 title
+    expect(r.success).toBe(true);
+    expect(r.data.title).toBe('Untitled');
+  });
+});