growork 1.0.0

package/src/commands/init.ts

@@ -0,0 +1,58 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { getConfigPath, configExists, getDefaultConfig } from '../utils/config.js';
+
+const DIRS_TO_CREATE = [
+  'docs/product',
+  'docs/design',
+  'docs/api',
+  'docs/tech',
+  'docs/test',
+];
+
+export async function initCommand(): Promise<void> {
+  console.log(chalk.blue('📁 初始化 Growork 项目...\n'));
+
+  const cwd = process.cwd();
+
+  // 创建目录结构
+  for (const dir of DIRS_TO_CREATE) {
+    const fullPath = path.join(cwd, dir);
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+      console.log(chalk.green(`  ✓ 创建目录: ${dir}`));
+    } else {
+      console.log(chalk.gray(`  - 目录已存在: ${dir}`));
+    }
+  }
+
+  // 创建配置文件
+  const configPath = getConfigPath();
+  if (!configExists()) {
+    fs.writeFileSync(configPath, getDefaultConfig(), 'utf-8');
+    console.log(chalk.green(`  ✓ 创建配置文件: growork.config.yaml`));
+  } else {
+    console.log(chalk.gray(`  - 配置文件已存在: growork.config.yaml`));
+  }
+
+  // 更新 .gitignore
+  const gitignorePath = path.join(cwd, '.gitignore');
+  const ignoreEntry = 'growork.config.yaml';
+
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, 'utf-8');
+    if (!content.includes(ignoreEntry)) {
+      fs.appendFileSync(gitignorePath, `\n# Growork 配置文件（包含敏感凭证）\n${ignoreEntry}\n`);
+      console.log(chalk.green(`  ✓ 已将配置文件添加到 .gitignore`));
+    }
+  } else {
+    fs.writeFileSync(gitignorePath, `# Growork 配置文件（包含敏感凭证）\n${ignoreEntry}\n`);
+    console.log(chalk.green(`  ✓ 创建 .gitignore 并添加配置文件`));
+  }
+
+  console.log(chalk.blue('\n✅ 初始化完成！\n'));
+  console.log(chalk.yellow('下一步：'));
+  console.log('  1. 编辑 growork.config.yaml，填入飞书凭证和文档链接');
+  console.log('  2. 运行 growork sync 同步文档\n');
+}

package/src/commands/list.ts

@@ -0,0 +1,37 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { loadConfig, configExists } from '../utils/config.js';
+
+export async function listCommand(): Promise<void> {
+  if (!configExists()) {
+    console.log(chalk.red('❌ 配置文件不存在，请先运行 growork init'));
+    process.exit(1);
+  }
+
+  const config = loadConfig();
+  const cwd = process.cwd();
+
+  console.log(chalk.blue('📋 文档列表\n'));
+
+  console.log(chalk.gray('  名称'.padEnd(18) + '类型'.padEnd(10) + '输出路径'.padEnd(30) + '状态'));
+  console.log(chalk.gray('  ' + '-'.repeat(70)));
+
+  for (const doc of config.docs) {
+    const outputPath = path.join(cwd, doc.output);
+    const exists = fs.existsSync(outputPath);
+
+    const status = exists
+      ? chalk.green('已同步')
+      : chalk.yellow('未同步');
+
+    const name = `  ${doc.name}`.padEnd(18);
+    const type = doc.type.padEnd(10);
+    const output = doc.output.padEnd(30);
+
+    console.log(`${name}${chalk.gray(type)}${output}${status}`);
+  }
+
+  console.log('');
+  console.log(chalk.gray(`共 ${config.docs.length} 个文档配置`));
+}

package/src/commands/sync.ts

@@ -0,0 +1,77 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { loadConfig } from '../utils/config.js';
+import { FeishuService } from '../services/feishu.js';
+import { NotionService } from '../services/notion.js';
+
+function clearLine(): void {
+  if (process.stdout.isTTY) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+  } else {
+    console.log('');
+  }
+}
+
+export async function syncCommand(docName?: string): Promise<void> {
+  const config = loadConfig();
+  const feishuService = config.feishu ? new FeishuService(config.feishu) : null;
+  const notionService = config.notion ? new NotionService(config.notion) : null;
+
+  let docsToSync = config.docs;
+
+  if (docName) {
+    const doc = config.docs.find(d => d.name === docName);
+    if (!doc) {
+      console.log(chalk.red(`❌ 未找到名为 "${docName}" 的文档配置`));
+      console.log(chalk.gray(`可用的文档: ${config.docs.map(d => d.name).join(', ')}`));
+      process.exit(1);
+    }
+    docsToSync = [doc];
+  }
+
+  console.log(chalk.blue('📄 开始同步文档...\n'));
+
+  let successCount = 0;
+
+  for (const doc of docsToSync) {
+    process.stdout.write(chalk.gray(`  ⏳ ${doc.name.padEnd(15)} → ${doc.output}`));
+
+    try {
+      let content: string;
+      if (doc.type === 'feishu') {
+        if (!feishuService) throw new Error('飞书服务未配置');
+        content = await feishuService.getDocumentAsMarkdown(doc.url);
+      } else if (doc.type === 'notion') {
+        if (!notionService) throw new Error('Notion 服务未配置');
+        content = await notionService.getPageAsMarkdown(doc.url);
+      } else {
+        throw new Error(`不支持的文档类型: ${doc.type}`);
+      }
+
+      const outputPath = path.join(process.cwd(), doc.output);
+      const outputDir = path.dirname(outputPath);
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+
+      fs.writeFileSync(outputPath, content, 'utf-8');
+
+      clearLine();
+      console.log(chalk.green(`  ✓ ${doc.name.padEnd(15)} → ${doc.output}`));
+      successCount++;
+    } catch (error) {
+      clearLine();
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.log(chalk.red(`  ✗ ${doc.name.padEnd(15)} → ${errorMessage}`));
+    }
+  }
+
+  console.log('');
+  if (successCount === docsToSync.length) {
+    console.log(chalk.green(`✅ 同步完成，共 ${docsToSync.length} 个文档`));
+  } else {
+    console.log(chalk.yellow(`⚠️  同步完成: ${successCount}/${docsToSync.length} 个文档成功`));
+  }
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { syncCommand } from './commands/sync.js';
+import { listCommand } from './commands/list.js';
+
+const program = new Command();
+
+program
+  .name('growork')
+  .description('将飞书文档同步到本地，为 AI Agent 提供完整上下文')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('初始化 Growork 配置和目录结构')
+  .action(initCommand);
+
+program
+  .command('sync [name]')
+  .description('同步文档，可选指定文档名称')
+  .action(syncCommand);
+
+program
+  .command('list')
+  .description('列出所有配置的文档')
+  .action(listCommand);
+
+program.parse();

package/src/services/feishu.ts

@@ -0,0 +1,360 @@
+import * as lark from '@larksuiteoapi/node-sdk';
+import { FeishuConfig } from '../utils/config.js';
+
+export class FeishuService {
+  private client: lark.Client;
+
+  constructor(config: FeishuConfig) {
+    const domain = config.domain === 'lark' ? lark.Domain.Lark : lark.Domain.Feishu;
+
+    this.client = new lark.Client({
+      appId: config.appId,
+      appSecret: config.appSecret,
+      disableTokenCache: false,
+      domain: domain,
+    });
+  }
+
+  parseDocumentId(url: string): { type: 'docx' | 'wiki'; documentId: string } {
+    const docxMatch = url.match(/\/docx\/([a-zA-Z0-9]+)/);
+    if (docxMatch) {
+      return { type: 'docx', documentId: docxMatch[1] };
+    }
+
+    const wikiMatch = url.match(/\/wiki\/([a-zA-Z0-9]+)/);
+    if (wikiMatch) {
+      return { type: 'wiki', documentId: wikiMatch[1] };
+    }
+
+    throw new Error(`无法解析飞书文档 URL: ${url}`);
+  }
+
+  async getWikiNodeInfo(token: string): Promise<{ objToken: string; objType: string }> {
+    const response = await this.client.wiki.v2.space.getNode({
+      params: { token },
+    });
+
+    const objToken = response.data?.node?.obj_token;
+    const objType = response.data?.node?.obj_type;
+
+    if (!objToken) {
+      throw new Error(`无法获取 Wiki 节点信息，请检查权限和链接是否正确`);
+    }
+
+    return { objToken, objType: objType || 'docx' };
+  }
+
+  private async resolveDocumentId(url: string): Promise<string> {
+    const { type, documentId } = this.parseDocumentId(url);
+    if (type === 'wiki') {
+      const nodeInfo = await this.getWikiNodeInfo(documentId);
+      return nodeInfo.objToken;
+    }
+    return documentId;
+  }
+
+  async getDocumentAsMarkdown(url: string): Promise<string> {
+    const actualDocumentId = await this.resolveDocumentId(url);
+
+    const docInfo = await this.client.docx.document.get({
+      path: { document_id: actualDocumentId },
+    });
+
+    const title = docInfo.data?.document?.title || '未命名文档';
+
+    const blocks = await this.getAllBlocks(actualDocumentId);
+
+    // 构建块索引
+    const blockMap = new Map<string, any>();
+    for (const block of blocks) {
+      blockMap.set(block.block_id, block);
+    }
+
+    // 找到根块（page）
+    const rootBlock = blocks.find(b => b.block_type === 1);
+    if (!rootBlock) {
+      throw new Error('无法找到文档根节点');
+    }
+
+    // 递归转换
+    const lines: string[] = [];
+    lines.push(`# ${title}`);
+    lines.push('');
+
+    this.convertChildrenToMarkdown(rootBlock.children || [], blockMap, lines, 0);
+
+    return lines.join('\n');
+  }
+
+  private async getAllBlocks(documentId: string): Promise<any[]> {
+    const allBlocks: any[] = [];
+    let pageToken: string | undefined;
+
+    do {
+      const response = await this.client.docx.documentBlock.list({
+        path: { document_id: documentId },
+        params: {
+          page_size: 500,
+          page_token: pageToken,
+        },
+      });
+
+      const blocks = response.data?.items || [];
+      allBlocks.push(...blocks);
+      pageToken = response.data?.page_token;
+    } while (pageToken);
+
+    return allBlocks;
+  }
+
+  private convertChildrenToMarkdown(
+    childIds: string[],
+    blockMap: Map<string, any>,
+    lines: string[],
+    indent: number
+  ): void {
+    for (const childId of childIds) {
+      const block = blockMap.get(childId);
+      if (!block) continue;
+
+      const md = this.blockToMarkdown(block, blockMap, indent);
+      if (md !== null) {
+        lines.push(md);
+      }
+    }
+  }
+
+  private blockToMarkdown(block: any, blockMap: Map<string, any>, indent: number): string | null {
+    const blockType = block.block_type;
+    const indentStr = '  '.repeat(indent);
+
+    switch (blockType) {
+      case 1: // Page
+        return null;
+
+      case 2: // Text
+        const text = this.textElementsToMarkdown(block.text?.elements);
+        return text ? text + '\n' : '';
+
+      case 3: // Heading1
+        return `# ${this.textElementsToMarkdown(block.heading1?.elements)}\n`;
+
+      case 4: // Heading2
+        return `## ${this.textElementsToMarkdown(block.heading2?.elements)}\n`;
+
+      case 5: // Heading3
+        return `### ${this.textElementsToMarkdown(block.heading3?.elements)}\n`;
+
+      case 6: // Heading4
+        return `#### ${this.textElementsToMarkdown(block.heading4?.elements)}\n`;
+
+      case 7: // Heading5
+        return `##### ${this.textElementsToMarkdown(block.heading5?.elements)}\n`;
+
+      case 8: // Heading6
+        return `###### ${this.textElementsToMarkdown(block.heading6?.elements)}\n`;
+
+      case 9: // Heading7
+      case 10: // Heading8
+      case 11: // Heading9
+        return `###### ${this.textElementsToMarkdown(block[`heading${blockType - 6}`]?.elements)}\n`;
+
+      case 12: // Bullet
+      case 13: // Ordered
+        const isBullet = blockType === 12;
+        const listText = this.textElementsToMarkdown(block[isBullet ? 'bullet' : 'ordered']?.elements);
+        const listChildren = block.children || [];
+        let listResult = `${indentStr}${isBullet ? '-' : '1.'} ${listText}`;
+        if (listChildren.length > 0) {
+          const childLines: string[] = [];
+          this.convertChildrenToMarkdown(listChildren, blockMap, childLines, indent + 1);
+          if (childLines.length > 0) {
+            listResult += '\n' + childLines.join('\n');
+          }
+        }
+        return listResult;
+
+      case 14: // Code
+        const lang = this.getLanguageName(block.code?.style?.language || 0);
+        const codeText = this.textElementsToMarkdown(block.code?.elements);
+        return `\`\`\`${lang}\n${codeText}\n\`\`\`\n`;
+
+      case 15: // Quote
+        return `> ${this.textElementsToMarkdown(block.quote?.elements)}\n`;
+
+      case 17: // TodoList
+        const checked = block.todo?.style?.done ? 'x' : ' ';
+        return `${indentStr}- [${checked}] ${this.textElementsToMarkdown(block.todo?.elements)}`;
+
+      case 18: // Divider
+        return '---\n';
+
+      case 19: // Image
+        const imageToken = block.image?.token;
+        return imageToken ? `![image](${imageToken})\n` : '';
+
+      case 27: // Quote Container
+        const quoteChildren = block.children || [];
+        if (quoteChildren.length > 0) {
+          const childLines: string[] = [];
+          this.convertChildrenToMarkdown(quoteChildren, blockMap, childLines, 0);
+          return childLines.map(line => `> ${line}`).join('\n') + '\n';
+        }
+        return '';
+
+      case 24: // Grid - 分栏布局
+        const gridChildren = block.children || [];
+        if (gridChildren.length > 0) {
+          const childLines: string[] = [];
+          this.convertChildrenToMarkdown(gridChildren, blockMap, childLines, indent);
+          return childLines.join('\n');
+        }
+        return '';
+
+      case 25: // Callout - 高亮块
+        const calloutChildren = block.children || [];
+        if (calloutChildren.length > 0) {
+          const childLines: string[] = [];
+          this.convertChildrenToMarkdown(calloutChildren, blockMap, childLines, indent);
+          return childLines.join('\n');
+        }
+        return '';
+
+      case 30: // Sheet - 嵌入表格
+        const sheetToken = block.sheet?.token;
+        return sheetToken ? `[嵌入表格: ${sheetToken}]\n` : '';
+
+      case 31: // Table
+        return this.tableToMarkdown(block, blockMap);
+
+      case 32: // Table Cell - 跳过，由表格统一处理
+        return null;
+
+      default:
+        return null;
+    }
+  }
+
+  private 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 = this.getCellContent(cellBlock, blockMap);
+        rowCells.push(cellContent);
+      }
+      rows.push(rowCells);
+    }
+
+    // 生成 Markdown 表格
+    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';
+  }
+
+  private 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(this.textElementsToMarkdown(child.text?.elements));
+      }
+    }
+
+    return contents.join(' ').replace(/\|/g, '\\|').replace(/\n/g, ' ');
+  }
+
+  private textElementsToMarkdown(elements: any[] | undefined): string {
+    if (!elements) return '';
+
+    return elements.map(el => {
+      if (el.text_run) {
+        let text = el.text_run.content || '';
+        const style = el.text_run.text_element_style;
+
+        if (style?.bold) {
+          text = `**${text}**`;
+        }
+        if (style?.italic) {
+          text = `*${text}*`;
+        }
+        if (style?.strikethrough) {
+          text = `~~${text}~~`;
+        }
+        if (style?.inline_code) {
+          text = `\`${text}\``;
+        }
+        if (style?.link?.url) {
+          text = `[${text}](${style.link.url})`;
+        }
+
+        return text;
+      }
+
+      if (el.mention_user) {
+        return `@${el.mention_user.user_id || 'user'}`;
+      }
+
+      if (el.mention_doc) {
+        const title = el.mention_doc.title || '文档';
+        const url = el.mention_doc.url || '';
+        return `[${title}](${url})`;
+      }
+
+      return '';
+    }).join('');
+  }
+
+  private getLanguageName(langCode: number | string): string {
+    const langMap: Record<number, string> = {
+      1: 'plaintext', 2: 'abap', 3: 'ada', 4: 'apache', 5: 'apex',
+      6: 'assembly', 7: 'bash', 8: 'csharp', 9: 'cpp', 10: 'c',
+      11: 'cobol', 12: 'css', 13: 'coffeescript', 14: 'd', 15: 'dart',
+      16: 'delphi', 17: 'django', 18: 'dockerfile', 19: 'erlang', 20: 'fortran',
+      21: 'foxpro', 22: 'go', 23: 'groovy', 24: 'html', 25: 'htmlbars',
+      26: 'http', 27: 'haskell', 28: 'json', 29: 'java', 30: 'javascript',
+      31: 'julia', 32: 'kotlin', 33: 'latex', 34: 'lisp', 35: 'lua',
+      36: 'matlab', 37: 'makefile', 38: 'markdown', 39: 'nginx', 40: 'objectivec',
+      41: 'openedgeabl', 42: 'php', 43: 'perl', 44: 'powershell', 45: 'prolog',
+      46: 'protobuf', 47: 'python', 48: 'r', 49: 'rpm', 50: 'ruby',
+      51: 'rust', 52: 'sas', 53: 'scss', 54: 'sql', 55: 'scala',
+      56: 'scheme', 57: 'scratch', 58: 'shell', 59: 'swift', 60: 'thrift',
+      61: 'typescript', 62: 'vbscript', 63: 'visual-basic', 64: 'xml', 65: 'yaml',
+    };
+
+    if (typeof langCode === 'number') {
+      return langMap[langCode] || '';
+    }
+    return String(langCode);
+  }
+}

package/src/services/notion.ts

@@ -0,0 +1,129 @@
+import { Client } from '@notionhq/client';
+import { NotionToMarkdown } from 'notion-to-md';
+import { NotionConfig } from '../utils/config.js';
+
+export class NotionService {
+  private client: Client;
+  private n2m: NotionToMarkdown;
+
+  constructor(config: NotionConfig) {
+    this.client = new Client({ auth: config.token });
+    this.n2m = new NotionToMarkdown({ notionClient: this.client });
+    this.setupCustomTransformers();
+  }
+
+  private setupCustomTransformers(): void {
+    this.n2m.setCustomTransformer('child_database', async (block: any) => {
+      const dbId = block.id;
+
+      try {
+        const db = await this.client.databases.retrieve({ database_id: dbId }) as any;
+        const title = db.title?.[0]?.plain_text || '未命名数据库';
+
+        if (!db.data_sources || db.data_sources.length === 0) {
+          return `### ${title}\n\n(无法获取数据源)\n`;
+        }
+
+        const dataSourceId = db.data_sources[0].id;
+        const result = await (this.client as any).dataSources.query({ data_source_id: dataSourceId });
+
+        if (!result.results || result.results.length === 0) {
+          return `### ${title}\n\n(空数据库)\n`;
+        }
+
+        const columns = Object.keys(result.results[0].properties);
+        const rows = result.results.map((page: any) => {
+          const row: Record<string, string> = {};
+          for (const [key, prop] of Object.entries(page.properties)) {
+            row[key] = this.extractPropertyValue(prop);
+          }
+          return row;
+        });
+
+        let md = `### ${title}\n\n`;
+        md += '| ' + columns.join(' | ') + ' |\n';
+        md += '| ' + columns.map(() => '---').join(' | ') + ' |\n';
+        for (const row of rows) {
+          const cells = columns.map(col => {
+            const val = row[col] || '';
+            return val.replace(/\|/g, '\\|').replace(/\n/g, '<br>').slice(0, 200);
+          });
+          md += '| ' + cells.join(' | ') + ' |\n';
+        }
+
+        return md;
+      } catch (e: any) {
+        return `### ${block.child_database?.title || '数据库'}\n\n(导出失败: ${e.message})\n`;
+      }
+    });
+  }
+
+  private extractPropertyValue(prop: any): string {
+    if (!prop) return '';
+    switch (prop.type) {
+      case 'title':
+        return prop.title?.map((t: any) => t.plain_text).join('') || '';
+      case 'rich_text':
+        return prop.rich_text?.map((t: any) => t.plain_text).join('') || '';
+      case 'select':
+        return prop.select?.name || '';
+      case 'multi_select':
+        return prop.multi_select?.map((s: any) => s.name).join(', ') || '';
+      case 'number':
+        return prop.number?.toString() ?? '';
+      case 'checkbox':
+        return prop.checkbox ? '✓' : '';
+      case 'date':
+        return prop.date?.start || '';
+      case 'url':
+        return prop.url || '';
+      case 'files':
+        return prop.files?.map((f: any) => f.name || 'file').join(', ') || '';
+      default:
+        return '';
+    }
+  }
+
+  parsePageId(url: string): string {
+    // 支持多种 Notion URL 格式
+    // https://www.notion.so/workspace/Page-Title-abc123def456
+    // https://www.notion.so/abc123def456
+    // https://notion.so/abc123def456?v=xxx
+    const match = url.match(/([a-f0-9]{32})|([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i);
+    if (!match) {
+      throw new Error(`无法解析 Notion 页面 URL: ${url}`);
+    }
+    return match[0].replace(/-/g, '');
+  }
+
+  async getPageAsMarkdown(url: string): Promise<string> {
+    const pageId = this.parsePageId(url);
+
+    const page = await this.client.pages.retrieve({ page_id: pageId }) as any;
+    const title = this.getPageTitle(page);
+
+    const mdBlocks = await this.n2m.pageToMarkdown(pageId);
+    const mdString = this.n2m.toMarkdownString(mdBlocks);
+
+    const lines: string[] = [];
+    lines.push(`# ${title}`);
+    lines.push('');
+    lines.push(mdString.parent);
+
+    return lines.join('\n');
+  }
+
+  private 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 '未命名';
+  }
+}