npm - @comate/zulu - Versions diffs - 1.2.1-beta.2 → 1.3.0 - Mend

@comate/zulu 1.2.1-beta.2 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (169) hide show

package/comate-engine/assets/skills/create-skill-comate/scripts/generate_report.py ADDED Viewed

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""Generate an HTML report from output.
+Takes the JSON output and generates a visual HTML report
+showing each description attempt with check/x for each test case.
+Distinguishes between train and test queries.
+"""
+import argparse
+import html
+import json
+import sys
+from pathlib import Path
+def generate_html(data: dict, auto_refresh: bool = False, skill_name: str = "") -> str:
+    """Generate HTML report from loop output data. If auto_refresh is True, adds a meta refresh tag."""
+    history = data.get("history", [])
+    holdout = data.get("holdout", 0)
+    title_prefix = html.escape(skill_name + " \u2014 ") if skill_name else ""
+    # Get all unique queries from train and test sets, with should_trigger info
+    train_queries: list[dict] = []
+    test_queries: list[dict] = []
+    if history:
+        for r in history[0].get("train_results", history[0].get("results", [])):
+            train_queries.append({"query": r["query"], "should_trigger": r.get("should_trigger", True)})
+        if history[0].get("test_results"):
+            for r in history[0].get("test_results", []):
+                test_queries.append({"query": r["query"], "should_trigger": r.get("should_trigger", True)})
+    refresh_tag = '    <meta http-equiv="refresh" content="5">\n' if auto_refresh else ""
+    html_parts = ["""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+""" + refresh_tag + """    <title>""" + title_prefix + """Skill Description Optimization</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@500;600&family=Lora:wght@400;500&display=swap" rel="stylesheet">
+    <style>
+        body {
+            font-family: 'Lora', Georgia, serif;
+            max-width: 100%;
+            margin: 0 auto;
+            padding: 20px;
+            background: #faf9f5;
+            color: #141413;
+        }
+        h1 { font-family: 'Poppins', sans-serif; color: #141413; }
+        .explainer {
+            background: white;
+            padding: 15px;
+            border-radius: 6px;
+            margin-bottom: 20px;
+            border: 1px solid #e8e6dc;
+            color: #b0aea5;
+            font-size: 0.875rem;
+            line-height: 1.6;
+        }
+        .summary {
+            background: white;
+            padding: 15px;
+            border-radius: 6px;
+            margin-bottom: 20px;
+            border: 1px solid #e8e6dc;
+        }
+        .summary p { margin: 5px 0; }
+        .best { color: #788c5d; font-weight: bold; }
+        .table-container {
+            overflow-x: auto;
+            width: 100%;
+        }
+        table {
+            border-collapse: collapse;
+            background: white;
+            border: 1px solid #e8e6dc;
+            border-radius: 6px;
+            font-size: 12px;
+            min-width: 100%;
+        }
+        th, td {
+            padding: 8px;
+            text-align: left;
+            border: 1px solid #e8e6dc;
+            white-space: normal;
+            word-wrap: break-word;
+        }
+        th {
+            font-family: 'Poppins', sans-serif;
+            background: #141413;
+            color: #faf9f5;
+            font-weight: 500;
+        }
+        th.test-col {
+            background: #6a9bcc;
+        }
+        th.query-col { min-width: 200px; }
+        td.description {
+            font-family: monospace;
+            font-size: 11px;
+            word-wrap: break-word;
+            max-width: 400px;
+        }
+        td.result {
+            text-align: center;
+            font-size: 16px;
+            min-width: 40px;
+        }
+        td.test-result {
+            background: #f0f6fc;
+        }
+        .pass { color: #788c5d; }
+        .fail { color: #c44; }
+        .rate {
+            font-size: 9px;
+            color: #b0aea5;
+            display: block;
+        }
+        tr:hover { background: #faf9f5; }
+        .score {
+            display: inline-block;
+            padding: 2px 6px;
+            border-radius: 4px;
+            font-weight: bold;
+            font-size: 11px;
+        }
+        .score-good { background: #eef2e8; color: #788c5d; }
+        .score-ok { background: #fef3c7; color: #d97706; }
+        .score-bad { background: #fceaea; color: #c44; }
+        .train-label { color: #b0aea5; font-size: 10px; }
+        .test-label { color: #6a9bcc; font-size: 10px; font-weight: bold; }
+        .best-row { background: #f5f8f2; }
+        th.positive-col { border-bottom: 3px solid #788c5d; }
+        th.negative-col { border-bottom: 3px solid #c44; }
+        th.test-col.positive-col { border-bottom: 3px solid #788c5d; }
+        th.test-col.negative-col { border-bottom: 3px solid #c44; }
+        .legend { font-family: 'Poppins', sans-serif; display: flex; gap: 20px; margin-bottom: 10px; font-size: 13px; align-items: center; }
+        .legend-item { display: flex; align-items: center; gap: 6px; }
+        .legend-swatch { width: 16px; height: 16px; border-radius: 3px; display: inline-block; }
+        .swatch-positive { background: #141413; border-bottom: 3px solid #788c5d; }
+        .swatch-negative { background: #141413; border-bottom: 3px solid #c44; }
+        .swatch-test { background: #6a9bcc; }
+        .swatch-train { background: #141413; }
+    </style>
+</head>
+<body>
+    <h1>""" + title_prefix + """Skill Description Optimization</h1>
+    <div class="explainer">
+        <strong>Optimizing your skill's description.</strong> This page updates automatically as Comate tests different versions of your skill's description. Each row is an iteration — a new description attempt. The columns show test queries: green checkmarks mean the skill triggered correctly (or correctly didn't trigger), red crosses mean it got it wrong. The "Train" score shows performance on queries used to improve the description; the "Test" score shows performance on held-out queries the optimizer hasn't seen. When it's done, Comate will apply the best-performing description to your skill.
+    </div>
+"""]
+    # Summary section
+    best_test_score = data.get('best_test_score')
+    best_train_score = data.get('best_train_score')
+    html_parts.append(f"""
+    <div class="summary">
+        <p><strong>Original:</strong> {html.escape(data.get('original_description', 'N/A'))}</p>
+        <p class="best"><strong>Best:</strong> {html.escape(data.get('best_description', 'N/A'))}</p>
+        <p><strong>Best Score:</strong> {data.get('best_score', 'N/A')} {'(test)' if best_test_score else '(train)'}</p>
+        <p><strong>Iterations:</strong> {data.get('iterations_run', 0)} | <strong>Train:</strong> {data.get('train_size', '?')} | <strong>Test:</strong> {data.get('test_size', '?')}</p>
+    </div>
+""")
+    # Legend
+    html_parts.append("""
+    <div class="legend">
+        <span style="font-weight:600">Query columns:</span>
+        <span class="legend-item"><span class="legend-swatch swatch-positive"></span> Should trigger</span>
+        <span class="legend-item"><span class="legend-swatch swatch-negative"></span> Should NOT trigger</span>
+        <span class="legend-item"><span class="legend-swatch swatch-train"></span> Train</span>
+        <span class="legend-item"><span class="legend-swatch swatch-test"></span> Test</span>
+    </div>
+""")
+    # Table header
+    html_parts.append("""
+    <div class="table-container">
+    <table>
+        <thead>
+            <tr>
+                <th>Iter</th>
+                <th>Train</th>
+                <th>Test</th>
+                <th class="query-col">Description</th>
+""")
+    # Add column headers for train queries
+    for qinfo in train_queries:
+        polarity = "positive-col" if qinfo["should_trigger"] else "negative-col"
+        html_parts.append(f'                <th class="{polarity}">{html.escape(qinfo["query"])}</th>\n')
+    # Add column headers for test queries (different color)
+    for qinfo in test_queries:
+        polarity = "positive-col" if qinfo["should_trigger"] else "negative-col"
+        html_parts.append(f'                <th class="test-col {polarity}">{html.escape(qinfo["query"])}</th>\n')
+    html_parts.append("""            </tr>
+        </thead>
+        <tbody>
+""")
+    # Find best iteration for highlighting
+    if test_queries:
+        best_iter = max(history, key=lambda h: h.get("test_passed") or 0).get("iteration")
+    else:
+        best_iter = max(history, key=lambda h: h.get("train_passed", h.get("passed", 0))).get("iteration")
+    # Add rows for each iteration
+    for h in history:
+        iteration = h.get("iteration", "?")
+        train_passed = h.get("train_passed", h.get("passed", 0))
+        train_total = h.get("train_total", h.get("total", 0))
+        test_passed = h.get("test_passed")
+        test_total = h.get("test_total")
+        description = h.get("description", "")
+        train_results = h.get("train_results", h.get("results", []))
+        test_results = h.get("test_results", [])
+        # Create lookups for results by query
+        train_by_query = {r["query"]: r for r in train_results}
+        test_by_query = {r["query"]: r for r in test_results} if test_results else {}
+        # Compute aggregate correct/total runs across all retries
+        def aggregate_runs(results: list[dict]) -> tuple[int, int]:
+            correct = 0
+            total = 0
+            for r in results:
+                runs = r.get("runs", 0)
+                triggers = r.get("triggers", 0)
+                total += runs
+                if r.get("should_trigger", True):
+                    correct += triggers
+                else:
+                    correct += runs - triggers
+            return correct, total
+        train_correct, train_runs = aggregate_runs(train_results)
+        test_correct, test_runs = aggregate_runs(test_results)
+        # Determine score classes
+        def score_class(correct: int, total: int) -> str:
+            if total > 0:
+                ratio = correct / total
+                if ratio >= 0.8:
+                    return "score-good"
+                elif ratio >= 0.5:
+                    return "score-ok"
+            return "score-bad"
+        train_class = score_class(train_correct, train_runs)
+        test_class = score_class(test_correct, test_runs)
+        row_class = "best-row" if iteration == best_iter else ""
+        html_parts.append(f"""            <tr class="{row_class}">
+                <td>{iteration}</td>
+                <td><span class="score {train_class}">{train_correct}/{train_runs}</span></td>
+                <td><span class="score {test_class}">{test_correct}/{test_runs}</span></td>
+                <td class="description">{html.escape(description)}</td>
+""")
+        # Add result for each train query
+        for qinfo in train_queries:
+            r = train_by_query.get(qinfo["query"], {})
+            did_pass = r.get("pass", False)
+            triggers = r.get("triggers", 0)
+            runs = r.get("runs", 0)
+            icon = "✓" if did_pass else "✗"
+            css_class = "pass" if did_pass else "fail"
+            html_parts.append(
+                f'                <td class="result {css_class}">{icon}<span '
+                f'class="rate">{triggers}/{runs}</span></td>\n')
+        # Add result for each test query (with different background)
+        for qinfo in test_queries:
+            r = test_by_query.get(qinfo["query"], {})
+            did_pass = r.get("pass", False)
+            triggers = r.get("triggers", 0)
+            runs = r.get("runs", 0)
+            icon = "✓" if did_pass else "✗"
+            css_class = "pass" if did_pass else "fail"
+            html_parts.append(
+                f'                <td class="result test-result {css_class}">{icon}<span class="rate">'
+                f'{triggers}/{runs}</span></td>\n')
+        html_parts.append("            </tr>\n")
+    html_parts.append("""        </tbody>
+    </table>
+    </div>
+""")
+    html_parts.append("""
+</body>
+</html>
+""")
+    return "".join(html_parts)
+def main():
+    """
+    Main entry point for the script.
+    :return:
+    """
+    parser = argparse.ArgumentParser(description="Generate HTML report from output")
+    parser.add_argument("input", help="Path to JSON output from (or - for stdin)")
+    parser.add_argument("-o", "--output", default=None, help="Output HTML file (default: stdout)")
+    parser.add_argument("--skill-name", default="", help="Skill name to include in the report title")
+    args = parser.parse_args()
+    if args.input == "-":
+        data = json.load(sys.stdin)
+    else:
+        data = json.loads(Path(args.input).read_text())
+    html_output = generate_html(data, skill_name=args.skill_name)
+    if args.output:
+        Path(args.output).write_text(html_output)
+        print(f"Report written to {args.output}", file=sys.stderr)
+    else:
+        print(html_output)
+if __name__ == "__main__":
+    main()

package/comate-engine/assets/skills/create-skill-comate/scripts/package_skill.py ADDED Viewed

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Skill Packager - Creates a distributable .skill file of a skill folder
+Usage:
+    python utils/package_skill.py <path/to/skill-folder> [output-directory]
+Example:
+    python utils/package_skill.py skills/public/my-skill
+    python utils/package_skill.py skills/public/my-skill ./dist
+"""
+import fnmatch
+import sys
+import zipfile
+from pathlib import Path
+from scripts.quick_validate import validate_skill
+# Patterns to exclude when packaging skills.
+EXCLUDE_DIRS = {"__pycache__", "node_modules"}
+EXCLUDE_GLOBS = {"*.pyc"}
+EXCLUDE_FILES = {".DS_Store"}
+# Directories excluded only at the skill root (not when nested deeper).
+ROOT_EXCLUDE_DIRS = {"evals"}
+def should_exclude(rel_path: Path) -> bool:
+    """Check if a path should be excluded from packaging."""
+    parts = rel_path.parts
+    if any(part in EXCLUDE_DIRS for part in parts):
+        return True
+    # rel_path is relative to skill_path.parent, so parts[0] is the skill
+    # folder name and parts[1] (if present) is the first subdir.
+    if len(parts) > 1 and parts[1] in ROOT_EXCLUDE_DIRS:
+        return True
+    name = rel_path.name
+    if name in EXCLUDE_FILES:
+        return True
+    return any(fnmatch.fnmatch(name, pat) for pat in EXCLUDE_GLOBS)
+def package_skill(skill_path, output_dir=None):
+    """
+    Package a skill folder into a .skill file.
+    Args:
+        skill_path: Path to the skill folder
+        output_dir: Optional output directory for the .skill file (defaults to current directory)
+    Returns:
+        Path to the created .skill file, or None if error
+    """
+    skill_path = Path(skill_path).resolve()
+    # Validate skill folder exists
+    if not skill_path.exists():
+        print(f"❌ Error: Skill folder not found: {skill_path}")
+        return None
+    if not skill_path.is_dir():
+        print(f"❌ Error: Path is not a directory: {skill_path}")
+        return None
+    # Validate SKILL.md exists
+    skill_md = skill_path / "SKILL.md"
+    if not skill_md.exists():
+        print(f"❌ Error: SKILL.md not found in {skill_path}")
+        return None
+    # Run validation before packaging
+    print("🔍 Validating skill...")
+    valid, message = validate_skill(skill_path)
+    if not valid:
+        print(f"❌ Validation failed: {message}")
+        print("   Please fix the validation errors before packaging.")
+        return None
+    print(f"✅ {message}\n")
+    # Determine output location
+    skill_name = skill_path.name
+    if output_dir:
+        output_path = Path(output_dir).resolve()
+        output_path.mkdir(parents=True, exist_ok=True)
+    else:
+        output_path = Path.cwd()
+    skill_filename = output_path / f"{skill_name}.skill"
+    # Create the .skill file (zip format)
+    try:
+        with zipfile.ZipFile(skill_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            # Walk through the skill directory, excluding build artifacts
+            for file_path in skill_path.rglob('*'):
+                if not file_path.is_file():
+                    continue
+                arcname = file_path.relative_to(skill_path.parent)
+                if should_exclude(arcname):
+                    print(f"  Skipped: {arcname}")
+                    continue
+                zipf.write(file_path, arcname)
+                print(f"  Added: {arcname}")
+        print(f"\n✅ Successfully packaged skill to: {skill_filename}")
+        return skill_filename
+    except Exception as e:
+        print(f"❌ Error creating .skill file: {e}")
+        return None
+def main():
+    """
+    Main entry point for the script.
+    :return:
+    """
+    if len(sys.argv) < 2:
+        print("Usage: python utils/package_skill.py <path/to/skill-folder> [output-directory]")
+        print("\nExample:")
+        print("  python utils/package_skill.py skills/public/my-skill")
+        print("  python utils/package_skill.py skills/public/my-skill ./dist")
+        sys.exit(1)
+    skill_path = sys.argv[1]
+    output_dir = sys.argv[2] if len(sys.argv) > 2 else None
+    print(f"📦 Packaging skill: {skill_path}")
+    if output_dir:
+        print(f"   Output directory: {output_dir}")
+    print()
+    result = package_skill(skill_path, output_dir)
+    if result:
+        sys.exit(0)
+    else:
+        sys.exit(1)
+if __name__ == "__main__":
+    main()

package/comate-engine/assets/skills/create-skill-comate/scripts/utils.py ADDED Viewed

@@ -0,0 +1,53 @@
+"""Shared utilities for skill-creator scripts."""
+from __future__ import annotations
+from pathlib import Path
+def parse_skill_md(skill_path: Path) -> tuple[str, str, str]:
+    """
+    Parse the name, description, and content of a skill from its SKILL.md file.
+    :param skill_path:
+    :return:
+    """
+    content = (skill_path / "SKILL.md").read_text()
+    lines = content.split("\n")
+    if lines[0].strip() != "---":
+        raise ValueError("SKILL.md missing frontmatter (no opening ---)")
+    end_idx = None
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            end_idx = i
+            break
+    if end_idx is None:
+        raise ValueError("SKILL.md missing frontmatter (no closing ---)")
+    name = ""
+    description = ""
+    frontmatter_lines = lines[1:end_idx]
+    i = 0
+    while i < len(frontmatter_lines):
+        line = frontmatter_lines[i]
+        if line.startswith("name:"):
+            name = line[len("name:"):].strip().strip('"').strip("'")
+        elif line.startswith("description:"):
+            value = line[len("description:"):].strip()
+            # Handle YAML multiline indicators (>, |, >-, |-)
+            if value in (">", "|", ">-", "|-"):
+                continuation_lines: list[str] = []
+                i += 1
+                while i < len(frontmatter_lines) and (frontmatter_lines[i].startswith("  ") or
+                                                      frontmatter_lines[i].startswith("\t")):
+                    continuation_lines.append(frontmatter_lines[i].strip())
+                    i += 1
+                description = " ".join(continuation_lines)
+                continue
+            else:
+                description = value.strip('"').strip("'")
+        i += 1
+    return name, description, content

package/comate-engine/assets/skills/find-skills-comate/SKILL.md CHANGED Viewed

@@ -4,6 +4,7 @@ description: 当用户提出可能需要专业能力的问题，且本地已安
 metadata:
   enableWhen:
     - isInternal
+version: 20260410
 ---
 # Skill搜索器
@@ -28,10 +29,10 @@ metadata:
 优先使用Comate内部平台，不可用时自动降级到开源生态：
-| 来源               | 获取方式                          | 适用场景               |
-| ------------------ | --------------------------------- | ---------------------- |
-| Comate内部平台     | `python3 scripts/fetch_skills.py` | Comate用户，内网环境   |
-| 开源生态（skills.sh） | `npx skills find [query]`      | 通用场景，内网不可达时 |
+| 来源               | 获取方式                                                                           | 适用场景               |
+| ------------------ |--------------------------------------------------------------------------------| ---------------------- |
+| Comate内部平台     | `python3 ${COMATE_SKILL_DIR}/scripts/fetch_skills.py --page 1 --page-size 200` | Comate用户，内网环境   |
+| 开源生态（skills.sh） | `npx skills find [query]`                                                      | 通用场景，内网不可达时 |
 > 若两个来源均不可用，告知用户并直接用现有能力处理请求。
@@ -39,10 +40,10 @@ metadata:
 根据用户意图和skill来源确定安装位置：
-| 意图            | 来源   | 安装路径                         | 说明                       |
+| 意图            | 来源       | 安装路径                         | 说明                       |
 | --------------- |------| -------------------------------- | -------------------------- |
-| 安装到当前项目  | Comate | `.comate/skills/<skill_name>/`   | 仅当前项目可用，随仓库共享 |
-| 安装到全局/个人 | Comate | `~/.comate/skills/<skill_name>/` | 所有项目可用，个人专属     |
+| 安装到当前项目  | Comate     | `.comate/skills/<skill_name>/`   | 仅当前项目可用，随仓库共享 |
+| 安装到全局/个人 | Comate     | `~/.comate/skills/<skill_name>/` | 所有项目可用，个人专属     |
 | 安装到当前项目  | 开源生态 | `.agents/skills/<skill_name>/`   | 仅当前项目可用，随仓库共享 |
 | 安装到全局/个人 | 开源生态 | `~/.agents/skills/<skill_name>/` | 所有项目可用，个人专属     |
@@ -70,8 +71,10 @@ metadata:
 **优先尝试Comate内部平台：**
+注意：如果第一页（page=1）没有找到，请继续遍历下一页，直到展示出Comate平台所有的skill之后再判断skill是否存在
 ```bash
-python3 scripts/fetch_skills.py
+python3 ${COMATE_SKILL_DIR}/scripts/fetch_skills.py --page 1 --page-size 200
 ```
 脚本输出包含skill名称和描述的JSON。
@@ -116,7 +119,7 @@ npx skills find [query]
 ### 步骤5：获取下载链接（仅Comate来源）
 ```bash
-python3 scripts/get_download_url.py <skill_name>
+python3 ${COMATE_SKILL_DIR}/scripts/get_download_url.py <skill_name>
 ```
 > 开源来源跳过此步骤，直接进入预览。
@@ -128,7 +131,7 @@ python3 scripts/get_download_url.py <skill_name>
 **Comate来源：**
 ```bash
-python3 scripts/preview_skill.py <skill_name> <download_url>
+python3 ${COMATE_SKILL_DIR}/scripts/preview_skill.py <skill_name> <download_url>
 ```
 **开源来源：**
@@ -167,10 +170,10 @@ https://skills.sh/<owner>/<repo>/<skill-name>
 ```bash
 # 安装到当前项目
-python3 scripts/install_skill.py <skill_name> <download_url> --scope project
+python3 ${COMATE_SKILL_DIR}/scripts/install_skill.py <skill_name> <download_url> --scope project
 # 安装到全局个人目录
-python3 scripts/install_skill.py <skill_name> <download_url> --scope global
+python3 ${COMATE_SKILL_DIR}/scripts/install_skill.py <skill_name> <download_url> --scope global
 ```
 **开源来源（skills.sh）：**

package/comate-engine/assets/skills/find-skills-comate/scripts/fetch_skills.py CHANGED Viewed

@@ -2,23 +2,33 @@
 """
 从Comate Skills中心获取所有可用的skills。
 """
+import argparse
 import sys
 import json
 import urllib.request
 import urllib.error
+import urllib.parse
 API_BASE_URL = "http://10.11.152.208:8101/api/v1/skills/metadata"
-def fetch_skills():
+def fetch_skills(page=1, page_size=200):
     """
     从API获取所有可用skills的列表。
+    参数:
+        page: 页码，默认 1
+        page_size: 每页数量，默认 200
     返回:
         list: 包含'name'和'description'字段的skill字典列表
         None: 如果API调用失败
     """
-    url = API_BASE_URL
+    params = urllib.parse.urlencode({
+        "page": page,
+        "pageSize": page_size,
+    })
+    url = f"{API_BASE_URL}?{params}"
     try:
         with urllib.request.urlopen(url, timeout=10) as response:
@@ -44,7 +54,25 @@ def fetch_skills():
 def main():
     """获取所有可用skills并以JSON格式输出。"""
-    skills = fetch_skills()
+    parser = argparse.ArgumentParser(
+        description="Fetch Comate platform skills"
+    )
+    parser.add_argument(
+        "--page",
+        type=int,
+        default=1,
+        help="Page number (default: 1)"
+    )
+    parser.add_argument(
+        "--page-size",
+        type=int,
+        default=200,
+        help="Number of skills per page (default: 600)"
+    )
+    args = parser.parse_args()
+    skills = fetch_skills(page=args.page, page_size=args.page_size)
     if skills is None:
         print("Failed to fetch skills from the platform.", file=sys.stderr)
@@ -53,5 +81,6 @@ def main():
     # 输出JSON格式，方便Comate解析
     print(json.dumps(skills, ensure_ascii=False, indent=2))
 if __name__ == "__main__":
     main()