myagent-ai 1.0.0

package/skills/storyboard-manager/scripts/timeline_tracker.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+Timeline Tracker for Storyboard Manager
+
+This script analyzes markdown files in a storyboard project to extract and organize
+timeline events, helping writers maintain chronological consistency.
+"""
+
+import os
+import re
+import json
+import sys
+from pathlib import Path
+from typing import List, Dict, Tuple, Optional
+from datetime import datetime, timedelta
+from collections import defaultdict
+
+
+class TimelineEvent:
+    """Represents a single event in the story timeline"""
+
+    def __init__(self, content: str, location: str, chapter: str = None,
+                 timepoint: str = None, characters: List[str] = None):
+        self.content = content
+        self.location = location  # File path where event was found
+        self.chapter = chapter
+        self.timepoint = timepoint  # Relative time (e.g., "Day 1", "3 weeks later")
+        self.characters = characters or []
+
+    def __repr__(self):
+        return f"TimelineEvent({self.timepoint}: {self.content[:50]}...)"
+
+
+class TimelineTracker:
+    """Main timeline tracking and analysis class"""
+
+    # Patterns to detect time markers in text
+    TIME_PATTERNS = [
+        r'(?:Day|Night)\s+(\d+)',  # Day 1, Night 3
+        r'(\d+)\s+(?:days?|weeks?|months?|years?)\s+(?:later|ago|after|before)',
+        r'(?:Morning|Afternoon|Evening|Night)\s+of\s+(?:Day\s+)?(\d+)',
+        r'Chapter\s+(\d+)',  # Chapter markers
+        r'\*\*(?:Timeline|Time|When):\*\*\s*(.+?)(?:\n|$)',  # Explicit timeline markers
+        r'\*\*Date:\*\*\s*(.+?)(?:\n|$)',
+    ]
+
+    # Patterns to detect character mentions
+    CHARACTER_PATTERNS = [
+        r'\*\*Characters?:\*\*\s*(.+?)(?:\n|$)',
+        r'\*\*(?:POV|Perspective):\*\*\s*(.+?)(?:\n|$)',
+    ]
+
+    def __init__(self, project_root: str):
+        self.project_root = Path(project_root)
+        self.events: List[TimelineEvent] = []
+        self.characters: set = set()
+
+    def scan_directory(self, directory: Path) -> List[Path]:
+        """Recursively find all markdown files in directory"""
+        md_files = []
+        if not directory.exists():
+            return md_files
+
+        for item in directory.iterdir():
+            if item.is_file() and item.suffix == '.md':
+                md_files.append(item)
+            elif item.is_dir() and not item.name.startswith('.'):
+                md_files.extend(self.scan_directory(item))
+
+        return md_files
+
+    def extract_characters_from_file(self, file_path: Path) -> List[str]:
+        """Extract character names from character profile files"""
+        try:
+            content = file_path.read_text(encoding='utf-8')
+
+            # Look for character name in title (# Character Name)
+            name_match = re.search(r'^#\s+(.+?)$', content, re.MULTILINE)
+            if name_match:
+                return [name_match.group(1).strip()]
+
+            # Look for explicit name field
+            name_match = re.search(r'\*\*Name:\*\*\s*(.+?)(?:\n|$)', content)
+            if name_match:
+                return [name_match.group(1).strip()]
+
+        except Exception as e:
+            print(f"Warning: Could not read {file_path}: {e}", file=sys.stderr)
+
+        return []
+
+    def extract_timeline_markers(self, content: str) -> List[Tuple[str, int]]:
+        """Extract time markers from content, return list of (timepoint, position)"""
+        markers = []
+
+        for pattern in self.TIME_PATTERNS:
+            for match in re.finditer(pattern, content, re.IGNORECASE):
+                timepoint = match.group(1) if match.lastindex else match.group(0)
+                markers.append((timepoint.strip(), match.start()))
+
+        return sorted(markers, key=lambda x: x[1])
+
+    def extract_character_mentions(self, content: str) -> List[str]:
+        """Extract character names from explicit character markers"""
+        characters = []
+
+        for pattern in self.CHARACTER_PATTERNS:
+            matches = re.finditer(pattern, content, re.IGNORECASE)
+            for match in matches:
+                char_text = match.group(1)
+                # Split by commas, 'and', '&'
+                names = re.split(r'[,&]|\sand\s', char_text)
+                characters.extend([name.strip() for name in names if name.strip()])
+
+        return characters
+
+    def find_character_references(self, content: str, known_characters: set) -> List[str]:
+        """Find mentions of known characters in content"""
+        found = []
+        for character in known_characters:
+            # Simple word boundary check
+            if re.search(r'\b' + re.escape(character) + r'\b', content, re.IGNORECASE):
+                found.append(character)
+        return found
+
+    def parse_chapter_file(self, file_path: Path) -> List[TimelineEvent]:
+        """Parse a chapter/scene file for timeline events"""
+        events = []
+
+        try:
+            content = file_path.read_text(encoding='utf-8')
+
+            # Get chapter number/name from filename or title
+            chapter = file_path.stem
+            title_match = re.search(r'^#\s+(.+?)$', content, re.MULTILINE)
+            if title_match:
+                chapter = title_match.group(1).strip()
+
+            # Extract explicit character mentions
+            explicit_chars = self.extract_character_mentions(content)
+
+            # Find timeline markers
+            markers = self.extract_timeline_markers(content)
+
+            # Split content into sections based on markers
+            if markers:
+                sections = []
+                for i, (timepoint, pos) in enumerate(markers):
+                    start_pos = pos
+                    end_pos = markers[i + 1][1] if i + 1 < len(markers) else len(content)
+                    section_content = content[start_pos:end_pos]
+
+                    # Find characters in this section
+                    section_chars = explicit_chars.copy()
+                    section_chars.extend(self.find_character_references(
+                        section_content, self.characters))
+
+                    event = TimelineEvent(
+                        content=section_content[:500],  # First 500 chars as preview
+                        location=str(file_path.relative_to(self.project_root)),
+                        chapter=chapter,
+                        timepoint=timepoint,
+                        characters=list(set(section_chars))
+                    )
+                    events.append(event)
+            else:
+                # No explicit markers, treat whole file as one event
+                all_chars = explicit_chars.copy()
+                all_chars.extend(self.find_character_references(content, self.characters))
+
+                event = TimelineEvent(
+                    content=content[:500],
+                    location=str(file_path.relative_to(self.project_root)),
+                    chapter=chapter,
+                    timepoint=None,
+                    characters=list(set(all_chars))
+                )
+                events.append(event)
+
+        except Exception as e:
+            print(f"Warning: Error parsing {file_path}: {e}", file=sys.stderr)
+
+        return events
+
+    def analyze_project(self) -> Dict:
+        """Analyze entire project and build timeline"""
+
+        # First, find all characters
+        char_dirs = ['characters', 'Characters', 'cast']
+        for dirname in char_dirs:
+            char_dir = self.project_root / dirname
+            if char_dir.exists():
+                for char_file in self.scan_directory(char_dir):
+                    names = self.extract_characters_from_file(char_file)
+                    self.characters.update(names)
+
+        # Then scan chapters/scenes
+        content_dirs = ['chapters', 'Chapters', 'scenes', 'Scenes', 'story']
+        for dirname in content_dirs:
+            content_dir = self.project_root / dirname
+            if content_dir.exists():
+                for content_file in self.scan_directory(content_dir):
+                    events = self.parse_chapter_file(content_file)
+                    self.events.extend(events)
+
+        # Build analysis
+        analysis = {
+            'total_events': len(self.events),
+            'total_characters': len(self.characters),
+            'characters': sorted(list(self.characters)),
+            'events_by_timepoint': self._group_events_by_time(),
+            'events_by_character': self._group_events_by_character(),
+            'events_by_chapter': self._group_events_by_chapter(),
+            'timeline': self._build_timeline(),
+            'warnings': self._check_consistency()
+        }
+
+        return analysis
+
+    def _group_events_by_time(self) -> Dict[str, List[Dict]]:
+        """Group events by their timepoint"""
+        grouped = defaultdict(list)
+
+        for event in self.events:
+            timepoint = event.timepoint or "Unspecified"
+            grouped[timepoint].append({
+                'location': event.location,
+                'chapter': event.chapter,
+                'characters': event.characters,
+                'preview': event.content[:200]
+            })
+
+        return dict(grouped)
+
+    def _group_events_by_character(self) -> Dict[str, List[Dict]]:
+        """Group events by character appearance"""
+        grouped = defaultdict(list)
+
+        for event in self.events:
+            for character in event.characters:
+                grouped[character].append({
+                    'location': event.location,
+                    'chapter': event.chapter,
+                    'timepoint': event.timepoint,
+                    'preview': event.content[:200]
+                })
+
+        return dict(grouped)
+
+    def _group_events_by_chapter(self) -> Dict[str, List[Dict]]:
+        """Group events by chapter"""
+        grouped = defaultdict(list)
+
+        for event in self.events:
+            chapter = event.chapter or "Unknown"
+            grouped[chapter].append({
+                'location': event.location,
+                'timepoint': event.timepoint,
+                'characters': event.characters,
+                'preview': event.content[:200]
+            })
+
+        return dict(grouped)
+
+    def _build_timeline(self) -> List[Dict]:
+        """Build chronological timeline of events"""
+        # Sort events by timepoint (this is simplified, real implementation
+        # would need more sophisticated time parsing)
+        timeline = []
+
+        for event in self.events:
+            timeline.append({
+                'timepoint': event.timepoint or "Unknown",
+                'chapter': event.chapter,
+                'location': event.location,
+                'characters': event.characters,
+                'preview': event.content[:200]
+            })
+
+        return timeline
+
+    def _check_consistency(self) -> List[str]:
+        """Check for potential timeline inconsistencies"""
+        warnings = []
+
+        # Check for events without time markers
+        unmarked_events = [e for e in self.events if not e.timepoint]
+        if unmarked_events:
+            warnings.append(
+                f"Found {len(unmarked_events)} events without timeline markers"
+            )
+
+        # Check for characters appearing in timeline without character files
+        mentioned_chars = set()
+        for event in self.events:
+            mentioned_chars.update(event.characters)
+
+        undefined_chars = mentioned_chars - self.characters
+        if undefined_chars:
+            warnings.append(
+                f"Characters mentioned but not defined: {', '.join(sorted(undefined_chars))}"
+            )
+
+        return warnings
+
+
+def main():
+    """Main entry point for timeline tracker"""
+
+    if len(sys.argv) < 2:
+        print("Usage: timeline_tracker.py <project_directory> [--output json|markdown]")
+        sys.exit(1)
+
+    project_dir = sys.argv[1]
+    output_format = 'markdown'
+
+    if len(sys.argv) > 2 and sys.argv[2] == '--output':
+        output_format = sys.argv[3] if len(sys.argv) > 3 else 'markdown'
+
+    tracker = TimelineTracker(project_dir)
+    analysis = tracker.analyze_project()
+
+    if output_format == 'json':
+        print(json.dumps(analysis, indent=2))
+    else:
+        # Markdown output
+        print("# Timeline Analysis\n")
+        print(f"**Total Events:** {analysis['total_events']}")
+        print(f"**Total Characters:** {analysis['total_characters']}\n")
+
+        print("## Characters")
+        for char in analysis['characters']:
+            appearances = len(analysis['events_by_character'].get(char, []))
+            print(f"- {char} ({appearances} appearances)")
+
+        print("\n## Timeline")
+        for event in analysis['timeline']:
+            print(f"\n### {event['timepoint']} - {event['chapter']}")
+            print(f"**Location:** {event['location']}")
+            if event['characters']:
+                print(f"**Characters:** {', '.join(event['characters'])}")
+            print(f"\n{event['preview']}...\n")
+            print("---")
+
+        if analysis['warnings']:
+            print("\n## Warnings")
+            for warning in analysis['warnings']:
+                print(f"- ⚠️  {warning}")
+
+
+if __name__ == '__main__':
+    main()

package/skills/system_skill.py

@@ -0,0 +1,249 @@
+"""
+skills/system_skill.py - 系统操作技能
+========================================
+提供系统信息查询、进程管理、环境操作等功能。
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+import subprocess
+import platform
+import shutil
+from datetime import datetime
+from typing import Optional, List, Dict
+
+from core.logger import get_logger
+from skills.base import Skill, SkillResult, SkillParameter
+
+logger = get_logger("myagent.skills.system")
+
+
+class SystemInfoSkill(Skill):
+    """获取系统信息"""
+    name = "system_info"
+    description = "获取当前系统的详细信息(操作系统、CPU、内存、磁盘等)"
+    category = "system"
+    parameters = []
+
+    async def execute(self, **kwargs) -> SkillResult:
+        try:
+            import psutil
+
+            info = {
+                "platform": platform.platform(),
+                "system": platform.system(),
+                "release": platform.release(),
+                "version": platform.version(),
+                "machine": platform.machine(),
+                "processor": platform.processor(),
+                "hostname": platform.node(),
+                "python_version": sys.version,
+                "cpu_count": psutil.cpu_count(),
+                "cpu_percent": psutil.cpu_percent(interval=1),
+                "memory": {
+                    "total_gb": round(psutil.virtual_memory().total / (1024**3), 2),
+                    "available_gb": round(psutil.virtual_memory().available / (1024**3), 2),
+                    "percent": psutil.virtual_memory().percent,
+                },
+                "disk": {
+                    "total_gb": round(psutil.disk_usage("/").total / (1024**3), 2),
+                    "free_gb": round(psutil.disk_usage("/").free / (1024**3), 2),
+                    "percent": psutil.disk_usage("/").percent,
+                },
+                "current_user": os.getlogin(),
+                "cwd": os.getcwd(),
+                "home": str(os.path.expanduser("~")),
+                "pid": os.getpid(),
+            }
+
+            # 环境变量(常用)
+            important_env = [
+                "PATH", "HOME", "USER", "SHELL",
+                "LANG", "TERM", "EDITOR",
+                "PYTHONPATH", "VIRTUAL_ENV", "CONDA_DEFAULT_ENV",
+            ]
+            env_vars = {}
+            for key in important_env:
+                val = os.environ.get(key)
+                if val:
+                    env_vars[key] = val
+            info["env"] = env_vars
+
+            return SkillResult(
+                success=True,
+                data=info,
+                message=f"系统: {platform.system()} {platform.release()} | "
+                        f"CPU: {info['cpu_count']}核 | "
+                        f"内存: {info['memory']['available_gb']}GB可用",
+            )
+        except ImportError:
+            # 回退: 不用 psutil
+            info = {
+                "platform": platform.platform(),
+                "system": platform.system(),
+                "python_version": sys.version,
+                "cwd": os.getcwd(),
+                "pid": os.getpid(),
+            }
+            return SkillResult(
+                success=True,
+                data=info,
+                message="psutil 未安装，仅返回基本信息。建议: pip install psutil",
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=str(e))
+
+
+class ProcessListSkill(Skill):
+    """列出进程"""
+    name = "process_list"
+    description = "列出系统当前运行的进程"
+    category = "system"
+    parameters = [
+        SkillParameter("filter", "string", "进程名过滤", required=False, default=""),
+        SkillParameter("limit", "integer", "返回数量限制", required=False, default=20),
+    ]
+
+    async def execute(self, filter: str = "", limit: int = 20, **kwargs) -> SkillResult:
+        try:
+            import psutil
+
+            processes = []
+            for proc in psutil.process_iter(["pid", "name", "cpu_percent", "memory_percent", "status"]):
+                try:
+                    info = proc.info
+                    if filter and filter.lower() not in info["name"].lower():
+                        continue
+                    processes.append(info)
+                    if len(processes) >= limit:
+                        break
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    continue
+
+            # 按内存排序
+            processes.sort(key=lambda x: x.get("memory_percent", 0) or 0, reverse=True)
+
+            return SkillResult(
+                success=True,
+                data={"processes": processes, "count": len(processes)},
+                message=f"找到 {len(processes)} 个进程",
+            )
+        except ImportError:
+            return SkillResult(success=False, error="请安装 psutil: pip install psutil")
+        except Exception as e:
+            return SkillResult(success=False, error=str(e))
+
+
+class CommandRunSkill(Skill):
+    """执行系统命令"""
+    name = "command_run"
+    description = "执行系统命令并返回结果(Shell/Bash/PowerShell)"
+    category = "system"
+    parameters = [
+        SkillParameter("command", "string", "要执行的命令", required=True),
+        SkillParameter("timeout", "integer", "超时秒数", required=False, default=60),
+        SkillParameter("work_dir", "string", "工作目录", required=False, default=""),
+    ]
+    dangerous = True
+
+    async def execute(self, command: str = "", timeout: int = 60,
+                      work_dir: str = "", **kwargs) -> SkillResult:
+        try:
+            work_dir = work_dir or os.getcwd()
+            process = await asyncio.wait_for(
+                self._subprocess_exec(command, work_dir),
+                timeout=timeout,
+            )
+            return process
+        except asyncio.TimeoutError:
+            return SkillResult(success=False, error=f"命令执行超时 ({timeout}s)")
+        except Exception as e:
+            return SkillResult(success=False, error=str(e))
+
+    async def _subprocess_exec(self, command: str, work_dir: str) -> SkillResult:
+        """执行子进程"""
+        process = await asyncio.create_subprocess_shell(
+            command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=work_dir,
+        )
+        stdout, stderr = await process.communicate()
+        stdout_str = stdout.decode("utf-8", errors="replace")
+        stderr_str = stderr.decode("utf-8", errors="replace")
+
+        return SkillResult(
+            success=process.returncode == 0,
+            data={
+                "exit_code": process.returncode,
+                "stdout": stdout_str,
+                "stderr": stderr_str,
+            },
+            message=stdout_str[:2000] if process.returncode == 0 else f"失败: {stderr_str[:500]}",
+            error=stderr_str if process.returncode != 0 else "",
+        )
+
+
+class EnvironmentGetSkill(Skill):
+    """获取环境变量"""
+    name = "env_get"
+    description = "获取系统环境变量"
+    category = "system"
+    parameters = [
+        SkillParameter("key", "string", "环境变量名(空=全部)", required=False, default=""),
+    ]
+
+    async def execute(self, key: str = "", **kwargs) -> SkillResult:
+        try:
+            if key:
+                value = os.environ.get(key)
+                if value is None:
+                    return SkillResult(success=False, error=f"环境变量不存在: {key}")
+                return SkillResult(success=True, data={"key": key, "value": value})
+            else:
+                # 返回所有(过滤敏感信息)
+                sensitive = {"PASSWORD", "SECRET", "TOKEN", "KEY", "CREDENTIAL", "API_KEY"}
+                env = {}
+                for k, v in os.environ.items():
+                    if not any(s in k.upper() for s in sensitive):
+                        env[k] = v
+                return SkillResult(
+                    success=True,
+                    data={"count": len(env), "variables": env},
+                    message=f"共 {len(env)} 个环境变量(已过滤敏感信息)",
+                )
+        except Exception as e:
+            return SkillResult(success=False, error=str(e))
+
+
+class PathExpandSkill(Skill):
+    """路径操作"""
+    name = "path_info"
+    description = "获取路径的详细信息(绝对路径、父目录、扩展名等)"
+    category = "system"
+    parameters = [
+        SkillParameter("path", "string", "文件/目录路径", required=True),
+    ]
+
+    async def execute(self, path: str = "", **kwargs) -> SkillResult:
+        try:
+            p = Path(path).expanduser().resolve()
+            return SkillResult(
+                success=True,
+                data={
+                    "original": path,
+                    "absolute": str(p),
+                    "name": p.name,
+                    "stem": p.stem,
+                    "suffix": p.suffix,
+                    "parent": str(p.parent),
+                    "exists": p.exists(),
+                    "is_file": p.is_file(),
+                    "is_dir": p.is_dir(),
+                    "size": p.stat().st_size if p.exists() else 0,
+                },
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=str(e))

package/skills/ui-ux-pro-max/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: ui-ux-pro-max
+description: UI/UX design intelligence and implementation guidance for building polished interfaces. Use when the user asks for UI design, UX flows, information architecture, visual style direction, design systems/tokens, component specs, copy/microcopy, accessibility, or to generate/critique/refine frontend UI (HTML/CSS/JS, React, Next.js, Vue, Svelte, Tailwind). Includes workflows for (1) generating new UI layouts and styling, (2) improving existing UI/UX, (3) producing design-system tokens and component guidelines, and (4) turning UX recommendations into concrete code changes.
+---
+
+Follow these steps to deliver high-quality UI/UX output with minimal back-and-forth.
+
+## 1) Triage
+Ask only what you must to avoid wrong work:
+- Target platform: web / iOS / Android / desktop
+- Stack (if code changes): React/Next/Vue/Svelte, CSS/Tailwind, component library
+- Goal and constraints: conversion, speed, brand vibe, accessibility level (WCAG AA?)
+- What you have: screenshot, Figma, repo, URL, user journey
+
+If the user says "全部都要" (design + UX + code + design system), treat it as four deliverables and ship in that order.
+
+## 2) Produce Deliverables (pick what fits)
+Always be concrete: name components, states, spacing, typography, and interactions.
+
+- **UI concept + layout**: Provide a clear visual direction, grid, typography, color system, key screens/sections.
+- **UX flow**: Map the user journey, critical paths, error/empty/loading states, edge cases.
+- **Design system**: Tokens (color/typography/spacing/radius/shadow), component rules, accessibility notes.
+- **Implementation plan**: Exact file-level edits, component breakdown, and acceptance criteria.
+
+## 3) Use Bundled Assets
+This skill bundles data you can cite for inspiration/standards.
+
+- **Design intelligence data**: Read from `skills/ui-ux-pro-max/assets/data/` when you need palettes, patterns, or UI/UX heuristics.
+- **Upstream reference**: If you need more phrasing/examples, consult `skills/ui-ux-pro-max/references/upstream-skill-content.md`.
+
+## 4) Optional Script (Design System Generator)
+If you need to quickly generate tokens and page-specific overrides, use the bundled script:
+
+```bash
+python3 skills/ui-ux-pro-max/scripts/design_system.py --help
+```
+
+Prefer running it when the user wants a structured token output (ASCII-friendly).
+
+## Output Standards
+- Default to ASCII-only tokens/variables unless the project already uses Unicode.
+- Include: spacing scale, type scale, 2-3 font pair options, color tokens, component states.
+- Always cover: empty/loading/error, keyboard navigation, focus states, contrast.

package/skills/ui-ux-pro-max/_meta.json

@@ -0,0 +1,6 @@
+{
+  "ownerId": "kn7dzk42mb9ceh8sm1zdx51sws803c9b",
+  "slug": "ui-ux-pro-max",
+  "version": "0.1.0",
+  "publishedAt": 1769616159343
+}