agent-sin 0.1.11 → 0.1.15

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

@@ -0,0 +1,179 @@
+"""Builtin: memo-list
+
+notes/memo/*.md を更新日時の新しい順で列挙する。
+タイトル(=ファイル名のstem)＋本文先頭60文字＋更新日時を返す。
+"""
+
+from __future__ import annotations
+
+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
+
+
+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):
+    loc = localizer(input)
+    args = input.get("args", {}) or {}
+    notes_dir = input.get("sources", {}).get("notes_dir", "")
+    if not notes_dir:
+        return _err(loc.t("Notes unavailable", "ノート不明"), loc.t("notes_dir is unavailable.", "notes_dir が取得できません"))
+
+    limit = int(args.get("limit", 20))
+    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)
+
+    if not shown:
+        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:
+            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[:57] + "..."
+
+
+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": {
+            "memos": memos,
+            "count": len(memos),
+            "total": total if total is not None else len(memos),
+        },
+        "suggestions": [],
+    }
+
+
+def _err(title, summary):
+    return {
+        "status": "error",
+        "title": title,
+        "summary": summary,
+        "outputs": {},
+        "data": {},
+        "suggestions": [],
+    }

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

@@ -0,0 +1,51 @@
+# Builtin: memo-list
+# notes/memo/ 配下のメモファイルを更新日時の新しい順で一覧表示する。
+
+id: memo-list
+name: Memo List
+name_i18n:
+  en: Memo List
+  ja: メモ一覧
+description: 最近更新したMarkdownメモを一覧表示する
+description_i18n:
+  en: List recently updated Markdown memos
+  ja: 最近更新したMarkdownメモを一覧表示する
+runtime: python
+output_mode: raw
+
+invocation:
+  command: memo.list
+  phrases:
+    - メモ一覧
+    - メモを見せて
+    - 最近のメモ
+  phrases_i18n:
+    en:
+      - list memos
+      - show memos
+      - recent memos
+    ja:
+      - メモ一覧
+      - メモを見せて
+      - 最近のメモ
+
+input:
+  schema:
+    type: object
+    additionalProperties: false
+    properties:
+      limit:
+        type: integer
+        minimum: 1
+        maximum: 100
+        default: 20
+        description: 表示する最大件数
+        description_i18n:
+          en: Maximum number of memos to show
+          ja: 表示する最大件数
+    required: []
+
+memory:
+  namespace: memo
+  read: true
+  write: false

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:

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

@@ -1,18 +1,19 @@
 """Builtin: memo-search
 
-input.sources.notes_dir 配下の *.md を全文走査し、query にすべての語が含まれる
-最初の 1 行を結果に含める。outputs は持たず data.matches に結果を返すのみ。
+notes/memo/*.md を全文走査し、query にすべての語が含まれる
+最初の本文行を結果に含める。outputs は持たず data.matches に結果を返すのみ。
 
 入力:
   args.query: 検索語 (空白区切りで AND 検索)
   args.limit: 上限 (1..50, default 10)
 出力:
-  data.matches: [{file, line, text}]
+  data.matches: [{title, file, line, text}]
 """
 
 from __future__ import annotations
 
 import os
+import re
 import sys
 from pathlib import Path
 
@@ -20,6 +21,9 @@ sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(
 from i18n import localizer  # noqa: E402
 
 
+FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---\n?", re.DOTALL)
+
+
 async def run(ctx, input):
     loc = localizer(input)
     args = input.get("args", {})
@@ -34,46 +38,62 @@ async def run(ctx, input):
         ctx.log.error("memo-search: notes_dir not provided by runtime")
         return result("error", loc.t("Cannot search", "検索できません"), loc.t("The notes directory was not provided by the runtime.", "ノート保存先がRuntimeから渡されていません"), [])
 
-    root = Path(notes_dir).expanduser().resolve()
-    if not root.exists():
-        ctx.log.info(f"memo-search: notes_dir does not exist yet: {root}")
+    memo_dir = Path(notes_dir).expanduser().resolve() / "memo"
+    if not memo_dir.exists():
+        ctx.log.info(f"memo-search: memo dir does not exist yet: {memo_dir}")
         return result("ok", loc.t("0 matches", "0件見つかりました"), loc.t("There are no memos yet.", "まだメモがありません"), [])
 
     terms = [term.casefold() for term in query.split() if term]
-    ctx.log.info(f"memo-search: searching {len(terms)} term(s) in {root}, limit={limit}")
-    matches = search_notes(root, terms, limit)
+    ctx.log.info(f"memo-search: searching {len(terms)} term(s) in {memo_dir}, limit={limit}")
+    matches = search_notes(memo_dir, Path(notes_dir).expanduser().resolve(), terms, limit)
     if not matches:
         return result("ok", loc.t("0 matches", "0件見つかりました"), loc.t(f'No memos contain "{query}".', f"「{query}」を含むメモは見つかりませんでした"), [])
 
     lines = [loc.t("Found memos:", "見つかったメモ:")]
     for item in matches:
-        lines.append(f"- {item['file']}:{item['line']} {item['text']}")
+        lines.append(f"- {item['title']} ({item['file']}:{item['line']}) {item['text']}")
     return result("ok", loc.t(f"{len(matches)} matches", f"{len(matches)}件見つかりました"), "\n".join(lines), matches)
 
 
-def search_notes(root, terms, limit):
+def search_notes(memo_dir, notes_root, terms, limit):
     matches = []
-    for file in sorted(root.rglob("*.md")):
+    for file in sorted(memo_dir.glob("*.md")):
         if len(matches) >= limit:
             break
         try:
-            resolved = file.resolve()
-            if root != resolved and root not in resolved.parents:
-                continue
-            lines = file.read_text(encoding="utf-8", errors="ignore").splitlines()
+            raw = file.read_text(encoding="utf-8", errors="ignore")
         except OSError:
             continue
-
-        for index, line in enumerate(lines, start=1):
+        body_start = 1
+        body = raw
+        m = FRONTMATTER_RE.match(raw)
+        if m:
+            body = raw[m.end():]
+            body_start = raw[: m.end()].count("\n") + 1
+        haystack = (file.stem + "\n" + body).casefold()
+        if not all(term in haystack for term in terms):
+            continue
+        for index, line in enumerate(body.splitlines(), start=body_start):
             if all(term in line.casefold() for term in terms):
                 matches.append(
                     {
-                        "file": str(file.relative_to(root)),
+                        "title": file.stem,
+                        "file": str(file.relative_to(notes_root)),
                         "line": index,
                         "text": snippet(line),
                     }
                 )
                 break
+        else:
+            first_line = next((ln for ln in body.splitlines() if ln.strip()), "")
+            matches.append(
+                {
+                    "title": file.stem,
+                    "file": str(file.relative_to(notes_root)),
+                    "line": body_start,
+                    "text": snippet(first_line),
+                }
+            )
     return matches