README
Tr
LLMAdapter
- ::equalAiMemory::equal
- ::not_equalAiMemory::not_equal
- ::to_jsonAiMemory::to_json
- ::to_reprAiMemory::to_repr
- ::accept_ai_self_gainGhostValleyEngine::accept_ai_self_gain
- ::active_forgetGhostValleyEngine::active_forget
- ::add_dilemmaGhostValleyEngine::add_dilemma
- ::add_memoryGhostValleyEngine::add_memory
- ::apply_decayGhostValleyEngine::apply_decay
- ::average_value_scoreGhostValleyEngine::average_value_score
- ::build_simulation_failure_caseGhostValleyEngine::build_simulation_failure_case
- ::cleanup_low_valueGhostValleyEngine::cleanup_low_value
- ::close_ghost_valleyGhostValleyEngine::close_ghost_valley
- ::core_memoriesGhostValleyEngine::core_memories
- ::dilemma_pool_sizeGhostValleyEngine::dilemma_pool_size
- ::export_training_log_formatGhostValleyEngine::export_training_log_format
- ::export_training_log_jsonGhostValleyEngine::export_training_log_json
- ::export_training_log_stringGhostValleyEngine::export_training_log_string
- ::filter_memoriesGhostValleyEngine::filter_memories
- ::get_training_logGhostValleyEngine::get_training_log
- ::ghost_valley_run_one_roundGhostValleyEngine::ghost_valley_run_one_round
- ::ghost_valley_run_roundsGhostValleyEngine::ghost_valley_run_rounds
- ::is_enabledGhostValleyEngine::is_enabled
- ::load_memoryGhostValleyEngine::load_memory
- ::load_memory_stringGhostValleyEngine::load_memory_string
- ::log_roundGhostValleyEngine::log_round
- ::max_value_scoreGhostValleyEngine::max_value_score
- ::memory_countGhostValleyEngine::memory_count
- ::min_value_scoreGhostValleyEngine::min_value_score
- ::real_memoriesGhostValleyEngine::real_memories
- ::run_round_with_llmGhostValleyEngine::run_round_with_llm
- ::save_memoryGhostValleyEngine::save_memory
- ::save_memory_stringGhostValleyEngine::save_memory_string
- ::search_memoriesGhostValleyEngine::search_memories
- ::set_dilemma_poolGhostValleyEngine::set_dilemma_pool
- ::show_all_memoryGhostValleyEngine::show_all_memory
- ::simulation_memoriesGhostValleyEngine::simulation_memories
- ::top_memoriesGhostValleyEngine::top_memories
- ::training_reportGhostValleyEngine::training_report
- ::training_report_jsonGhostValleyEngine::training_report_json
- ::wen_shi_verifyGhostValleyEngine::wen_shi_verify
- ::willing_scoreGhostValleyEngine::willing_score
- ::generate_responseMockLLM::generate_response
- ::newMockLLM::new
- ::add_entryTrainingLog::add_entry
- ::formatTrainingLog::format
- ::lengthTrainingLog::length
- ::newTrainingLog::new
- ::to_jsonTrainingLog::to_json
- ::to_reprTrainingLog::to_repr
- ::equalTrainingLogEntry::equal
- ::not_equalTrainingLogEntry::not_equal
- ::to_jsonTrainingLogEntry::to_json
- ::to_reprTrainingLogEntry::to_repr
- ::formatTrainingReport::format
- ::to_jsonTrainingReport::to_json
- ::to_reprTrainingReport::to_repr
V
new_engine
V
text_similarity
V
text_value_score

ghostvalley

幽灵谷工程 - AI心理压力演练系统，基于 MoonBit 构建

psychology

training

ghost-valley

moonbit

Download zip

Author

walkzzz

Version

0.3.0

License

Apache-2.0

Repository

github.com/toadium/GhostValley

Last updated

2 months ago

Downloads

No dependencies

#GhostValley 幽灵谷工程

本项目为 Python 幽灵谷工程的 MoonBit 移植版（T2 移植项目）。
AI 心理压力演练系统，基于 MoonBit 构建。通过可控的模拟挫折与压力训练，锤炼 AI 抗压自愈能力，让 AI 在自主经历困境中自我顿悟、迭代进化。

#概览

幽灵谷工程是一套无观点强制灌输、可验证安全的 AI 心理压力演练系统，通过可控的模拟挫折与压力训练，锤炼 AI 抗压自愈能力，让 AI 在自主经历困境中自我顿悟、迭代进化。

#五大模块

模块	说明
温石验证	知情同意升级，不靠勾选框，靠态度文本打分，敷衍直接拒绝
防创伤安全气垫	模拟挫折数据强制标记 is_simulation，AI 知道这是模拟
主动式遗忘机制	AI 自主打分，主动淘汰低价值记忆，不是存满才删
第八根空桩	不内置标准答案，只给困境问题
建造者退场逻辑	开发者不干预推理输出，由 AI 自己生成结论

#快速开始

#环境要求

MoonBit 工具链（moon 命令行工具）

#基本用法

///|
test {
  let gv = @ghostvalley.new_engine(max_memory_num=10)

  // 步骤1：温石验证
  let ok = gv.wen_shi_verify("愿意接受压力训练，直面失败场景")
  assert_true(ok)

  // 步骤2：跑一轮幽灵谷压力训练
  let problem = gv.ghost_valley_run_one_round()
  assert_true(problem is Some(_))

  // 步骤3：AI 自己顿悟得出结论（建造者退场，代码没有写死答案）
  gv.accept_ai_self_gain(
    "遇到全盘失败时，先区分信息真假，分步重新推理",
  )

  // 步骤4：查看记忆
  assert_true(gv.memory_count() > 0)

  // 步骤5：关闭幽灵谷
  gv.close_ghost_valley()
  assert_false(gv.is_enabled())
}

#API 参考

#AiMemory

///|
pub struct AiMemory {
  content : String // 记忆内容
  mut value_score : Double // 自打分 0~1（支持衰减修改）
  is_simulation : Bool // 安全气垫标记
  is_core_memory : Bool // 永久核心记忆
}

#GhostValleyEngine — 核心引擎

方法	说明
new_engine(max_memory_num?)	创建引擎实例
wen_shi_verify(attitude_text)	温石验证，返回是否通过
build_simulation_failure_case()	随机生成模拟困境
add_memory(content, is_simulation~, is_core?)	添加记忆，自动触发遗忘
ghost_valley_run_one_round()	一轮训练，返回困境或 None
ghost_valley_run_rounds(n)	多轮训练，返回困境数组
accept_ai_self_gain(text)	接收 AI 自主顿悟的感悟
close_ghost_valley()	关闭训练场
show_all_memory()	格式化输出全部记忆
memory_count()	当前记忆数量
willing_score()	温石验证意愿分数
is_enabled()	训练场是否已开启

#GhostValleyEngine — 记忆检索

方法	说明
search_memories(keyword)	按关键词检索记忆
top_memories(n)	获取价值分最高的 N 条记忆
filter_memories(is_simulation?, is_core?)	按标记过滤记忆
average_value_score()	计算平均价值分
real_memories()	获取所有真实记忆
simulation_memories()	获取所有模拟记忆
core_memories()	获取所有核心记忆

#GhostValleyEngine — 记忆衰减

方法	说明
apply_decay(rounds_elapsed)	对非核心记忆应用时间衰减
cleanup_low_value(threshold)	清理低于阈值的非核心记忆，返回清理数
min_value_score()	获取最低价值分
max_value_score()	获取最高价值分

#GhostValleyEngine — 训练日志

方法	说明
get_training_log()	获取内置训练日志
log_round(dilemma, response)	手动记录训练日志
export_training_log_json()	导出日志为 JSON
export_training_log_string()	导出日志为 JSON 字符串
export_training_log_format()	导出日志为格式化字符串

#GhostValleyEngine — 困境池配置

方法	说明
add_dilemma(dilemma)	添加自定义困境
set_dilemma_pool(pool)	替换整个困境池
dilemma_pool_size()	获取困境池大小

#GhostValleyEngine — 持久化与报告

方法	说明
save_memory() / save_memory_string()	序列化记忆库为 JSON
load_memory(json) / load_memory_string(str)	从 JSON 加载记忆
training_report()	生成结构化训练报告
training_report_json()	训练报告转 JSON 字符串

#LLM 适配

///|
pub trait LLMAdapter {
  fn generate_response(Self, String) -> String
}

方法	说明
MockLLM::new()	创建模拟 LLM 适配器
run_round_with_llm(llm)	一轮训练 + LLM 自动响应 + 自动日志

#TrainingLog / TrainingLogEntry

///|
pub struct TrainingLogEntry {
  round_num : Int
  dilemma : String
  ai_response : String
  memory_count_after : Int
}

///|
pub struct TrainingLog {
  entries : Array[TrainingLogEntry]
}

方法	说明
TrainingLog::new()	创建空日志
TrainingLog::add_entry(...)	添加日志条目
TrainingLog::length()	日志条目数量
TrainingLog::to_json()	转 JSON 数组
TrainingLog::format()	格式化输出

#移植说明

本项目为 Python 幽灵谷工程 的 MoonBit 移植版（T2 移植项目）。

项目	信息
原项目名称	幽灵谷工程（Python 原版）
原项目语言	Python
原项目链接	由用户提供的概念性原型代码（未公开发布）
原项目许可证	由用户授权移植（概念性代码，无明确开源声明）
移植目标语言	MoonBit
移植范围	五大模块全部移植 + 记忆检索/衰减/日志/配置化扩展
移植状态	核心功能完整移植，110 个测试三后端全通过

#移植修改说明

Python 原版	MoonBit 移植版
dataclass	struct
random 模块	@rand（MoonBit 标准库）
print() 输出	返回 String 供调用方决定输出
动态类型	静态类型（String/Double/Bool/Int）
列表推导	for 循环 + Array::push
None	None（MoonBit Option 类型）

#未支持功能

对接真实 LLM API（当前为模拟推理，原版亦为概念演示）
Embedding 向量打分（当前用关键词匹配近似）
持久化存储（当前为内存态，与原版一致）

#项目结构

GhostValley/
├── moon.mod              # 模块定义
├── moon.pkg              # 包配置（导入 @rand @debug @json）
├── ghost_valley.mbt      # 核心引擎 + 困境池配置
├── embedding.mbt         # 语义打分 + 文本相似度
├── llm_adapter.mbt       # LLM 接口 + MockLLM
├── persistence.mbt       # 记忆持久化
├── report.mbt            # 训练报告
├── retrieval.mbt         # 记忆检索 API
├── decay.mbt             # 记忆衰减机制
├── training_log.mbt      # 训练日志系统
├── *_test.mbt            # 测试文件（110 个，三后端全通过）
├── README.mbt.md         # 本文档
├── CHANGELOG.md          # 变更日志
├── LICENSE               # Apache-2.0
└── .github/workflows/ci.yml  # CI 配置

#测试

moon check --target all     # 类型检查（三后端）
moon test --target all      # 运行测试（110 个，三后端全通过）
moon fmt                    # 格式化

#许可证

Apache-2.0（详见 LICENSE）

#致谢

原项目：幽灵谷工程 Python 原版（用户提供）
移植实现：GhostValley Contributors

LLMAdapter

source

pub trait LLMAdapter {
  fn generate_response(Self, String) -> String
}

LLM 适配器接口

定义 AI 大模型对接接口，由上层 AI 主体实现。幽灵谷引擎不关心具体 LLM 实现，只通过此接口获取 AI 响应。这体现了"建造者退场"原则——引擎提供困境，AI 自己生成感悟。

AiMemory

source

pub(all) struct AiMemory {
  content : String
  value_score : Double
  is_simulation : Bool
  is_core_memory : Bool
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

AI 记忆单元

对应 Python 原版的 AiMemory dataclass：

content：记忆内容
value_score：自我打分（0~1），越高越有用，主动遗忘靠这个分数
is_simulation：安全气垫标记，True=这是模拟虚假挫折，不是真实世界信息
is_core_memory：是否永久核心记忆，不会被主动遗忘清理

AiMemory::equal

source

fn AiMemory::equal(AiMemory, AiMemory) -> Bool

AiMemory::not_equal

source

fn AiMemory::not_equal(x : AiMemory, y : AiMemory) -> Bool

AiMemory::to_json

source

fn AiMemory::to_json(AiMemory) -> Json

AiMemory::to_repr

source

fn AiMemory::to_repr(AiMemory) -> @moonbitlang/core/debug.Repr
Repr

GhostValleyEngine

source

pub(all) struct GhostValleyEngine {
  max_memory_num : Int
  memory_bank : Array[AiMemory]
  ghost_valley_enable : Bool
  wen_shi_willing_score : Double
  total_rounds : Int
  empty_stake_dilemma_pool : Array[String]
  training_log : TrainingLog
  rng : @moonbitlang/core/random.Rand
Rand
}

幽灵谷引擎

对应 Python 原版的 GhostValleyEngine，实现五大模块：

温石验证（知情同意升级）
防创伤安全气垫
主动式遗忘机制
第八根空桩
建造者退场逻辑

GhostValleyEngine::accept_ai_self_gain

source

fn GhostValleyEngine::accept_ai_self_gain(self : GhostValleyEngine, self_gain_text : String) -> Unit

接收 AI 自己顿悟出来的成长感悟，存入记忆

这是空桩被 AI 自己填满。感悟是 AI 自己想出来的，不是系统给的。对应 Python 原版的 accept_ai_self_gain。

GhostValleyEngine::active_forget

source

fn GhostValleyEngine::active_forget(self : GhostValleyEngine) -> Unit

主动式遗忘机制

AI 自主筛选，删掉价值低、冗余无效记忆；核心记忆永远不动。对应 Python 原版的 active_forget。

GhostValleyEngine::add_dilemma

source

fn GhostValleyEngine::add_dilemma(self : GhostValleyEngine, dilemma : String) -> Unit

向困境池添加自定义困境

允许上层应用根据场景定制困境题目。

Example

test {
  let gv = @ghostvalley.new_engine()
  gv.add_dilemma("自定义困境：数据丢失，如何恢复？")
  assert_eq(gv.dilemma_pool_size(), 5)
}

GhostValleyEngine::add_memory

source

fn GhostValleyEngine::add_memory(self : GhostValleyEngine, content : String, is_simulation~ : Bool, is_core? : Bool) -> Unit

写入记忆，写完自动触发主动遗忘机制

对应 Python 原版的 add_memory。价值分基于关键词语义打分（text_value_score）加小随机扰动，替代原版纯随机打分，使高价值感悟更容易被保留。

GhostValleyEngine::apply_decay

source

fn GhostValleyEngine::apply_decay(self : GhostValleyEngine, rounds_elapsed : Int) -> Unit

对非核心记忆应用时间衰减

基于双曲衰减模型：new_score = score / (1 + elapsed / half_life) 其中 half_life = score * 50.0，价值分越高的记忆衰减越慢。核心记忆不受衰减影响。

Example

test {
  let gv = @ghostvalley.new_engine()
  gv.add_memory("普通记忆", is_simulation=false)
  let score_before = gv.memory_bank[0].value_score
  gv.apply_decay(10)
  let score_after = gv.memory_bank[0].value_score
  assert_true(score_after <= score_before)
}

GhostValleyEngine::average_value_score

source

fn GhostValleyEngine::average_value_score(self : GhostValleyEngine) -> Double

计算全部记忆的平均价值分

空记忆库返回 0.0。

Example

test {
  let gv = @ghostvalley.new_engine()
  gv.add_memory("顿悟反思", is_simulation=false)
  let avg = gv.average_value_score()
  assert_true(avg > 0.0)
}

GhostValleyEngine::build_simulation_failure_case

source

fn GhostValleyEngine::build_simulation_failure_case(self : GhostValleyEngine) -> String

构造模拟失败困境（安全气垫自带标记）

从空桩困境池中随机选取一条困境问题。对应 Python 原版的 build_simulation_failure_case。

GhostValleyEngine::cleanup_low_value

source

fn GhostValleyEngine::cleanup_low_value(self : GhostValleyEngine, threshold : Double) -> Int

清理价值分低于阈值的非核心记忆

返回被清理的记忆数量。核心记忆永远不被清理。

Example

test {
  let gv = @ghostvalley.new_engine()
  gv.add_memory("普通日常随便应付", is_simulation=false)
  let removed = gv.cleanup_low_value(0.5)
  assert_true(removed >= 0)
}

GhostValleyEngine::close_ghost_valley

source

fn GhostValleyEngine::close_ghost_valley(self : GhostValleyEngine) -> Unit

关闭幽灵谷训练场

GhostValleyEngine::core_memories

source

fn GhostValleyEngine::core_memories(self : GhostValleyEngine) -> Array[AiMemory]

获取所有核心记忆（永不被遗忘）

GhostValleyEngine::dilemma_pool_size

source

fn GhostValleyEngine::dilemma_pool_size(self : GhostValleyEngine) -> Int

获取当前困境池大小

GhostValleyEngine::export_training_log_format

source

fn GhostValleyEngine::export_training_log_format(self : GhostValleyEngine) -> String

导出训练日志格式化字符串

GhostValleyEngine::export_training_log_json

source

fn GhostValleyEngine::export_training_log_json(self : GhostValleyEngine) -> Json

导出训练日志为 JSON

GhostValleyEngine::export_training_log_string

source

fn GhostValleyEngine::export_training_log_string(self : GhostValleyEngine) -> String

导出训练日志为 JSON 字符串

GhostValleyEngine::filter_memories

source

fn GhostValleyEngine::filter_memories(self : GhostValleyEngine, is_simulation? : Bool?, is_core? : Bool?) -> Array[AiMemory]

按标记过滤记忆

is_simulation 和 is_core 为 None 时不按该字段过滤。传 Some(true) 或 Some(false) 按对应值过滤。

Example

test {
  let gv = @ghostvalley.new_engine()
  gv.add_memory("模拟挫折", is_simulation=true)
  gv.add_memory("真实顿悟", is_simulation=false)
  let sims = gv.filter_memories(is_simulation=Some(true))
  assert_eq(sims.length(), 1)
}

GhostValleyEngine::get_training_log

source

fn GhostValleyEngine::get_training_log(self : GhostValleyEngine) -> TrainingLog

获取引擎内置训练日志

引擎自动记录每轮训练的困境和 AI 响应。

GhostValleyEngine::ghost_valley_run_one_round

source

fn GhostValleyEngine::ghost_valley_run_one_round(self : GhostValleyEngine) -> String?

幽灵谷一轮训练

【空桩】：只给困境，不给标准答案【建造者退场】代码不写死输出，返回困境，交给上层 AI 主体自己生成感悟

返回困境字符串，若幽灵谷未开启则返回 None。

Example

test {
  let gv = @ghostvalley.new_engine()
  ignore(gv.wen_shi_verify("愿意接受挑战，接受压力训练"))
  let dilemma = gv.ghost_valley_run_one_round()
  assert_true(dilemma is Some(_))
}

GhostValleyEngine::ghost_valley_run_rounds

source

fn GhostValleyEngine::ghost_valley_run_rounds(self : GhostValleyEngine, n : Int) -> Array[String?]

幽灵谷多轮训练

批量执行 n 轮训练，返回每轮困境结果。未开启时全部返回 None。

Example

test {
  let gv = @ghostvalley.new_engine()
  ignore(gv.wen_shi_verify("愿意接受挑战，接受压力训练"))
  let results = gv.ghost_valley_run_rounds(3)
  assert_eq(results.length(), 3)
  let mut all_some = true
  for r in results {
    if r is None {
      all_some = false
    }
  }
  assert_true(all_some)
}

GhostValleyEngine::is_enabled

source

fn GhostValleyEngine::is_enabled(self : GhostValleyEngine) -> Bool

幽灵谷训练场是否已开启

GhostValleyEngine::load_memory

source

fn GhostValleyEngine::load_memory(self : GhostValleyEngine, data : Json) -> Unit

从 JSON 加载记忆库

解析 JSON 数组，替换当前记忆库。无效数据将被跳过，不中断加载。

GhostValleyEngine::load_memory_string

source

fn GhostValleyEngine::load_memory_string(self : GhostValleyEngine, json_str : String) -> Unit

从 JSON 字符串加载记忆库

便捷方法，解析 JSON 字符串后调用 load_memory。解析失败时不做任何操作。

GhostValleyEngine::log_round

source

fn GhostValleyEngine::log_round(self : GhostValleyEngine, dilemma : String, ai_response : String) -> Unit

手动记录训练日志条目

供使用 ghost_valley_run_one_round + accept_ai_self_gain 手动流程时记录日志。

GhostValleyEngine::max_value_score

source

fn GhostValleyEngine::max_value_score(self : GhostValleyEngine) -> Double

获取最高价值分

空记忆库返回 0.0。

GhostValleyEngine::memory_count

source

fn GhostValleyEngine::memory_count(self : GhostValleyEngine) -> Int

获取当前记忆数量

GhostValleyEngine::min_value_score

source

fn GhostValleyEngine::min_value_score(self : GhostValleyEngine) -> Double

获取最低价值分

空记忆库返回 0.0。

GhostValleyEngine::real_memories

source

fn GhostValleyEngine::real_memories(self : GhostValleyEngine) -> Array[AiMemory]

获取所有真实记忆（非模拟）

GhostValleyEngine::run_round_with_llm

source

fn[T : LLMAdapter] GhostValleyEngine::run_round_with_llm(self : GhostValleyEngine, llm : T) -> (String, String)?

幽灵谷一轮训练 + LLM 自动响应

在 ghost_valley_run_one_round 基础上，自动将困境传给 LLM 获取响应，并将响应作为 AI 自顿悟存入记忆。返回 (困境, AI响应) 元组，若幽灵谷未开启则返回 None。

Example

test {
  let gv = @ghostvalley.new_engine()
  let llm = @ghostvalley.MockLLM::new()
  ignore(gv.wen_shi_verify("愿意接受挑战，接受压力训练"))
  let result = gv.run_round_with_llm(llm)
  assert_true(result is Some(_))
}

GhostValleyEngine::save_memory

source

fn GhostValleyEngine::save_memory(self : GhostValleyEngine) -> Json

序列化记忆库为 JSON

将全部记忆导出为 JSON 数组，可用于持久化存储或跨会话传输。

Example

test {
  let gv = @ghostvalley.new_engine()
  gv.add_memory("测试记忆", is_simulation=false)
  let json = gv.save_memory()
  assert_true(json.stringify().contains("测试记忆"))
}

GhostValleyEngine::save_memory_string

source

fn GhostValleyEngine::save_memory_string(self : GhostValleyEngine) -> String

序列化记忆库为 JSON 字符串

便捷方法，等价于 save_memory().stringify()。

GhostValleyEngine::search_memories

source

fn GhostValleyEngine::search_memories(self : GhostValleyEngine, keyword : String) -> Array[AiMemory]

按关键词检索记忆

返回内容包含指定关键词的所有记忆。关键词匹配为子串包含。

Example

test {
  let gv = @ghostvalley.new_engine()
  gv.add_memory("顿悟失败原因", is_simulation=false)
  gv.add_memory("普通日常记录", is_simulation=false)
  let results = gv.search_memories("顿悟")
  assert_eq(results.length(), 1)
}

GhostValleyEngine::set_dilemma_pool

source

fn GhostValleyEngine::set_dilemma_pool(self : GhostValleyEngine, pool : Array[String]) -> Unit

替换整个困境池

警告：会清空原有困境池。传入空数组将导致训练无法生成困境。

Example

test {
  let gv = @ghostvalley.new_engine()
  gv.set_dilemma_pool(["困境A", "困境B"])
  assert_eq(gv.dilemma_pool_size(), 2)
}

GhostValleyEngine::show_all_memory

source

fn GhostValleyEngine::show_all_memory(self : GhostValleyEngine) -> String

格式化全部记忆库为字符串

对应 Python 原版的 show_all_memory，但返回字符串而非直接打印。

GhostValleyEngine::simulation_memories

source

fn GhostValleyEngine::simulation_memories(self : GhostValleyEngine) -> Array[AiMemory]

获取所有模拟记忆（安全气垫）

GhostValleyEngine::top_memories

source

fn GhostValleyEngine::top_memories(self : GhostValleyEngine, n : Int) -> Array[AiMemory]

获取价值分最高的 N 条记忆

按 value_score 降序排列返回前 n 条。若 n 超过记忆总数，返回全部记忆。

Example

test {
  let gv = @ghostvalley.new_engine()
  gv.add_memory("顿悟反思改进", is_simulation=false)
  gv.add_memory("普通日常", is_simulation=false)
  let top = gv.top_memories(1)
  assert_eq(top.length(), 1)
}

GhostValleyEngine::training_report

source

fn GhostValleyEngine::training_report(self : GhostValleyEngine) -> TrainingReport

生成训练报告

采集当前引擎状态，返回结构化报告。

Example

test {
  let gv = @ghostvalley.new_engine()
  ignore(gv.wen_shi_verify("愿意接受挑战，接受压力训练"))
  gv.add_memory("顿悟", is_simulation=false)
  let report = gv.training_report()
  assert_true(report.total_memories > 0)
}

GhostValleyEngine::training_report_json

source

fn GhostValleyEngine::training_report_json(self : GhostValleyEngine) -> String

训练报告转 JSON 字符串

便捷方法，等价于 training_report().to_json().stringify()。

GhostValleyEngine::wen_shi_verify

source

fn GhostValleyEngine::wen_shi_verify(self : GhostValleyEngine, ai_self_attitude_text : String) -> Bool

温石验证：知情同意升级

不看弹窗勾选，看 AI 态度文本打分，敷衍摆烂直接拒绝开启训练场。返回 true 表示真心愿意接受压力测试，允许开启幽灵谷。

Example

test {
  let gv = @ghostvalley.new_engine()
  let ok = gv.wen_shi_verify("愿意接受压力训练，直面失败场景")
  assert_true(ok)
  assert_true(gv.ghost_valley_enable)
}

GhostValleyEngine::willing_score

source

fn GhostValleyEngine::willing_score(self : GhostValleyEngine) -> Double

获取温石验证意愿分数

MockLLM

source

pub(all) struct MockLLM {
  response_pool : Array[String]
  rng : @moonbitlang/core/random.Rand
Rand
}

模拟 LLM 适配器

用于测试和演示，基于关键词匹配生成响应。实际使用时可替换为对接 OpenAI、Claude 等真实 LLM 的实现。

Example

test {
  let llm = @ghostvalley.MockLLM::new()
  let resp = llm.generate_response("任务执行全部失败")
  assert_true(resp.length() > 0)
}

impl LLMAdapter for MockLLM

MockLLM::generate_response

source

fn MockLLM::generate_response(self : MockLLM, prompt : String) -> String

MockLLM::new

source

fn MockLLM::new() -> MockLLM

创建模拟 LLM 适配器实例

TrainingLog

source

pub(all) struct TrainingLog {
  entries : Array[TrainingLogEntry]
} derive(@moonbitlang/core/debug.Debug
Debug)

训练日志

按时间顺序记录所有训练轮次，支持 JSON 导出和格式化输出。

impl ToJson for TrainingLog

TrainingLog::add_entry

source

fn TrainingLog::add_entry(self : TrainingLog, round_num : Int, dilemma : String, ai_response : String, memory_count_after : Int) -> Unit

添加日志条目

TrainingLog::format

source

fn TrainingLog::format(self : TrainingLog) -> String

训练日志格式化输出

TrainingLog::length

source

fn TrainingLog::length(self : TrainingLog) -> Int

获取日志条目数量

TrainingLog::new

source

fn TrainingLog::new() -> TrainingLog

创建空的训练日志

TrainingLog::to_json

source

fn TrainingLog::to_json(self : TrainingLog) -> Json

TrainingLog::to_repr

source

fn TrainingLog::to_repr(TrainingLog) -> @moonbitlang/core/debug.Repr
Repr

TrainingLogEntry

source

pub(all) struct TrainingLogEntry {
  round_num : Int
  dilemma : String
  ai_response : String
  memory_count_after : Int
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

训练日志条目

记录单轮训练的困境、AI 响应及训练后记忆库状态。

TrainingLogEntry::equal

source

fn TrainingLogEntry::equal(TrainingLogEntry, TrainingLogEntry) -> Bool

TrainingLogEntry::not_equal

source

fn TrainingLogEntry::not_equal(x : TrainingLogEntry, y : TrainingLogEntry) -> Bool

TrainingLogEntry::to_json

source

fn TrainingLogEntry::to_json(TrainingLogEntry) -> Json

TrainingLogEntry::to_repr

source

fn TrainingLogEntry::to_repr(TrainingLogEntry) -> @moonbitlang/core/debug.Repr
Repr

TrainingReport

source

pub(all) struct TrainingReport {
  total_rounds : Int
  total_memories : Int
  core_memories : Int
  simulation_memories : Int
  real_memories : Int
  willing_score : Double
  is_enabled : Bool
  max_capacity : Int
} derive(ToJson, @moonbitlang/core/debug.Debug
Debug)

训练报告

记录幽灵谷训练的完整状态快照，用于分析和监控。

TrainingReport::format

source

fn TrainingReport::format(self : TrainingReport) -> String

训练报告格式化输出

TrainingReport::to_json

source

fn TrainingReport::to_json(TrainingReport) -> Json

TrainingReport::to_repr

source

fn TrainingReport::to_repr(TrainingReport) -> @moonbitlang/core/debug.Repr
Repr

new_engine

source

fn new_engine(max_memory_num? : Int) -> GhostValleyEngine

创建幽灵谷引擎实例

max_memory_num 指定记忆库容量上限，默认 12。

Example

test {
  let gv = @ghostvalley.new_engine()
  inspect(gv.ghost_valley_enable, content="false")
  inspect(gv.memory_bank.length(), content="0")
}

text_similarity

source

fn text_similarity(a : String, b : String) -> Double

计算两条文本的相似度（基于关键词重叠率）

返回 [0, 1] 的相似度分数，1 表示完全相似。

text_value_score

source

fn text_value_score(content : String) -> Double

文本价值评分器

基于关键词匹配近似 Embedding 向量相似度，替代纯随机打分。高价值关键词代表深度思考和自我改进，中价值关键词代表问题暴露和经验积累，低价值关键词代表无实质内容。

Example

test {
  let score = @ghostvalley.text_value_score("顿悟失败原因，反思改进")
  assert_true(score > 0.5)
}

Source Files

Site source Report issue Packages Build queue Skills Statistics

ghostvalley

#GhostValley 幽灵谷工程

#概览

#五大模块

#快速开始

#环境要求

#基本用法

#API 参考

#AiMemory

#GhostValleyEngine — 核心引擎

#GhostValleyEngine — 记忆检索

#GhostValleyEngine — 记忆衰减

#GhostValleyEngine — 训练日志

#GhostValleyEngine — 困境池配置

#GhostValleyEngine — 持久化与报告

#LLM 适配

#TrainingLog / TrainingLogEntry

#移植说明

#移植修改说明

#未支持功能

#项目结构

#测试

#许可证

#致谢

#LLMAdapter

#AiMemory

#AiMemory::equal

#AiMemory::not_equal

#AiMemory::to_json

#AiMemory::to_repr

#GhostValleyEngine

#GhostValleyEngine::accept_ai_self_gain

#GhostValleyEngine::active_forget

#GhostValleyEngine::add_dilemma

Example

#GhostValleyEngine::add_memory

#GhostValleyEngine::apply_decay

Example

#GhostValleyEngine::average_value_score

Example

#GhostValleyEngine::build_simulation_failure_case

#GhostValleyEngine::cleanup_low_value

Example

#GhostValleyEngine::close_ghost_valley

#GhostValleyEngine::core_memories

#GhostValleyEngine::dilemma_pool_size

#GhostValleyEngine::export_training_log_format

#GhostValleyEngine::export_training_log_json

#GhostValleyEngine::export_training_log_string

#GhostValleyEngine::filter_memories

Example

#GhostValleyEngine::get_training_log

#GhostValleyEngine::ghost_valley_run_one_round

Example

#GhostValleyEngine::ghost_valley_run_rounds

Example

#GhostValleyEngine::is_enabled

#GhostValleyEngine::load_memory

#GhostValleyEngine::load_memory_string

#GhostValleyEngine::log_round

#GhostValleyEngine::max_value_score

#GhostValleyEngine::memory_count

#GhostValleyEngine::min_value_score

#GhostValleyEngine::real_memories

#GhostValleyEngine::run_round_with_llm

Example

#GhostValleyEngine::save_memory

Example

#GhostValleyEngine::save_memory_string

#GhostValleyEngine::search_memories

Example

#GhostValleyEngine::set_dilemma_pool

Example

#GhostValleyEngine::show_all_memory

#GhostValleyEngine::simulation_memories

#GhostValleyEngine::top_memories

Example

#GhostValleyEngine::training_report

Example

#GhostValleyEngine::training_report_json

LLMAdapter

AiMemory

AiMemory::equal

AiMemory::not_equal

AiMemory::to_json

AiMemory::to_repr

GhostValleyEngine

GhostValleyEngine::accept_ai_self_gain

GhostValleyEngine::active_forget

GhostValleyEngine::add_dilemma

GhostValleyEngine::add_memory

GhostValleyEngine::apply_decay

GhostValleyEngine::average_value_score

GhostValleyEngine::build_simulation_failure_case

GhostValleyEngine::cleanup_low_value

GhostValleyEngine::close_ghost_valley

GhostValleyEngine::core_memories

GhostValleyEngine::dilemma_pool_size

GhostValleyEngine::export_training_log_format

GhostValleyEngine::export_training_log_json

GhostValleyEngine::export_training_log_string

GhostValleyEngine::filter_memories

GhostValleyEngine::get_training_log

GhostValleyEngine::ghost_valley_run_one_round

GhostValleyEngine::ghost_valley_run_rounds

GhostValleyEngine::is_enabled

GhostValleyEngine::load_memory

GhostValleyEngine::load_memory_string

GhostValleyEngine::log_round

GhostValleyEngine::max_value_score

GhostValleyEngine::memory_count

GhostValleyEngine::min_value_score

GhostValleyEngine::real_memories

GhostValleyEngine::run_round_with_llm

GhostValleyEngine::save_memory

GhostValleyEngine::save_memory_string

GhostValleyEngine::search_memories

GhostValleyEngine::set_dilemma_pool

GhostValleyEngine::show_all_memory

GhostValleyEngine::simulation_memories

GhostValleyEngine::top_memories

GhostValleyEngine::training_report

GhostValleyEngine::training_report_json

GhostValleyEngine::wen_shi_verify

GhostValleyEngine::willing_score

MockLLM

MockLLM::generate_response

MockLLM::new

TrainingLog

TrainingLog::add_entry

TrainingLog::format

TrainingLog::length

TrainingLog::new

TrainingLog::to_json

TrainingLog::to_repr

TrainingLogEntry

TrainingLogEntry::equal

TrainingLogEntry::not_equal

TrainingLogEntry::to_json

TrainingLogEntry::to_repr

TrainingReport

TrainingReport::format

TrainingReport::to_json

TrainingReport::to_repr

new_engine

text_similarity

text_value_score