@guru-ai-product/ai-product-kit 0.2.251112183752 → 0.2.251113155253

package/mcp/src/server_core.js.jinja2

@@ -0,0 +1,202 @@
+/**
+ * AI Product Kit MCP Server - Core (Generated)
+ * DO NOT EDIT DIRECTLY - Regenerate via: node tools/build_package update-mcp
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import {
+  normalizeInput,
+  rewriteAndCacheMarkdown,
+  PROJECT_ROOT,
+} from './server_core.js';
+import { join } from 'path';
+
+// Product Kit Skills 映射 - 只包含 skills 下一级目录的主 skill
+// 每个键对应一个主 skill 目录，值是该 skill 的 SKILL.md 文件路径
+const PRODUCT_KIT_SKILLS = {
+{% for skill_name, skill_path in skills.items() %}
+  "{{ skill_name }}": join(PROJECT_ROOT, "{{ skill_path }}"),
+{% endfor %}
+};
+
+// Skill 描述映射
+const SKILL_DESCRIPTIONS = {
+{% for skill_name, description in skill_descriptions.items() %}
+  "{{ skill_name }}": "{{ description }}",
+{% endfor %}
+};
+
+const server = new Server(
+  {
+    name: 'AI-Product-Kit-MCP',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+/**
+ * 生成支持的技能列表及其描述
+ */
+function getSupportedSkills() {
+  const supportedList = [];
+  for (const name of Object.keys(PRODUCT_KIT_SKILLS).sort()) {
+    const description = SKILL_DESCRIPTIONS[name] || 'No description available';
+    supportedList.push({
+      name,
+      description,
+    });
+  }
+  return supportedList;
+}
+
+/**
+ * 获取技能描述（从SKILL.md文件的第一行）
+ */
+async function extractSkillDescription(skillPath) {
+  let description = '';
+  try {
+    const fs = await import('fs');
+    const firstLine = fs.readFileSync(skillPath, 'utf-8')
+      .split('\n')[0]
+      .trim();
+    if (firstLine && !firstLine.startsWith('#')) {
+      description = firstLine.substring(0, 200); // 限制长度
+    }
+  } catch (error) {
+    // ignore
+  }
+  return description;
+}
+
+// 设置工具处理器
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  const skills = getSupportedSkills();
+
+  // 生成工具描述中的技能列表
+  let skillList = '';
+  for (const skill of skills) {
+    skillList += `    - ${skill.name}: ${skill.description}\n`;
+  }
+
+  return {
+    tools: [
+      {
+        name: 'product_kit_skill',
+        description: `获取 AI Product Kit 中指定技能的指南文档或模板。\n该工具提供对 AI Product Kit 所有技能的统一访问入口。\n参数说明：\n- skill_name (string): 要获取的技能名称。\n  具体说明如下：\n${skillList}\n返回信息：\n- skill_name: 技能名称\n- description: 技能描述\n- cache_path: 缓存文件绝对路径（用于后续读取内容）`,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            skill_name: {
+              type: 'string',
+              description: '需要获取的技能名称，具体可选值及其用途见上方说明',
+            },
+          },
+          required: ['skill_name'],
+        },
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  if (request.params.name === 'product_kit_skill') {
+    const skillName = request.params.arguments?.skill_name;
+
+    if (!skillName) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              error: 'Missing required parameter: skill_name',
+            }),
+          },
+        ],
+      };
+    }
+
+    const normalizedName = normalizeInput(skillName);
+
+    // 查找匹配的skill
+    let skillPath = null;
+    for (const [key, path] of Object.entries(PRODUCT_KIT_SKILLS)) {
+      if (normalizeInput(key) === normalizedName) {
+        skillPath = path;
+        break;
+      }
+    }
+
+    if (!skillPath) {
+      // 构建包含名称和描述的详细列表
+      const supportedList = getSupportedSkills();
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              error: `Unsupported skill name: ${skillName}`,
+              supported_skills: supportedList,
+            }, null, 2),
+          },
+        ],
+      };
+    }
+
+    const fs = await import('fs');
+    if (!fs.existsSync(skillPath)) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              error: `Skill file not found: ${skillPath}`,
+            }),
+          },
+        ],
+      };
+    }
+
+    const cachePath = rewriteAndCacheMarkdown(skillPath);
+    const description = await extractSkillDescription(skillPath);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(
+            {
+              skill_name: skillName,
+              description: description,
+              cache_path: cachePath,
+            },
+            null,
+            2
+          ),
+        },
+      ],
+    };
+  }
+
+  throw new Error(`Unknown tool: ${request.params.name}`);
+});
+
+// 主函数
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('AI Product Kit MCP Server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Fatal error in main():', error);
+  process.exit(1);
+});

package/mcp/src/test_server.js

@@ -0,0 +1,33 @@
+/**
+ * 测试 Node.js MCP Server
+ * 直接调用 server 的功能进行测试
+ */
+
+import { main } from './server.js';
+
+// 模拟测试环境
+console.log('Starting MCP Server test...\n');
+
+// 需要等待服务器启动
+setTimeout(async () => {
+  try {
+    // 这里可以添加实际的 MCP 客户端测试代码
+    console.log('✓ MCP Server started successfully');
+    console.log('  - Server: AI-Product-Kit-MCP v1.0.0');
+    console.log('  - Transport: stdio');
+    console.log('\nTo fully test the server:');
+    console.log('1. Configure your MCP client to use this server');
+    console.log('2. Call the product_kit_skill tool with a valid skill name');
+    console.log('3. Example: { skill_name: "aipk_requirements" }');
+    process.exit(0);
+  } catch (error) {
+    console.error('Test failed:', error);
+    process.exit(1);
+  }
+}, 2000);
+
+// 注意：实际测试需要使用 MCP 客户端协议
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/mcp/test/test_server.py

@@ -0,0 +1,398 @@
+import sys
+import os
+import pytest
+import re
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '../..'))
+SKILLS_DIR = os.path.join(PROJECT_ROOT, 'skills')
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
+from server import fetch_documentation_guide, fetch_prompt_template, init_project, rewrite_and_cache_markdown
+
+@pytest.fixture(autouse=True)
+def clear_cache_before_tests():
+    cache_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../.doc_cache'))
+    if os.path.exists(cache_dir):
+        for filename in os.listdir(cache_dir):
+            file_path = os.path.join(cache_dir, filename)
+            if os.path.isfile(file_path):
+                os.remove(file_path)
+
+def test_fetch_documentation_guide_valid():
+    result = fetch_documentation_guide("需求文档")
+    print("test_fetch_documentation_guide_valid result:", result)
+    assert "cache_path" in result
+    assert result["document_category"] == "需求文档"
+    assert os.path.exists(result["cache_path"])
+    with open(result["cache_path"], "r", encoding="utf-8") as f:
+        content = f.read()
+    assert content.strip() != ""
+
+def test_fetch_documentation_guide_invalid():
+    result = fetch_documentation_guide("未知文档")
+    print("test_fetch_documentation_guide_invalid result:", result)
+    assert "error" in result
+    assert "supported" in result
+    assert "需求文档" in result["supported"]
+
+def test_fetch_prompt_template_invalid():
+    result = fetch_prompt_template("未知工具")
+    print("test_fetch_prompt_template_invalid result:", result)
+    assert "error" in result
+    assert "supported" in result
+    assert "Prompt生成" in result["supported"]
+    
+def test_fetch_prompt_template_valid():
+    result = fetch_prompt_template("Prompt生成")
+    print("test_fetch_prompt_template_valid result:", result)
+    assert "cache_path" in result
+    assert result["template_name"] == "Prompt生成"
+    assert os.path.exists(result["cache_path"])
+    with open(result["cache_path"], "r", encoding="utf-8") as f:
+        content = f.read()
+    assert content.strip() != ""
+
+def test_init_project():
+    result = init_project()
+    print("test_init_project result:", result)
+    assert "cache_path" in result
+    assert os.path.exists(result["cache_path"])
+    with open(result["cache_path"], "r", encoding="utf-8") as f:
+        content = f.read()
+    assert content.strip() != ""
+
+
+def test_fetch_requirement_iteration_without_clearing_cache():
+    """
+    测试在不清除缓存的情况下获取需求迭代模板
+    这个测试验证缓存机制是否正常工作
+    """
+    # 第一次获取需求迭代模板，生成缓存
+    result1 = fetch_documentation_guide("需求迭代")
+    print("First fetch result:", result1)
+    assert "cache_path" in result1
+    assert result1["document_category"] == "需求迭代"
+    assert os.path.exists(result1["cache_path"])
+    
+    # 记录第一次的缓存路径
+    first_cache_path = result1["cache_path"]
+    
+    # 第二次获取需求迭代模板，应该使用缓存
+    result2 = fetch_documentation_guide("需求迭代")
+    print("Second fetch result:", result2)
+    assert "cache_path" in result2
+    assert result2["document_category"] == "需求迭代"
+    assert os.path.exists(result2["cache_path"])
+    
+    # 验证两次获取的缓存路径相同（使用缓存）
+    assert result1["cache_path"] == result2["cache_path"], "Cache path should be the same when using cache"
+    
+    # 验证缓存文件内容正确
+    with open(result2["cache_path"], "r", encoding="utf-8") as f:
+        content = f.read()
+    assert content.strip() != ""
+    
+    # 验证缓存映射文件存在且包含正确的映射关系
+    cache_mapping_file = os.path.join(os.path.dirname(__file__), '../.doc_cache/cache_mapping.json')
+    assert os.path.exists(cache_mapping_file), "Cache mapping file should exist"
+    
+    import json
+    with open(cache_mapping_file, "r", encoding="utf-8") as f:
+        cache_mapping = json.load(f)
+    
+    # 验证缓存映射包含当前缓存文件
+    assert first_cache_path in cache_mapping, "Cache mapping should contain the cache file"
+    
+    print("✅ Successfully tested cache mechanism for 需求迭代 template")
+    print(f"Cache file: {first_cache_path}")
+    print(f"Cache mapping entries: {len(cache_mapping)}")
+
+
+# 新增：测试rewrite_and_cache_markdown递归改写和缓存
+
+@pytest.mark.skip(reason="Temporarily skipped for debugging")
+def test_rewrite_and_cache_markdown_basic():
+    src_path = os.path.join(SKILLS_DIR, "requirements/documentation/SKILL.md")
+    cache_path = rewrite_and_cache_markdown(src_path)
+    assert os.path.exists(cache_path)
+    with open(cache_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    assert ".doc_cache" in content or "__" in content
+    assert content.strip() != ""
+
+@pytest.mark.skip(reason="Temporarily skipped for debugging")
+def test_rewrite_and_cache_markdown_recursive():
+    src_path = os.path.join(SKILLS_DIR, "requirements/documentation/SKILL.md")
+    cache_path = rewrite_and_cache_markdown(src_path)
+    assert os.path.exists(cache_path)
+    with open(cache_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    md_links = re.findall(r'\[([^\]]+)\]\(([^)]+)\)', content)
+    for _, link in md_links:
+        if link.endswith(".md") and not link.startswith("http"):
+            assert link.startswith("/Users") or link.startswith("mcp/cache") or os.path.isabs(link)
+
+def test_all_related_documents_cache_paths():
+    """
+    测试生成的文档中所有相关联的文档（以及级联相关联的文档）地址都是正确的，
+    且都在.doc_cache下（除了http的地址外）
+    """
+    # 测试所有文档类型
+    doc_types = ["需求文档", "立项规划文档", "需求迭代", "需求变动", "运营ASO新版本"]
+    
+    for doc_type in doc_types:
+        print(f"Testing doc_type: {doc_type}")
+        result = fetch_documentation_guide(doc_type)
+        assert "cache_path" in result, f"Failed to get cache path for {doc_type}"
+        
+        cache_path = result["cache_path"]
+        assert os.path.exists(cache_path), f"Cache file does not exist: {cache_path}"
+        
+        # 检查缓存文件路径是否在.doc_cache目录下
+        cache_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../.doc_cache'))
+        assert cache_path.startswith(cache_dir), f"Cache file not in .doc_cache directory: {cache_path}"
+        
+        # 读取缓存文件内容
+        with open(cache_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        
+        # 检查所有文档链接
+        _check_all_document_links(content, cache_dir, f"Document: {doc_type}")
+    
+    # 测试所有工具类型
+    tool_names = ["Prompt生成", "标记文档更新", "生成DrawIO文档"]
+    
+    for tool_name in tool_names:
+        print(f"Testing tool_name: {tool_name}")
+        result = fetch_prompt_template(tool_name)
+        assert "cache_path" in result, f"Failed to get cache path for {tool_name}"
+        
+        cache_path = result["cache_path"]
+        assert os.path.exists(cache_path), f"Cache file does not exist: {cache_path}"
+        
+        # 检查缓存文件路径是否在.doc_cache目录下
+        cache_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../.doc_cache'))
+        assert cache_path.startswith(cache_dir), f"Cache file not in .doc_cache directory: {cache_path}"
+        
+        # 读取缓存文件内容
+        with open(cache_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        
+        # 检查所有文档链接
+        _check_all_document_links(content, cache_dir, f"Tool: {tool_name}")
+
+def test_cache_integrity():
+    """
+    测试缓存完整性：确保所有缓存文件中的链接都指向有效的缓存文件
+    """
+    cache_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../.doc_cache'))
+    
+    # 获取所有缓存文件
+    cache_files = []
+    supported_extensions = {'.md', '.txt', '.rst', '.adoc', '.html', '.htm'}
+    for root, _, files in os.walk(cache_dir):
+        for file in files:
+            if any(file.endswith(ext) for ext in supported_extensions):
+                cache_files.append(os.path.join(root, file))
+    
+    print(f"Found {len(cache_files)} cached document files")
+    
+    # 检查每个缓存文件中的链接
+    broken_links = []
+    valid_links = []
+    
+    for cache_file in cache_files:
+        print(f"Checking cache file: {os.path.basename(cache_file)}")
+        
+        try:
+            with open(cache_file, "r", encoding="utf-8") as f:
+                content = f.read()
+            
+            # 匹配所有文档链接
+            doc_links = re.findall(r'\[([^\]]+)\]\(([^)]+)\)', content)
+            
+            for _, link in doc_links:
+                # 跳过不需要检查的链接类型
+                if (link.startswith("http") or 
+                    link.startswith("#")):
+                    continue
+                
+                # 检查文件扩展名是否支持
+                file_ext = os.path.splitext(link)[1].lower()
+                if file_ext not in supported_extensions:
+                    continue
+                
+                # 检查链接是否指向缓存目录
+                if not link.startswith(cache_dir):
+                    broken_links.append({
+                        'file': os.path.basename(cache_file),
+                        'link': link,
+                        'reason': 'Link does not point to cache directory'
+                    })
+                    continue
+                
+                # 检查链接指向的文件是否存在
+                if not os.path.exists(link):
+                    broken_links.append({
+                        'file': os.path.basename(cache_file),
+                        'link': link,
+                        'reason': 'Linked file does not exist'
+                    })
+                else:
+                    valid_links.append({
+                        'file': os.path.basename(cache_file),
+                        'link': os.path.basename(link)
+                    })
+                    
+        except Exception as e:
+            print(f"Error reading cache file {cache_file}: {e}")
+    
+    # 输出检查结果
+    print(f"\nCache integrity check results:")
+    print(f"Valid links: {len(valid_links)}")
+    print(f"Broken links: {len(broken_links)}")
+    
+    if broken_links:
+        print(f"\nBroken links found:")
+        for broken in broken_links:
+            print(f"  - {broken['file']}: {broken['link']} ({broken['reason']})")
+    
+    # 如果存在损坏的链接，记录警告但不失败
+    if broken_links:
+        print(f"\n⚠️  Warning: Found {len(broken_links)} broken links in cache files")
+        print("This may indicate issues with the caching mechanism")
+    else:
+        print(f"\n✅ All cache links are valid!")
+    
+    # 验证所有缓存文件都在.doc_cache目录下
+    for file_path in cache_files:
+        assert file_path.startswith(cache_dir), f"Cache file not in .doc_cache directory: {file_path}"
+
+def _check_all_document_links(content: str, cache_dir: str, context: str, depth: int = 0, max_depth: int = 5, visited: set = None):
+    """
+    检查文档内容中的所有链接是否符合要求，支持递归检查级联相关联的文档
+    
+    Args:
+        content: 文档内容
+        cache_dir: 缓存目录路径
+        context: 上下文信息（用于错误信息）
+        depth: 当前递归深度
+        max_depth: 最大递归深度，防止无限递归
+        visited: 已访问的文件集合，防止循环引用
+    """
+    if visited is None:
+        visited = set()
+    
+    if depth >= max_depth:
+        print(f"  Max depth reached ({max_depth}), stopping recursion in {context}")
+        return
+    
+    # 匹配所有文档链接：[text](link)
+    doc_links = re.findall(r'\[([^\]]+)\]\(([^)]+)\)', content)
+    
+    # 定义支持的文件类型
+    supported_extensions = {'.md', '.txt', '.rst', '.adoc', '.html', '.htm'}
+    recursive_extensions = {'.md', '.txt', '.rst', '.adoc'}  # 可以递归检查内容的文件类型
+    
+    for _, link in doc_links:
+        print(f"  {'  ' * depth}Checking link: [{link}] in {context}")
+        
+        # 跳过不需要检查的链接类型
+        if (link.startswith("http") or 
+            link.startswith("#")):
+            print(f"    {'  ' * depth}Skipping external/anchor link: {link}")
+            continue
+        
+        # 检查文件扩展名是否支持
+        file_ext = os.path.splitext(link)[1].lower()
+        if file_ext not in supported_extensions:
+            print(f"    {'  ' * depth}Skipping unsupported file type: {link}")
+            continue
+        
+        # 检查链接是否指向缓存目录
+        if not link.startswith(cache_dir):
+            # 如果不是绝对路径，检查是否为相对路径指向缓存目录
+            if not os.path.isabs(link):
+                # 相对路径应该指向缓存目录
+                assert False, f"Relative document link should point to cache directory: {link} in {context}"
+            else:
+                # 绝对路径应该指向缓存目录
+                assert link.startswith(cache_dir), f"Absolute document link should point to cache directory: {link} in {context}"
+        
+        # 检查链接指向的文件是否存在
+        target_path = link
+        if not os.path.isabs(link):
+            # 如果是相对路径，需要转换为绝对路径进行检查
+            target_path = os.path.join(cache_dir, link)
+        
+        assert os.path.exists(target_path), f"Linked file does not exist: {link} in {context}"
+        
+        # 检查是否已经访问过这个文件，防止循环引用
+        if target_path in visited:
+            print(f"    {'  ' * depth}Already visited, skipping to prevent circular reference: {target_path}")
+            continue
+        
+        # 只有支持递归的文件类型才进行递归检查
+        if file_ext in recursive_extensions:
+            try:
+                with open(target_path, "r", encoding="utf-8") as f:
+                    linked_content = f.read()
+                
+                # 添加到已访问集合
+                visited.add(target_path)
+                
+                # 递归检查被链接文件中的链接
+                print(f"    {'  ' * depth}Recursively checking linked file: {target_path}")
+                _check_all_document_links(
+                    linked_content, 
+                    cache_dir, 
+                    f"Linked file: {os.path.basename(target_path)}", 
+                    depth + 1, 
+                    max_depth, 
+                    visited
+                )
+                
+            except Exception as e:
+                print(f"    {'  ' * depth}⚠️  Warning: Failed to read linked file {link}: {e} in {context}")
+                continue
+        else:
+            # 对于不支持递归的文件类型，只验证文件存在性
+            print(f"    {'  ' * depth}Non-recursive file type, skipping content check: {target_path}")
+        
+        print(f"    {'  ' * depth}✓ Valid document link: {link}")
+    
+    print(f"  {'  ' * depth}✓ All document links checked for {context}")
+
+def test_cascading_document_links():
+    """
+    测试级联相关联的文档链接，确保所有链接都正确指向缓存目录
+    这个测试会检查一个文档及其所有相关联的文档（递归检查）
+    """
+    # 选择一个有较多链接的文档进行测试
+    result = fetch_documentation_guide("需求文档")
+    assert "cache_path" in result
+    
+    cache_path = result["cache_path"]
+    cache_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../.doc_cache'))
+    
+    # 读取缓存文件内容
+    with open(cache_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    
+    print(f"Testing cascading links for: {cache_path}")
+    
+    # 使用递归检查，设置最大深度为3
+    _check_all_document_links(content, cache_dir, "需求文档", max_depth=3)
+    
+    # 验证所有生成的缓存文件都在.doc_cache目录下
+    cache_files = []
+    supported_extensions = {'.md', '.txt', '.rst', '.adoc', '.html', '.htm'}
+    for root, _, files in os.walk(cache_dir):
+        for file in files:
+            if any(file.endswith(ext) for ext in supported_extensions):
+                cache_files.append(os.path.join(root, file))
+    
+    print(f"Found {len(cache_files)} cached document files:")
+    for file_path in cache_files:
+        print(f"  - {file_path}")
+        assert file_path.startswith(cache_dir), f"Cache file not in .doc_cache directory: {file_path}" 

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@guru-ai-product/ai-product-kit",
-  "version": "0.2.251112183752",
+  "version": "0.2.251113155253",
   "description": "Sync the AI Product Kit Skill bundle through npx without cloning the repository.",
   "bin": {
-    "ai-product-kit": "bin/setup.js"
+    "ai-product-kit": "bin/setup.js",
+    "ai-product-kit-mcp": "bin/mcp-server.js"
   },
   "files": [
     "bin",
-    "skills"
+    "skills",
+    "mcp"
   ],
   "keywords": [
     "mcp",

package/skills/aipk_design/GURU_AI.md

@@ -1,10 +1,10 @@
 # GURU AI Snapshot
 
-Last refreshed: 2025-11-12T10:37:52.798004+00:00
+Last refreshed: 2025-11-13T07:52:53.270Z
 
 | File | Last Modified (UTC) |
 | --- | --- |
-| `SKILL.md` | 2025-11-12T07:57:23.698734+00:00 |
-| `auto_panel_splitter/SKILL.md` | 2025-11-12T07:01:50.772859+00:00 |
-| `auto_panel_splitter/scripts/auto_panel_splitter.js` | 2025-11-12T06:58:38.936920+00:00 |
-| `auto_panel_splitter/scripts/panel_asset_mapper.js` | 2025-11-12T06:59:17.886824+00:00 |
+| `auto_panel_splitter/scripts/auto_panel_splitter.js` | 2025-11-12T10:41:15.854Z |
+| `auto_panel_splitter/scripts/panel_asset_mapper.js` | 2025-11-12T10:41:15.855Z |
+| `auto_panel_splitter/SKILL.md` | 2025-11-12T10:41:15.854Z |
+| `SKILL.md` | 2025-11-12T10:41:15.853Z |

package/skills/aipk_development/GURU_AI.md

@@ -1,8 +1,8 @@
 # GURU AI Snapshot
 
-Last refreshed: 2025-11-12T10:37:52.798886+00:00
+Last refreshed: 2025-11-13T07:52:53.270Z
 
 | File | Last Modified (UTC) |
 | --- | --- |
-| `SKILL.md` | 2025-11-11T13:08:54.321712+00:00 |
-| `templates/实施计划文档.md` | 2025-11-12T07:51:57.026767+00:00 |
+| `SKILL.md` | 2025-11-12T10:41:15.855Z |
+| `templates/实施计划文档.md` | 2025-11-12T10:41:15.855Z |