refactor(proc): coreHandler.Handle 550 行按 method 组拆成 14 个分部函数

原 Handle 是一个 550 行的巨型 switch(C ABI 51 个 case 的整块平移),
按协议面拆进同包 5 个新文件、14 个小函数:

  corehandler_register.go  handleRegister        注册面(tool/stage/output/api/input)
  corehandler_inject.go    handleInject          IO 注入 + SetToolBlocks
  corehandler_memory.go    handleGraphMemory     图记忆
                           handleDocMemory       文档记忆
                           handleKnowledge       知识库
                           handleTextMemory      文本记忆
  corehandler_settings.go  handleSettings        设置(14 个 method 共用一条实现)
                           handleLLM             LLM 源
                           handleSocial          社交图只读
                           handleLifecycle       生命周期开关
  corehandler_runtime.go   handlePluginMgr       插件管理
                           handleStageLocks      段锁仲裁
                           handleEvents          事件订阅
                           handleArena           共享槽池

Handle 保留 capability 强制检查,只做「method → 分部函数」一跳。

零漂移保证:case 标签由脚本从原文提取(不手抄常量名),case 体逐字搬迁,
逐函数比对确认 59 个标签 / 510 行 case 体与原文件完全一致(仅行首缩进经 gofmt 重排)。

验证:go build ./... / go vet / go test ./internal/plugin/... / -race 全绿。
This commit is contained in:
HomeAgent Agent
2026-09-13 23:29:13 +08:00
parent dcae21b24c
commit 129a3aeb38
6 changed files with 798 additions and 520 deletions

View File

@ -0,0 +1,306 @@
package proc
import (
"encoding/json"
"fmt"
pubsdk "gitcode.com/JianFeeeee/homeagent-sdk/sdk"
)
// handleGraphMemory 处理图记忆(实体/关系):recall / commit / introspect / merge / purge。
//
// 本函数体是 corehandler.go 里 Handle 那一个大 switch 的**整块平移**:
// case 标签与 case 体逐字保留,只换了宿主函数(§3.2 的平移原则)。
func (h *coreHandler) handleGraphMemory(method string, params json.RawMessage) (interface{}, error) {
switch method {
// ---- 图记忆(原 case 9/10/11/12/13)----
case MethodMemoryRecall:
mem := h.sdk.Memory()
if mem == nil {
return nil, errUnavailable("memory")
}
var p struct {
Query []string `json:"query"`
Depth int `json:"depth"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
entities, relations, err := mem.Recall(p.Query, p.Depth)
if err != nil {
return nil, err
}
if entities == nil {
entities = []pubsdk.Entity{}
}
if relations == nil {
relations = []pubsdk.Relation{}
}
return map[string]interface{}{"entities": entities, "relations": relations}, nil
case MethodMemoryCommit:
mem := h.sdk.Memory()
if mem == nil {
return nil, errUnavailable("memory")
}
var p struct {
Triples []pubsdk.Triple `json:"triples"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
return nil, mem.Commit(p.Triples)
case MethodMemoryIntrospect:
mem := h.sdk.Memory()
if mem == nil {
return nil, errUnavailable("memory")
}
return mem.Introspect()
case MethodMemoryMerge:
mem := h.sdk.Memory()
if mem == nil {
return nil, errUnavailable("memory")
}
var p struct {
Source string `json:"source"`
Target string `json:"target"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
n, err := mem.MergeEntities(p.Source, p.Target)
if err != nil {
return nil, err
}
return map[string]interface{}{"merged": n}, nil
case MethodMemoryPurge:
mem := h.sdk.Memory()
if mem == nil {
return nil, errUnavailable("memory")
}
var p struct {
Criteria map[string]string `json:"criteria"`
Mode string `json:"mode"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
if p.Mode == "" {
p.Mode = "soft"
}
n, err := mem.Purge(p.Criteria, p.Mode)
if err != nil {
return nil, err
}
return map[string]interface{}{"purged": n}, nil
}
// 组内不应到达:Handle 的分派表与本函数的 case 标签同源,
// 出现即说明两处不同步。
return nil, fmt.Errorf("未知 method: %s", method)
}
// handleDocMemory 处理文档记忆:query / insert / insertWithMedia / remove / stats。
//
// 本函数体是 corehandler.go 里 Handle 那一个大 switch 的**整块平移**:
// case 标签与 case 体逐字保留,只换了宿主函数(§3.2 的平移原则)。
func (h *coreHandler) handleDocMemory(method string, params json.RawMessage) (interface{}, error) {
switch method {
// ---- 文档记忆(原 case 14/32/33/34)----
case MethodDocQuery:
dm := h.sdk.DocMemory()
if dm == nil {
return nil, errUnavailable("doc memory")
}
var p struct {
Text string `json:"text"`
TopK int `json:"top_k"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
docs := dm.Query(p.Text, p.TopK)
if docs == nil {
docs = []*pubsdk.Doc{}
}
return map[string]interface{}{"docs": docs}, nil
case MethodDocInsert:
dm := h.sdk.DocMemory()
if dm == nil {
return nil, errUnavailable("doc memory")
}
var p struct {
Doc *pubsdk.Doc `json:"doc,omitempty"`
DocRef SharedRef `json:"doc_ref,omitempty"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
// 文档全文可达几十 KB~数 MB,优先走共享内存。
if err := h.resolveJSONRef(p.DocRef, &p.Doc); err != nil {
return nil, err
}
if p.Doc == nil {
return nil, fmt.Errorf("doc.insert: 缺少 doc 字段")
}
return nil, dm.Insert(p.Doc)
case MethodDocInsertMedia:
dm := h.sdk.DocMemory()
if dm == nil {
return nil, errUnavailable("doc memory")
}
var p struct {
Doc *pubsdk.Doc `json:"doc,omitempty"`
Attachments []pubsdk.MediaAttachment `json:"attachments,omitempty"`
DocRef SharedRef `json:"doc_ref,omitempty"`
AttachRef SharedRef `json:"attachments_ref,omitempty"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
// 文档正文 + 附件(含媒体二进制/data URL)都优先走共享内存。
if err := h.resolveJSONRef(p.DocRef, &p.Doc); err != nil {
return nil, err
}
if err := h.resolveJSONRef(p.AttachRef, &p.Attachments); err != nil {
return nil, err
}
if p.Doc == nil {
return nil, fmt.Errorf("doc.insertWithMedia: 缺少 doc 字段")
}
if err := dm.InsertWithMedia(p.Doc, p.Attachments); err != nil {
return nil, err
}
// 回传内核补过的字段:ID 新建时才生成,Content 含内核补的媒体标记,
// MediaDigests 是附件落盘后的完整 digest——插件靠它们后续引用同一份媒体。
return map[string]interface{}{"doc": p.Doc}, nil
case MethodDocRemove:
dm := h.sdk.DocMemory()
if dm == nil {
return nil, errUnavailable("doc memory")
}
var p struct {
ID string `json:"id"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
dm.Remove(p.ID)
return nil, nil
case MethodDocStats:
dm := h.sdk.DocMemory()
if dm == nil {
return nil, errUnavailable("doc memory")
}
return dm.Stats(), nil
}
// 组内不应到达:Handle 的分派表与本函数的 case 标签同源,
// 出现即说明两处不同步。
return nil, fmt.Errorf("未知 method: %s", method)
}
// handleKnowledge 处理知识库:search / add / list。
//
// 本函数体是 corehandler.go 里 Handle 那一个大 switch 的**整块平移**:
// case 标签与 case 体逐字保留,只换了宿主函数(§3.2 的平移原则)。
func (h *coreHandler) handleKnowledge(method string, params json.RawMessage) (interface{}, error) {
switch method {
// ---- 知识库(原 case 15/35/36)----
case MethodKnowledgeSearch:
kn := h.sdk.Knowledge()
if kn == nil {
return nil, errUnavailable("knowledge")
}
var p struct {
Query string `json:"query"`
TopK int `json:"top_k"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
results, err := kn.Search(p.Query, p.TopK)
if err != nil {
return nil, err
}
if results == nil {
results = []*pubsdk.Knowledge{}
}
return map[string]interface{}{"results": results}, nil
case MethodKnowledgeAdd:
kn := h.sdk.Knowledge()
if kn == nil {
return nil, errUnavailable("knowledge")
}
var p struct {
Name string `json:"name"`
Content string `json:"content,omitempty"`
ContentRef SharedRef `json:"content_ref,omitempty"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
// 知识正文可达数十 KB,优先走共享内存。内容是 JSON 字符串,
// 所以从 ref 读出后需再解一层。
if err := h.resolveJSONRef(p.ContentRef, &p.Content); err != nil {
return nil, err
}
return nil, kn.Add(p.Name, p.Content)
case MethodKnowledgeList:
kn := h.sdk.Knowledge()
if kn == nil {
return nil, errUnavailable("knowledge")
}
names, err := kn.List()
if err != nil {
return nil, err
}
if names == nil {
names = []string{}
}
return map[string]interface{}{"names": names}, nil
}
// 组内不应到达:Handle 的分派表与本函数的 case 标签同源,
// 出现即说明两处不同步。
return nil, fmt.Errorf("未知 method: %s", method)
}
// handleTextMemory 处理文本记忆追加。
//
// 本函数体是 corehandler.go 里 Handle 那一个大 switch 的**整块平移**:
// case 标签与 case 体逐字保留,只换了宿主函数(§3.2 的平移原则)。
func (h *coreHandler) handleTextMemory(method string, params json.RawMessage) (interface{}, error) {
switch method {
// ---- 文本记忆(原 case 41)----
case MethodTextMemoryAppend:
tm := h.sdk.TextMemory()
if tm == nil {
return nil, errUnavailable("text memory")
}
var p struct {
Event pubsdk.TextEvent `json:"event"`
}
if err := unmarshal(params, &p); err != nil {
return nil, err
}
return nil, tm.Append(p.Event)
}
// 组内不应到达:Handle 的分派表与本函数的 case 标签同源,
// 出现即说明两处不同步。
return nil, fmt.Errorf("未知 method: %s", method)
}