agent-sin 0.1.12 → 0.1.15

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

@@ -0,0 +1,403 @@
+"""Builtin: nightly-topic-knowledge
+
+Reads the previous day's daily memory, conversation log and notes, asks a local
+Ollama model to distill them into per-topic JSON, and merges the result into
+memory/topic-knowledge/. Designed to run once a day via cron.
+
+This skill writes its own files (multiple JSONs per run) so it bypasses the
+runtime's declarative outputs system. memory.md is never touched.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from datetime import datetime, timezone
+from typing import Any
+
+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 _topics_lib import (  # noqa: E402
+    DEFAULT_MAX_CHARS,
+    DEFAULT_TIMEZONE,
+    build_index,
+    build_prompt,
+    bundle_sources,
+    index_path,
+    list_existing_topic_ids,
+    load_json,
+    merge_topic,
+    normalize_topics,
+    parse_llm_response,
+    read_conversation_log,
+    read_daily_memory,
+    read_notes,
+    resolve_target_date,
+    run_path,
+    topic_path,
+    write_json,
+)
+from _feedback_lib import (  # noqa: E402
+    build_feedback_prompt,
+    collect_skill_summary,
+    format_notification,
+    format_proposal_for_history,
+    parse_feedback_response,
+)
+
+
+OLLAMA_PREFIX = "ollama:"
+DEFAULT_MODEL_LABEL = "chat"
+FAKE_ENV = "NIGHTLY_TOPIC_KNOWLEDGE_FAKE_JSON"
+FAKE_FEEDBACK_ENV = "NIGHTLY_TOPIC_KNOWLEDGE_FAKE_FEEDBACK_JSON"
+
+
+async def run(ctx, input):
+    loc = localizer(input)
+    args = input.get("args", {}) or {}
+    sources = input.get("sources", {}) or {}
+
+    workspace = sources.get("workspace")
+    memory_dir = sources.get("memory_dir")
+    notes_dir = sources.get("notes_dir")
+    logs_dir = sources.get("logs_dir")
+    if not workspace or not memory_dir or not notes_dir or not logs_dir:
+        return _err(loc.t("Workspace unavailable", "ワークスペース不明"),
+                    loc.t("workspace / memory_dir / notes_dir / logs_dir not provided.",
+                          "workspace / memory_dir / notes_dir / logs_dir が取得できません"))
+
+    tz_name = str(args.get("timezone") or DEFAULT_TIMEZONE).strip() or DEFAULT_TIMEZONE
+    model_arg = str(args.get("model") or "").strip()
+    max_chars = int(args.get("max_chars") or DEFAULT_MAX_CHARS)
+    dry_run = bool(args.get("dry_run"))
+
+    try:
+        date_str = resolve_target_date(args.get("date"), tz_name)
+    except Exception as e:
+        return _err(loc.t("Invalid date", "日付不正"), str(e))
+
+    daily_path, daily_text = read_daily_memory(memory_dir, date_str)
+    convo_path, convo_text = read_conversation_log(logs_dir, date_str)
+    notes_path, notes_text = read_notes(notes_dir, date_str)
+
+    sources_used = [p for p in (daily_path, convo_path, notes_path) if p]
+    bundle, bundle_chars = bundle_sources(
+        [
+            ("daily-memory", daily_text),
+            ("conversations", convo_text),
+            ("notes", notes_text),
+        ],
+        max_chars,
+    )
+
+    if not bundle.strip():
+        ctx.log.info(f"nightly-topic-knowledge: nothing to read for {date_str}")
+        return {
+            "status": "skipped",
+            "title": loc.t("No sources", "対象なし"),
+            "summary": loc.t(
+                f"No daily memory / conversation log / notes found for {date_str}.",
+                f"{date_str} の日次メモ・会話ログ・ノートが見つかりませんでした",
+            ),
+            "outputs": {},
+            "data": {"date": date_str, "sources_used": sources_used},
+            "suggestions": [],
+        }
+
+    prompt = build_prompt(date_str, bundle, list_existing_topic_ids(memory_dir))
+
+    model_label = model_arg or DEFAULT_MODEL_LABEL
+    try:
+        raw_text, model_label = await _call_model(ctx, model_arg, prompt)
+    except Exception as e:
+        ctx.log.error(f"nightly-topic-knowledge: model call failed: {e}")
+        return _err(
+            loc.t("Model call failed", "モデル呼び出し失敗"),
+            loc.t(
+                f"Failed to call {model_label}: {e}",
+                f"{model_label} の呼び出しに失敗しました: {e}",
+            ),
+        )
+
+    try:
+        parsed = parse_llm_response(raw_text)
+        topic_updates = normalize_topics(parsed)
+    except Exception as e:
+        ctx.log.error(f"nightly-topic-knowledge: invalid response: {e}")
+        return _err(
+            loc.t("Invalid response", "応答不正"),
+            loc.t(f"Could not parse model response as JSON: {e}", f"モデル応答をJSONとして解釈できません: {e}"),
+        )
+
+    if not topic_updates:
+        ctx.log.info(f"nightly-topic-knowledge: model returned no topics for {date_str}")
+        return {
+            "status": "skipped",
+            "title": loc.t("No topics", "トピックなし"),
+            "summary": loc.t(
+                f"Model produced no usable topics for {date_str}.",
+                f"{date_str} のソースから有用なトピックは抽出されませんでした",
+            ),
+            "outputs": {},
+            "data": {
+                "date": date_str,
+                "sources_used": sources_used,
+                "input_chars": bundle_chars,
+                "model": model_label,
+                "raw_response_chars": len(raw_text),
+            },
+            "suggestions": [],
+        }
+
+    now_iso = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    merged_topics: list[dict[str, Any]] = []
+    for update in topic_updates:
+        tid = update["topic_id"]
+        existing = load_json(topic_path(memory_dir, tid))
+        merged = merge_topic(existing, update, date_str, now_iso)
+        merged_topics.append(merged)
+
+    index = build_index(load_json(index_path(memory_dir)), merged_topics, now_iso)
+
+    run_record = {
+        "date": date_str,
+        "generated_at": now_iso,
+        "model": model_label,
+        "timezone": tz_name,
+        "sources_used": sources_used,
+        "input_chars": bundle_chars,
+        "raw_response_chars": len(raw_text),
+        "topics_updated": [topic["topic_id"] for topic in merged_topics],
+        "dry_run": dry_run,
+    }
+
+    if not dry_run:
+        for topic in merged_topics:
+            write_json(topic_path(memory_dir, topic["topic_id"]), topic)
+        write_json(index_path(memory_dir), index)
+        write_json(run_path(memory_dir, date_str), run_record)
+
+    feedback_result = await _run_skill_feedback(
+        ctx,
+        date_str=date_str,
+        bundle=bundle,
+        sources=sources,
+        dry_run=dry_run,
+    )
+
+    ctx.log.info(
+        f"nightly-topic-knowledge: {date_str} model={model_label} topics={len(merged_topics)} "
+        f"feedback={feedback_result['count']} dry_run={dry_run}"
+    )
+
+    return {
+        "status": "ok",
+        "title": loc.t("Distilled", "整理しました"),
+        "summary": loc.t(
+            f"Distilled {date_str}: {len(merged_topics)} topic(s){' (dry-run)' if dry_run else ''}",
+            f"{date_str} を整理しました: {len(merged_topics)}トピック{'（dry-run）' if dry_run else ''}",
+        ),
+        "outputs": {},
+        "data": {
+            "date": date_str,
+            "model": model_label,
+            "sources_used": sources_used,
+            "input_chars": bundle_chars,
+            "topics_updated": run_record["topics_updated"],
+            "dry_run": dry_run,
+            "run_path": run_path(memory_dir, date_str) if not dry_run else None,
+            "topics": merged_topics if dry_run else None,
+            "skill_feedback": feedback_result,
+        },
+        "suggestions": [],
+    }
+
+
+async def _call_model(ctx, model_arg: str, prompt: str) -> tuple[str, str]:
+    """Returns (raw_text, model_label).
+
+    No model_arg → route through the configured chat model (works for any
+    provider the user has set up: API / CLI / Ollama). Explicit
+    "ollama:<name>" → talk to a local Ollama directly so users can pin a cheap
+    local model for the nightly run without changing models.yaml. Any other
+    explicit value is rejected — those should be wired in models.yaml and
+    selected via the chat role instead.
+    """
+    # Validate input before the test/offline hook so an invalid override is
+    # rejected even when the fake env is set (otherwise our own tests for
+    # invalid input could pass for the wrong reason).
+    if model_arg and not model_arg.startswith(OLLAMA_PREFIX):
+        raise RuntimeError(
+            f'Direct mode supports only Ollama models (got "{model_arg}"). '
+            f'Use "ollama:<name>", or omit `model` to use the configured chat model.'
+        )
+
+    fake = os.environ.get(FAKE_ENV)
+    if fake:
+        return fake, (model_arg or DEFAULT_MODEL_LABEL)
+
+    if not model_arg:
+        result = await ctx.ai.run("distill", prompt)
+        if not isinstance(result, dict) or result.get("status") != "ok":
+            reason = (result or {}).get("reason") if isinstance(result, dict) else None
+            raise RuntimeError(reason or "chat model returned no result")
+        text = result.get("text") or ""
+        provider = result.get("provider") or "ai"
+        model_id = result.get("model_id") or "chat"
+        return text, f"{provider}:{model_id}"
+
+    text = _call_ollama(model_arg, prompt)
+    return text, model_arg
+
+
+def _call_ollama(model_id: str, prompt: str) -> str:
+    ollama_model = model_id[len(OLLAMA_PREFIX):]
+    if not ollama_model:
+        raise RuntimeError("Ollama model name is empty after the prefix.")
+    host = os.environ.get("OLLAMA_HOST") or "http://localhost:11434"
+    url = host.rstrip("/") + "/api/chat"
+    body = json.dumps(
+        {
+            "model": ollama_model,
+            "messages": [
+                {
+                    "role": "system",
+                    "content": "You distill conversation logs into per-topic JSON.",
+                },
+                {"role": "user", "content": prompt},
+            ],
+            "stream": False,
+            "format": "json",
+            "options": {"temperature": 0.2},
+        },
+        ensure_ascii=False,
+    ).encode("utf-8")
+    request = urllib.request.Request(
+        url,
+        data=body,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=300) as response:
+            payload = response.read().decode("utf-8")
+    except urllib.error.HTTPError as e:
+        detail = e.read().decode("utf-8", errors="replace") if hasattr(e, "read") else str(e)
+        raise RuntimeError(f"Ollama HTTP {e.code}: {detail[:400]}")
+    except urllib.error.URLError as e:
+        raise RuntimeError(f"Ollama unreachable at {host}: {e.reason}")
+    parsed = json.loads(payload)
+    message = parsed.get("message") or {}
+    content = message.get("content")
+    if not isinstance(content, str):
+        raise RuntimeError("Ollama response had no message.content")
+    return content
+
+
+async def _run_skill_feedback(
+    ctx,
+    *,
+    date_str: str,
+    bundle: str,
+    sources: dict[str, Any],
+    dry_run: bool,
+) -> dict[str, Any]:
+    """Second AI step: derive skill improvement / new-skill proposals.
+
+    Failures here must not break the nightly run — feedback is best-effort
+    on top of the topic-knowledge distillation. Any error is logged and
+    surfaced in the returned summary instead of raising.
+    """
+    skills_dir = sources.get("skills_dir")
+    builtin_skills_dir = sources.get("builtin_skills_dir")
+    catalog = collect_skill_summary(skills_dir, builtin_skills_dir)
+    prompt = build_feedback_prompt(date_str, bundle, catalog)
+
+    raw_text = ""
+    try:
+        fake = os.environ.get(FAKE_FEEDBACK_ENV)
+        if fake:
+            raw_text = fake
+        else:
+            response = await ctx.ai.run("skill_feedback", prompt)
+            if not isinstance(response, dict) or response.get("status") != "ok":
+                reason = (response or {}).get("reason") if isinstance(response, dict) else None
+                ctx.log.warn(f"nightly-topic-knowledge: skill_feedback skipped: {reason or 'no result'}")
+                return {"count": 0, "notified": False, "skipped_reason": reason or "no result"}
+            raw_text = response.get("text") or ""
+    except Exception as e:
+        ctx.log.warn(f"nightly-topic-knowledge: skill_feedback failed: {e}")
+        return {"count": 0, "notified": False, "skipped_reason": str(e)}
+
+    proposals = parse_feedback_response(raw_text)
+    if not proposals:
+        ctx.log.info(f"nightly-topic-knowledge: skill_feedback produced no proposals for {date_str}")
+        return {"count": 0, "notified": False, "skipped_reason": "empty"}
+
+    saved_meta: list[dict[str, Any]] = []
+    now_iso = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    for index, proposal in enumerate(proposals, start=1):
+        entry_id = f"{date_str}#{index}"
+        content = format_proposal_for_history(date_str, index, proposal)
+        meta = {
+            "id": entry_id,
+            "date": date_str,
+            "index": index,
+            "type": proposal["type"],
+            "target_kind": proposal["target_kind"],
+            "target_skill": proposal.get("target_skill") or "",
+            "target_change": proposal.get("target_change") or "other",
+            "status": "pending",
+            "generated_at": now_iso,
+        }
+        if not dry_run:
+            try:
+                await ctx.history.append({"meta": meta, "content": content, "replace": True})
+            except Exception as e:
+                ctx.log.warn(f"nightly-topic-knowledge: history.append failed for {entry_id}: {e}")
+                continue
+        saved_meta.append(meta)
+
+    notified = False
+    notify_detail: str | None = None
+    if saved_meta and not dry_run:
+        message = format_notification(date_str, proposals[: len(saved_meta)])
+        if message:
+            try:
+                outcome = await ctx.notify({
+                    "title": f"スキル振り返り {date_str}",
+                    "body": message,
+                })
+                notified = bool(outcome.get("ok"))
+                notify_detail = outcome.get("detail")
+                if not notified:
+                    ctx.log.warn(f"nightly-topic-knowledge: notify failed: {notify_detail}")
+            except Exception as e:
+                ctx.log.warn(f"nightly-topic-knowledge: notify error: {e}")
+                notify_detail = str(e)
+
+    return {
+        "count": len(saved_meta),
+        "notified": notified,
+        "notify_detail": notify_detail,
+        "proposals": proposals if dry_run else None,
+    }
+
+
+def _err(title: str, summary: str) -> dict[str, Any]:
+    return {
+        "status": "error",
+        "title": title,
+        "summary": summary,
+        "outputs": {},
+        "data": {},
+        "suggestions": [],
+    }
+
+
+# Re-export for tests
+__all__ = ["run"]

package/builtin-skills/nightly-topic-knowledge/skill.yaml

@@ -0,0 +1,88 @@
+# Builtin: nightly-topic-knowledge
+# Reads the previous day's conversations, daily memory and notes after midnight,
+# distills them into per-topic lightweight knowledge files, and updates an index.
+# Designed to be invoked once a day via cron (e.g. "10 0 * * *").
+
+id: nightly-topic-knowledge
+name: Nightly Topic Knowledge
+name_i18n:
+  en: Nightly Topic Knowledge
+  ja: 夜間トピックナレッジ
+description: Distill the previous day's logs and notes into per-topic knowledge files
+description_i18n:
+  en: Distill the previous day's logs and notes into per-topic knowledge files
+  ja: 前日の会話ログとメモをトピック別のナレッジに整理する
+runtime: python
+output_mode: raw
+side_effect: true
+
+invocation:
+  command: knowledge.nightly
+  phrases:
+    - update topic knowledge
+    - distill yesterday
+    - run nightly knowledge
+  phrases_i18n:
+    en:
+      - update topic knowledge
+      - distill yesterday
+      - run nightly knowledge
+    ja:
+      - トピックナレッジを更新
+      - 昨日の話を整理
+      - ナレッジを更新して
+
+input:
+  schema:
+    type: object
+    additionalProperties: false
+    properties:
+      date:
+        type: string
+        pattern: "^[0-9]{4}-[0-9]{2}-[0-9]{2}$"
+        description: Target day in YYYY-MM-DD. Defaults to yesterday in the chosen timezone.
+        description_i18n:
+          en: Target day in YYYY-MM-DD. Defaults to yesterday in the chosen timezone.
+          ja: 対象日 (YYYY-MM-DD)。省略時はタイムゾーン基準の前日
+      model:
+        type: string
+        minLength: 1
+        description: Optional model override. Use "ollama:<name>" to call a local Ollama model directly. If omitted, the configured chat model is used.
+        description_i18n:
+          en: Optional model override. Use "ollama:<name>" to call a local Ollama model directly. If omitted, the configured chat model is used.
+          ja: モデル上書き(任意)。"ollama:<name>" でローカル Ollama を直接呼ぶ。省略時は設定済みのチャットモデルを使う
+      timezone:
+        type: string
+        minLength: 1
+        description: IANA timezone used to compute "yesterday". Defaults to Asia/Tokyo.
+        description_i18n:
+          en: IANA timezone used to compute "yesterday". Defaults to Asia/Tokyo.
+          ja: 前日判定に使うタイムゾーン。既定は Asia/Tokyo
+      max_chars:
+        type: integer
+        minimum: 1000
+        maximum: 200000
+        description: Upper bound on the combined source text passed to the model.
+        description_i18n:
+          en: Upper bound on the combined source text passed to the model.
+          ja: モデルに渡す合算ソース本文の上限文字数
+      dry_run:
+        type: boolean
+        default: false
+        description: If true, do not write files; return the planned updates only.
+        description_i18n:
+          en: If true, do not write files; return the planned updates only.
+          ja: true ならファイルに書かず、結果だけ返す
+
+ai_steps:
+  - id: distill
+    purpose: Distill the previous day's daily memory, conversations and notes into per-topic JSON.
+    model: chat
+  - id: skill_feedback
+    purpose: From the same sources plus the current skill catalog, propose concrete skill improvements or new-skill candidates the user can batch-apply later.
+    model: chat
+    optional: true
+
+history:
+  read: true
+  write: true

package/builtin-skills/schedule-add/main.py

@@ -83,6 +83,32 @@ async def run(ctx, input):
             loc.t(f'Schedule ID "{schedule_id}" is already registered with different settings. Remove it first or use another ID.', f'スケジュールID "{schedule_id}" は別の内容で既に登録されています。先に削除してから追加するか、別のIDを使ってください'),
         )
 
+    # Content-based duplicate: if a different id already holds the same
+    # cron/skill/args/description/approve combination, treat as idempotent
+    # so building "毎朝4時のブリーフィング" twice doesn't double-register.
+    twin = next(
+        (item for item in entries if isinstance(item, dict) and _same_schedule(item, entry)),
+        None,
+    )
+    if twin is not None:
+        twin_id = str(twin.get("id", "")).strip() or schedule_id
+        ctx.log.info(f"schedule-add: duplicate content found at id={twin_id} (skipped)")
+        disabled_note = " (disabled)" if _enabled_value(twin) is False else ""
+        return {
+            "status": "ok",
+            "title": loc.t("Already registered", "登録済み"),
+            "summary": loc.t(f"Already registered: {twin_id}: {cron} -> {skill}{disabled_note}", f"登録済みです: {twin_id}: {cron} → {skill}{disabled_note}"),
+            "outputs": {},
+            "data": {
+                "entry": twin,
+                "total": len(entries),
+                "path": _schedules_path(workspace),
+                "already_registered": True,
+                "duplicate_of": twin_id,
+            },
+            "suggestions": [],
+        }
+
     entries.append(entry)
 
     try: