agent-sin 0.1.12 → 0.1.15

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

@@ -1,7 +1,7 @@
 """Builtin: memo-list
 
-memo-save が書き込むデイリーノートからメモ行を読み、削除時に使える
-1始まり番号つきで表示する。
+notes/memo/*.md を更新日時の新しい順で列挙する。
+タイトル(=ファイル名のstem)＋本文先頭60文字＋更新日時を返す。
 """
 
 from __future__ import annotations
@@ -10,15 +10,14 @@ import os
 import re
 import sys
 from datetime import datetime
+from pathlib import Path
 
 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")
-_MEMO_HEAD_RE = re.compile(r"^-\s+(?:\d{4}-\d{2}-\d{2}T\S+\s+)?")
+FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---\n?", re.DOTALL)
+HASH_TAG_LINE_RE = re.compile(r"^\s*(?:#\S+\s*)+$")
 
 
 async def run(ctx, input):
@@ -28,87 +27,142 @@ async def run(ctx, input):
     if not notes_dir:
         return _err(loc.t("Notes unavailable", "ノート不明"), loc.t("notes_dir is unavailable.", "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 形式で指定してください"))
-
     limit = int(args.get("limit", 20))
-    year, month, _ = date_str.split("-")
-    path = os.path.join(notes_dir, year, month, f"{date_str}.md")
-    if not os.path.exists(path):
-        return _ok(loc.t("No memos", "メモなし"), loc.t(f"No memos for {date_str}.", f"{date_str} のメモはありません"), [], date_str, path)
-
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            raw = f.read()
-    except OSError as e:
-        return _err(loc.t("Cannot read", "読み取り失敗"), loc.t(f"Failed to read {path}: {e}", f"{path} を読み取れませんでした: {e}"))
+    memo_dir = Path(notes_dir) / "memo"
+    if not memo_dir.exists():
+        return _ok(loc.t("No memos", "メモなし"), loc.t("There are no memos yet.", "まだメモはありません"), [])
+
+    entries = []
+    for path in memo_dir.glob("*.md"):
+        try:
+            stat = path.stat()
+            raw = path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        updated_iso = _extract_frontmatter_field(raw, "updated") or _extract_frontmatter_field(raw, "created")
+        sort_key = _to_timestamp(updated_iso) or stat.st_mtime
+        snippet = _first_body_line(raw)
+        entries.append(
+            {
+                "title": path.stem,
+                "file": str(path.relative_to(notes_dir)),
+                "snippet": snippet,
+                "updated": updated_iso or datetime.fromtimestamp(stat.st_mtime).strftime("%Y-%m-%d %H:%M:%S"),
+                "_sort": sort_key,
+            }
+        )
+
+    entries.sort(key=lambda e: e["_sort"], reverse=True)
+    shown = entries[:limit]
+    for entry in shown:
+        entry.pop("_sort", None)
 
-    memos = _collect_memos(raw.splitlines(keepends=False))
-    shown = memos[:limit]
     if not shown:
-        return _ok(loc.t("No memos", "メモなし"), loc.t(f"No memo lines for {date_str}.", f"{date_str} にメモ行はありません"), [], date_str, path)
-
-    lines = [loc.t(f"Memos for {date_str}:", f"{date_str} のメモ:")]
-    for item in shown:
-        lines.append(f"{item['index']}. {item['text']}")
-    if len(memos) > len(shown):
-        lines.append(loc.t(f"...and {len(memos) - len(shown)} more", f"...他 {len(memos) - len(shown)} 件"))
-
-    title = loc.t(f"{len(memos)} memos", f"メモ {len(memos)}件")
-    return _ok(title, "\n".join(lines), shown, date_str, path, total=len(memos))
-
-
-def _collect_memos(lines):
-    items = []
-    i = 0
-    while i < len(lines):
-        if _MEMO_LINE_RE.match(lines[i]):
-            start = i
-            body = [_clean_head(lines[i])]
-            j = i + 1
-            while j < len(lines) and _CONTINUATION_RE.match(lines[j]):
-                body.append(lines[j].strip())
-                j += 1
-            text = " / ".join(part for part in body if part)
-            items.append(
-                {
-                    "index": len(items) + 1,
-                    "line": start + 1,
-                    "text": _snippet(text),
-                }
-            )
-            i = j
+        return _ok(loc.t("No memos", "メモなし"), loc.t("There are no memos yet.", "まだメモはありません"), [])
+
+    header = loc.t(f"Latest {len(shown)} memos:", f"最近のメモ {len(shown)}件:")
+    lines = [header]
+    for idx, entry in enumerate(shown, start=1):
+        rel_time = _relative_time(entry["updated"], loc)
+        snippet = entry["snippet"]
+        if snippet:
+            lines.append(f"{idx}. {entry['title']} — {snippet} ({rel_time})")
         else:
-            i += 1
-    return items
-
-
-def _clean_head(line):
-    return _MEMO_HEAD_RE.sub("", line, count=1).strip()
-
-
-def _snippet(text):
-    compact = " ".join(str(text).split())
-    if len(compact) <= 160:
+            lines.append(f"{idx}. {entry['title']} ({rel_time})")
+    if len(entries) > len(shown):
+        lines.append(loc.t(f"...and {len(entries) - len(shown)} more", f"...他 {len(entries) - len(shown)} 件"))
+
+    title = loc.t(f"{len(entries)} memos", f"メモ {len(entries)}件")
+    return _ok(title, "\n".join(lines), shown, total=len(entries))
+
+
+def _extract_frontmatter_field(raw: str, field: str):
+    match = FRONTMATTER_RE.match(raw)
+    if not match:
+        return None
+    block = match.group(1)
+    for line in block.splitlines():
+        if not line.strip():
+            continue
+        key, _, val = line.partition(":")
+        if key.strip() == field:
+            v = val.strip()
+            if (v.startswith("\"") and v.endswith("\"")) or (v.startswith("'") and v.endswith("'")):
+                v = v[1:-1]
+            return v or None
+    return None
+
+
+def _first_body_line(raw: str) -> str:
+    body = raw
+    match = FRONTMATTER_RE.match(raw)
+    if match:
+        body = raw[match.end():]
+    for line in body.splitlines():
+        text = line.strip()
+        if not text:
+            continue
+        if HASH_TAG_LINE_RE.match(text):
+            continue
+        if text.startswith("#") and not text.startswith("##"):
+            continue
+        return _snippet(text)
+    return ""
+
+
+def _snippet(text: str) -> str:
+    compact = " ".join(text.split())
+    if len(compact) <= 60:
         return compact
-    return compact[:157] + "..."
+    return compact[:57] + "..."
 
 
-def _ok(title, summary, memos, date_str, path, total=None):
+def _parse_datetime(iso: str):
+    if not iso:
+        return None
+    text = iso.replace("Z", "+00:00")
+    if " " in text and "T" not in text:
+        text = text.replace(" ", "T", 1)
+    try:
+        return datetime.fromisoformat(text)
+    except (ValueError, TypeError):
+        return None
+
+
+def _to_timestamp(iso: str):
+    dt = _parse_datetime(iso)
+    return dt.timestamp() if dt else None
+
+
+def _relative_time(iso: str, loc) -> str:
+    when = _parse_datetime(iso)
+    if when is None:
+        return iso or ""
+    now = datetime.now().astimezone()
+    if when.tzinfo is None:
+        when = when.astimezone()
+    delta = (now - when).total_seconds()
+    if delta < 60:
+        return loc.t("just now", "たった今")
+    if delta < 3600:
+        return loc.t(f"{int(delta // 60)} min ago", f"{int(delta // 60)}分前")
+    if delta < 86400:
+        return loc.t(f"{int(delta // 3600)}h ago", f"{int(delta // 3600)}時間前")
+    if delta < 86400 * 7:
+        return loc.t(f"{int(delta // 86400)}d ago", f"{int(delta // 86400)}日前")
+    return when.strftime("%Y-%m-%d")
+
+
+def _ok(title, summary, memos, total=None):
     return {
         "status": "ok",
         "title": title,
         "summary": summary,
         "outputs": {},
         "data": {
-            "date": date_str,
             "memos": memos,
             "count": len(memos),
-            "total": len(memos) if total is None else total,
-            "path": path,
+            "total": total if total is not None else len(memos),
         },
         "suggestions": [],
     }

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

@@ -1,15 +1,15 @@
 # Builtin: memo-list
-# memo-save が書き込むデイリーノートのメモ行を一覧表示する。
+# notes/memo/ 配下のメモファイルを更新日時の新しい順で一覧表示する。
 
 id: memo-list
 name: Memo List
 name_i18n:
   en: Memo List
   ja: メモ一覧
-description: 指定日のMarkdownメモを一覧表示する
+description: 最近更新したMarkdownメモを一覧表示する
 description_i18n:
-  en: List Markdown memos for a date
-  ja: 指定日のMarkdownメモを一覧表示する
+  en: List recently updated Markdown memos
+  ja: 最近更新したMarkdownメモを一覧表示する
 runtime: python
 output_mode: raw
 
@@ -18,32 +18,26 @@ invocation:
   phrases:
     - メモ一覧
     - メモを見せて
-    - 今日のメモ
+    - 最近のメモ
   phrases_i18n:
     en:
       - list memos
       - show memos
-      - today's memos
+      - recent memos
     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)。省略時は今日"
       limit:
         type: integer
         minimum: 1
-        maximum: 50
+        maximum: 100
         default: 20
         description: 表示する最大件数
         description_i18n:

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

@@ -1,19 +1,15 @@
 """Builtin: memo-save
 
-入力 text を Markdown メモのデイリーファイルに追記する。複数行に対応し、
-1メモ = 1バレット + 継続行(2スペースインデント)の Markdown リスト形式で書き出す。
-Runtime が outputs.note を skill.yaml の outputs[id=note] に従って保存するため、
-このスキル自身は **content を返すだけ**でファイルには触らない。
-
-入力:
-  args.text: 保存する本文 (必須, 改行可)
-出力:
-  outputs.note: 追記用の Markdown。保存先の表示は skill.yaml 側で抑制する。
+1メモ=1ファイル方式で notes/memo/{title}.md に保存する。
+- AI でタイトルを生成し、サニタイズしてファイル名にする
+- 同名既存ファイルがあれば本文末尾に追記し、updated を更新する (runtime 側 update_or_append)
+- 旧バレット形式は廃止
 """
 
 from __future__ import annotations
 
 import os
+import re
 import sys
 from datetime import datetime
 
@@ -21,6 +17,42 @@ sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(
 from i18n import localizer  # noqa: E402
 
 
+MAX_TAGS = 3
+MAX_TITLE_LEN = 48
+GENERIC_TAGS = {
+    "memo",
+    "memos",
+    "note",
+    "notes",
+    "daily",
+    "メモ",
+    "ノート",
+    "日記",
+}
+KEYWORD_TAGS = [
+    ("agent-sin", ("agent-sin", "agent sin", "agentsin")),
+    ("kingcoding", ("kingcoding", "king coding", "king-coding")),
+    ("obsidian", ("obsidian",)),
+    ("ai", ("ai", "openai", "codex", "gpt", "claude", "gemini", "ollama", "llm", "生成ai", "生成AI")),
+    ("仕事", ("仕事", "業務", "プロジェクト", "案件", "顧客", "client", "project")),
+    ("会議", ("会議", "打ち合わせ", "ミーティング", "mtg", "meeting")),
+    ("todo", ("todo", "タスク", "やること", "対応", "締切", "deadline")),
+    ("アイデア", ("アイデア", "idea", "思いつき", "案", "企画")),
+    ("バグ", ("バグ", "不具合", "エラー", "修正", "bug", "error", "fix")),
+    ("学習", ("学習", "勉強", "読書", "本", "study", "learning", "book")),
+    ("健康", ("健康", "体調", "睡眠", "運動", "散歩", "病院", "health")),
+    ("お金", ("お金", "支払い", "請求", "家計", "税金", "money", "invoice")),
+    ("予定", ("予定", "予約", "スケジュール", "schedule", "appointment")),
+    ("買い物", ("買い物", "購入", "買う", "shopping", "buy")),
+    ("食事", ("食事", "昼食", "夕食", "ランチ", "店", "restaurant", "food")),
+    ("生活", ("生活", "掃除", "洗濯", "家事", "home")),
+    ("旅行", ("旅行", "ホテル", "航空券", "travel", "hotel", "flight")),
+]
+HASH_TAG_RE = re.compile(r"(?<!\S)#([^\s#]+)")
+FORBIDDEN_FILENAME_RE = re.compile(r"[\\/:*?\"<>|#\^\[\]]")
+CONTROL_CHARS_RE = re.compile(r"[\x00-\x1f\x7f]")
+
+
 async def run(ctx, input):
     loc = localizer(input)
     args = input.get("args", {})
@@ -38,37 +70,171 @@ async def run(ctx, input):
         }
 
     ctx.log.info(f"memo-save: saving {len(text)} chars")
-    timestamp = input.get("trigger", {}).get("time") or datetime.now().isoformat()
-    content = format_memo(timestamp, text)
+    timestamp = input.get("trigger", {}).get("time") or datetime.now().astimezone().isoformat()
+    tags = build_tags(text, args.get("tags"), args.get("auto_tags", True) is not False)
+
+    explicit_title = str(args.get("title", "")).strip()
+    raw_title = explicit_title or await generate_title(ctx, text)
+    sanitized = sanitize_filename(raw_title) or fallback_title(timestamp)
+    filename = f"{sanitized}.md"
+
+    content = format_memo_body(text, tags)
+    iso_now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
     return {
         "status": "ok",
         "title": loc.t("Saved", "保存しました"),
-        "summary": loc.t("Memo saved.", "メモを保存しました"),
+        "summary": loc.t(f"Memo saved as {filename}.", f"メモを保存しました: {filename}"),
         "outputs": {
             "note": {
+                "filename": filename,
                 "content": content,
                 "frontmatter": {
-                    "tags": ["memo"]
+                    "tags": ["memo"] + [t for t in tags if t not in ("memo",)],
+                    "created": iso_now,
+                    "updated": iso_now,
                 },
             }
         },
         "data": {
-            "length": len(text)
+            "title": sanitized,
+            "filename": filename,
+            "length": len(text),
+            "tags": tags,
         },
         "suggestions": [],
     }
 
 
-def format_memo(timestamp, text):
-    # 改行を正規化し、空行はメモ区切りと衝突するため除外する
-    raw_lines = [line.rstrip() for line in text.replace("\r\n", "\n").split("\n")]
-    body_lines = [line for line in raw_lines if line.strip()]
-    if not body_lines:
+async def generate_title(ctx, text: str) -> str:
+    if os.environ.get("AGENT_SIN_FAKE_PROVIDER") == "1":
+        return fallback_from_text(text)
+    prompt = build_title_prompt(text)
+    try:
+        result = await ctx.ai.run("title", prompt)
+    except Exception as e:
+        ctx.log.warn(f"memo-save: title generation failed: {e}")
+        return fallback_from_text(text)
+    if not isinstance(result, dict) or result.get("status") != "ok":
+        reason = (result or {}).get("reason") if isinstance(result, dict) else None
+        ctx.log.warn(f"memo-save: title generation returned no result: {reason}")
+        return fallback_from_text(text)
+    raw = str(result.get("text") or "").strip()
+    cleaned = strip_quotes_and_lines(raw)
+    if not cleaned:
+        return fallback_from_text(text)
+    return cleaned
+
+
+def build_title_prompt(text: str) -> str:
+    truncated = text if len(text) <= 600 else (text[:600] + "...")
+    return (
+        "次のメモ本文から、24文字以下の短いタイトルを1つだけ返してください。\n"
+        "引用符・カギ括弧・句読点・絵文字・説明文は付けず、タイトル本文のみを1行で返してください。\n"
+        "本文の言語に合わせて日本語/英語で返してください。\n\n"
+        f"本文:\n{truncated}"
+    )
+
+
+def strip_quotes_and_lines(text: str) -> str:
+    first_line = text.splitlines()[0] if text else ""
+    return first_line.strip().strip("「」『』\"'`").strip()
+
+
+def fallback_from_text(text: str) -> str:
+    head = text.strip().splitlines()[0] if text.strip() else ""
+    if len(head) > 40:
+        head = head[:40]
+    return head
+
+
+def fallback_title(timestamp: str) -> str:
+    dt = parse_datetime(timestamp) or datetime.now().astimezone()
+    return f"untitled-{dt.strftime('%H%M%S')}"
+
+
+def sanitize_filename(raw: str) -> str:
+    if not raw:
+        return ""
+    cleaned = CONTROL_CHARS_RE.sub("", raw)
+    cleaned = FORBIDDEN_FILENAME_RE.sub("-", cleaned)
+    cleaned = cleaned.replace("\n", " ").replace("\r", " ")
+    cleaned = re.sub(r"\s+", " ", cleaned).strip()
+    cleaned = cleaned.strip("._- ")
+    if not cleaned:
         return ""
-    first, *rest = body_lines
-    head = f"- {timestamp} {first}"
-    if not rest:
-        return head + "\n"
-    indented = "\n".join(f"  {line}" for line in rest)
-    return f"{head}\n{indented}\n"
+    if len(cleaned) > MAX_TITLE_LEN:
+        cleaned = cleaned[:MAX_TITLE_LEN].rstrip("._- ")
+    if cleaned in (".", ".."):
+        return ""
+    return cleaned
+
+
+def format_memo_body(text: str, tags) -> str:
+    body = text.rstrip()
+    if tags:
+        tag_line = " ".join(f"#{tag}" for tag in tags)
+        return f"{body}\n\n{tag_line}\n"
+    return f"{body}\n"
+
+
+def build_tags(text, explicit_tags=None, auto_tags=True):
+    tags = []
+    for tag in parse_tag_values(explicit_tags):
+        add_tag(tags, tag)
+    for tag in extract_hash_tags(text):
+        add_tag(tags, tag)
+    if auto_tags:
+        haystack = text.lower()
+        for tag, keywords in KEYWORD_TAGS:
+            if any(str(keyword).lower() in haystack for keyword in keywords):
+                add_tag(tags, tag)
+            if len(tags) >= MAX_TAGS:
+                break
+    return tags[:MAX_TAGS]
+
+
+def parse_tag_values(value):
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    if isinstance(value, str):
+        return [part for part in re.split(r"[,、\s]+", value) if part.strip()]
+    return [value]
+
+
+def extract_hash_tags(text):
+    return [match.group(1) for match in HASH_TAG_RE.finditer(text)]
+
+
+def add_tag(tags, value):
+    tag = normalize_tag(value)
+    if not tag or tag in tags:
+        return
+    tags.append(tag)
+
+
+def normalize_tag(value):
+    tag = str(value).strip().lstrip("#＃")
+    if not tag:
+        return None
+    tag = re.sub(r"\s+", "-", tag)
+    tag = re.sub(r"[^\w\-/一-龯ぁ-んァ-ヶー]+", "", tag, flags=re.UNICODE)
+    tag = tag.strip("-_/")
+    if not tag or tag.isdigit():
+        return None
+    if re.fullmatch(r"[A-Za-z0-9_\-/]+", tag):
+        tag = tag.lower()
+    if tag.lower() in GENERIC_TAGS:
+        return None
+    return tag[:32]
+
+
+def parse_datetime(value):
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+    except ValueError:
+        return None

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

@@ -1,7 +1,7 @@
 # Builtin: memo-save
 # 会話の skill-call または agent-sin run memo-save --text "..." で呼ばれる。
-# Markdown のデイリーノートに追記する低リスクスキル。複数行テキストにも対応する。
-# ユーザースキル著作のリファレンスとしても読まれる。詳細は https://agent.shingoirie.com/skill-authoring を参照。
+# 1メモ=1ファイル形式で notes/memo/{title}.md に保存する低リスクスキル。
+# AIで短いタイトルを生成し、同名既存ファイルがあれば末尾に追記して updated を更新する。
 
 id: memo-save
 name: Memo Save
@@ -35,15 +35,39 @@ input:
     properties:
       text:
         type: string
+      title:
+        type: string
+        description: Optional explicit title. When provided, used as the filename without AI generation.
+        description_i18n:
+          en: Optional explicit title. When provided, used as the filename without AI generation.
+          ja: 任意のタイトル。指定するとAIタイトル生成をスキップしてそのまま使う
+      tags:
+        description: Optional Obsidian tags for this memo. Use 1-3 short tags without leading #, based on the memo content.
+        description_i18n:
+          en: Optional Obsidian tags for this memo. Use 1-3 short tags without leading #, based on the memo content.
+          ja: メモ内容に合うObsidianタグ。#なしで1〜3個まで。
+      auto_tags:
+        type: boolean
+        default: true
+        description: Add simple content-based tags when tags are not enough.
+        description_i18n:
+          en: Add simple content-based tags when tags are not enough.
+          ja: 本文から簡単なタグを補完する
     required:
       - text
 
+ai_steps:
+  - id: title
+    purpose: Generate a short title (within 24 characters, no quotes or punctuation) summarizing the memo body. Return only the title text on a single line.
+    model: chat
+    optional: true
+
 outputs:
   - id: note
     type: markdown
-    path: notes/{{yyyy}}/{{MM}}
-    filename: "{{date}}.md"
-    append: true
+    path: notes/memo
+    filename: "untitled.md"
+    merge_mode: update_or_append
     show_saved: false
 
 memory: