abelworkflow 0.1.0

package/skills/sequential-think/scripts/sequential_think_cli.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""Sequential Think CLI - Standalone iterative thinking engine for complex problem-solving."""
+
+import argparse
+import json
+import sys
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional, Dict
+
+
+# ============================================================================
+# Data Models
+# ============================================================================
+
+@dataclass
+class ThoughtData:
+    thought: str
+    thought_number: int
+    total_thoughts: int
+    next_thought_needed: bool = True
+    is_revision: bool = False
+    revises_thought: Optional[int] = None
+    branch_from_thought: Optional[int] = None
+    branch_id: Optional[str] = None
+    needs_more_thoughts: bool = False
+    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
+
+
+# ============================================================================
+# Thought History Manager
+# ============================================================================
+
+class ThoughtHistoryManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._history: List[ThoughtData] = []
+            cls._instance._branches: Dict[str, List[ThoughtData]] = {}
+            cls._instance._history_file: Optional[Path] = None
+        return cls._instance
+
+    @property
+    def history_file(self) -> Path:
+        if self._history_file is None:
+            config_dir = Path.home() / ".config" / "sequential-think"
+            config_dir.mkdir(parents=True, exist_ok=True)
+            self._history_file = config_dir / "thought_history.json"
+        return self._history_file
+
+    def _load_history(self) -> None:
+        if self.history_file.exists():
+            try:
+                with open(self.history_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    self._history = [ThoughtData(**t) for t in data.get("history", [])]
+                    self._branches = {
+                        k: [ThoughtData(**t) for t in v]
+                        for k, v in data.get("branches", {}).items()
+                    }
+            except (json.JSONDecodeError, IOError, TypeError):
+                self._history = []
+                self._branches = {}
+
+    def _save_history(self) -> None:
+        data = {
+            "history": [asdict(t) for t in self._history],
+            "branches": {k: [asdict(t) for t in v] for k, v in self._branches.items()}
+        }
+        with open(self.history_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def add_thought(self, thought: ThoughtData) -> Dict:
+        self._load_history()
+
+        # Auto-adjust total if thought_number exceeds it
+        if thought.thought_number > thought.total_thoughts:
+            thought.total_thoughts = thought.thought_number
+
+        self._history.append(thought)
+
+        # Track branches
+        if thought.branch_from_thought and thought.branch_id:
+            if thought.branch_id not in self._branches:
+                self._branches[thought.branch_id] = []
+            self._branches[thought.branch_id].append(thought)
+
+        self._save_history()
+
+        return {
+            "thoughtNumber": thought.thought_number,
+            "totalThoughts": thought.total_thoughts,
+            "nextThoughtNeeded": thought.next_thought_needed,
+            "branches": list(self._branches.keys()),
+            "thoughtHistoryLength": len(self._history)
+        }
+
+    def get_history(self) -> Dict:
+        self._load_history()
+        return {
+            "history": [asdict(t) for t in self._history],
+            "branches": {k: [asdict(t) for t in v] for k, v in self._branches.items()},
+            "totalThoughts": len(self._history)
+        }
+
+    def clear_history(self) -> Dict:
+        self._history = []
+        self._branches = {}
+        if self.history_file.exists():
+            self.history_file.unlink()
+        return {"status": "cleared", "message": "Thought history cleared"}
+
+
+manager = ThoughtHistoryManager()
+
+
+# ============================================================================
+# Formatters
+# ============================================================================
+
+def format_thought_text(thought: ThoughtData) -> str:
+    prefix = ""
+    context = ""
+
+    if thought.is_revision:
+        prefix = "🔄 Revision"
+        context = f" (revising thought {thought.revises_thought})"
+    elif thought.branch_from_thought:
+        prefix = "🌿 Branch"
+        context = f" (from thought {thought.branch_from_thought}, ID: {thought.branch_id})"
+    else:
+        prefix = "💭 Thought"
+
+    header = f"{prefix} {thought.thought_number}/{thought.total_thoughts}{context}"
+    border = "─" * max(len(header), min(len(thought.thought), 60)) + "────"
+
+    return f"""
+┌{border}┐
+│ {header.ljust(len(border) - 2)} │
+├{border}┤
+│ {thought.thought[:len(border) - 2].ljust(len(border) - 2)} │
+└{border}┘"""
+
+
+def format_history_text(history: Dict) -> str:
+    if not history["history"]:
+        return "No thoughts recorded yet."
+
+    lines = ["=" * 60, "THOUGHT HISTORY", "=" * 60, ""]
+
+    for t in history["history"]:
+        thought = ThoughtData(**t)
+        lines.append(format_thought_text(thought))
+
+    if history["branches"]:
+        lines.extend(["", "-" * 60, "BRANCHES:", "-" * 60])
+        for branch_id, thoughts in history["branches"].items():
+            lines.append(f"\n[{branch_id}]")
+            for t in thoughts:
+                lines.append(f"  Thought {t['thought_number']}: {t['thought'][:50]}...")
+
+    return "\n".join(lines)
+
+
+# ============================================================================
+# Commands
+# ============================================================================
+
+def cmd_think(args) -> None:
+    thought = ThoughtData(
+        thought=args.thought,
+        thought_number=args.thought_number,
+        total_thoughts=args.total_thoughts,
+        next_thought_needed=not args.no_next,
+        is_revision=args.is_revision,
+        revises_thought=args.revises_thought,
+        branch_from_thought=args.branch_from,
+        branch_id=args.branch_id,
+        needs_more_thoughts=args.needs_more
+    )
+
+    result = manager.add_thought(thought)
+
+    # Print formatted thought to stderr for visibility
+    if not args.quiet:
+        print(format_thought_text(thought), file=sys.stderr)
+
+    # Output JSON result
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+def cmd_history(args) -> None:
+    history = manager.get_history()
+
+    if args.format == "json":
+        print(json.dumps(history, ensure_ascii=False, indent=2))
+    else:
+        print(format_history_text(history))
+
+
+def cmd_clear(args) -> None:
+    result = manager.clear_history()
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+# ============================================================================
+# Main
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="sequential_think_cli",
+        description="Sequential Think CLI - Iterative thinking engine for complex problem-solving"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # think command
+    p_think = subparsers.add_parser("think", help="Process a thought in the chain")
+    p_think.add_argument("--thought", "-t", required=True, help="Current thinking step content")
+    p_think.add_argument("--thought-number", "-n", type=int, required=True, help="Current position (1-based)")
+    p_think.add_argument("--total-thoughts", "-T", type=int, required=True, help="Estimated total thoughts")
+    p_think.add_argument("--no-next", action="store_true", help="Mark as final thought (no more needed)")
+    p_think.add_argument("--is-revision", action="store_true", help="This thought revises previous thinking")
+    p_think.add_argument("--revises-thought", type=int, help="Which thought number is being reconsidered")
+    p_think.add_argument("--branch-from", type=int, help="Branching point thought number")
+    p_think.add_argument("--branch-id", help="Identifier for current branch")
+    p_think.add_argument("--needs-more", action="store_true", help="Signal more thoughts needed beyond estimate")
+    p_think.add_argument("--quiet", "-q", action="store_true", help="Suppress formatted output to stderr")
+
+    # history command
+    p_history = subparsers.add_parser("history", help="View thought history")
+    p_history.add_argument("--format", "-f", choices=["json", "text"], default="text", help="Output format")
+
+    # clear command
+    subparsers.add_parser("clear", help="Clear thought history")
+
+    args = parser.parse_args()
+
+    commands = {
+        "think": cmd_think,
+        "history": cmd_history,
+        "clear": cmd_clear,
+    }
+
+    commands[args.command](args)
+
+
+if __name__ == "__main__":
+    main()

package/skills/time/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: time
+description: |
+  Time and timezone utilities for getting current time and converting between timezones. Use when: (1) Getting current time in any timezone, (2) Converting time between different timezones, (3) Working with IANA timezone names, (4) Scheduling across timezones, (5) Time-sensitive operations. Triggers: "what time is it", "current time", "convert time", "timezone", "time in [city]". Supports both MCP server and standalone CLI.
+---
+
+# Time
+
+Time and timezone conversion utilities. Supports both MCP server and standalone CLI.
+
+## Execution Methods
+
+### Method 1: MCP Tools (if available)
+Use `mcp__time__*` tools directly:
+- `mcp__time__get_current_time` - Get current time in a timezone
+- `mcp__time__convert_time` - Convert time between timezones
+
+### Method 2: CLI Script (no MCP dependency)
+Run `scripts/time_cli.py` via Bash:
+
+```bash
+# Prerequisites: pip install pytz (or use Python 3.9+ with zoneinfo)
+
+# Get current time in a timezone
+python scripts/time_cli.py get --timezone "Asia/Shanghai"
+python scripts/time_cli.py get --timezone "America/New_York"
+python scripts/time_cli.py get  # Uses system timezone
+
+# Convert time between timezones
+python scripts/time_cli.py convert \
+  --time "16:30" \
+  --from "America/New_York" \
+  --to "Asia/Tokyo"
+
+# List available timezones
+python scripts/time_cli.py list [--filter "Asia"]
+```
+
+## Tool Capability Matrix
+
+| Tool | Parameters | Output |
+|------|------------|--------|
+| `get_current_time` | `timezone` (required, IANA name) | `{timezone, datetime, is_dst}` |
+| `convert_time` | `source_timezone`, `time` (HH:MM), `target_timezone` | `{source, target, time_difference}` |
+
+## Common IANA Timezone Names
+
+| Region | Timezone |
+|--------|----------|
+| China | `Asia/Shanghai` |
+| Japan | `Asia/Tokyo` |
+| Korea | `Asia/Seoul` |
+| US East | `America/New_York` |
+| US West | `America/Los_Angeles` |
+| UK | `Europe/London` |
+| Germany | `Europe/Berlin` |
+| France | `Europe/Paris` |
+| Australia | `Australia/Sydney` |
+| UTC | `UTC` |
+
+## Workflow
+
+### Getting Current Time
+1. Identify target timezone (use IANA name)
+2. Call `get_current_time` with timezone parameter
+3. Response includes ISO 8601 datetime and DST status
+
+### Converting Time
+1. Identify source timezone and time (24-hour format HH:MM)
+2. Identify target timezone
+3. Call `convert_time` with all parameters
+4. Response includes both times and time difference
+
+## Output Format
+
+### get_current_time Response
+```json
+{
+  "timezone": "Asia/Shanghai",
+  "datetime": "2024-01-01T21:00:00+08:00",
+  "is_dst": false
+}
+```
+
+### convert_time Response
+```json
+{
+  "source": {
+    "timezone": "America/New_York",
+    "datetime": "2024-01-01T16:30:00-05:00",
+    "is_dst": false
+  },
+  "target": {
+    "timezone": "Asia/Tokyo",
+    "datetime": "2024-01-02T06:30:00+09:00",
+    "is_dst": false
+  },
+  "time_difference": "+14.0h"
+}
+```
+
+## Error Handling
+
+| Error | Recovery |
+|-------|----------|
+| Invalid timezone | Check IANA timezone name spelling |
+| Invalid time format | Use 24-hour format HH:MM |
+| MCP unavailable | Fall back to CLI script |
+
+## Anti-Patterns
+
+| Prohibited | Correct |
+|------------|---------|
+| Use city names directly | Use IANA timezone names (e.g., `Asia/Tokyo` not `Tokyo`) |
+| Use 12-hour format | Use 24-hour format (e.g., `16:30` not `4:30 PM`) |
+| Assume timezone | Always specify timezone explicitly |

package/skills/time/scripts/time_cli.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Time CLI - Standalone time and timezone utilities."""
+
+import argparse
+import json
+import sys
+from datetime import datetime
+
+try:
+    from zoneinfo import ZoneInfo, available_timezones
+except ImportError:
+    from pytz import timezone as ZoneInfo, all_timezones as _all_tz
+    def available_timezones():
+        return set(_all_tz)
+
+
+def get_current_time(tz_name: str) -> dict:
+    """Get current time in specified timezone."""
+    try:
+        tz = ZoneInfo(tz_name)
+        now = datetime.now(tz)
+        return {
+            "timezone": tz_name,
+            "datetime": now.isoformat(),
+            "is_dst": bool(now.dst()) if hasattr(now, 'dst') and now.dst() else False
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def convert_time(source_tz: str, time_str: str, target_tz: str) -> dict:
+    """Convert time between timezones."""
+    try:
+        hour, minute = map(int, time_str.split(':'))
+        source = ZoneInfo(source_tz)
+        target = ZoneInfo(target_tz)
+
+        today = datetime.now(source).date()
+        source_dt = datetime(today.year, today.month, today.day, hour, minute, tzinfo=source)
+        target_dt = source_dt.astimezone(target)
+
+        source_offset = source_dt.utcoffset().total_seconds() / 3600
+        target_offset = target_dt.utcoffset().total_seconds() / 3600
+        diff = target_offset - source_offset
+
+        return {
+            "source": {
+                "timezone": source_tz,
+                "datetime": source_dt.isoformat(),
+                "is_dst": bool(source_dt.dst()) if hasattr(source_dt, 'dst') and source_dt.dst() else False
+            },
+            "target": {
+                "timezone": target_tz,
+                "datetime": target_dt.isoformat(),
+                "is_dst": bool(target_dt.dst()) if hasattr(target_dt, 'dst') and target_dt.dst() else False
+            },
+            "time_difference": f"{diff:+.1f}h"
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def list_timezones(filter_str: str = None) -> list:
+    """List available timezones."""
+    zones = sorted(available_timezones())
+    if filter_str:
+        zones = [z for z in zones if filter_str.lower() in z.lower()]
+    return zones
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Time and timezone utilities")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # get command
+    get_parser = subparsers.add_parser("get", help="Get current time")
+    get_parser.add_argument("--timezone", "-tz", default="UTC", help="IANA timezone name")
+
+    # convert command
+    convert_parser = subparsers.add_parser("convert", help="Convert time between timezones")
+    convert_parser.add_argument("--time", "-t", required=True, help="Time in HH:MM format")
+    convert_parser.add_argument("--from", "-f", dest="source", required=True, help="Source timezone")
+    convert_parser.add_argument("--to", "-o", dest="target", required=True, help="Target timezone")
+
+    # list command
+    list_parser = subparsers.add_parser("list", help="List available timezones")
+    list_parser.add_argument("--filter", "-f", help="Filter timezones by substring")
+
+    args = parser.parse_args()
+
+    if args.command == "get":
+        result = get_current_time(args.timezone)
+        print(json.dumps(result, indent=2))
+    elif args.command == "convert":
+        result = convert_time(args.source, args.time, args.target)
+        print(json.dumps(result, indent=2))
+    elif args.command == "list":
+        zones = list_timezones(args.filter)
+        for z in zones:
+            print(z)
+
+
+if __name__ == "__main__":
+    main()