agent-sin 0.1.12 → 0.1.16

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
 
 

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

@@ -9,7 +9,7 @@ memo-index で索引化した Chroma collection に対してクエリを embeddi
   args.collection: 索引コレクション名 (default: memo)
 
 出力:
-  data.matches: [{text, file, line, timestamp, distance}]
+  data.matches: [{title, file, tags, updated, distance, snippet}]
 """
 
 from __future__ import annotations
@@ -86,13 +86,17 @@ async def run(ctx, input):
     dists = (r.get("distances") or [[]])[0]
     for doc, meta, dist in zip(docs, metas, dists):
         meta = meta or {}
+        snippet = (doc or "").strip().splitlines()[0] if doc else ""
+        if len(snippet) > 100:
+            snippet = snippet[:97] + "..."
         matches.append(
             {
-                "text": doc,
+                "title": meta.get("title", ""),
                 "file": meta.get("file", ""),
-                "line": meta.get("line", 0),
-                "timestamp": meta.get("timestamp", ""),
+                "tags": meta.get("tags", ""),
+                "updated": meta.get("updated", ""),
                 "distance": float(dist),
+                "snippet": snippet,
             }
         )
 
@@ -103,8 +107,9 @@ async def run(ctx, input):
 
     lines = [loc.t("Closest memos:", "近いメモ:")]
     for i, m in enumerate(matches, start=1):
-        lines.append(f"  {i}) {m['file']}:{m['line']}  dist={m['distance']:.3f}")
-        lines.append(f"     {m['text'][:80]}")
+        lines.append(f"  {i}) {m['title']}  dist={m['distance']:.3f}")
+        if m["snippet"]:
+            lines.append(f"     {m['snippet']}")
     return result_value(
         "ok", loc.t(f"{len(matches)} matches", f"{len(matches)}件見つかりました"), "\n".join(lines), matches
     )

package/builtin-skills/nightly-topic-knowledge/_feedback_lib.py

@@ -0,0 +1,391 @@
+"""Helpers for the skill-feedback AI step of nightly-topic-knowledge.
+
+Reads the current skill catalog (id / name / description / phrases / enabled
+state) from the builtin and user skills directories, builds an LLM prompt that
+asks for actionable suggestions derived from the previous day's sources, and
+parses the JSON response into a normalized list of proposals that can be
+appended to ctx.history and broadcast over the configured notification
+channel.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any, Iterable
+
+try:  # PyYAML is already used by other builtin skills.
+    import yaml as _yaml  # type: ignore
+    HAS_PYYAML = True
+except Exception:
+    HAS_PYYAML = False
+
+
+PROPOSAL_TYPES = ("misalign", "repeat", "unused", "user-feedback")
+TARGET_KINDS = ("existing", "new", "rule")
+TARGET_CHANGES = (
+    "description",
+    "phrases",
+    "main",
+    "new",
+    "claude-md",
+    "other",
+)
+
+MAX_PROPOSALS = 12
+MAX_TEXT_LEN = 600
+MAX_TITLE_LEN = 120
+
+
+# ---------- skill catalog ----------
+
+def collect_skill_summary(skills_dir: str | None, builtin_skills_dir: str | None) -> list[dict[str, Any]]:
+    """Walk both skill roots and return a deduped list of skill summaries.
+
+    User skills shadow builtin ids when override=true; otherwise builtins win,
+    matching the runtime's registry behaviour. Keeps the prompt small by only
+    extracting fields the LLM actually needs.
+    """
+    by_id: dict[str, dict[str, Any]] = {}
+    for source, root in (("builtin", builtin_skills_dir), ("user", skills_dir)):
+        if not root or not os.path.isdir(root):
+            continue
+        for entry in sorted(os.listdir(root)):
+            if entry.startswith(".") or entry.startswith("_"):
+                continue
+            yaml_path = os.path.join(root, entry, "skill.yaml")
+            if not os.path.isfile(yaml_path):
+                continue
+            manifest = _read_yaml(yaml_path)
+            if not isinstance(manifest, dict):
+                continue
+            summary = _summarize_manifest(manifest, source)
+            if not summary:
+                continue
+            sid = summary["id"]
+            if source == "user" and sid in by_id and not bool(manifest.get("override")):
+                continue
+            by_id[sid] = summary
+    return sorted(by_id.values(), key=lambda s: s["id"])
+
+
+def _read_yaml(path: str) -> Any:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            text = f.read()
+    except Exception:
+        return None
+    if HAS_PYYAML:
+        try:
+            return _yaml.safe_load(text)
+        except Exception:
+            return None
+    return _fallback_skill_yaml(text)
+
+
+def _fallback_skill_yaml(text: str) -> dict[str, Any]:
+    """Minimal scalar/list extractor used only when PyYAML is missing.
+
+    Skill.yaml uses nested structures for invocation/input/etc. that the
+    fallback can't fully parse — but the few top-level fields we care about
+    (id / name / description / enabled) are simple strings, so we can salvage
+    enough to keep the prompt useful instead of failing the whole step.
+    """
+    out: dict[str, Any] = {}
+    for line in text.splitlines():
+        match = re.match(r"^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*?)\s*$", line)
+        if not match:
+            continue
+        key, raw = match.group(1), match.group(2)
+        if not raw or raw.startswith("#"):
+            continue
+        if raw.startswith(('"', "'")) and raw.endswith(raw[0]):
+            raw = raw[1:-1]
+        if key in out:
+            continue
+        out[key] = raw
+    return out
+
+
+def _summarize_manifest(manifest: dict[str, Any], source: str) -> dict[str, Any] | None:
+    sid = manifest.get("id")
+    if not isinstance(sid, str) or not sid:
+        return None
+    description = _pick_localized(manifest, "description")
+    invocation = manifest.get("invocation") or {}
+    phrases = _pick_localized_list(invocation, "phrases")
+    command = invocation.get("command") if isinstance(invocation, dict) else None
+    enabled = manifest.get("enabled")
+    return {
+        "id": sid,
+        "name": _pick_localized(manifest, "name") or sid,
+        "description": description or "",
+        "phrases": phrases,
+        "command": command if isinstance(command, str) else "",
+        "source": source,
+        "enabled": False if enabled is False else True,
+    }
+
+
+def _pick_localized(manifest: dict[str, Any], key: str) -> str:
+    i18n = manifest.get(f"{key}_i18n")
+    if isinstance(i18n, dict):
+        ja = i18n.get("ja")
+        if isinstance(ja, str) and ja.strip():
+            return ja.strip()
+        en = i18n.get("en")
+        if isinstance(en, str) and en.strip():
+            return en.strip()
+    value = manifest.get(key)
+    if isinstance(value, str):
+        return value.strip()
+    return ""
+
+
+def _pick_localized_list(node: Any, key: str) -> list[str]:
+    if not isinstance(node, dict):
+        return []
+    i18n = node.get(f"{key}_i18n")
+    if isinstance(i18n, dict):
+        ja = i18n.get("ja")
+        if isinstance(ja, list):
+            return [str(x).strip() for x in ja if isinstance(x, str) and x.strip()]
+        en = i18n.get("en")
+        if isinstance(en, list):
+            return [str(x).strip() for x in en if isinstance(x, str) and x.strip()]
+    raw = node.get(key)
+    if isinstance(raw, list):
+        return [str(x).strip() for x in raw if isinstance(x, str) and x.strip()]
+    return []
+
+
+# ---------- prompt ----------
+
+def build_feedback_prompt(
+    date_str: str,
+    source_bundle: str,
+    skill_catalog: Iterable[dict[str, Any]],
+) -> str:
+    catalog_lines: list[str] = []
+    for skill in skill_catalog:
+        state = "" if skill.get("enabled") else " [disabled]"
+        phrases = skill.get("phrases") or []
+        phrases_text = " / ".join(phrases[:6]) if phrases else ""
+        line = f"- {skill['id']}{state}: {skill.get('description', '').strip()}"
+        if phrases_text:
+            line += f"  (phrases: {phrases_text})"
+        catalog_lines.append(line)
+    catalog_text = "\n".join(catalog_lines) if catalog_lines else "(no skills registered)"
+
+    schema = {
+        "proposals": [
+            {
+                "type": "<one of: misalign | repeat | unused | user-feedback>",
+                "title": "<short Japanese title under 60 chars>",
+                "citation": "<short quote / timestamp showing where in the sources this came from>",
+                "proposal": "<concrete change: what to add/remove/rename and where>",
+                "target_kind": "<existing | new | rule>",
+                "target_skill": "<existing skill id, or proposed new skill id (kebab-case), or empty for rule>",
+                "target_change": "<description | phrases | main | new | claude-md | other>",
+            }
+        ]
+    }
+
+    instructions = [
+        "You are reviewing one day of an individual user's conversations / daily memory / notes",
+        "to look for ways to improve the assistant's skill set. The goal is to surface concrete,",
+        "actionable proposals that the user can later batch-apply by replying with item numbers.",
+        "",
+        "Detect four categories — keep the `type` field to one of these literal strings:",
+        "- misalign: the assistant misread the user's intent, took the wrong tool, or had to redo work.",
+        "- repeat: the user asked for the same hand-driven task more than once → should become a skill.",
+        "- unused: an existing skill was not called when it should have been, or its phrases / description",
+        "  did not match how the user actually asked for it.",
+        "- user-feedback: explicit corrective or affirming feedback the user gave that should change",
+        "  default behaviour (rule / description / phrases).",
+        "",
+        "Hard rules:",
+        "- Output ONE JSON object only. No prose, no markdown fences.",
+        f"- At most {MAX_PROPOSALS} proposals. Skip trivial or speculative ones.",
+        "- Skip anything already obviously satisfied by the existing skills below.",
+        "- For `target_kind: existing`, `target_skill` MUST match an id from the skill catalog.",
+        "- For `target_kind: new`, propose a fresh kebab-case id that does NOT collide with any existing id.",
+        "- For `target_kind: rule`, leave `target_skill` empty and explain in `proposal` where the rule lives",
+        "  (e.g. CLAUDE.md, feedback memory, runtime gate).",
+        "- `citation` must include a short verbatim quote or timestamp so the user can verify.",
+        "- All text in Japanese. Keep each field under 600 characters.",
+        "",
+        f"Date: {date_str}",
+        "",
+        "Current skill catalog (id [disabled?]: description (phrases: ...)):",
+        catalog_text,
+        "",
+        "JSON schema (output shape):",
+        json.dumps(schema, ensure_ascii=False, indent=2),
+        "",
+        "Sources:",
+        source_bundle or "(empty)",
+    ]
+    return "\n".join(instructions)
+
+
+# ---------- response parsing ----------
+
+_JSON_OBJECT_PATTERN = re.compile(r"\{[\s\S]*\}")
+
+
+def parse_feedback_response(text: str) -> list[dict[str, Any]]:
+    raw = (text or "").strip()
+    if not raw:
+        return []
+    fenced = re.match(r"^```(?:json)?\s*([\s\S]*?)\s*```$", raw)
+    if fenced:
+        raw = fenced.group(1).strip()
+    parsed: Any
+    try:
+        parsed = json.loads(raw)
+    except Exception:
+        match = _JSON_OBJECT_PATTERN.search(raw)
+        if not match:
+            return []
+        try:
+            parsed = json.loads(match.group(0))
+        except Exception:
+            return []
+    if not isinstance(parsed, dict):
+        return []
+    items = parsed.get("proposals")
+    if not isinstance(items, list):
+        return []
+    out: list[dict[str, Any]] = []
+    known_ids: set[str] = set()
+    for raw_item in items:
+        normalized = _normalize_proposal(raw_item, known_ids)
+        if normalized is None:
+            continue
+        out.append(normalized)
+        if len(out) >= MAX_PROPOSALS:
+            break
+    return out
+
+
+def _normalize_proposal(item: Any, known_ids: set[str]) -> dict[str, Any] | None:
+    if not isinstance(item, dict):
+        return None
+    ptype = _clamp_enum(item.get("type"), PROPOSAL_TYPES)
+    if not ptype:
+        return None
+    title = _clean_str(item.get("title"), MAX_TITLE_LEN)
+    if not title:
+        return None
+    citation = _clean_str(item.get("citation"), MAX_TEXT_LEN)
+    proposal = _clean_str(item.get("proposal"), MAX_TEXT_LEN)
+    if not proposal:
+        return None
+    target_kind = _clamp_enum(item.get("target_kind"), TARGET_KINDS) or "rule"
+    target_skill = _sanitize_skill_id(item.get("target_skill"))
+    if target_kind == "existing" and not target_skill:
+        return None
+    if target_kind == "new" and not target_skill:
+        return None
+    target_change = _clamp_enum(item.get("target_change"), TARGET_CHANGES) or "other"
+    # Avoid duplicate identical proposals from the model.
+    fingerprint = f"{ptype}|{title}|{target_kind}|{target_skill}"
+    if fingerprint in known_ids:
+        return None
+    known_ids.add(fingerprint)
+    return {
+        "type": ptype,
+        "title": title,
+        "citation": citation,
+        "proposal": proposal,
+        "target_kind": target_kind,
+        "target_skill": target_skill,
+        "target_change": target_change,
+    }
+
+
+def _clean_str(value: Any, cap: int) -> str:
+    if not isinstance(value, str):
+        return ""
+    text = value.strip()
+    if len(text) > cap:
+        text = text[:cap].rstrip() + "…"
+    return text
+
+
+def _clamp_enum(value: Any, allowed: Iterable[str]) -> str | None:
+    if not isinstance(value, str):
+        return None
+    text = value.strip().lower()
+    for candidate in allowed:
+        if text == candidate:
+            return candidate
+    return None
+
+
+def _sanitize_skill_id(value: Any) -> str:
+    if not isinstance(value, str):
+        return ""
+    text = value.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "-", text).strip("-")
+    if not text:
+        return ""
+    if len(text) > 48:
+        text = text[:48].rstrip("-")
+    if not re.match(r"^[a-z][a-z0-9-]*$", text):
+        return ""
+    return text
+
+
+# ---------- formatting for Telegram + history ----------
+
+TYPE_LABEL = {
+    "misalign": "ズレ",
+    "repeat": "繰り返し",
+    "unused": "未活用",
+    "user-feedback": "フィードバック",
+}
+
+TARGET_KIND_LABEL = {
+    "existing": "既存",
+    "new": "新規",
+    "rule": "ルール",
+}
+
+
+def format_proposal_for_history(date_str: str, index: int, proposal: dict[str, Any]) -> str:
+    type_label = TYPE_LABEL.get(proposal["type"], proposal["type"])
+    kind_label = TARGET_KIND_LABEL.get(proposal["target_kind"], proposal["target_kind"])
+    target = proposal.get("target_skill") or ""
+    target_block = (
+        f"{kind_label}: {target}" if target else kind_label
+    )
+    parts = [
+        f"#{index}. [{type_label}] {proposal['title']}",
+        f"対象: {target_block} / {proposal.get('target_change') or 'other'}",
+    ]
+    citation = proposal.get("citation")
+    if citation:
+        parts.append(f"該当: {citation}")
+    parts.append(f"提案: {proposal['proposal']}")
+    return "\n".join(parts)
+
+
+def format_notification(date_str: str, proposals: list[dict[str, Any]], char_budget: int = 3500) -> str:
+    if not proposals:
+        return ""
+    header = f"📋 スキル振り返り {date_str} ({len(proposals)}件)\n返信例: 「1, 3 を適用」「2 は不要」"
+    lines: list[str] = [header]
+    used = len(header)
+    for index, proposal in enumerate(proposals, start=1):
+        body = format_proposal_for_history(date_str, index, proposal)
+        addition = "\n\n" + body
+        if used + len(addition) > char_budget:
+            remaining = len(proposals) - (index - 1)
+            lines.append(f"\n\n…他 {remaining} 件は保存済み（履歴参照）")
+            break
+        lines.append(addition)
+        used += len(addition)
+    return "".join(lines)