growork 1.0.1 → 1.1.2

package/tests/config.test.ts

@@ -1,10 +1,8 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
-import * as fs from 'fs';
-import * as path from 'path';
 import * as yaml from 'yaml';
 
-// 直接测试配置解析逻辑，不依赖 process.cwd()
+// ============ V1.0 配置类型（用于兼容性测试）============
 interface DocConfig {
   name: string;
   type: 'feishu' | 'notion';
@@ -35,6 +33,133 @@ function validateConfig(config: GroworkConfig): void {
   }
 }
 
+// ============ V2.0 配置类型和函数（从 config.ts 复制）============
+type DocInput = string | { url: string; name?: string };
+
+type FeatureValue = DocInput[] | {
+  prd?: DocInput[];
+  design?: DocInput[];
+  api?: DocInput[];
+  test?: DocInput[];
+};
+
+interface GroworkConfigV2 {
+  feishu?: { appId: string; appSecret: string; domain?: 'feishu' | 'lark' };
+  notion?: { token: string };
+  outputDir?: string;
+  custom?: DocInput[];
+  versions?: {
+    [version: string]: {
+      [feature: string]: FeatureValue;
+    };
+  };
+}
+
+interface NormalizedDoc {
+  url: string;
+  name?: string;
+  type: 'feishu' | 'notion' | 'figma';
+  outputPath: string;
+}
+
+interface SyncOptions {
+  version?: string;
+  feature?: string;
+  custom?: boolean;
+}
+
+function inferDocType(url: string): 'feishu' | 'notion' | 'figma' {
+  if (url.includes('feishu.cn') || url.includes('larksuite.com')) {
+    return 'feishu';
+  }
+  if (url.includes('notion.so') || url.includes('notion.site')) {
+    return 'notion';
+  }
+  if (url.includes('figma.com')) {
+    return 'figma';
+  }
+  throw new Error(`无法从 URL 推断文档类型: ${url}`);
+}
+
+function sanitizeFileName(title: string): string {
+  return title
+    .replace(/[\/\\:*?"<>|]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function parseDocInput(input: DocInput): { url: string; name?: string } {
+  if (typeof input === 'string') {
+    return { url: input };
+  }
+  return input;
+}
+
+function isTypedFeature(value: FeatureValue): value is { prd?: DocInput[]; design?: DocInput[]; api?: DocInput[]; test?: DocInput[] } {
+  return !Array.isArray(value);
+}
+
+function normalizeConfig(config: GroworkConfigV2, options: SyncOptions = {}): NormalizedDoc[] {
+  const docs: NormalizedDoc[] = [];
+  const outputDir = config.outputDir || 'docs';
+
+  if (config.custom && (options.custom || (!options.version && !options.feature))) {
+    for (const input of config.custom) {
+      const { url, name } = parseDocInput(input);
+      docs.push({
+        url,
+        name,
+        type: inferDocType(url),
+        outputPath: `${outputDir}/custom/{title}.md`,
+      });
+    }
+  }
+
+  if (options.custom) {
+    return docs;
+  }
+
+  if (config.versions) {
+    for (const [version, features] of Object.entries(config.versions)) {
+      if (options.version && options.version !== version) continue;
+
+      for (const [feature, value] of Object.entries(features)) {
+        if (options.feature && options.feature !== feature) continue;
+
+        if (isTypedFeature(value)) {
+          for (const docType of ['prd', 'design', 'api', 'test'] as const) {
+            const docInputs = value[docType];
+            if (!docInputs) continue;
+
+            for (const input of docInputs) {
+              const { url, name } = parseDocInput(input);
+              docs.push({
+                url,
+                name,
+                type: inferDocType(url),
+                outputPath: `${outputDir}/${version}/${feature}/${docType}/{title}.md`,
+              });
+            }
+          }
+        } else {
+          for (const input of value) {
+            const { url, name } = parseDocInput(input);
+            docs.push({
+              url,
+              name,
+              type: inferDocType(url),
+              outputPath: `${outputDir}/${version}/${feature}/{title}.md`,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return docs;
+}
+
 describe('配置文件解析', () => {
   it('应正确解析有效的 YAML 配置', () => {
     const yamlContent = `
@@ -184,3 +309,258 @@ describe('配置文件验证', () => {
     );
   });
 });
+
+// ============ V2.0 配置测试 ============
+
+describe('文档类型推断', () => {
+  it('应识别飞书 feishu.cn URL', () => {
+    assert.strictEqual(inferDocType('https://xxx.feishu.cn/docx/abc123'), 'feishu');
+  });
+
+  it('应识别飞书 larksuite.com URL', () => {
+    assert.strictEqual(inferDocType('https://xxx.larksuite.com/docx/abc123'), 'feishu');
+  });
+
+  it('应识别 Notion notion.so URL', () => {
+    assert.strictEqual(inferDocType('https://www.notion.so/abc123'), 'notion');
+  });
+
+  it('应识别 Notion notion.site URL', () => {
+    assert.strictEqual(inferDocType('https://myworkspace.notion.site/abc123'), 'notion');
+  });
+
+  it('应识别 Figma URL', () => {
+    assert.strictEqual(inferDocType('https://www.figma.com/design/abc123'), 'figma');
+  });
+
+  it('应识别 Figma 文件 URL', () => {
+    assert.strictEqual(inferDocType('https://figma.com/file/abc123/My-Design'), 'figma');
+  });
+
+  it('应拒绝未知域名', () => {
+    assert.throws(
+      () => inferDocType('https://example.com/doc/123'),
+      /无法从 URL 推断文档类型/
+    );
+  });
+});
+
+describe('文件名清理', () => {
+  it('应移除文件系统保留字符', () => {
+    assert.strictEqual(sanitizeFileName('test/file:name'), 'testfilename');
+  });
+
+  it('应将空格替换为连字符', () => {
+    assert.strictEqual(sanitizeFileName('hello world'), 'hello-world');
+  });
+
+  it('应合并连续空格为单个连字符', () => {
+    assert.strictEqual(sanitizeFileName('hello   world'), 'hello-world');
+  });
+
+  it('应移除首尾连字符', () => {
+    assert.strictEqual(sanitizeFileName(' hello world '), 'hello-world');
+  });
+
+  it('应处理复杂标题', () => {
+    assert.strictEqual(sanitizeFileName('PRD: 用户登录 v1.0'), 'PRD-用户登录-v1.0');
+  });
+
+  it('应处理只有特殊字符的情况', () => {
+    assert.strictEqual(sanitizeFileName('***'), '');
+  });
+});
+
+describe('文档输入解析', () => {
+  it('应解析字符串输入', () => {
+    const result = parseDocInput('https://xxx.feishu.cn/docx/abc');
+    assert.deepStrictEqual(result, { url: 'https://xxx.feishu.cn/docx/abc' });
+  });
+
+  it('应解析对象输入（只有 url）', () => {
+    const result = parseDocInput({ url: 'https://xxx.feishu.cn/docx/abc' });
+    assert.deepStrictEqual(result, { url: 'https://xxx.feishu.cn/docx/abc' });
+  });
+
+  it('应解析对象输入（带 name）', () => {
+    const result = parseDocInput({ url: 'https://xxx.feishu.cn/docx/abc', name: '产品文档' });
+    assert.deepStrictEqual(result, { url: 'https://xxx.feishu.cn/docx/abc', name: '产品文档' });
+  });
+});
+
+describe('V2.0 配置规范化', () => {
+  it('应处理 custom 文档', () => {
+    const config: GroworkConfigV2 = {
+      custom: ['https://xxx.feishu.cn/docx/abc123']
+    };
+    const docs = normalizeConfig(config);
+
+    assert.strictEqual(docs.length, 1);
+    assert.strictEqual(docs[0].url, 'https://xxx.feishu.cn/docx/abc123');
+    assert.strictEqual(docs[0].type, 'feishu');
+    assert.strictEqual(docs[0].outputPath, 'docs/custom/{title}.md');
+  });
+
+  it('应处理带 name 的 custom 文档', () => {
+    const config: GroworkConfigV2 = {
+      custom: [{ url: 'https://www.notion.so/abc123', name: '技术架构' }]
+    };
+    const docs = normalizeConfig(config);
+
+    assert.strictEqual(docs.length, 1);
+    assert.strictEqual(docs[0].name, '技术架构');
+    assert.strictEqual(docs[0].type, 'notion');
+  });
+
+  it('应处理 versions 中的简单 feature', () => {
+    const config: GroworkConfigV2 = {
+      versions: {
+        'v1.0': {
+          '用户登录': ['https://xxx.feishu.cn/docx/abc']
+        }
+      }
+    };
+    const docs = normalizeConfig(config);
+
+    assert.strictEqual(docs.length, 1);
+    assert.strictEqual(docs[0].outputPath, 'docs/v1.0/用户登录/{title}.md');
+  });
+
+  it('应处理 versions 中的分类型 feature', () => {
+    const config: GroworkConfigV2 = {
+      versions: {
+        'v1.0': {
+          '用户登录': {
+            prd: ['https://xxx.feishu.cn/docx/prd'],
+            design: ['https://xxx.feishu.cn/docx/design'],
+            api: ['https://xxx.feishu.cn/docx/api']
+          }
+        }
+      }
+    };
+    const docs = normalizeConfig(config);
+
+    assert.strictEqual(docs.length, 3);
+    assert.strictEqual(docs[0].outputPath, 'docs/v1.0/用户登录/prd/{title}.md');
+    assert.strictEqual(docs[1].outputPath, 'docs/v1.0/用户登录/design/{title}.md');
+    assert.strictEqual(docs[2].outputPath, 'docs/v1.0/用户登录/api/{title}.md');
+  });
+
+  it('应支持自定义 outputDir', () => {
+    const config: GroworkConfigV2 = {
+      outputDir: 'output',
+      custom: ['https://xxx.feishu.cn/docx/abc']
+    };
+    const docs = normalizeConfig(config);
+
+    assert.strictEqual(docs[0].outputPath, 'output/custom/{title}.md');
+  });
+
+  it('应支持 version 过滤', () => {
+    const config: GroworkConfigV2 = {
+      versions: {
+        'v1.0': { 'feat1': ['https://xxx.feishu.cn/docx/1'] },
+        'v2.0': { 'feat2': ['https://xxx.feishu.cn/docx/2'] }
+      }
+    };
+    const docs = normalizeConfig(config, { version: 'v1.0' });
+
+    assert.strictEqual(docs.length, 1);
+    assert.ok(docs[0].outputPath.includes('v1.0'));
+  });
+
+  it('应支持 feature 过滤', () => {
+    const config: GroworkConfigV2 = {
+      versions: {
+        'v1.0': {
+          '登录': ['https://xxx.feishu.cn/docx/1'],
+          '注册': ['https://xxx.feishu.cn/docx/2']
+        }
+      }
+    };
+    const docs = normalizeConfig(config, { feature: '登录' });
+
+    assert.strictEqual(docs.length, 1);
+    assert.ok(docs[0].outputPath.includes('登录'));
+  });
+
+  it('应支持 custom 选项（只获取 custom 文档）', () => {
+    const config: GroworkConfigV2 = {
+      custom: ['https://xxx.feishu.cn/docx/custom'],
+      versions: {
+        'v1.0': { 'feat': ['https://xxx.feishu.cn/docx/versioned'] }
+      }
+    };
+    const docs = normalizeConfig(config, { custom: true });
+
+    assert.strictEqual(docs.length, 1);
+    assert.ok(docs[0].outputPath.includes('custom'));
+  });
+
+  it('默认情况下应返回所有文档', () => {
+    const config: GroworkConfigV2 = {
+      custom: ['https://xxx.feishu.cn/docx/custom'],
+      versions: {
+        'v1.0': { 'feat': ['https://xxx.feishu.cn/docx/versioned'] }
+      }
+    };
+    const docs = normalizeConfig(config);
+
+    assert.strictEqual(docs.length, 2);
+  });
+
+  it('应正确处理多版本多 feature', () => {
+    const config: GroworkConfigV2 = {
+      versions: {
+        'v1.0': {
+          'feat1': ['https://xxx.feishu.cn/docx/1'],
+          'feat2': ['https://xxx.feishu.cn/docx/2']
+        },
+        'v2.0': {
+          'feat3': ['https://xxx.feishu.cn/docx/3']
+        }
+      }
+    };
+    const docs = normalizeConfig(config);
+
+    assert.strictEqual(docs.length, 3);
+  });
+});
+
+describe('V2.0 YAML 配置解析', () => {
+  it('应正确解析 V2.0 配置', () => {
+    const yamlContent = `
+feishu:
+  appId: "cli_test"
+  appSecret: "secret_test"
+  domain: "feishu"
+
+outputDir: "docs"
+
+custom:
+  - "https://xxx.feishu.cn/docx/custom1"
+  - url: "https://xxx.feishu.cn/docx/custom2"
+    name: "技术架构"
+
+versions:
+  v1.0:
+    用户登录:
+      prd:
+        - "https://xxx.feishu.cn/docx/prd"
+      api:
+        - "https://xxx.feishu.cn/docx/api"
+    小优化:
+      - "https://xxx.feishu.cn/docx/opt"
+`;
+    const config = yaml.parse(yamlContent) as GroworkConfigV2;
+
+    assert.strictEqual(config.feishu?.appId, 'cli_test');
+    assert.strictEqual(config.feishu?.domain, 'feishu');
+    assert.strictEqual(config.outputDir, 'docs');
+    assert.strictEqual(config.custom?.length, 2);
+    assert.ok(config.versions?.['v1.0']);
+
+    const docs = normalizeConfig(config);
+    assert.strictEqual(docs.length, 5); // 2 custom + 2 分类 + 1 简单
+  });
+});

package/tests/feishu.test.ts

@@ -239,6 +239,16 @@ describe('Block 转 Markdown', () => {
         return `## ${textElementsToMarkdown(block.heading2?.elements)}\n`;
       case 5: // Heading3
         return `### ${textElementsToMarkdown(block.heading3?.elements)}\n`;
+      case 6: // Heading4
+        return `#### ${textElementsToMarkdown(block.heading4?.elements)}\n`;
+      case 7: // Heading5
+        return `##### ${textElementsToMarkdown(block.heading5?.elements)}\n`;
+      case 8: // Heading6
+        return `###### ${textElementsToMarkdown(block.heading6?.elements)}\n`;
+      case 9: // Heading7
+      case 10: // Heading8
+      case 11: // Heading9
+        return `###### ${textElementsToMarkdown(block[`heading${blockType - 6}`]?.elements)}\n`;
       case 12: // Bullet
         return `- ${textElementsToMarkdown(block.bullet?.elements)}`;
       case 13: // Ordered
@@ -254,6 +264,12 @@ describe('Block 转 Markdown', () => {
         return `- [${checked}] ${textElementsToMarkdown(block.todo?.elements)}`;
       case 18: // Divider
         return '---\n';
+      case 19: // Image
+        const imageToken = block.image?.token;
+        return imageToken ? `![image](${imageToken})\n` : '';
+      case 30: // Sheet
+        const sheetToken = block.sheet?.token;
+        return sheetToken ? `[嵌入表格: ${sheetToken}]\n` : '';
       default:
         return null;
     }
@@ -342,4 +358,175 @@ describe('Block 转 Markdown', () => {
   it('应转换分割线', () => {
     assert.strictEqual(blockToMarkdown({ block_type: 18 }), '---\n');
   });
+
+  it('应转换 Heading4', () => {
+    assert.strictEqual(
+      blockToMarkdown({ block_type: 6, heading4: { elements: [{ text_run: { content: 'H4' } }] } }),
+      '#### H4\n'
+    );
+  });
+
+  it('应转换 Heading5', () => {
+    assert.strictEqual(
+      blockToMarkdown({ block_type: 7, heading5: { elements: [{ text_run: { content: 'H5' } }] } }),
+      '##### H5\n'
+    );
+  });
+
+  it('应转换 Heading6', () => {
+    assert.strictEqual(
+      blockToMarkdown({ block_type: 8, heading6: { elements: [{ text_run: { content: 'H6' } }] } }),
+      '###### H6\n'
+    );
+  });
+
+  it('应转换 Heading7-9 为 H6', () => {
+    // Heading7-9 都映射为 ###### (H6)
+    assert.strictEqual(
+      blockToMarkdown({ block_type: 9, heading3: { elements: [{ text_run: { content: 'H7' } }] } }),
+      '###### H7\n'
+    );
+    assert.strictEqual(
+      blockToMarkdown({ block_type: 10, heading4: { elements: [{ text_run: { content: 'H8' } }] } }),
+      '###### H8\n'
+    );
+    assert.strictEqual(
+      blockToMarkdown({ block_type: 11, heading5: { elements: [{ text_run: { content: 'H9' } }] } }),
+      '###### H9\n'
+    );
+  });
+
+  it('应转换图片块', () => {
+    const block = {
+      block_type: 19,
+      image: { token: 'img_token_123' }
+    };
+    assert.strictEqual(blockToMarkdown(block), '![image](img_token_123)\n');
+  });
+
+  it('应处理无 token 的图片块', () => {
+    const block = { block_type: 19, image: {} };
+    assert.strictEqual(blockToMarkdown(block), '');
+  });
+
+  it('应转换嵌入表格', () => {
+    const block = {
+      block_type: 30,
+      sheet: { token: 'sheet_token_456' }
+    };
+    assert.strictEqual(blockToMarkdown(block), '[嵌入表格: sheet_token_456]\n');
+  });
+
+  it('应处理无 token 的嵌入表格', () => {
+    const block = { block_type: 30, sheet: {} };
+    assert.strictEqual(blockToMarkdown(block), '');
+  });
+
+  it('应对未知块类型返回 null', () => {
+    assert.strictEqual(blockToMarkdown({ block_type: 999 }), null);
+  });
+});
+
+describe('表格转 Markdown', () => {
+  function getCellContent(cellBlock: any, blockMap: Map<string, any>): string {
+    if (!cellBlock) return '';
+    const children = cellBlock.children || [];
+    const contents: string[] = [];
+    for (const childId of children) {
+      const child = blockMap.get(childId);
+      if (!child) continue;
+      if (child.block_type === 2) {
+        contents.push(textElementsToMarkdown(child.text?.elements));
+      }
+    }
+    return contents.join(' ').replace(/\|/g, '\\|').replace(/\n/g, ' ');
+  }
+
+  function tableToMarkdown(tableBlock: any, blockMap: Map<string, any>): string {
+    const table = tableBlock.table;
+    if (!table) return '';
+    const colSize = table.property?.column_size || 0;
+    const rowSize = table.property?.row_size || 0;
+    const cellIds = table.cells || [];
+    if (colSize === 0 || rowSize === 0) return '';
+
+    const rows: string[][] = [];
+    for (let row = 0; row < rowSize; row++) {
+      const rowCells: string[] = [];
+      for (let col = 0; col < colSize; col++) {
+        const cellIndex = row * colSize + col;
+        const cellId = cellIds[cellIndex];
+        const cellBlock = blockMap.get(cellId);
+        const cellContent = getCellContent(cellBlock, blockMap);
+        rowCells.push(cellContent);
+      }
+      rows.push(rowCells);
+    }
+
+    const lines: string[] = [];
+    if (rows.length > 0) {
+      lines.push('| ' + rows[0].join(' | ') + ' |');
+      lines.push('| ' + rows[0].map(() => '---').join(' | ') + ' |');
+    }
+    for (let i = 1; i < rows.length; i++) {
+      lines.push('| ' + rows[i].join(' | ') + ' |');
+    }
+    return lines.join('\n') + '\n';
+  }
+
+  it('应转换简单表格', () => {
+    const blockMap = new Map<string, any>();
+    // 创建单元格内容块
+    blockMap.set('text1', { block_type: 2, text: { elements: [{ text_run: { content: 'Header1' } }] } });
+    blockMap.set('text2', { block_type: 2, text: { elements: [{ text_run: { content: 'Header2' } }] } });
+    blockMap.set('text3', { block_type: 2, text: { elements: [{ text_run: { content: 'Cell1' } }] } });
+    blockMap.set('text4', { block_type: 2, text: { elements: [{ text_run: { content: 'Cell2' } }] } });
+    // 创建单元格
+    blockMap.set('cell1', { children: ['text1'] });
+    blockMap.set('cell2', { children: ['text2'] });
+    blockMap.set('cell3', { children: ['text3'] });
+    blockMap.set('cell4', { children: ['text4'] });
+
+    const tableBlock = {
+      block_type: 31,
+      table: {
+        property: { column_size: 2, row_size: 2 },
+        cells: ['cell1', 'cell2', 'cell3', 'cell4']
+      }
+    };
+
+    const result = tableToMarkdown(tableBlock, blockMap);
+    assert.strictEqual(result, '| Header1 | Header2 |\n| --- | --- |\n| Cell1 | Cell2 |\n');
+  });
+
+  it('应处理空表格', () => {
+    const blockMap = new Map<string, any>();
+    const tableBlock = {
+      block_type: 31,
+      table: { property: { column_size: 0, row_size: 0 }, cells: [] }
+    };
+    assert.strictEqual(tableToMarkdown(tableBlock, blockMap), '');
+  });
+
+  it('应处理无 table 属性的块', () => {
+    const blockMap = new Map<string, any>();
+    assert.strictEqual(tableToMarkdown({ block_type: 31 }, blockMap), '');
+  });
+
+  it('应转义单元格中的管道符', () => {
+    const blockMap = new Map<string, any>();
+    blockMap.set('text1', { block_type: 2, text: { elements: [{ text_run: { content: 'A|B' } }] } });
+    blockMap.set('cell1', { children: ['text1'] });
+
+    const tableBlock = {
+      block_type: 31,
+      table: {
+        property: { column_size: 1, row_size: 1 },
+        cells: ['cell1']
+      }
+    };
+
+    const result = tableToMarkdown(tableBlock, blockMap);
+    assert.ok(result.includes('A\\|B'));
+  });
 });

package/tests/notion.test.ts

@@ -102,6 +102,87 @@ describe('Notion URL 解析', () => {
   });
 });
 
+describe('Notion 页面标题提取', () => {
+  function getPageTitle(page: any): string {
+    const properties = page.properties;
+    if (!properties) return '未命名';
+
+    for (const key of Object.keys(properties)) {
+      const prop = properties[key];
+      if (prop.type === 'title' && prop.title?.length > 0) {
+        return prop.title.map((t: any) => t.plain_text).join('');
+      }
+    }
+
+    return '未命名';
+  }
+
+  it('应提取标准 title 属性', () => {
+    const page = {
+      properties: {
+        Name: {
+          type: 'title',
+          title: [{ plain_text: 'My Page Title' }]
+        }
+      }
+    };
+    assert.strictEqual(getPageTitle(page), 'My Page Title');
+  });
+
+  it('应合并多个 title 片段', () => {
+    const page = {
+      properties: {
+        Title: {
+          type: 'title',
+          title: [{ plain_text: 'Hello ' }, { plain_text: 'World' }]
+        }
+      }
+    };
+    assert.strictEqual(getPageTitle(page), 'Hello World');
+  });
+
+  it('应处理空 properties', () => {
+    const page = { properties: {} };
+    assert.strictEqual(getPageTitle(page), '未命名');
+  });
+
+  it('应处理无 properties 的页面', () => {
+    const page = {};
+    assert.strictEqual(getPageTitle(page), '未命名');
+  });
+
+  it('应处理空 title 数组', () => {
+    const page = {
+      properties: {
+        Name: { type: 'title', title: [] }
+      }
+    };
+    assert.strictEqual(getPageTitle(page), '未命名');
+  });
+
+  it('应跳过非 title 类型属性', () => {
+    const page = {
+      properties: {
+        Status: { type: 'select', select: { name: 'Done' } },
+        Name: { type: 'title', title: [{ plain_text: 'Actual Title' }] }
+      }
+    };
+    assert.strictEqual(getPageTitle(page), 'Actual Title');
+  });
+
+  it('应处理自定义属性名的 title', () => {
+    const page = {
+      properties: {
+        '页面标题': {
+          type: 'title',
+          title: [{ plain_text: '中文标题' }]
+        }
+      }
+    };
+    assert.strictEqual(getPageTitle(page), '中文标题');
+  });
+});
+
 describe('Notion 属性值提取', () => {
   describe('title 属性', () => {
     it('应提取 title 文本', () => {