774 lines
33 KiB
Python
774 lines
33 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""persona.py — jsc-persona 的人格 / 記憶 / 情緒 / 關係圖 CLI。
|
||
|
||
所有子指令都需要 `--session <session_id>`（除了 list / status / gc）。
|
||
session_id 由 SessionStart hook 注入到上下文（PERSONA_SESSION=...），
|
||
hook 會驗證 CLI 帶的 --session 與真實 session 相符，藉此讓「人格鎖」與
|
||
「跨人格隔離」無法被繞過。
|
||
|
||
用法（皆為 `python3 persona.py <subcommand> ...`）：
|
||
create/load/release/status/list/heartbeat/show/brief
|
||
remember/recall/consolidate/prune/reindex
|
||
emotion/mindmap/relation
|
||
invite/leave/room/gc
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import json
|
||
import os
|
||
import sys
|
||
from pathlib import Path
|
||
|
||
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||
import persona_lib as pl # noqa: E402
|
||
|
||
|
||
def die(message: str, code: int = 1):
|
||
print(f"✖ {message}", file=sys.stderr)
|
||
raise SystemExit(code)
|
||
|
||
|
||
def ok(message: str):
|
||
print(f"✔ {message}")
|
||
|
||
|
||
def emit(payload: dict, as_json: bool, lines: list[str]):
|
||
if as_json:
|
||
print(json.dumps(payload, ensure_ascii=False, indent=2))
|
||
else:
|
||
print("\n".join(lines))
|
||
|
||
|
||
def parse_kv_numbers(raw: str | None) -> dict:
|
||
"""`joy=+12,anger=-5` → {"joy": 12.0, "anger": -5.0}"""
|
||
out = {}
|
||
for chunk in (raw or "").split(","):
|
||
chunk = chunk.strip()
|
||
if not chunk or "=" not in chunk:
|
||
continue
|
||
key, _, value = chunk.partition("=")
|
||
try:
|
||
out[key.strip()] = float(value)
|
||
except ValueError:
|
||
continue
|
||
return out
|
||
|
||
|
||
def csv_list(raw: str | None) -> list[str]:
|
||
return [x.strip() for x in (raw or "").split(",") if x.strip()]
|
||
|
||
|
||
# --------------------------------------------------------------------------- #
|
||
# session / 權限檢查
|
||
# --------------------------------------------------------------------------- #
|
||
|
||
def require_owner(slug: str | None, session_id: str) -> dict:
|
||
"""呼叫者必須是這個人格的 exclusive 持有者。"""
|
||
if not slug:
|
||
die("未指定人格，且本 session 沒有載入人格。")
|
||
if not pl.persona_exists(slug):
|
||
die(f"人格 `{slug}` 不存在。可用：{pl.list_personas() or '（無）'}")
|
||
data = pl.load_session(session_id)
|
||
if data.get("host") != slug:
|
||
die(
|
||
f"本 session 的 host 人格是 `{data.get('host') or '（未載入）'}`，"
|
||
f"不是 `{slug}`。禁止跨人格操作；請先 `release` 再 `load`。"
|
||
)
|
||
lock = pl.read_json(pl.lock_path(slug)) or {}
|
||
if lock.get("session_id") != session_id:
|
||
die(f"人格 `{slug}` 的載入鎖不屬於本 session，請重新 `load`（必要時加 --takeover）。")
|
||
pl.heartbeat_lock(slug, session_id)
|
||
return data
|
||
|
||
|
||
def require_member(slug: str | None, session_id: str, as_guest: bool = False) -> tuple[dict, str]:
|
||
"""呼叫者是 host（owner）或以 `--as-guest` 自稱的受邀人格。回傳 (session_data, role)。
|
||
|
||
受邀人格的資料只有它自己（`persona-guest` sub agent）能讀；主程序即使邀請了它，
|
||
也只能看它在聊天室說出口的話。`--as-guest` 由 PreToolUse hook 把關，主程序帶了會被拒絕。
|
||
"""
|
||
if not slug:
|
||
die("未指定人格，且本 session 沒有載入人格。")
|
||
if not pl.persona_exists(slug):
|
||
die(f"人格 `{slug}` 不存在。")
|
||
data = pl.load_session(session_id)
|
||
if data.get("host") == slug:
|
||
if as_guest:
|
||
die(f"`{slug}` 是本 session 的 host 人格，不需要也不得使用 `--as-guest`。")
|
||
pl.heartbeat_lock(slug, session_id)
|
||
return data, "owner"
|
||
if slug in (data.get("guests") or {}):
|
||
if not as_guest:
|
||
die(
|
||
f"`{slug}` 是本 session 邀請的 guest 人格，它的記憶與情緒不對主程序開放"
|
||
"（跨人格資料隔離）。你只能透過 `room read` 看它說出口的話；"
|
||
"要以它的身分行動必須是 persona-guest sub agent 並帶 `--as-guest`。"
|
||
)
|
||
return data, "guest"
|
||
die(f"人格 `{slug}` 未被本 session 載入或邀請，禁止存取（跨人格資料隔離）。")
|
||
|
||
|
||
# --------------------------------------------------------------------------- #
|
||
# 模板
|
||
# --------------------------------------------------------------------------- #
|
||
|
||
TEMPLATE_DIR = Path(__file__).resolve().parent.parent / "skills" / "persona-create" / "templates"
|
||
|
||
|
||
def render_template(name: str, mapping: dict) -> str:
|
||
text = (TEMPLATE_DIR / name).read_text(encoding="utf-8")
|
||
for key, value in mapping.items():
|
||
text = text.replace("{{" + key + "}}", str(value))
|
||
return text
|
||
|
||
|
||
# --------------------------------------------------------------------------- #
|
||
# 子指令
|
||
# --------------------------------------------------------------------------- #
|
||
|
||
def cmd_create(args):
|
||
slug = args.persona
|
||
if not pl.valid_slug(slug):
|
||
die("slug 只能是小寫英數與連字號（最長 48 字），例如 `lumi`、`shen-yu`。")
|
||
if pl.persona_exists(slug) and not args.force:
|
||
die(f"人格 `{slug}` 已存在（{pl.persona_dir(slug)}）。要覆寫請加 --force。")
|
||
root = pl.ensure_persona_dirs(slug)
|
||
mapping = {
|
||
"SLUG": slug,
|
||
"NAME": args.name or slug,
|
||
"CREATURE": args.creature or "",
|
||
"VIBE": args.vibe or "",
|
||
"EMOJI": args.emoji or "",
|
||
"AVATAR": args.avatar or "",
|
||
"CREATED": pl.iso(),
|
||
}
|
||
for filename in ("IDENTITY.md", "SOUL.md", "AGENTS.md", "USER.md"):
|
||
target = root / filename
|
||
if target.exists() and not args.force:
|
||
continue
|
||
pl.write_text(target, render_template(filename, mapping))
|
||
pl.write_json(pl.emotion_path(slug), pl.default_emotion_state(parse_kv_numbers(args.baseline)))
|
||
pl.write_json(pl.config_path(slug), {
|
||
"persona": slug,
|
||
"display_name": args.name or slug,
|
||
"created_at": pl.iso(),
|
||
"created_by_session": args.session,
|
||
"schema": 1,
|
||
})
|
||
pl.write_json(pl.relations_json(slug), {"nodes": [], "edges": []})
|
||
pl.write_text(pl.mindmap_path(slug), (
|
||
"%% 心智圖（長期語意結構）：概念如何互相勾連\n"
|
||
"mindmap\n"
|
||
f" root(({mapping['NAME']}))\n"
|
||
" 自我\n"
|
||
" 使用者\n"
|
||
" 共同經驗\n"
|
||
))
|
||
pl.rebuild_index(slug)
|
||
pl.acquire_lock(slug, args.session, cwd=args.cwd)
|
||
pl.bind_host(args.session, slug, cwd=args.cwd)
|
||
ok(f"人格 `{slug}` 建立於 {root}，已取得載入鎖並綁定本 session。")
|
||
print(f" 下一步：補完 {root}/IDENTITY.md 與 SOUL.md，再用 /jsc-persona:persona-chat 開始對話。")
|
||
|
||
|
||
def cmd_list(args):
|
||
rows = []
|
||
for slug in pl.list_personas():
|
||
status = pl.lock_status(slug)
|
||
owner = status["owner"]
|
||
rows.append({
|
||
"persona": slug,
|
||
"identity": pl.identity_brief(slug),
|
||
"locked": status["locked"],
|
||
"stale": status["stale"],
|
||
"owner_session": (owner.get("session_id") or "")[:8],
|
||
"owner_cwd": owner.get("cwd"),
|
||
"guests": len(status["guests"]),
|
||
"long_term": len(list(pl.long_term_dir(slug).glob("*.md"))),
|
||
"short_term": len(pl.read_jsonl(pl.short_term_path(slug))),
|
||
})
|
||
lines = [f"人格倉庫：{pl.persona_home()}"]
|
||
if not rows:
|
||
lines.append("（尚無人格，用 /jsc-persona:persona-create 建立）")
|
||
for r in rows:
|
||
state = "🔒 已載入" if r["locked"] else ("⚠ 死鎖可接手" if r["stale"] else "🔓 空閒")
|
||
lines.append(
|
||
f"- `{r['persona']}` {state}"
|
||
+ (f"（session {r['owner_session']}…, cwd {r['owner_cwd']}）" if r["locked"] else "")
|
||
+ f"｜guest {r['guests']}｜長期記憶 {r['long_term']}｜短期 {r['short_term']}"
|
||
+ (f"｜{r['identity']}" if r["identity"] else "")
|
||
)
|
||
emit({"home": str(pl.persona_home()), "personas": rows}, args.json, lines)
|
||
|
||
|
||
def cmd_load(args):
|
||
slug = args.persona
|
||
if not pl.persona_exists(slug):
|
||
die(f"人格 `{slug}` 不存在。可用：{pl.list_personas() or '（無）'}")
|
||
data = pl.load_session(args.session)
|
||
current = data.get("host")
|
||
if current and current != slug:
|
||
die(
|
||
f"本 session 已載入人格 `{current}`。一個程序只能載入一個人格；"
|
||
f"請先 `release --session <id>` 再載入 `{slug}`"
|
||
"（若只是想讓兩個人格對話，請用 /jsc-persona:persona-invite）。"
|
||
)
|
||
try:
|
||
lock = pl.acquire_lock(slug, args.session, cwd=args.cwd, takeover=args.takeover)
|
||
except pl.LockError as exc:
|
||
die(f"{exc}\n 若確定那個程序已結束，可加 --takeover 接手。")
|
||
pl.bind_host(args.session, slug, cwd=args.cwd)
|
||
pl.prune_short_term(slug)
|
||
pl.rebuild_index(slug)
|
||
lines = [
|
||
f"✔ 已載入人格 `{slug}`（exclusive，session {args.session[:8]}…，租約 {lock['lease_seconds']}s）",
|
||
]
|
||
if lock.get("took_over_from"):
|
||
prev = lock["took_over_from"]
|
||
lines.append(
|
||
f"⚠ 這把鎖是接手來的：原持有者 session {(prev.get('session_id') or '')[:8]}…"
|
||
f"（cwd {prev.get('cwd')}）已失聯 {prev.get('stale_minutes')} 分鐘。"
|
||
"請向使用者說明，若那個程序其實還活著，兩邊的記憶可能會互相覆蓋。"
|
||
)
|
||
lines.append(pl.turn_context(slug, args.session))
|
||
emit({"persona": slug, "lock": lock, "context": pl.turn_context(slug, args.session)}, args.json, lines)
|
||
|
||
|
||
def cmd_release(args):
|
||
data = pl.load_session(args.session)
|
||
slug = args.persona or data.get("host")
|
||
if not slug:
|
||
die("本 session 沒有載入任何人格。")
|
||
released = pl.unbind_session(args.session)
|
||
ok(f"已釋放人格 `{slug}` 的載入鎖" + (f"，並退出 guest：{released['guests']}" if released["guests"] else "。"))
|
||
|
||
|
||
def cmd_status(args):
|
||
if args.persona:
|
||
status = pl.lock_status(args.persona)
|
||
lines = [
|
||
f"人格 `{args.persona}`：" + ("🔒 已載入" if status["locked"] else "🔓 空閒"),
|
||
f" owner: {json.dumps(status['owner'], ensure_ascii=False)}",
|
||
f" guests: {json.dumps(status['guests'], ensure_ascii=False)}",
|
||
]
|
||
if pl.persona_exists(args.persona):
|
||
lines.append(" " + pl.emotion_brief(args.persona))
|
||
emit(status, args.json, lines)
|
||
return
|
||
data = pl.load_session(args.session) if args.session else {}
|
||
lines = [
|
||
f"session {(args.session or '-')[:12]}…",
|
||
f" host 人格：{data.get('host') or '（未載入）'}",
|
||
f" guest 人格：{list((data.get('guests') or {}).keys()) or '（無）'}",
|
||
f" 聊天室：{data.get('rooms') or '（無）'}",
|
||
]
|
||
emit(data, args.json, lines)
|
||
|
||
|
||
def cmd_heartbeat(args):
|
||
data = pl.load_session(args.session)
|
||
slug = data.get("host")
|
||
if slug:
|
||
pl.heartbeat_lock(slug, args.session)
|
||
for guest, info in (data.get("guests") or {}).items():
|
||
pl.add_guest_lease(guest, args.session, info.get("room", ""), slug or "")
|
||
ok(f"heartbeat：host={slug}，guests={list((data.get('guests') or {}).keys())}")
|
||
|
||
|
||
def cmd_show(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
if not slug:
|
||
die("未指定人格，且本 session 沒有載入人格。")
|
||
require_member(slug, args.session, args.as_guest)
|
||
root = pl.persona_dir(slug)
|
||
want = args.what
|
||
files = {"identity": "IDENTITY.md", "soul": "SOUL.md", "agents": "AGENTS.md", "user": "USER.md"}
|
||
chosen = files.values() if want == "all" else [files[want]]
|
||
out = []
|
||
for filename in chosen:
|
||
path = root / filename
|
||
if path.exists():
|
||
out.append(f"===== {filename} =====\n{path.read_text(encoding='utf-8').rstrip()}")
|
||
out.append("===== 狀態 =====\n" + pl.emotion_brief(slug))
|
||
print("\n\n".join(out))
|
||
|
||
|
||
def cmd_brief(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
if not slug:
|
||
die("未指定人格，且本 session 沒有載入人格。")
|
||
require_member(slug, args.session, args.as_guest)
|
||
print(pl.turn_context(slug, args.session, args.query or ""))
|
||
|
||
|
||
def cmd_remember(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
if not slug:
|
||
die("未指定人格。")
|
||
data, role = require_member(slug, args.session, args.as_guest)
|
||
scope = args.scope
|
||
if role == "guest" and scope != "inbox":
|
||
die("guest（sub agent）只能寫入 inbox：`--scope inbox --room <room>`。")
|
||
entry = {
|
||
"ts": pl.iso(),
|
||
"role": args.role,
|
||
"text": args.text,
|
||
"topics": csv_list(args.topics),
|
||
"entities": csv_list(args.entities),
|
||
"intent": args.intent or "",
|
||
"salience": int(args.salience),
|
||
"emotion_deltas": parse_kv_numbers(args.emotion),
|
||
"room": args.room or None,
|
||
"session": args.session[:8],
|
||
}
|
||
if scope == "inbox":
|
||
if not args.room:
|
||
die("`--scope inbox` 必須指定 `--room`。")
|
||
pl.append_jsonl(pl.inbox_path(slug, args.room), entry)
|
||
ok(f"已寫入 `{slug}` 的 inbox（room {args.room}）；等它下次自己載入時再固化。")
|
||
else:
|
||
pl.remember_short(slug, entry)
|
||
kept = pl.prune_short_term(slug)
|
||
if entry["emotion_deltas"]:
|
||
state = pl.apply_emotion(pl.load_emotion(slug), entry["emotion_deltas"], args.text[:80])
|
||
pl.write_json(pl.emotion_path(slug), state)
|
||
pl.append_jsonl(pl.journal_path(slug), {
|
||
"ts": pl.iso(), "kind": "emotion", "trigger": args.text[:120],
|
||
"deltas": entry["emotion_deltas"], "levels": state["levels"], "mood": pl.mood(state),
|
||
})
|
||
ok(f"已寫入短期記憶（顯著度 {entry['salience']}，目前 {kept} 筆）。")
|
||
if kept >= pl.CONSOLIDATE_THRESHOLD:
|
||
print(f" ⚠ 已達 {pl.CONSOLIDATE_THRESHOLD} 筆，建議執行 /jsc-persona:persona-memory 固化。")
|
||
if entry["emotion_deltas"]:
|
||
print(" " + pl.emotion_brief(slug))
|
||
|
||
|
||
def cmd_recall(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
if not slug:
|
||
die("未指定人格。")
|
||
require_member(slug, args.session, args.as_guest)
|
||
hits = pl.recall(slug, args.query, args.limit)
|
||
lines = [f"「{args.query}」的長期記憶命中 {len(hits)} 則："]
|
||
for meta in hits:
|
||
lines.append(
|
||
f"- {meta['_name']}｜{meta.get('type', 'fact')}｜顯著度 {meta.get('salience', '?')}"
|
||
f"｜{(meta.get('_body') or '').splitlines()[0][:120] if meta.get('_body') else ''}"
|
||
)
|
||
recents = pl.recent_short(slug, args.limit)
|
||
if recents:
|
||
lines.append("短期記憶（最近）：")
|
||
for row in recents:
|
||
lines.append(f"- [{row.get('role', '?')}] {(row.get('text') or '')[:110]}")
|
||
pl.touch_recall(slug, [m["_name"] for m in hits])
|
||
emit({"persona": slug, "long_term": hits, "short_term": recents}, args.json, lines)
|
||
|
||
|
||
def cmd_consolidate(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
require_owner(slug, args.session)
|
||
name = pl.slugify(args.name)
|
||
path = pl.long_term_dir(slug) / f"{name}.md"
|
||
today = f"{pl.utcnow():%Y-%m-%d}"
|
||
existing_meta = {}
|
||
if path.exists():
|
||
existing_meta, _body = pl.parse_front_matter(path.read_text(encoding="utf-8"))
|
||
body = args.body
|
||
if args.body_file:
|
||
body = Path(args.body_file).read_text(encoding="utf-8")
|
||
front = [
|
||
"---",
|
||
f"name: {name}",
|
||
f"type: {args.type}",
|
||
f"about: [{', '.join(csv_list(args.about)) or 'user'}]",
|
||
f"topics: [{', '.join(csv_list(args.topics))}]",
|
||
f"salience: {args.salience}",
|
||
f"emotion: {args.emotion or 'none'}",
|
||
f"first_seen: {existing_meta.get('first_seen', today)}",
|
||
f"last_seen: {today}",
|
||
f"recall_count: {existing_meta.get('recall_count', 0)}",
|
||
f"source: {args.source or 'short-term'}",
|
||
"---",
|
||
"",
|
||
body.strip(),
|
||
"",
|
||
]
|
||
pl.write_text(path, "\n".join(front))
|
||
total = pl.rebuild_index(slug)
|
||
if args.forget:
|
||
rows = pl.read_jsonl(pl.short_term_path(slug))
|
||
keep = [r for r in rows if int(r.get("salience") or 0) >= args.forget]
|
||
pl.write_text(pl.short_term_path(slug),
|
||
"".join(json.dumps(r, ensure_ascii=False) + "\n" for r in keep))
|
||
print(f" 短期記憶已淘汰顯著度 < {args.forget} 的項目，剩 {len(keep)} 筆。")
|
||
ok(f"長期記憶 `{name}` 已寫入（共 {total} 則），INDEX.md 已重建。")
|
||
|
||
|
||
def cmd_prune(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
require_owner(slug, args.session)
|
||
kept = pl.prune_short_term(slug)
|
||
ok(f"短期記憶已裁剪，剩 {kept} 筆（保留上限 {pl.SHORT_TERM_KEEP} 筆 / {pl.SHORT_TERM_DAYS} 天）。")
|
||
|
||
|
||
def cmd_reindex(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
require_owner(slug, args.session)
|
||
total = pl.rebuild_index(slug)
|
||
ok(f"INDEX.md 重建完成（{total} 則長期記憶）。")
|
||
|
||
|
||
def cmd_emotion(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
data, role = require_member(slug, args.session, args.as_guest)
|
||
state = pl.decay_emotion(pl.load_emotion(slug))
|
||
if args.baseline:
|
||
for key, value in parse_kv_numbers(args.baseline).items():
|
||
if key in pl.EMOTIONS:
|
||
state["baseline"][key] = pl.clamp(value)
|
||
if args.apply:
|
||
if role == "guest":
|
||
die("guest（sub agent）不得改寫人格的情緒狀態。")
|
||
state = pl.apply_emotion(state, parse_kv_numbers(args.apply), args.trigger)
|
||
pl.append_jsonl(pl.journal_path(slug), {
|
||
"ts": pl.iso(), "kind": "emotion", "trigger": args.trigger or "",
|
||
"deltas": parse_kv_numbers(args.apply), "levels": state["levels"], "mood": pl.mood(state),
|
||
})
|
||
if role != "guest":
|
||
pl.write_json(pl.emotion_path(slug), state)
|
||
m = pl.mood(state)
|
||
lines = [f"人格 `{slug}` 情緒狀態（{state['updated_at']}）", " 正向："]
|
||
for key in pl.POSITIVE:
|
||
zh = pl.EMOTIONS[key][0]
|
||
lines.append(f" {zh:<2}{key:<13}{state['levels'][key]:>6.1f}（基線 {state['baseline'][key]}）")
|
||
lines.append(" 負向：")
|
||
for key in pl.NEGATIVE:
|
||
zh = pl.EMOTIONS[key][0]
|
||
lines.append(f" {zh:<2}{key:<13}{state['levels'][key]:>6.1f}（基線 {state['baseline'][key]}）")
|
||
lines.append(f" 心情：{m['label']}/{m['tempo']}（valence {m['valence']:+.1f}, arousal {m['arousal']:.1f}）")
|
||
lines.append(" " + pl.emotion_brief(slug, state))
|
||
emit({"persona": slug, "state": state, "mood": m}, args.json, lines)
|
||
|
||
|
||
def cmd_mindmap(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
require_owner(slug, args.session)
|
||
if args.action == "show":
|
||
target = pl.thread_path(slug, args.topic) if args.topic else pl.mindmap_path(slug)
|
||
if not target.exists():
|
||
die(f"{target} 不存在。")
|
||
print(target.read_text(encoding="utf-8"))
|
||
return
|
||
if args.action == "thread":
|
||
if not args.topic:
|
||
die("`thread` 需要 --topic。")
|
||
path = pl.thread_path(slug, args.topic)
|
||
if not path.exists() or args.force:
|
||
pl.write_text(path, (
|
||
f"%% 思維導圖（短期）：{args.topic}\n"
|
||
f"%% created: {pl.iso()} ttl: short-term（固化後請併入 semantic.mmd 並刪除）\n"
|
||
"graph LR\n"
|
||
f' trigger["觸發：{args.topic}"] --> obs["觀察"]\n'
|
||
' obs --> infer["推論"]\n'
|
||
' infer --> concl["結論／待驗證"]\n'
|
||
))
|
||
ok(f"思維導圖：{path}（用 Write/Edit 續寫推理鏈）")
|
||
return
|
||
if args.action == "list":
|
||
threads = sorted(p.name for p in (pl.persona_dir(slug) / "mindmap" / "threads").glob("*.mmd"))
|
||
lines = [f"心智圖：{pl.mindmap_path(slug)}", f"思維導圖（{len(threads)}）："] + [f" - {t}" for t in threads]
|
||
emit({"semantic": str(pl.mindmap_path(slug)), "threads": threads}, args.json, lines)
|
||
return
|
||
die(f"未知 action：{args.action}")
|
||
|
||
|
||
def cmd_relation(args):
|
||
slug = args.persona or pl.load_session(args.session).get("host")
|
||
require_owner(slug, args.session)
|
||
if args.action == "node":
|
||
if not args.name:
|
||
die("`node` 需要 --name。")
|
||
pl.upsert_relation_node(slug, {
|
||
"id": args.id or pl.slugify(args.name),
|
||
"name": args.name,
|
||
"kind": args.kind,
|
||
"closeness": pl.clamp(args.closeness) if args.closeness is not None else None,
|
||
"trust": pl.clamp(args.trust) if args.trust is not None else None,
|
||
"note": args.note,
|
||
"tags": csv_list(args.tags) or None,
|
||
})
|
||
pl.render_relations(slug)
|
||
ok(f"關係節點 `{args.name}` 已更新。")
|
||
elif args.action == "edge":
|
||
if not args.to:
|
||
die("`edge` 需要 --to。")
|
||
pl.upsert_relation_edge(slug, {
|
||
"from": args.from_ or "self",
|
||
"to": args.to,
|
||
"label": args.label,
|
||
"affinity": pl.clamp(args.affinity) if args.affinity is not None else None,
|
||
})
|
||
pl.render_relations(slug)
|
||
ok(f"關係連線 {args.from_ or 'self'} → {args.to} 已更新。")
|
||
elif args.action == "render":
|
||
text = pl.render_relations(slug)
|
||
print(text)
|
||
elif args.action == "show":
|
||
data = pl.load_relations(slug)
|
||
lines = [f"人格 `{slug}` 人際關係圖：{len(data['nodes'])} 節點 / {len(data['edges'])} 連線",
|
||
pl.relations_brief(slug, None, 20) or "（空）"]
|
||
emit(data, args.json, lines)
|
||
else:
|
||
die(f"未知 action：{args.action}")
|
||
|
||
|
||
def cmd_invite(args):
|
||
host = args.host or pl.load_session(args.session).get("host")
|
||
if not host:
|
||
die("本 session 尚未載入 host 人格，無法邀請他人。")
|
||
require_owner(host, args.session)
|
||
guest = args.guest
|
||
if guest == host:
|
||
die("不能邀請自己。")
|
||
if not pl.persona_exists(guest):
|
||
die(f"人格 `{guest}` 不存在。可用：{pl.list_personas()}")
|
||
lock = pl.read_json(pl.lock_path(guest)) or {}
|
||
if lock and lock.get("session_id") != args.session and not pl.lock_is_dead(lock):
|
||
die(
|
||
f"人格 `{guest}` 正被另一個程序載入（session {lock.get('session_id', '')[:8]}…，"
|
||
f"cwd {lock.get('cwd')}）。同一人格同時只能被一個程序載入，無法邀請。"
|
||
)
|
||
room = args.room or f"{host}-{guest}-{pl.utcnow():%Y%m%d-%H%M%S}"
|
||
pl.create_room(room, host, args.session, args.topic or "")
|
||
pl.join_room(room, guest)
|
||
pl.add_guest_lease(guest, args.session, room, host)
|
||
data = pl.load_session(args.session)
|
||
data.setdefault("guests", {})[guest] = {"room": room, "joined_at": pl.iso(), "mode": "guest-readonly"}
|
||
rooms = data.setdefault("rooms", [])
|
||
if room not in rooms:
|
||
rooms.append(room)
|
||
pl.save_session(args.session, data)
|
||
if args.topic:
|
||
pl.room_post(room, "system", f"主題：{args.topic}", kind="meta")
|
||
lines = [
|
||
f"✔ 已邀請人格 `{guest}` 以 guest（唯讀）身分加入聊天室 `{room}`。",
|
||
f" 聊天室路徑：{pl.room_dir(room)}",
|
||
f" 請用 Agent 工具、subagent_type=\"persona:persona-guest\" 啟動它，prompt 內帶：",
|
||
f" persona={guest} room={room} session={args.session}",
|
||
" guest 只能讀自己的人格資料（跨人格隔離），發言請走 `persona.py room post`。",
|
||
]
|
||
emit({"room": room, "guest": guest, "host": host, "dir": str(pl.room_dir(room))}, args.json, lines)
|
||
|
||
|
||
def cmd_leave(args):
|
||
data = pl.load_session(args.session)
|
||
guest = args.guest
|
||
info = (data.get("guests") or {}).pop(guest, None)
|
||
if info is None:
|
||
die(f"`{guest}` 不在本 session 的 guest 名單。")
|
||
room = args.room or info.get("room")
|
||
pl.drop_guest_lease(guest, args.session, room)
|
||
for agent_id, slug in list((data.get("pins") or {}).items()):
|
||
if slug == guest:
|
||
data["pins"].pop(agent_id, None)
|
||
pl.save_session(args.session, data)
|
||
pl.room_post(room, "system", f"{guest} 離開聊天室。", kind="meta")
|
||
ok(f"`{guest}` 已離開聊天室 `{room}`，guest 租約已釋放。")
|
||
|
||
|
||
def cmd_room(args):
|
||
data = pl.load_session(args.session)
|
||
if args.action == "list":
|
||
lines = [f"本 session 的聊天室：{data.get('rooms') or '（無）'}"]
|
||
emit({"rooms": data.get("rooms") or []}, args.json, lines)
|
||
return
|
||
room = args.room
|
||
if not room:
|
||
die("需要 --room。")
|
||
if room not in (data.get("rooms") or []):
|
||
die(f"聊天室 `{room}` 不屬於本 session（可用：{data.get('rooms')}）。")
|
||
if args.action == "post":
|
||
speaker = args.as_ or data.get("host")
|
||
if not speaker:
|
||
die("需要 --as <persona>。")
|
||
require_member(speaker, args.session, args.as_guest)
|
||
text = args.text
|
||
if args.text_file:
|
||
text = Path(args.text_file).read_text(encoding="utf-8")
|
||
if not text:
|
||
die("需要 --text 或 --text-file。")
|
||
emotion = args.emotion or ""
|
||
if not emotion and pl.persona_exists(speaker):
|
||
top = pl.dominant(pl.decay_emotion(pl.load_emotion(speaker)), 2)
|
||
emotion = "/".join(f"{pl.EMOTIONS[k][0]}{v:.0f}" for k, v in top)
|
||
entry = pl.room_post(room, speaker, text, emotion=emotion)
|
||
ok(f"`{speaker}` 已發言於 `{room}`（情緒 {emotion}）。")
|
||
if args.json:
|
||
print(json.dumps(entry, ensure_ascii=False))
|
||
return
|
||
if args.action == "read":
|
||
rows = pl.room_read(room, args.limit)
|
||
meta = pl.read_json(pl.room_members(room), {}) or {}
|
||
lines = [f"聊天室 `{room}`｜成員 {meta.get('members')}｜主題 {meta.get('topic') or '-'}"]
|
||
for row in rows:
|
||
lines.append(f"[{row['ts']}] {row['speaker']}"
|
||
+ (f"（{row['emotion']}）" if row.get("emotion") else "")
|
||
+ f"：{row['text']}")
|
||
emit({"room": room, "meta": meta, "messages": rows}, args.json, lines)
|
||
return
|
||
die(f"未知 action：{args.action}")
|
||
|
||
|
||
def cmd_gc(args):
|
||
removed = pl.gc_runtime()
|
||
ok(f"清理完成：sessions={removed['sessions']}, 死鎖={removed['locks']}, guest 租約={removed['guests']}")
|
||
|
||
|
||
def cmd_guard(args):
|
||
"""給 hook 用：從 stdin 讀 hook event，輸出 allow/deny。也可手動測試。"""
|
||
try:
|
||
event = json.load(sys.stdin)
|
||
except json.JSONDecodeError:
|
||
die("stdin 不是合法 JSON")
|
||
decision, reason = pl.guard_decide(event)
|
||
print(json.dumps({"decision": decision, "reason": reason}, ensure_ascii=False, indent=2))
|
||
|
||
|
||
# --------------------------------------------------------------------------- #
|
||
# argparse
|
||
# --------------------------------------------------------------------------- #
|
||
|
||
def build_parser() -> argparse.ArgumentParser:
|
||
parser = argparse.ArgumentParser(prog="persona.py", description="jsc-persona 人格/記憶/情緒 CLI")
|
||
parser.add_argument("--json", action="store_true", help="以 JSON 輸出")
|
||
sub = parser.add_subparsers(dest="cmd", required=True)
|
||
|
||
def add(name, func, session_required=True, **kwargs):
|
||
p = sub.add_parser(name, **kwargs)
|
||
p.set_defaults(func=func)
|
||
p.add_argument("--json", action="store_true")
|
||
if session_required:
|
||
p.add_argument("--session", required=True, help="hook 注入的 PERSONA_SESSION")
|
||
else:
|
||
p.add_argument("--session", default="", help="（選填）")
|
||
return p
|
||
|
||
p = add("create", cmd_create, help="建立人格（OpenClaw 相同欄位）")
|
||
p.add_argument("--persona", required=True)
|
||
p.add_argument("--name"); p.add_argument("--creature"); p.add_argument("--vibe")
|
||
p.add_argument("--emoji"); p.add_argument("--avatar")
|
||
p.add_argument("--baseline", help="情緒基線，如 serenity=45,trust=35")
|
||
p.add_argument("--cwd"); p.add_argument("--force", action="store_true")
|
||
|
||
add("list", cmd_list, session_required=False, help="列出人格與鎖狀態")
|
||
|
||
p = add("load", cmd_load, help="載入人格（取得 exclusive 鎖）")
|
||
p.add_argument("--persona", required=True)
|
||
p.add_argument("--takeover", action="store_true", help="接手死鎖")
|
||
p.add_argument("--cwd")
|
||
|
||
p = add("release", cmd_release, help="釋放人格與所有 guest 租約")
|
||
p.add_argument("--persona")
|
||
|
||
p = add("status", cmd_status, session_required=False, help="查看鎖 / session 狀態")
|
||
p.add_argument("--persona")
|
||
|
||
add("heartbeat", cmd_heartbeat, help="續租鎖")
|
||
|
||
p = add("show", cmd_show, help="讀出人格檔案")
|
||
p.add_argument("--persona")
|
||
p.add_argument("--as-guest", action="store_true", help="以受邀人格身分（僅 persona-guest sub agent 可用）")
|
||
p.add_argument("--what", choices=["identity", "soul", "agents", "user", "all"], default="all")
|
||
|
||
p = add("brief", cmd_brief, help="輸出人格上下文（身分+情緒+記憶+關係）")
|
||
p.add_argument("--persona"); p.add_argument("--query", default="")
|
||
p.add_argument("--as-guest", action="store_true")
|
||
|
||
p = add("remember", cmd_remember, help="寫入短期記憶（或 guest 的 inbox）")
|
||
p.add_argument("--persona")
|
||
p.add_argument("--as-guest", action="store_true")
|
||
p.add_argument("--role", default="user", choices=["user", "persona", "guest", "system", "observation"])
|
||
p.add_argument("--text", required=True)
|
||
p.add_argument("--topics"); p.add_argument("--entities"); p.add_argument("--intent")
|
||
p.add_argument("--salience", type=int, default=40)
|
||
p.add_argument("--emotion", help="情緒變化，如 joy=+12,anxiety=-4")
|
||
p.add_argument("--scope", choices=["short", "inbox"], default="short")
|
||
p.add_argument("--room")
|
||
|
||
p = add("recall", cmd_recall, help="檢索長期 + 短期記憶")
|
||
p.add_argument("--persona"); p.add_argument("--query", required=True)
|
||
p.add_argument("--as-guest", action="store_true")
|
||
p.add_argument("--limit", type=int, default=5)
|
||
|
||
p = add("consolidate", cmd_consolidate, help="短期→長期記憶固化（一則一檔）")
|
||
p.add_argument("--persona"); p.add_argument("--name", required=True)
|
||
p.add_argument("--type", default="fact",
|
||
choices=["fact", "preference", "event", "promise", "relationship", "insight", "boundary"])
|
||
p.add_argument("--about"); p.add_argument("--topics")
|
||
p.add_argument("--salience", type=int, default=60)
|
||
p.add_argument("--emotion"); p.add_argument("--source")
|
||
p.add_argument("--body", default=""); p.add_argument("--body-file")
|
||
p.add_argument("--forget", type=int, help="固化後淘汰顯著度低於此值的短期記憶")
|
||
|
||
p = add("prune", cmd_prune, help="裁剪短期記憶")
|
||
p.add_argument("--persona")
|
||
|
||
p = add("reindex", cmd_reindex, help="重建長期記憶索引")
|
||
p.add_argument("--persona")
|
||
|
||
p = add("emotion", cmd_emotion, help="查看/調整十二情緒")
|
||
p.add_argument("--persona")
|
||
p.add_argument("--as-guest", action="store_true")
|
||
p.add_argument("--apply", help="如 joy=+15,anger=-5")
|
||
p.add_argument("--baseline"); p.add_argument("--trigger")
|
||
|
||
p = add("mindmap", cmd_mindmap, help="心智圖 / 思維導圖")
|
||
p.add_argument("action", choices=["show", "thread", "list"])
|
||
p.add_argument("--persona"); p.add_argument("--topic"); p.add_argument("--force", action="store_true")
|
||
|
||
p = add("relation", cmd_relation, help="人際關係圖")
|
||
p.add_argument("action", choices=["node", "edge", "render", "show"])
|
||
p.add_argument("--persona")
|
||
p.add_argument("--id"); p.add_argument("--name")
|
||
p.add_argument("--kind", default="human", choices=["human", "persona", "group", "pet", "org"])
|
||
p.add_argument("--closeness", type=float); p.add_argument("--trust", type=float)
|
||
p.add_argument("--note"); p.add_argument("--tags")
|
||
p.add_argument("--from", dest="from_"); p.add_argument("--to")
|
||
p.add_argument("--label"); p.add_argument("--affinity", type=float)
|
||
|
||
p = add("invite", cmd_invite, help="邀請另一個人格以 sub agent 加入聊天室")
|
||
p.add_argument("--guest", required=True); p.add_argument("--host")
|
||
p.add_argument("--room"); p.add_argument("--topic")
|
||
|
||
p = add("leave", cmd_leave, help="讓 guest 人格離開")
|
||
p.add_argument("--guest", required=True); p.add_argument("--room")
|
||
|
||
p = add("room", cmd_room, help="聊天室發言 / 讀取")
|
||
p.add_argument("action", choices=["post", "read", "list"])
|
||
p.add_argument("--as-guest", action="store_true")
|
||
p.add_argument("--room"); p.add_argument("--as", dest="as_")
|
||
p.add_argument("--text"); p.add_argument("--text-file")
|
||
p.add_argument("--emotion"); p.add_argument("--limit", type=int, default=30)
|
||
|
||
add("gc", cmd_gc, session_required=False, help="清理死鎖與過期租約")
|
||
add("guard", cmd_guard, session_required=False, help="（內部）測試 guard 判斷")
|
||
return parser
|
||
|
||
|
||
def main(argv=None):
|
||
args = build_parser().parse_args(argv)
|
||
try:
|
||
args.func(args)
|
||
except pl.LockError as exc:
|
||
die(str(exc))
|
||
except BrokenPipeError:
|
||
pass
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|