agent-sin 0.1.0

package/builtin-skills/schedule-add/_schedules_lib.py

@@ -0,0 +1,303 @@
+"""Common helpers for schedule-* builtin skills.
+
+Provides load / dump / cron-validation helpers for the
+~/.agent-sin/schedules.yaml file. PyYAML is used if available;
+otherwise a minimal hand-written parser/serializer (sufficient for the
+restricted schedules schema) is used.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import Any, Dict, List
+
+try:
+    import yaml as _yaml  # type: ignore
+    HAS_PYYAML = True
+except Exception:
+    HAS_PYYAML = False
+
+
+CANONICAL_KEY_ORDER = [
+    "id",
+    "description",
+    "cron",
+    "skill",
+    "args",
+    "enabled",
+    "approve",
+    "timezone",
+]
+
+
+def schedules_path(workspace: str) -> str:
+    return os.path.join(workspace, "schedules.yaml")
+
+
+def legacy_schedules_path(workspace: str) -> str:
+    return os.path.join(workspace, "schedules", "schedules.yaml")
+
+
+def migrate_legacy_schedules(workspace: str) -> None:
+    target = schedules_path(workspace)
+    legacy = legacy_schedules_path(workspace)
+    if os.path.exists(target) or not os.path.exists(legacy):
+        return
+    with open(legacy, "r", encoding="utf-8") as src:
+        content = src.read()
+    with open(target, "w", encoding="utf-8") as dst:
+        dst.write(content)
+
+
+def load_schedules(workspace: str) -> List[Dict[str, Any]]:
+    migrate_legacy_schedules(workspace)
+    path = schedules_path(workspace)
+    if not os.path.exists(path):
+        return []
+    with open(path, "r", encoding="utf-8") as f:
+        raw = f.read()
+    return _parse_schedules(raw)
+
+
+def _parse_schedules(raw: str) -> List[Dict[str, Any]]:
+    if not raw.strip():
+        return []
+    if HAS_PYYAML:
+        data = _yaml.safe_load(raw) or {}
+    else:
+        data = _minimal_parse(raw)
+    items = data.get("schedules") if isinstance(data, dict) else None
+    return list(items) if isinstance(items, list) else []
+
+
+def _minimal_parse(raw: str) -> Dict[str, Any]:
+    schedules: List[Dict[str, Any]] = []
+    current: Dict[str, Any] | None = None
+    in_args = False
+    in_schedules = False
+    for line in raw.splitlines():
+        if not line.strip() or line.lstrip().startswith("#"):
+            continue
+        if line.startswith("schedules:"):
+            in_schedules = True
+            rest = line[len("schedules:"):].strip()
+            if rest == "[]":
+                return {"schedules": []}
+            continue
+        if not in_schedules:
+            continue
+        indent = len(line) - len(line.lstrip(" "))
+        body = line.strip()
+        if body.startswith("- "):
+            if current is not None:
+                schedules.append(current)
+            current = {}
+            in_args = False
+            body = body[2:].strip()
+            if ":" in body:
+                k, _, v = body.partition(":")
+                current[k.strip()] = _parse_scalar(v.strip())
+            continue
+        if current is None:
+            continue
+        if in_args and indent >= 6:
+            if ":" in body:
+                k, _, v = body.partition(":")
+                current.setdefault("args", {})
+                current["args"][k.strip()] = _parse_scalar(v.strip())
+            continue
+        if ":" in body:
+            k, _, v = body.partition(":")
+            key = k.strip()
+            value = v.strip()
+            if key == "args" and value in ("", "{}"):
+                in_args = value == ""
+                current["args"] = {}
+            else:
+                in_args = False
+                current[key] = _parse_scalar(value)
+    if current is not None:
+        schedules.append(current)
+    return {"schedules": schedules}
+
+
+def _parse_scalar(value: str) -> Any:
+    if value == "":
+        return ""
+    if value.startswith('"') and value.endswith('"'):
+        try:
+            return bytes(value[1:-1], "utf-8").decode("unicode_escape")
+        except Exception:
+            return value[1:-1]
+    if value.startswith("'") and value.endswith("'"):
+        return value[1:-1]
+    low = value.lower()
+    if low == "true":
+        return True
+    if low == "false":
+        return False
+    if low in ("null", "~"):
+        return None
+    try:
+        if "." in value:
+            return float(value)
+        return int(value)
+    except ValueError:
+        return value
+
+
+def dump_schedules(items: List[Dict[str, Any]]) -> str:
+    if not items:
+        return "schedules: []\n"
+    if HAS_PYYAML:
+        cleaned = [_clean_item(item) for item in items]
+        return _yaml.safe_dump(
+            {"schedules": cleaned},
+            allow_unicode=True,
+            sort_keys=False,
+            default_flow_style=False,
+        )
+    lines = ["schedules:"]
+    for item in items:
+        cleaned = _clean_item(item)
+        keys = [k for k in CANONICAL_KEY_ORDER if k in cleaned]
+        keys.extend(k for k in cleaned.keys() if k not in keys)
+        first = True
+        for k in keys:
+            v = cleaned[k]
+            prefix = "  - " if first else "    "
+            first = False
+            if k == "args":
+                if not v:
+                    lines.append(f"{prefix}args: {{}}")
+                    continue
+                lines.append(f"{prefix}args:")
+                for ak, av in v.items():
+                    lines.append(f"      {ak}: {_yaml_scalar(av)}")
+            else:
+                lines.append(f"{prefix}{k}: {_yaml_scalar(v)}")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _clean_item(item: Dict[str, Any]) -> Dict[str, Any]:
+    return {k: v for k, v in item.items() if v is not None}
+
+
+def _yaml_scalar(v: Any) -> str:
+    if v is None:
+        return "null"
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, (int, float)):
+        return str(v)
+    s = str(v)
+    if _needs_quote(s):
+        escaped = s.replace("\\", "\\\\").replace("\"", "\\\"")
+        return f'"{escaped}"'
+    return s
+
+
+def _needs_quote(s: str) -> bool:
+    if s == "":
+        return True
+    if s.strip() != s:
+        return True
+    if s.lower() in ("null", "true", "false", "yes", "no", "on", "off", "~"):
+        return True
+    bad_start = set("-?:[]{},#&*!|>'\"%@`")
+    if s[0] in bad_start:
+        return True
+    for ch in s:
+        if ch in (":", "#", "\n"):
+            return True
+    return False
+
+
+def write_schedules_atomic(workspace: str, items: List[Dict[str, Any]]) -> str:
+    migrate_legacy_schedules(workspace)
+    path = schedules_path(workspace)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    text = dump_schedules(items)
+    # round-trip check before writing
+    roundtrip = _parse_schedules(text)
+    if len(roundtrip) != len(items):
+        raise RuntimeError(
+            "Round-trip check failed: parsed entry count "
+            f"{len(roundtrip)} != original {len(items)}",
+        )
+    fd, tmp_path = tempfile.mkstemp(
+        prefix=".schedules.", suffix=".yaml.tmp", dir=os.path.dirname(path)
+    )
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(text)
+        os.replace(tmp_path, path)
+    except Exception:
+        try:
+            os.unlink(tmp_path)
+        except Exception:
+            pass
+        raise
+    return path
+
+
+def validate_cron(raw: str) -> None:
+    fields = raw.strip().split()
+    if len(fields) != 5:
+        raise ValueError(
+            f'Cron must have 5 fields ("min hour dom month dow"): "{raw}"',
+        )
+    spec = [
+        (0, 59, "minute"),
+        (0, 23, "hour"),
+        (1, 31, "day-of-month"),
+        (1, 12, "month"),
+        (0, 6, "day-of-week"),
+    ]
+    for field, (mn, mx, label) in zip(fields, spec):
+        _validate_cron_field(field, mn, mx, label)
+
+
+def _validate_cron_field(field: str, mn: int, mx: int, label: str) -> None:
+    for part in field.split(","):
+        seg = part.strip()
+        if not seg:
+            raise ValueError(f'Empty segment in {label} field: "{field}"')
+        body = seg
+        step = 1
+        if "/" in body:
+            body, _, step_raw = body.partition("/")
+            try:
+                step = int(step_raw)
+            except ValueError as exc:
+                raise ValueError(
+                    f'Invalid step "{step_raw}" in {label} field: "{field}"',
+                ) from exc
+            if step <= 0:
+                raise ValueError(
+                    f'Invalid step "{step_raw}" in {label} field: "{field}"',
+                )
+        if body == "" or body == "*":
+            continue
+        if "-" in body:
+            a, _, b = body.partition("-")
+            try:
+                fr = int(a)
+                to = int(b)
+            except ValueError as exc:
+                raise ValueError(
+                    f'Invalid value "{body}" in {label} field: "{field}"',
+                ) from exc
+        else:
+            try:
+                fr = to = int(body)
+            except ValueError as exc:
+                raise ValueError(
+                    f'Invalid value "{body}" in {label} field: "{field}"',
+                ) from exc
+        if fr < mn or to > mx or fr > to:
+            raise ValueError(
+                f'{label} value out of range ({fr}-{to}); allowed {mn}-{mx} for "{field}"',
+            )

package/builtin-skills/schedule-add/main.py

@@ -0,0 +1,137 @@
+"""Builtin: schedule-add
+
+スケジュールを ~/.agent-sin/schedules.yaml に1件追加する。
+同じ id + 同じ内容で再度呼ばれた場合は冪等に登録済みを返す。
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "_shared"))
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from i18n import localizer  # noqa: E402
+from _schedules_lib import (  # noqa: E402
+    load_schedules,
+    validate_cron,
+    write_schedules_atomic,
+)
+
+
+_COMPARABLE_KEYS = ("cron", "skill", "description", "args", "approve")
+
+
+async def run(ctx, input):
+    loc = localizer(input)
+    args = input.get("args", {}) or {}
+    workspace = input.get("sources", {}).get("workspace", "")
+    if not workspace:
+        return _err(loc.t("Workspace unavailable", "ワークスペース不明"), loc.t("The workspace path is unavailable.", "workspace パスが取得できません"))
+
+    schedule_id = str(args.get("id", "")).strip()
+    cron = str(args.get("cron", "")).strip()
+    skill = str(args.get("skill", "")).strip()
+    if not schedule_id or not cron or not skill:
+        return _err(loc.t("Missing input", "入力不足"), loc.t("id / cron / skill are required.", "id / cron / skill は必須です"))
+
+    try:
+        validate_cron(cron)
+    except ValueError as e:
+        return _err(loc.t("Invalid cron", "cron不正"), str(e))
+
+    try:
+        entries = load_schedules(workspace)
+    except Exception as e:
+        return _err(loc.t("Load failed", "読込失敗"), loc.t(f"Could not read schedules.yaml: {e}", f"schedules.yaml を読めませんでした: {e}"))
+
+    entry = {"id": schedule_id, "cron": cron, "skill": skill}
+    description = args.get("description")
+    if description:
+        entry["description"] = str(description)
+    extra_args = args.get("args")
+    if isinstance(extra_args, dict) and extra_args:
+        entry["args"] = extra_args
+    if "enabled" in args:
+        entry["enabled"] = bool(args["enabled"])
+    if "approve" in args:
+        entry["approve"] = bool(args["approve"])
+
+    existing = next(
+        (item for item in entries if isinstance(item, dict) and item.get("id") == schedule_id),
+        None,
+    )
+    if existing is not None:
+        if _same_schedule(existing, entry):
+            ctx.log.info(f"schedule-add: id={schedule_id} already exists (idempotent)")
+            disabled_note = " (disabled)" if _enabled_value(existing) is False else ""
+            return {
+                "status": "ok",
+                "title": loc.t("Already registered", "登録済み"),
+                "summary": loc.t(f"Already registered: {schedule_id}: {cron} -> {skill}{disabled_note}", f"登録済みです: {schedule_id}: {cron} → {skill}{disabled_note}"),
+                "outputs": {},
+                "data": {
+                    "entry": existing,
+                    "total": len(entries),
+                    "path": _schedules_path(workspace),
+                    "already_registered": True,
+                },
+                "suggestions": [],
+            }
+        return _err(
+            loc.t("Duplicate ID", "ID重複"),
+            loc.t(f'Schedule ID "{schedule_id}" is already registered with different settings. Remove it first or use another ID.', f'スケジュールID "{schedule_id}" は別の内容で既に登録されています。先に削除してから追加するか、別のIDを使ってください'),
+        )
+
+    entries.append(entry)
+
+    try:
+        path = write_schedules_atomic(workspace, entries)
+    except Exception as e:
+        return _err(loc.t("Save failed", "保存失敗"), loc.t(f"Failed to write schedules.yaml: {e}", f"schedules.yaml への書き込みに失敗しました: {e}"))
+
+    ctx.log.info(f"schedule-add: id={schedule_id} cron={cron} skill={skill}")
+
+    disabled_note = " (disabled)" if entry.get("enabled") is False else ""
+    return {
+        "status": "ok",
+        "title": loc.t("Registered", "登録"),
+        "summary": loc.t(f"Registered: {schedule_id}: {cron} -> {skill}{disabled_note}", f"登録しました: {schedule_id}: {cron} → {skill}{disabled_note}"),
+        "outputs": {},
+        "data": {"entry": entry, "total": len(entries), "path": path},
+        "suggestions": [],
+    }
+
+
+def _same_schedule(existing: dict, candidate: dict) -> bool:
+    for key in _COMPARABLE_KEYS:
+        if existing.get(key) != candidate.get(key):
+            return False
+    # enabled defaults to True when unspecified; treat missing as True so a
+    # re-add that omits "enabled" still counts as identical to an entry that
+    # is enabled by default.
+    if _enabled_value(existing) != _enabled_value(candidate):
+        return False
+    return True
+
+
+def _enabled_value(entry: dict) -> bool:
+    value = entry.get("enabled")
+    if value is None:
+        return True
+    return bool(value)
+
+
+def _schedules_path(workspace: str) -> str:
+    return os.path.join(workspace, "schedules.yaml")
+
+
+def _err(title, summary):
+    return {
+        "status": "error",
+        "title": title,
+        "summary": summary,
+        "outputs": {},
+        "data": {},
+        "suggestions": [],
+    }

package/builtin-skills/schedule-add/skill.yaml

@@ -0,0 +1,94 @@
+# Builtin: schedule-add
+# ~/.agent-sin/schedules.yaml にスケジュールを1件追加する。
+
+id: schedule-add
+name: Schedule Add
+name_i18n:
+  en: Schedule Add
+  ja: スケジュール追加
+description: 定期実行(cron)スケジュールを1件追加する
+description_i18n:
+  en: Add one recurring cron schedule
+  ja: 定期実行(cron)スケジュールを1件追加する
+runtime: python
+output_mode: raw
+side_effect: true
+
+invocation:
+  command: schedule.add
+  phrases:
+    - スケジュール追加
+    - 定期実行を追加
+    - cronを追加
+    - 毎日X時に動かして
+    - 毎時X分に動かして
+  phrases_i18n:
+    en:
+      - add schedule
+      - add recurring task
+      - add cron
+      - run this every day
+      - run this every hour
+    ja:
+      - スケジュール追加
+      - 定期実行を追加
+      - cronを追加
+      - 毎日X時に動かして
+      - 毎時X分に動かして
+
+input:
+  schema:
+    type: object
+    additionalProperties: false
+    properties:
+      id:
+        type: string
+        minLength: 1
+        pattern: "^[A-Za-z0-9_-]+$"
+        description: スケジュールの一意ID
+        description_i18n:
+          en: Unique schedule ID
+          ja: スケジュールの一意ID
+      cron:
+        type: string
+        minLength: 1
+        description: 5フィールドのcron式 "min hour dom month dow"
+        description_i18n:
+          en: 5-field cron expression, "min hour dom month dow"
+          ja: 5フィールドのcron式 "min hour dom month dow"
+      skill:
+        type: string
+        minLength: 1
+        description: 実行するスキルID
+        description_i18n:
+          en: Skill ID to run
+          ja: 実行するスキルID
+      args:
+        type: object
+        additionalProperties: true
+        description: スキルに渡す引数(任意)
+        description_i18n:
+          en: Optional arguments passed to the skill
+          ja: スキルに渡す引数(任意)
+      description:
+        type: string
+        description: スケジュールの説明文(任意)
+        description_i18n:
+          en: Optional schedule description
+          ja: スケジュールの説明文(任意)
+      enabled:
+        type: boolean
+        description: 有効/無効 (default true)
+        description_i18n:
+          en: Enabled or disabled (default true)
+          ja: 有効/無効 (default true)
+      approve:
+        type: boolean
+        description: approve required フラグ (default false)
+        description_i18n:
+          en: Approval required flag (default false)
+          ja: approve required フラグ (default false)
+    required:
+      - id
+      - cron
+      - skill