agent-sin 0.1.0

package/builtin-skills/schedule-toggle/_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-toggle/main.py

@@ -0,0 +1,78 @@
+"""Builtin: schedule-toggle
+
+スケジュールの enabled フラグを切り替える(または指定値に設定する)。
+"""
+
+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 load_schedules, write_schedules_atomic  # noqa: E402
+
+
+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 パスが取得できません"))
+
+    target_id = str(args.get("id", "")).strip()
+    if not target_id:
+        return _err(loc.t("ID is missing", "ID未指定"), loc.t("Specify the target schedule ID.", "対象スケジュールのIDを指定してください"))
+
+    explicit = "enabled" in args
+    target_enabled = bool(args["enabled"]) if explicit else None
+
+    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}"))
+
+    target = None
+    for item in entries:
+        if isinstance(item, dict) and item.get("id") == target_id:
+            target = item
+            break
+    if target is None:
+        return _err(loc.t("Not found", "見つかりません"), loc.t(f'Schedule "{target_id}" is not registered.', f'スケジュール "{target_id}" は登録されていません'))
+
+    current = target.get("enabled")
+    if current is None:
+        current = True
+    new_value = target_enabled if explicit else (not bool(current))
+    target["enabled"] = new_value
+
+    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-toggle: id={target_id} {current} -> {new_value}",
+    )
+
+    state = loc.t("enabled", "有効") if new_value else loc.t("disabled", "無効")
+    return {
+        "status": "ok",
+        "title": loc.t("Updated", "切替"),
+        "summary": loc.t(f"{target_id} is now {state}.", f"{target_id} を{state}にしました"),
+        "outputs": {},
+        "data": {"entry": target, "previous_enabled": bool(current), "enabled": new_value, "path": path},
+        "suggestions": [],
+    }
+
+
+def _err(title, summary):
+    return {
+        "status": "error",
+        "title": title,
+        "summary": summary,
+        "outputs": {},
+        "data": {},
+        "suggestions": [],
+    }

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

@@ -0,0 +1,61 @@
+# Builtin: schedule-toggle
+# ~/.agent-sin/schedules.yaml の指定IDの enabled をトグルする。
+
+id: schedule-toggle
+name: Schedule Toggle
+name_i18n:
+  en: Schedule Toggle
+  ja: スケジュール切替
+description: スケジュールの有効/無効を切り替える
+description_i18n:
+  en: Enable or disable a schedule
+  ja: スケジュールの有効/無効を切り替える
+runtime: python
+output_mode: raw
+side_effect: true
+
+invocation:
+  command: schedule.toggle
+  phrases:
+    - スケジュール一時停止
+    - スケジュール再開
+    - スケジュール有効化
+    - スケジュール無効化
+    - 定期実行を止めて
+    - 定期実行を有効に
+  phrases_i18n:
+    en:
+      - pause schedule
+      - resume schedule
+      - enable schedule
+      - disable schedule
+      - stop recurring task
+      - turn schedule on
+    ja:
+      - スケジュール一時停止
+      - スケジュール再開
+      - スケジュール有効化
+      - スケジュール無効化
+      - 定期実行を止めて
+      - 定期実行を有効に
+
+input:
+  schema:
+    type: object
+    additionalProperties: false
+    properties:
+      id:
+        type: string
+        minLength: 1
+        description: 対象スケジュールのID
+        description_i18n:
+          en: Target schedule ID
+          ja: 対象スケジュールのID
+      enabled:
+        type: boolean
+        description: 明示的に有効/無効を指定する。省略時はトグル(反転)
+        description_i18n:
+          en: Explicitly set enabled or disabled. If omitted, toggle the current value
+          ja: 明示的に有効/無効を指定する。省略時はトグル(反転)
+    required:
+      - id

package/builtin-skills/skills-disable/main.py

@@ -0,0 +1,63 @@
+"""Builtin: skills-disable
+
+指定したスキルIDを skill-settings.yaml の disabled リストに追加する。
+スキル本体ファイルには触れない。
+"""
+
+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"))
+from i18n import localizer  # noqa: E402
+from _skill_settings_lib import set_skill_enabled  # noqa: E402
+
+
+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 パスが取得できません"))
+
+    target_id = str(args.get("id", "")).strip()
+    if not target_id:
+        return _err(loc.t("ID is missing", "ID未指定"), loc.t("Specify the skill ID to disable.", "無効化したいスキルのIDを指定してください"))
+
+    try:
+        changed, settings = set_skill_enabled(workspace, target_id, False)
+    except Exception as e:
+        return _err(loc.t("Save failed", "保存失敗"), loc.t(f"Failed to update skill-settings.yaml: {e}", f"skill-settings.yaml の更新に失敗しました: {e}"))
+
+    if not changed:
+        return {
+            "status": "ok",
+            "title": loc.t("Already disabled", "既に無効"),
+            "summary": loc.t(f"{target_id} is already disabled.", f"{target_id} は既に無効です"),
+            "outputs": {},
+            "data": {"id": target_id, "enabled": False, "changed": False, "disabled": list(settings.get("disabled") or [])},
+            "suggestions": [],
+        }
+
+    ctx.log.info(f"skills-disable: id={target_id}")
+
+    return {
+        "status": "ok",
+        "title": loc.t("Disabled", "無効化"),
+        "summary": loc.t(f"Disabled {target_id}.", f"{target_id} を無効化しました"),
+        "outputs": {},
+        "data": {"id": target_id, "enabled": False, "changed": True, "disabled": list(settings.get("disabled") or [])},
+        "suggestions": [],
+    }
+
+
+def _err(title, summary):
+    return {
+        "status": "error",
+        "title": title,
+        "summary": summary,
+        "outputs": {},
+        "data": {},
+        "suggestions": [],
+    }

package/builtin-skills/skills-disable/skill.yaml

@@ -0,0 +1,52 @@
+# Builtin: skills-disable
+# 任意のスキル(builtin/user 問わず)を無効化する。
+# ~/.agent-sin/skill-settings.yaml の disabled リストに id を追記するだけで、
+# スキル本体ファイルには触れない。
+
+id: skills-disable
+name: Skill Disable
+name_i18n:
+  en: Skill Disable
+  ja: スキル無効化
+description: 指定したスキルを無効化する
+description_i18n:
+  en: Disable the specified skill
+  ja: 指定したスキルを無効化する
+runtime: python
+entry: main.py
+handler: run
+output_mode: raw
+side_effect: true
+
+invocation:
+  command: skills.disable
+  phrases:
+    - スキルを無効化
+    - スキルをオフ
+    - スキル無効化
+    - 無効化して
+  phrases_i18n:
+    en:
+      - disable skill
+      - turn off skill
+      - skill disable
+    ja:
+      - スキルを無効化
+      - スキルをオフ
+      - スキル無効化
+      - 無効化して
+
+input:
+  schema:
+    type: object
+    additionalProperties: false
+    properties:
+      id:
+        type: string
+        minLength: 1
+        description: 無効化したいスキルのID
+        description_i18n:
+          en: ID of the skill to disable
+          ja: 無効化したいスキルのID
+    required:
+      - id

package/builtin-skills/skills-enable/main.py

@@ -0,0 +1,62 @@
+"""Builtin: skills-enable
+
+指定したスキルIDを skill-settings.yaml の disabled リストから取り除く。
+"""
+
+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"))
+from i18n import localizer  # noqa: E402
+from _skill_settings_lib import set_skill_enabled  # noqa: E402
+
+
+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 パスが取得できません"))
+
+    target_id = str(args.get("id", "")).strip()
+    if not target_id:
+        return _err(loc.t("ID is missing", "ID未指定"), loc.t("Specify the skill ID to enable.", "有効化したいスキルのIDを指定してください"))
+
+    try:
+        changed, settings = set_skill_enabled(workspace, target_id, True)
+    except Exception as e:
+        return _err(loc.t("Save failed", "保存失敗"), loc.t(f"Failed to update skill-settings.yaml: {e}", f"skill-settings.yaml の更新に失敗しました: {e}"))
+
+    if not changed:
+        return {
+            "status": "ok",
+            "title": loc.t("Already enabled", "既に有効"),
+            "summary": loc.t(f"{target_id} is already enabled.", f"{target_id} は既に有効です"),
+            "outputs": {},
+            "data": {"id": target_id, "enabled": True, "changed": False, "disabled": list(settings.get("disabled") or [])},
+            "suggestions": [],
+        }
+
+    ctx.log.info(f"skills-enable: id={target_id}")
+
+    return {
+        "status": "ok",
+        "title": loc.t("Enabled", "有効化"),
+        "summary": loc.t(f"Enabled {target_id}.", f"{target_id} を有効化しました"),
+        "outputs": {},
+        "data": {"id": target_id, "enabled": True, "changed": True, "disabled": list(settings.get("disabled") or [])},
+        "suggestions": [],
+    }
+
+
+def _err(title, summary):
+    return {
+        "status": "error",
+        "title": title,
+        "summary": summary,
+        "outputs": {},
+        "data": {},
+        "suggestions": [],
+    }

package/builtin-skills/skills-enable/skill.yaml

@@ -0,0 +1,51 @@
+# Builtin: skills-enable
+# 無効化されているスキルを再び有効化する。
+# ~/.agent-sin/skill-settings.yaml の disabled リストから id を取り除くだけ。
+
+id: skills-enable
+name: Skill Enable
+name_i18n:
+  en: Skill Enable
+  ja: スキル有効化
+description: 指定したスキルを有効化する
+description_i18n:
+  en: Enable the specified skill
+  ja: 指定したスキルを有効化する
+runtime: python
+entry: main.py
+handler: run
+output_mode: raw
+side_effect: true
+
+invocation:
+  command: skills.enable
+  phrases:
+    - スキルを有効化
+    - スキルをオン
+    - スキル有効化
+    - 有効化して
+  phrases_i18n:
+    en:
+      - enable skill
+      - turn on skill
+      - skill enable
+    ja:
+      - スキルを有効化
+      - スキルをオン
+      - スキル有効化
+      - 有効化して
+
+input:
+  schema:
+    type: object
+    additionalProperties: false
+    properties:
+      id:
+        type: string
+        minLength: 1
+        description: 有効化したいスキルのID
+        description_i18n:
+          en: ID of the skill to enable
+          ja: 有効化したいスキルのID
+    required:
+      - id