agent-sin 0.1.0

package/builtin-skills/_shared/_schedules_lib.py

@@ -0,0 +1,313 @@
+"""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)
+    if os.path.exists(target):
+        return
+    legacy = legacy_schedules_path(workspace)
+    if 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)
+    try:
+        os.remove(legacy)
+        os.rmdir(os.path.dirname(legacy))
+    except OSError:
+        pass
+
+
+def load_schedules(workspace: str) -> List[Dict[str, Any]]:
+    path = schedules_path(workspace)
+    if not os.path.exists(path):
+        legacy = legacy_schedules_path(workspace)
+        if os.path.exists(legacy):
+            path = legacy
+        else:
+            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/_shared/_skill_settings_lib.py

@@ -0,0 +1,153 @@
+"""Common helpers for skills-disable / skills-enable builtin skills.
+
+Reads/writes ~/.agent-sin/skill-settings.yaml in the same format used by
+src/core/skill-settings.ts. PyYAML is used if available; otherwise a minimal
+serializer for the single-key `disabled: [...]` document is used.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import Any, Dict, List, Tuple
+
+try:
+    import yaml as _yaml  # type: ignore
+    HAS_PYYAML = True
+except Exception:
+    HAS_PYYAML = False
+
+
+def skill_settings_path(workspace: str) -> str:
+    return os.path.join(workspace, "skill-settings.yaml")
+
+
+def load_skill_settings(workspace: str) -> Dict[str, Any]:
+    path = skill_settings_path(workspace)
+    if not os.path.exists(path):
+        return {"disabled": []}
+    with open(path, "r", encoding="utf-8") as f:
+        raw = f.read()
+    if not raw.strip():
+        return {"disabled": []}
+    if HAS_PYYAML:
+        data = _yaml.safe_load(raw) or {}
+    else:
+        data = _minimal_parse(raw)
+    disabled = data.get("disabled") if isinstance(data, dict) else None
+    items: List[str] = []
+    if isinstance(disabled, list):
+        for entry in disabled:
+            if isinstance(entry, str) and entry.strip():
+                items.append(entry.strip())
+    return {"disabled": items}
+
+
+def dump_skill_settings(settings: Dict[str, Any]) -> str:
+    disabled = sorted(set(settings.get("disabled") or []))
+    if not disabled:
+        return "disabled: []\n"
+    if HAS_PYYAML:
+        return _yaml.safe_dump(
+            {"disabled": disabled},
+            allow_unicode=True,
+            sort_keys=False,
+            default_flow_style=False,
+        )
+    lines = ["disabled:"]
+    for entry in disabled:
+        lines.append(f"  - {_yaml_scalar(entry)}")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def save_skill_settings(workspace: str, settings: Dict[str, Any]) -> str:
+    path = skill_settings_path(workspace)
+    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+    text = dump_skill_settings(settings)
+    fd, tmp_path = tempfile.mkstemp(
+        prefix=".skill-settings.", suffix=".yaml.tmp", dir=os.path.dirname(path) or "."
+    )
+    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 set_skill_enabled(
+    workspace: str, skill_id: str, enabled: bool
+) -> Tuple[bool, Dict[str, Any]]:
+    settings = load_skill_settings(workspace)
+    disabled: List[str] = list(settings.get("disabled") or [])
+    was_disabled = skill_id in disabled
+    if enabled:
+        if not was_disabled:
+            return False, settings
+        disabled = [d for d in disabled if d != skill_id]
+    else:
+        if was_disabled:
+            return False, settings
+        disabled.append(skill_id)
+    settings["disabled"] = disabled
+    save_skill_settings(workspace, settings)
+    return True, settings
+
+
+def _minimal_parse(raw: str) -> Dict[str, Any]:
+    disabled: List[str] = []
+    in_disabled = False
+    for line in raw.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        if line.startswith("disabled:"):
+            rest = line[len("disabled:"):].strip()
+            if rest == "[]" or rest == "":
+                in_disabled = rest == ""
+                continue
+            if rest.startswith("[") and rest.endswith("]"):
+                body = rest[1:-1]
+                for token in body.split(","):
+                    item = token.strip().strip('"').strip("'")
+                    if item:
+                        disabled.append(item)
+                in_disabled = False
+                continue
+        if in_disabled:
+            if stripped.startswith("- "):
+                value = stripped[2:].strip().strip('"').strip("'")
+                if value:
+                    disabled.append(value)
+            else:
+                in_disabled = False
+    return {"disabled": disabled}
+
+
+def _yaml_scalar(value: str) -> str:
+    if _needs_quote(value):
+        escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+        return f'"{escaped}"'
+    return value
+
+
+def _needs_quote(value: str) -> bool:
+    if value == "":
+        return True
+    if value.strip() != value:
+        return True
+    if value.lower() in ("null", "true", "false", "yes", "no", "on", "off", "~"):
+        return True
+    bad_start = set("-?:[]{},#&*!|>'\"%@`")
+    if value[0] in bad_start:
+        return True
+    for ch in value:
+        if ch in (":", "#", "\n"):
+            return True
+    return False

package/builtin-skills/_shared/i18n.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import os
+
+
+class Localizer:
+    def __init__(self, locale: str):
+        self.locale = locale
+
+    def t(self, en: str, ja: str) -> str:
+        return ja if self.locale == "ja" else en
+
+
+def localizer(input_payload: dict | None = None) -> Localizer:
+    return Localizer(detect_locale(input_payload))
+
+
+def detect_locale(input_payload: dict | None = None) -> str:
+    sources = (input_payload or {}).get("sources") or {}
+    explicit = str(sources.get("locale") or os.environ.get("AGENT_SIN_LOCALE") or "").strip().lower()
+    if explicit in {"en", "ja"}:
+        return explicit
+    lang = str(os.environ.get("LC_ALL") or os.environ.get("LANG") or "").strip().lower()
+    if lang:
+        return "ja" if lang.startswith("ja") else "en"
+    return "en"

package/builtin-skills/memo-delete/main.py

@@ -0,0 +1,155 @@
+"""Builtin: memo-delete
+
+memo-save が書き込むデイリーノートからメモを1件削除する。
+バレット行 + 続く 2 スペースインデントの継続行をまとめて取り除く。
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+import tempfile
+from datetime import datetime
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "_shared"))
+from i18n import localizer  # noqa: E402
+
+
+_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+_MEMO_LINE_RE = re.compile(r"^-\s+")
+_CONTINUATION_RE = re.compile(r"^  \S")
+
+
+async def run(ctx, input):
+    loc = localizer(input)
+    args = input.get("args", {}) or {}
+    workspace = input.get("sources", {}).get("workspace", "")
+    notes_dir = input.get("sources", {}).get("notes_dir", "")
+    if not workspace or not notes_dir:
+        return _err(loc.t("Workspace unavailable", "ワークスペース不明"), loc.t("workspace / notes_dir is unavailable.", "workspace / notes_dir が取得できません"))
+
+    date_str = str(args.get("date", "")).strip()
+    if not date_str:
+        date_str = datetime.now().strftime("%Y-%m-%d")
+    if not _DATE_RE.match(date_str):
+        return _err(loc.t("Invalid date", "日付不正"), loc.t("Use YYYY-MM-DD for date.", "date は YYYY-MM-DD 形式で指定してください"))
+
+    match = args.get("match")
+    match = str(match).strip() if match else None
+    index = args.get("index")
+    if index is not None and not isinstance(index, int):
+        return _err(loc.t("Invalid index", "index不正"), loc.t("index must be a positive integer.", "index は正の整数で指定してください"))
+    if not match and index is None:
+        return _err(loc.t("Cannot identify memo", "特定不可"), loc.t("Specify either match or index.", "match か index のどちらかを指定してください"))
+
+    year, month, _ = date_str.split("-")
+    path = os.path.join(notes_dir, year, month, f"{date_str}.md")
+    if not os.path.exists(path):
+        return _err(loc.t("File not found", "ファイルなし"), loc.t(f"No memo file exists for {date_str}.", f"{date_str} のメモファイルがありません"))
+
+    with open(path, "r", encoding="utf-8") as f:
+        raw = f.read()
+    lines = raw.splitlines(keepends=False)
+
+    memo_ranges = _collect_memo_ranges(lines)
+    if not memo_ranges:
+        return _err(loc.t("No memos", "メモなし"), loc.t(f"No memo lines can be removed for {date_str}.", f"{date_str} に削除対象のメモ行がありません"))
+
+    target_range = None
+    if index is not None:
+        if index < 1 or index > len(memo_ranges):
+            return _err(loc.t("Invalid index", "index不正"), loc.t(f"index {index} is out of range ({len(memo_ranges)} memos).", f"index {index} は範囲外です (メモ {len(memo_ranges)} 件)"))
+        target_range = memo_ranges[index - 1]
+    else:
+        candidates = [
+            r for r in memo_ranges
+            if any(match in lines[i] for i in range(r[0], r[1]))
+        ]
+        if not candidates:
+            return _err(loc.t("Not found", "見つかりません"), loc.t(f'No memo matches "{match}".', f'"{match}" に一致するメモがありません'))
+        if len(candidates) > 1:
+            preview = "\n".join(
+                f"  {idx + 1}. {lines[start]}" for idx, (start, _end) in enumerate(candidates[:5])
+            )
+            return _err(
+                loc.t("Ambiguous match", "曖昧です"),
+                loc.t(f"{len(candidates)} memos matched. Specify index:\n{preview}", f"{len(candidates)} 件一致しました。index で指定してください:\n{preview}"),
+            )
+        target_range = candidates[0]
+
+    start, end = target_range
+    removed_lines = lines[start:end]
+    new_lines = lines[:start] + lines[end:]
+    new_content = "\n".join(new_lines)
+    if raw.endswith("\n") and not new_content.endswith("\n"):
+        new_content += "\n"
+    if not raw.endswith("\n") and new_content.endswith("\n"):
+        new_content = new_content.rstrip("\n")
+
+    try:
+        _write_atomic(path, new_content)
+    except Exception as e:
+        return _err(loc.t("Save failed", "保存失敗"), loc.t(f"Failed to write {path}: {e}", f"{path} への書き込みに失敗しました: {e}"))
+
+    ctx.log.info(f"memo-delete: {date_str} {len(removed_lines)} line(s) removed")
+
+    preview = removed_lines[0].lstrip("- ").strip()
+    if len(preview) > 60:
+        preview = preview[:57] + "..."
+    remaining = len(memo_ranges) - 1
+    return {
+        "status": "ok",
+        "title": loc.t("Deleted", "削除"),
+        "summary": loc.t(f"Deleted memo from {date_str}: {preview}", f"{date_str} のメモを削除しました: {preview}"),
+        "outputs": {},
+        "data": {
+            "date": date_str,
+            "removed_lines": removed_lines,
+            "remaining_memos": remaining,
+            "path": path,
+        },
+        "suggestions": [],
+    }
+
+
+def _collect_memo_ranges(lines):
+    ranges = []
+    i = 0
+    while i < len(lines):
+        if _MEMO_LINE_RE.match(lines[i]):
+            start = i
+            j = i + 1
+            while j < len(lines) and _CONTINUATION_RE.match(lines[j]):
+                j += 1
+            ranges.append((start, j))
+            i = j
+        else:
+            i += 1
+    return ranges
+
+
+def _write_atomic(path, content):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    fd, tmp = tempfile.mkstemp(prefix=".memo.", suffix=".md.tmp", dir=os.path.dirname(path))
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+        os.replace(tmp, path)
+    except Exception:
+        try:
+            os.unlink(tmp)
+        except Exception:
+            pass
+        raise
+
+
+def _err(title, summary):
+    return {
+        "status": "error",
+        "title": title,
+        "summary": summary,
+        "outputs": {},
+        "data": {},
+        "suggestions": [],
+    }

package/builtin-skills/memo-delete/skill.yaml

@@ -0,0 +1,57 @@
+# Builtin: memo-delete
+# デイリーノートの memo 行を削除する。memo-save と対称。
+
+id: memo-delete
+name: Memo Delete
+name_i18n:
+  en: Memo Delete
+  ja: メモ削除
+description: メモの行を削除する
+description_i18n:
+  en: Delete a memo line from the daily note
+  ja: メモの行を削除する
+runtime: python
+output_mode: raw
+side_effect: true
+
+invocation:
+  command: memo.delete
+  phrases:
+    - メモを消して
+    - メモ削除
+    - さっきのメモを消して
+  phrases_i18n:
+    en:
+      - delete memo
+      - remove that memo
+      - delete the previous memo
+    ja:
+      - メモを消して
+      - メモ削除
+      - さっきのメモを消して
+
+input:
+  schema:
+    type: object
+    additionalProperties: false
+    properties:
+      date:
+        type: string
+        description: "対象日 (YYYY-MM-DD)。省略時は今日"
+        description_i18n:
+          en: "Target date (YYYY-MM-DD). Defaults to today"
+          ja: "対象日 (YYYY-MM-DD)。省略時は今日"
+      match:
+        type: string
+        minLength: 1
+        description: メモ行に含まれる文字列で特定する
+        description_i18n:
+          en: Text contained in the memo line to identify
+          ja: メモ行に含まれる文字列で特定する
+      index:
+        type: integer
+        minimum: 1
+        description: 該当日メモ行の1始まり番号で特定する
+        description_i18n:
+          en: 1-based memo line number for the target day
+          ja: 該当日メモ行の1始まり番号で特定する