metame-cli 1.5.11 → 1.5.13

package/skills/skill-manager/scripts/scan_and_check.py

@@ -0,0 +1,125 @@
+import os
+import sys
+import yaml
+import json
+import subprocess
+import concurrent.futures
+
+def get_remote_hash(url):
+    """Fetch the latest commit hash from the remote repository."""
+    try:
+        # Using git ls-remote to avoid downloading the whole repo
+        # Asking for HEAD specifically
+        result = subprocess.run(
+            ['git', 'ls-remote', url, 'HEAD'], 
+            capture_output=True, 
+            text=True, 
+            timeout=10
+        )
+        if result.returncode != 0:
+            return None
+        # Output format: <hash>\tHEAD
+        parts = result.stdout.split()
+        if parts:
+            return parts[0]
+        return None
+    except Exception:
+        return None
+
+def scan_skills(skills_root):
+    """Scan all subdirectories for SKILL.md and extract metadata."""
+    skill_list = []
+    
+    if not os.path.exists(skills_root):
+        print(f"Skills root not found: {skills_root}", file=sys.stderr)
+        return []
+
+    for item in os.listdir(skills_root):
+        skill_dir = os.path.join(skills_root, item)
+        if not os.path.isdir(skill_dir):
+            continue
+            
+        skill_md = os.path.join(skill_dir, "SKILL.md")
+        if not os.path.exists(skill_md):
+            continue
+            
+        # Parse Frontmatter
+        try:
+            with open(skill_md, 'r', encoding='utf-8') as f:
+                content = f.read()
+                
+            # Extract YAML between first two ---
+            parts = content.split('---')
+            if len(parts) < 3:
+                continue # Invalid format
+                
+            frontmatter = yaml.safe_load(parts[1])
+            
+            # Check if managed by github-to-skills
+            if 'github_url' in frontmatter:
+                skill_list.append({
+                    "name": frontmatter.get('name', item),
+                    "dir": skill_dir,
+                    "github_url": frontmatter['github_url'],
+                    "local_hash": frontmatter.get('github_hash', 'unknown'),
+                    "local_version": frontmatter.get('version', '0.0.0')
+                })
+        except Exception as e:
+            # print(f"Skipping {item}: {e}", file=sys.stderr)
+            pass
+            
+    return skill_list
+
+def check_updates(skills):
+    """Check for updates concurrently."""
+    results = []
+    
+    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+        # Create a map of future -> skill
+        future_to_skill = {
+            executor.submit(get_remote_hash, skill['github_url']): skill 
+            for skill in skills
+        }
+        
+        for future in concurrent.futures.as_completed(future_to_skill):
+            skill = future_to_skill[future]
+            try:
+                remote_hash = future.result()
+                skill['remote_hash'] = remote_hash
+                
+                if not remote_hash:
+                    skill['status'] = 'error'
+                    skill['message'] = 'Could not reach remote'
+                elif remote_hash != skill['local_hash']:
+                    skill['status'] = 'outdated'
+                    skill['message'] = 'New commits available'
+                else:
+                    skill['status'] = 'current'
+                    skill['message'] = 'Up to date'
+                    
+                results.append(skill)
+            except Exception as e:
+                skill['status'] = 'error'
+                skill['message'] = str(e)
+                results.append(skill)
+                
+    return results
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        # Default to standard Claude skills path if not provided
+        # Trying to guess typical Windows path for this user context
+        default_path = os.path.expanduser(r"~\.claude\skills")
+        # But we are in a tool env, let's use the provided one or current dir
+        if os.path.exists(r"C:\Users\20515\.claude\skills"):
+            target_dir = r"C:\Users\20515\.claude\skills"
+        else:
+            print("Usage: python scan_and_check.py <skills_dir>")
+            sys.exit(1)
+    else:
+        target_dir = sys.argv[1]
+
+    skills = scan_skills(target_dir)
+    updates = check_updates(skills)
+    
+    print(json.dumps(updates, indent=2))

package/skills/skill-manager/scripts/sync_index.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import re
+import sys
+from pathlib import Path
+
+import yaml
+
+START_MARKER = "<!-- AUTO-SKILL-INDEX:START -->"
+END_MARKER = "<!-- AUTO-SKILL-INDEX:END -->"
+
+
+def parse_frontmatter(skill_md_path: Path):
+    try:
+        text = skill_md_path.read_text(encoding="utf-8")
+    except Exception:
+        return None, None
+
+    m = re.match(r"^---\n(.*?)\n---", text, re.DOTALL)
+    if not m:
+        return None, None
+
+    try:
+        meta = yaml.safe_load(m.group(1)) or {}
+    except Exception:
+        return None, None
+
+    name = str(meta.get("name") or "").strip()
+    desc = str(meta.get("description") or "").strip()
+    return name, desc
+
+
+def short_desc(text: str, limit: int = 72):
+    clean = re.sub(r"\s+", " ", text).strip()
+    if len(clean) <= limit:
+        return clean
+    return clean[: limit - 3] + "..."
+
+
+def table_escape(text: str):
+    return text.replace("|", "\\|")
+
+
+def source_label(root: Path):
+    s = str(root)
+    if "/.claude/" in s:
+        return "claude"
+    if "/.opencode/" in s:
+        return "opencode"
+    return root.name or "local"
+
+
+def collect_skills(roots):
+    skills = {}
+    for root in roots:
+        if not root.exists() or not root.is_dir():
+            continue
+        src = source_label(root)
+        for entry in sorted(root.iterdir(), key=lambda p: p.name.lower()):
+            if entry.name.startswith("."):
+                continue
+            if not entry.is_dir():
+                continue
+            skill_md = entry / "SKILL.md"
+            if not skill_md.exists():
+                continue
+            name, desc = parse_frontmatter(skill_md)
+            if not name:
+                name = entry.name
+            if name in skills:
+                continue
+            skills[name] = {
+                "source": src,
+                "desc": short_desc(desc or "No description"),
+            }
+    return skills
+
+
+def render_table(skills):
+    lines = [
+        "| Skill 名 | 来源 | 描述摘要 |",
+        "|---|---|---|",
+    ]
+    for name in sorted(skills.keys(), key=str.lower):
+        item = skills[name]
+        lines.append(
+            f"| `{table_escape(name)}` | {table_escape(item['source'])} | {table_escape(item['desc'])} |"
+        )
+    return "\n".join(lines)
+
+
+def inject_table(skill_md_path: Path, table_md: str):
+    text = skill_md_path.read_text(encoding="utf-8")
+    block = f"{START_MARKER}\n{table_md}\n{END_MARKER}"
+
+    if START_MARKER in text and END_MARKER in text:
+        pattern = re.compile(
+            re.escape(START_MARKER) + r".*?" + re.escape(END_MARKER),
+            re.DOTALL,
+        )
+        new_text = pattern.sub(block, text)
+    else:
+        append = (
+            "\n\n## 已注册技能清单（自动生成）\n\n"
+            "由 `scripts/sync_index.py` 维护，请勿手工编辑该区块。\n\n"
+            f"{block}\n"
+        )
+        new_text = text + append
+
+    skill_md_path.write_text(new_text, encoding="utf-8")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Scan skills folders and sync auto-generated skill index section in SKILL.md."
+    )
+    parser.add_argument(
+        "--skill-md",
+        required=True,
+        help="Path to skill-manager SKILL.md to update.",
+    )
+    parser.add_argument(
+        "roots",
+        nargs="+",
+        help="Skill root folders to scan (e.g. ~/.claude/skills ~/.opencode/skills).",
+    )
+    args = parser.parse_args()
+
+    skill_md_path = Path(os.path.expanduser(args.skill_md)).resolve()
+    roots = [Path(os.path.expanduser(r)).resolve() for r in args.roots]
+
+    if not skill_md_path.exists():
+        print(f"[ERROR] skill markdown not found: {skill_md_path}")
+        sys.exit(1)
+
+    skills = collect_skills(roots)
+    table_md = render_table(skills)
+    inject_table(skill_md_path, table_md)
+    print(f"[OK] synced {len(skills)} skills into {skill_md_path}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/skill-manager/scripts/update_helper.py

@@ -0,0 +1,39 @@
+import shutil
+import os
+import sys
+import datetime
+
+def backup_skill(skill_path):
+    """
+    Backs up SKILL.md to SKILL.md.bak.<timestamp>
+    """
+    if not os.path.exists(skill_path):
+        return False, "Skill path does not exist"
+        
+    skill_md = os.path.join(skill_path, "SKILL.md")
+    if not os.path.exists(skill_md):
+        return False, "SKILL.md not found"
+        
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_name = f"SKILL.md.bak.{timestamp}"
+    backup_path = os.path.join(skill_path, backup_name)
+    
+    try:
+        shutil.copy2(skill_md, backup_path)
+        return True, backup_path
+    except Exception as e:
+        return False, str(e)
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python update_helper.py <skill_dir>")
+        sys.exit(1)
+        
+    skill_dir = sys.argv[1]
+    success, msg = backup_skill(skill_dir)
+    
+    if success:
+        print(f"Backup created: {msg}")
+    else:
+        print(f"Backup failed: {msg}")
+        sys.exit(1)