growork 1.0.0

package/dist/index.js

@@ -0,0 +1,681 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import chalk from "chalk";
+
+// src/utils/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "yaml";
+var CONFIG_FILE_NAME = "growork.config.yaml";
+function getConfigPath() {
+  return path.join(process.cwd(), CONFIG_FILE_NAME);
+}
+function configExists() {
+  return fs.existsSync(getConfigPath());
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${configPath}
+\u8BF7\u5148\u8FD0\u884C growork init \u521D\u59CB\u5316\u914D\u7F6E`);
+  }
+  const content = fs.readFileSync(configPath, "utf-8");
+  const config = yaml.parse(content);
+  if (!config.docs || config.docs.length === 0) {
+    throw new Error("\u914D\u7F6E\u6587\u4EF6\u4E2D\u6CA1\u6709\u914D\u7F6E\u4EFB\u4F55\u6587\u6863");
+  }
+  const hasFeishuDocs = config.docs.some((d) => d.type === "feishu");
+  const hasNotionDocs = config.docs.some((d) => d.type === "notion");
+  if (hasFeishuDocs && (!config.feishu?.appId || !config.feishu?.appSecret)) {
+    throw new Error("\u914D\u7F6E\u6587\u4EF6\u7F3A\u5C11\u98DE\u4E66\u51ED\u8BC1 (feishu.appId, feishu.appSecret)");
+  }
+  if (hasNotionDocs && !config.notion?.token) {
+    throw new Error("\u914D\u7F6E\u6587\u4EF6\u7F3A\u5C11 Notion \u51ED\u8BC1 (notion.token)");
+  }
+  return config;
+}
+function getDefaultConfig() {
+  return `# Growork \u914D\u7F6E\u6587\u4EF6
+
+# \u98DE\u4E66\u5E94\u7528\u51ED\u8BC1 (\u4F7F\u7528\u98DE\u4E66\u6587\u6863\u65F6\u9700\u8981)
+feishu:
+  appId: "cli_xxxx"
+  appSecret: "xxxx"
+  domain: "feishu"  # feishu(\u4E2D\u56FD\u7248) \u6216 lark(\u56FD\u9645\u7248)
+
+# Notion \u51ED\u8BC1 (\u4F7F\u7528 Notion \u6587\u6863\u65F6\u9700\u8981)
+notion:
+  token: "ntn_xxxx"  # Notion Integration Token
+
+# \u6587\u6863\u540C\u6B65\u914D\u7F6E
+docs:
+  # \u98DE\u4E66\u6587\u6863\u793A\u4F8B
+  - name: prd
+    type: feishu
+    url: "https://xxx.feishu.cn/docx/xxxxx"
+    output: "docs/product/prd.md"
+
+  # Notion \u6587\u6863\u793A\u4F8B
+  - name: notion-prd
+    type: notion
+    url: "https://www.notion.so/xxxxx"
+    output: "docs/product/notion-prd.md"
+`;
+}
+
+// src/commands/init.ts
+var DIRS_TO_CREATE = [
+  "docs/product",
+  "docs/design",
+  "docs/api",
+  "docs/tech",
+  "docs/test"
+];
+async function initCommand() {
+  console.log(chalk.blue("\u{1F4C1} \u521D\u59CB\u5316 Growork \u9879\u76EE...\n"));
+  const cwd = process.cwd();
+  for (const dir of DIRS_TO_CREATE) {
+    const fullPath = path2.join(cwd, dir);
+    if (!fs2.existsSync(fullPath)) {
+      fs2.mkdirSync(fullPath, { recursive: true });
+      console.log(chalk.green(`  \u2713 \u521B\u5EFA\u76EE\u5F55: ${dir}`));
+    } else {
+      console.log(chalk.gray(`  - \u76EE\u5F55\u5DF2\u5B58\u5728: ${dir}`));
+    }
+  }
+  const configPath = getConfigPath();
+  if (!configExists()) {
+    fs2.writeFileSync(configPath, getDefaultConfig(), "utf-8");
+    console.log(chalk.green(`  \u2713 \u521B\u5EFA\u914D\u7F6E\u6587\u4EF6: growork.config.yaml`));
+  } else {
+    console.log(chalk.gray(`  - \u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728: growork.config.yaml`));
+  }
+  const gitignorePath = path2.join(cwd, ".gitignore");
+  const ignoreEntry = "growork.config.yaml";
+  if (fs2.existsSync(gitignorePath)) {
+    const content = fs2.readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(ignoreEntry)) {
+      fs2.appendFileSync(gitignorePath, `
+# Growork \u914D\u7F6E\u6587\u4EF6\uFF08\u5305\u542B\u654F\u611F\u51ED\u8BC1\uFF09
+${ignoreEntry}
+`);
+      console.log(chalk.green(`  \u2713 \u5DF2\u5C06\u914D\u7F6E\u6587\u4EF6\u6DFB\u52A0\u5230 .gitignore`));
+    }
+  } else {
+    fs2.writeFileSync(gitignorePath, `# Growork \u914D\u7F6E\u6587\u4EF6\uFF08\u5305\u542B\u654F\u611F\u51ED\u8BC1\uFF09
+${ignoreEntry}
+`);
+    console.log(chalk.green(`  \u2713 \u521B\u5EFA .gitignore \u5E76\u6DFB\u52A0\u914D\u7F6E\u6587\u4EF6`));
+  }
+  console.log(chalk.blue("\n\u2705 \u521D\u59CB\u5316\u5B8C\u6210\uFF01\n"));
+  console.log(chalk.yellow("\u4E0B\u4E00\u6B65\uFF1A"));
+  console.log("  1. \u7F16\u8F91 growork.config.yaml\uFF0C\u586B\u5165\u98DE\u4E66\u51ED\u8BC1\u548C\u6587\u6863\u94FE\u63A5");
+  console.log("  2. \u8FD0\u884C growork sync \u540C\u6B65\u6587\u6863\n");
+}
+
+// src/commands/sync.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import chalk2 from "chalk";
+
+// src/services/feishu.ts
+import * as lark from "@larksuiteoapi/node-sdk";
+var FeishuService = class {
+  constructor(config) {
+    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
+    });
+  }
+  parseDocumentId(url) {
+    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(`\u65E0\u6CD5\u89E3\u6790\u98DE\u4E66\u6587\u6863 URL: ${url}`);
+  }
+  async getWikiNodeInfo(token) {
+    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(`\u65E0\u6CD5\u83B7\u53D6 Wiki \u8282\u70B9\u4FE1\u606F\uFF0C\u8BF7\u68C0\u67E5\u6743\u9650\u548C\u94FE\u63A5\u662F\u5426\u6B63\u786E`);
+    }
+    return { objToken, objType: objType || "docx" };
+  }
+  async resolveDocumentId(url) {
+    const { type, documentId } = this.parseDocumentId(url);
+    if (type === "wiki") {
+      const nodeInfo = await this.getWikiNodeInfo(documentId);
+      return nodeInfo.objToken;
+    }
+    return documentId;
+  }
+  async getDocumentAsMarkdown(url) {
+    const actualDocumentId = await this.resolveDocumentId(url);
+    const docInfo = await this.client.docx.document.get({
+      path: { document_id: actualDocumentId }
+    });
+    const title = docInfo.data?.document?.title || "\u672A\u547D\u540D\u6587\u6863";
+    const blocks = await this.getAllBlocks(actualDocumentId);
+    const blockMap = /* @__PURE__ */ new Map();
+    for (const block of blocks) {
+      blockMap.set(block.block_id, block);
+    }
+    const rootBlock = blocks.find((b) => b.block_type === 1);
+    if (!rootBlock) {
+      throw new Error("\u65E0\u6CD5\u627E\u5230\u6587\u6863\u6839\u8282\u70B9");
+    }
+    const lines = [];
+    lines.push(`# ${title}`);
+    lines.push("");
+    this.convertChildrenToMarkdown(rootBlock.children || [], blockMap, lines, 0);
+    return lines.join("\n");
+  }
+  async getAllBlocks(documentId) {
+    const allBlocks = [];
+    let pageToken;
+    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;
+  }
+  convertChildrenToMarkdown(childIds, blockMap, lines, indent) {
+    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);
+      }
+    }
+  }
+  blockToMarkdown(block, blockMap, indent) {
+    const blockType = block.block_type;
+    const indentStr = "  ".repeat(indent);
+    switch (blockType) {
+      case 1:
+        return null;
+      case 2:
+        const text = this.textElementsToMarkdown(block.text?.elements);
+        return text ? text + "\n" : "";
+      case 3:
+        return `# ${this.textElementsToMarkdown(block.heading1?.elements)}
+`;
+      case 4:
+        return `## ${this.textElementsToMarkdown(block.heading2?.elements)}
+`;
+      case 5:
+        return `### ${this.textElementsToMarkdown(block.heading3?.elements)}
+`;
+      case 6:
+        return `#### ${this.textElementsToMarkdown(block.heading4?.elements)}
+`;
+      case 7:
+        return `##### ${this.textElementsToMarkdown(block.heading5?.elements)}
+`;
+      case 8:
+        return `###### ${this.textElementsToMarkdown(block.heading6?.elements)}
+`;
+      case 9:
+      // Heading7
+      case 10:
+      // Heading8
+      case 11:
+        return `###### ${this.textElementsToMarkdown(block[`heading${blockType - 6}`]?.elements)}
+`;
+      case 12:
+      // Bullet
+      case 13:
+        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 = [];
+          this.convertChildrenToMarkdown(listChildren, blockMap, childLines, indent + 1);
+          if (childLines.length > 0) {
+            listResult += "\n" + childLines.join("\n");
+          }
+        }
+        return listResult;
+      case 14:
+        const lang = this.getLanguageName(block.code?.style?.language || 0);
+        const codeText = this.textElementsToMarkdown(block.code?.elements);
+        return `\`\`\`${lang}
+${codeText}
+\`\`\`
+`;
+      case 15:
+        return `> ${this.textElementsToMarkdown(block.quote?.elements)}
+`;
+      case 17:
+        const checked = block.todo?.style?.done ? "x" : " ";
+        return `${indentStr}- [${checked}] ${this.textElementsToMarkdown(block.todo?.elements)}`;
+      case 18:
+        return "---\n";
+      case 19:
+        const imageToken = block.image?.token;
+        return imageToken ? `![image](${imageToken})
+` : "";
+      case 27:
+        const quoteChildren = block.children || [];
+        if (quoteChildren.length > 0) {
+          const childLines = [];
+          this.convertChildrenToMarkdown(quoteChildren, blockMap, childLines, 0);
+          return childLines.map((line) => `> ${line}`).join("\n") + "\n";
+        }
+        return "";
+      case 24:
+        const gridChildren = block.children || [];
+        if (gridChildren.length > 0) {
+          const childLines = [];
+          this.convertChildrenToMarkdown(gridChildren, blockMap, childLines, indent);
+          return childLines.join("\n");
+        }
+        return "";
+      case 25:
+        const calloutChildren = block.children || [];
+        if (calloutChildren.length > 0) {
+          const childLines = [];
+          this.convertChildrenToMarkdown(calloutChildren, blockMap, childLines, indent);
+          return childLines.join("\n");
+        }
+        return "";
+      case 30:
+        const sheetToken = block.sheet?.token;
+        return sheetToken ? `[\u5D4C\u5165\u8868\u683C: ${sheetToken}]
+` : "";
+      case 31:
+        return this.tableToMarkdown(block, blockMap);
+      case 32:
+        return null;
+      default:
+        return null;
+    }
+  }
+  tableToMarkdown(tableBlock, blockMap) {
+    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 = [];
+    for (let row = 0; row < rowSize; row++) {
+      const rowCells = [];
+      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);
+    }
+    const lines = [];
+    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";
+  }
+  getCellContent(cellBlock, blockMap) {
+    if (!cellBlock) return "";
+    const children = cellBlock.children || [];
+    const contents = [];
+    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, " ");
+  }
+  textElementsToMarkdown(elements) {
+    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 || "\u6587\u6863";
+        const url = el.mention_doc.url || "";
+        return `[${title}](${url})`;
+      }
+      return "";
+    }).join("");
+  }
+  getLanguageName(langCode) {
+    const langMap = {
+      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);
+  }
+};
+
+// src/services/notion.ts
+import { Client as Client2 } from "@notionhq/client";
+import { NotionToMarkdown } from "notion-to-md";
+var NotionService = class {
+  constructor(config) {
+    this.client = new Client2({ auth: config.token });
+    this.n2m = new NotionToMarkdown({ notionClient: this.client });
+    this.setupCustomTransformers();
+  }
+  setupCustomTransformers() {
+    this.n2m.setCustomTransformer("child_database", async (block) => {
+      const dbId = block.id;
+      try {
+        const db = await this.client.databases.retrieve({ database_id: dbId });
+        const title = db.title?.[0]?.plain_text || "\u672A\u547D\u540D\u6570\u636E\u5E93";
+        if (!db.data_sources || db.data_sources.length === 0) {
+          return `### ${title}
+
+(\u65E0\u6CD5\u83B7\u53D6\u6570\u636E\u6E90)
+`;
+        }
+        const dataSourceId = db.data_sources[0].id;
+        const result = await this.client.dataSources.query({ data_source_id: dataSourceId });
+        if (!result.results || result.results.length === 0) {
+          return `### ${title}
+
+(\u7A7A\u6570\u636E\u5E93)
+`;
+        }
+        const columns = Object.keys(result.results[0].properties);
+        const rows = result.results.map((page) => {
+          const row = {};
+          for (const [key, prop] of Object.entries(page.properties)) {
+            row[key] = this.extractPropertyValue(prop);
+          }
+          return row;
+        });
+        let md = `### ${title}
+
+`;
+        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) {
+        return `### ${block.child_database?.title || "\u6570\u636E\u5E93"}
+
+(\u5BFC\u51FA\u5931\u8D25: ${e.message})
+`;
+      }
+    });
+  }
+  extractPropertyValue(prop) {
+    if (!prop) return "";
+    switch (prop.type) {
+      case "title":
+        return prop.title?.map((t) => t.plain_text).join("") || "";
+      case "rich_text":
+        return prop.rich_text?.map((t) => t.plain_text).join("") || "";
+      case "select":
+        return prop.select?.name || "";
+      case "multi_select":
+        return prop.multi_select?.map((s) => s.name).join(", ") || "";
+      case "number":
+        return prop.number?.toString() ?? "";
+      case "checkbox":
+        return prop.checkbox ? "\u2713" : "";
+      case "date":
+        return prop.date?.start || "";
+      case "url":
+        return prop.url || "";
+      case "files":
+        return prop.files?.map((f) => f.name || "file").join(", ") || "";
+      default:
+        return "";
+    }
+  }
+  parsePageId(url) {
+    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(`\u65E0\u6CD5\u89E3\u6790 Notion \u9875\u9762 URL: ${url}`);
+    }
+    return match[0].replace(/-/g, "");
+  }
+  async getPageAsMarkdown(url) {
+    const pageId = this.parsePageId(url);
+    const page = await this.client.pages.retrieve({ page_id: pageId });
+    const title = this.getPageTitle(page);
+    const mdBlocks = await this.n2m.pageToMarkdown(pageId);
+    const mdString = this.n2m.toMarkdownString(mdBlocks);
+    const lines = [];
+    lines.push(`# ${title}`);
+    lines.push("");
+    lines.push(mdString.parent);
+    return lines.join("\n");
+  }
+  getPageTitle(page) {
+    const properties = page.properties;
+    if (!properties) return "\u672A\u547D\u540D";
+    for (const key of Object.keys(properties)) {
+      const prop = properties[key];
+      if (prop.type === "title" && prop.title?.length > 0) {
+        return prop.title.map((t) => t.plain_text).join("");
+      }
+    }
+    return "\u672A\u547D\u540D";
+  }
+};
+
+// src/commands/sync.ts
+function clearLine() {
+  if (process.stdout.isTTY) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+  } else {
+    console.log("");
+  }
+}
+async function syncCommand(docName) {
+  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(chalk2.red(`\u274C \u672A\u627E\u5230\u540D\u4E3A "${docName}" \u7684\u6587\u6863\u914D\u7F6E`));
+      console.log(chalk2.gray(`\u53EF\u7528\u7684\u6587\u6863: ${config.docs.map((d) => d.name).join(", ")}`));
+      process.exit(1);
+    }
+    docsToSync = [doc];
+  }
+  console.log(chalk2.blue("\u{1F4C4} \u5F00\u59CB\u540C\u6B65\u6587\u6863...\n"));
+  let successCount = 0;
+  for (const doc of docsToSync) {
+    process.stdout.write(chalk2.gray(`  \u23F3 ${doc.name.padEnd(15)} \u2192 ${doc.output}`));
+    try {
+      let content;
+      if (doc.type === "feishu") {
+        if (!feishuService) throw new Error("\u98DE\u4E66\u670D\u52A1\u672A\u914D\u7F6E");
+        content = await feishuService.getDocumentAsMarkdown(doc.url);
+      } else if (doc.type === "notion") {
+        if (!notionService) throw new Error("Notion \u670D\u52A1\u672A\u914D\u7F6E");
+        content = await notionService.getPageAsMarkdown(doc.url);
+      } else {
+        throw new Error(`\u4E0D\u652F\u6301\u7684\u6587\u6863\u7C7B\u578B: ${doc.type}`);
+      }
+      const outputPath = path3.join(process.cwd(), doc.output);
+      const outputDir = path3.dirname(outputPath);
+      if (!fs3.existsSync(outputDir)) {
+        fs3.mkdirSync(outputDir, { recursive: true });
+      }
+      fs3.writeFileSync(outputPath, content, "utf-8");
+      clearLine();
+      console.log(chalk2.green(`  \u2713 ${doc.name.padEnd(15)} \u2192 ${doc.output}`));
+      successCount++;
+    } catch (error) {
+      clearLine();
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.log(chalk2.red(`  \u2717 ${doc.name.padEnd(15)} \u2192 ${errorMessage}`));
+    }
+  }
+  console.log("");
+  if (successCount === docsToSync.length) {
+    console.log(chalk2.green(`\u2705 \u540C\u6B65\u5B8C\u6210\uFF0C\u5171 ${docsToSync.length} \u4E2A\u6587\u6863`));
+  } else {
+    console.log(chalk2.yellow(`\u26A0\uFE0F  \u540C\u6B65\u5B8C\u6210: ${successCount}/${docsToSync.length} \u4E2A\u6587\u6863\u6210\u529F`));
+  }
+}
+
+// src/commands/list.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import chalk3 from "chalk";
+async function listCommand() {
+  if (!configExists()) {
+    console.log(chalk3.red("\u274C \u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u8FD0\u884C growork init"));
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const cwd = process.cwd();
+  console.log(chalk3.blue("\u{1F4CB} \u6587\u6863\u5217\u8868\n"));
+  console.log(chalk3.gray("  \u540D\u79F0".padEnd(18) + "\u7C7B\u578B".padEnd(10) + "\u8F93\u51FA\u8DEF\u5F84".padEnd(30) + "\u72B6\u6001"));
+  console.log(chalk3.gray("  " + "-".repeat(70)));
+  for (const doc of config.docs) {
+    const outputPath = path4.join(cwd, doc.output);
+    const exists = fs4.existsSync(outputPath);
+    const status = exists ? chalk3.green("\u5DF2\u540C\u6B65") : chalk3.yellow("\u672A\u540C\u6B65");
+    const name = `  ${doc.name}`.padEnd(18);
+    const type = doc.type.padEnd(10);
+    const output = doc.output.padEnd(30);
+    console.log(`${name}${chalk3.gray(type)}${output}${status}`);
+  }
+  console.log("");
+  console.log(chalk3.gray(`\u5171 ${config.docs.length} \u4E2A\u6587\u6863\u914D\u7F6E`));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("growork").description("\u5C06\u98DE\u4E66\u6587\u6863\u540C\u6B65\u5230\u672C\u5730\uFF0C\u4E3A AI Agent \u63D0\u4F9B\u5B8C\u6574\u4E0A\u4E0B\u6587").version("1.0.0");
+program.command("init").description("\u521D\u59CB\u5316 Growork \u914D\u7F6E\u548C\u76EE\u5F55\u7ED3\u6784").action(initCommand);
+program.command("sync [name]").description("\u540C\u6B65\u6587\u6863\uFF0C\u53EF\u9009\u6307\u5B9A\u6587\u6863\u540D\u79F0").action(syncCommand);
+program.command("list").description("\u5217\u51FA\u6240\u6709\u914D\u7F6E\u7684\u6587\u6863").action(listCommand);
+program.parse();